test(macos): keep POSIX updater fixtures off Windows

Author: pavelhov

tests/macos-update-helper.test.ts

@@ -20,6 +20,7 @@ import { join, resolve } from "node:path";
 import { performMacOSUpdateCommand, trustedMacOSUpdateSource, type MacOSUpdateHelperIo } from "../src/cli/macos-update";
 import { MacosUpdateTransactionStore, assertMacosUpdateAllowsMutation, type MacosUpdateSemanticSnapshot } from "../src/server/macos-update-transaction";
 import { acquireProxyLifecycleAuthority } from "../src/server/proxy-lifecycle-authority";
+// Store-backed macOS fixtures require POSIX permissions and durable directory fsync.
 const temporary: string[] = [];
 afterEach(() => { for (const root of temporary.splice(0)) rmSync(root,{recursive:true,force:true}); });
 const id = "c94b8309-5c96-41f1-8dd1-fd57aeab8913";
@@ -37,14 +38,14 @@ function fixture(snapshot: Partial<MacosUpdateSemanticSnapshot> = {}) {
   return {io,store,resumed,get stopped(){return stopped;},replace(){source={...source,build:"101",fingerprint:"replacement"};},setIntent(){fingerprint="external-edit";},setActive(n:number){active=n;},failVerify(){verified=false;},failResume(){resumeSucceeds=false;},allowResume(){resumeSucceeds=true;}};
 }
 const prepare = {action:"prepare" as const,transactionId:id,targetBuild:"101"};
-test("active prepare immediately returns confirmation; cancel preserves the live runtime",async()=>{
+test.skipIf(process.platform === "win32")("active prepare immediately returns confirmation; cancel preserves the live runtime",async()=>{
   const f=fixture();f.setActive(2);
   expect((await performMacOSUpdateCommand(prepare,f.io)).status).toBe("confirmation-required");
   expect(f.stopped).toBe(0);
   expect((await performMacOSUpdateCommand({action:"cancel",transactionId:id},f.io)).status).toBe("recovered");
   expect(f.stopped).toBe(0);expect(f.resumed).toEqual([]);expect(f.store.read()).toBeNull();
 });
-test("arming reverifies exit and uncertain/armed cancellation cannot clear exclusion",async()=>{
+test.skipIf(process.platform === "win32")("arming reverifies exit and uncertain/armed cancellation cannot clear exclusion",async()=>{
   const f=fixture();await performMacOSUpdateCommand(prepare,f.io);f.failVerify();
   expect((await performMacOSUpdateCommand({action:"arm",transactionId:id},f.io)).status).toBe("blocked");
   expect(f.store.read()).not.toBeNull();
@@ -53,7 +54,7 @@ test("arming reverifies exit and uncertain/armed cancellation cannot clear exclu
   expect((await performMacOSUpdateCommand({action:"reconcile"},g.io)).status).toBe("finish-required");
   expect(g.resumed).toEqual([]);
 });
-test("successful replacement restores owned intent unless newer file edits or native intent superseded it",async()=>{
+test.skipIf(process.platform === "win32")("successful replacement restores owned intent unless newer file edits or native intent superseded it",async()=>{
   for (const changed of [false,true]) {
     const f=fixture();await performMacOSUpdateCommand(prepare,f.io);await performMacOSUpdateCommand({action:"arm",transactionId:id},f.io);f.replace();if(changed)f.setIntent();
     expect((await performMacOSUpdateCommand({action:"reconcile"},f.io)).status).toBe("recovered");expect(f.resumed).toEqual([!changed]);expect(f.store.read()).toBeNull();
@@ -62,13 +63,13 @@ test("successful replacement restores owned intent unless newer file edits or na
   const a=await f.io.authority!({includeStart:true});f.store.recordNative(a);a.releaseAll();f.replace();
   await performMacOSUpdateCommand({action:"reconcile"},f.io);expect(f.resumed).toEqual([false]);
 });
-test("running-native never enables routing, and failed resume retains a retryable recovery record",async()=>{
+test.skipIf(process.platform === "win32")("running-native never enables routing, and failed resume retains a retryable recovery record",async()=>{
   const f=fixture({routing:"native"});await performMacOSUpdateCommand(prepare,f.io);f.replace();f.failResume();
   expect((await performMacOSUpdateCommand({action:"reconcile"},f.io)).status).toBe("blocked");expect(f.store.read()?.phase).toBe("recovering");
   f.allowResume();expect((await performMacOSUpdateCommand({action:"reconcile"},f.io)).status).toBe("recovered");expect(f.resumed).toEqual([false,false]);
   expect((await performMacOSUpdateCommand({action:"reconcile"},f.io)).status).toBe("idle");
 });
-test("prearm cancellation recovery survives helper failure and cold-launch retry",async()=>{
+test.skipIf(process.platform === "win32")("prearm cancellation recovery survives helper failure and cold-launch retry",async()=>{
   const f=fixture();await performMacOSUpdateCommand(prepare,f.io);f.failResume();
   expect((await performMacOSUpdateCommand({action:"cancel",transactionId:id},f.io)).status).toBe("blocked");f.allowResume();
   expect((await performMacOSUpdateCommand({action:"reconcile"},f.io)).status).toBe("recovered");
@@ -89,15 +90,15 @@ test.skipIf(process.platform !== "darwin")("real bundled CLI helper derives sour
 },15000);
 
 import { macOSUpdateResumeIntent } from "../src/cli/macos-update";
-test("semantic matrix preserves stopped/native/supervised and newer OFF without copying settings",async()=>{
+test.skipIf(process.platform === "win32")("semantic matrix preserves stopped/native/supervised and newer OFF without copying settings",async()=>{
   for (const running of [true,false]) for (const routing of ["owned","native","external"] as const) for (const supervision of ["none","launchd"] as const) {
     const f=fixture({running,routing,supervision});await performMacOSUpdateCommand(prepare,f.io);
     expect(macOSUpdateResumeIntent(f.store.read()!,"after")).toEqual({running,restoreOwned:routing==="owned",supervised:supervision==="launchd"});
     await performMacOSUpdateCommand({action:"record-off"},f.io);
     expect(macOSUpdateResumeIntent(f.store.read()!,"after")).toEqual({running:false,restoreOwned:false,supervised:supervision==="launchd"});
   }
 });
-test("partial preparation stays excluded and Finish Update retries the same captured target",async()=>{
+test.skipIf(process.platform === "win32")("partial preparation stays excluded and Finish Update retries the same captured target",async()=>{
   const f=fixture();let stopAttempt=0;
   const base=f.io.preparation!;f.io.preparation=(source,authority)=>{const original=base(source,authority);return {...original,stop:async(t,a)=>{if(++stopAttempt===1)throw Error("partial stop");await original.stop(t,a);}};};
   expect((await performMacOSUpdateCommand(prepare,f.io)).status).toBe("blocked");expect(f.store.read()?.phase).toBe("uncertain");
@@ -108,7 +109,7 @@ test("partial preparation stays excluded and Finish Update retries the same capt
 });
 
 import { resumeProduction } from "../src/cli/macos-update";
-test("newer OFF stops a recovery child or active bundle supervisor before clearing exclusion",async()=>{
+test.skipIf(process.platform === "win32")("newer OFF stops a recovery child or active bundle supervisor before clearing exclusion",async()=>{
   const f=fixture();await performMacOSUpdateCommand(prepare,f.io);await performMacOSUpdateCommand({action:"record-off"},f.io);
   const authority=await f.io.authority!({includeStart:true});let stops=0;
   const stop=async()=>{stops++;return {schemaVersion:1 as const,action:"stop" as const,ok:true,state:"stopped" as const,changed:true,pid:null,port:null,message:"stopped"};};
@@ -129,7 +130,7 @@ test("permission hardening reads do not supersede routing intent but user writes
   expect(macOSUpdateIntentFingerprint([config])).not.toBe(before);
 });
 
-test("deferred native routing applies before independent service/runtime returns and retains exclusion on failure",async()=>{
+test.skipIf(process.platform === "win32")("deferred native routing applies before independent service/runtime returns and retains exclusion on failure",async()=>{
   for (const independentService of [false,true]) for (const success of [false,true]) {
     const f=fixture({running:false});await performMacOSUpdateCommand(prepare,f.io);
     const a=await f.io.authority!({includeStart:true});f.store.recordNative(a);a.releaseAll();f.replace();
@@ -148,7 +149,7 @@ test("deferred native routing applies before independent service/runtime returns
   }
 });
 
-test("deferred native recovery publishes OFF and preserves a newer external route in an isolated home",async()=>{
+test.skipIf(process.platform === "win32")("deferred native recovery publishes OFF and preserves a newer external route in an isolated home",async()=>{
   for (const external of [false,true]) for (const confirmation of [false,true]) {
     const root=mkdtempSync(join(tmpdir(),"ccx-update-native-recovery-"));temporary.push(root);
     for(const directory of ["home","codex","state","tmp"])mkdirSync(join(root,directory));
@@ -178,7 +179,7 @@ test("deferred native recovery publishes OFF and preserves a newer external rout
   }
 },60000);
 
-test("Later publishes deferred native intent under authority and retries without stopping or resuming",async()=>{
+test.skipIf(process.platform === "win32")("Later publishes deferred native intent under authority and retries without stopping or resuming",async()=>{
   for (const failure of ["none","false","throw"] as const) for (const retry of ["cancel","reconcile"] as const) {
     const f=fixture();f.setActive(1);
     expect((await performMacOSUpdateCommand(prepare,f.io)).status).toBe("confirmation-required");
@@ -206,7 +207,7 @@ test("Later publishes deferred native intent under authority and retries without
   }
 });
 
-test("settings changed before the first stop supersede owned restoration on initial and confirmation preparation",async()=>{
+test.skipIf(process.platform === "win32")("settings changed before the first stop supersede owned restoration on initial and confirmation preparation",async()=>{
   for(const confirmation of [false,true]) for(const changed of [false,true]) {
     const f=fixture();
     if(confirmation) {
@@ -229,7 +230,7 @@ test("settings changed before the first stop supersede owned restoration on init
   }
 });
 
-test("confirmation reached after a partial stop does not become a routing-only cancellation",async()=>{
+test.skipIf(process.platform === "win32")("confirmation reached after a partial stop does not become a routing-only cancellation",async()=>{
   const f=fixture();const preparation=f.io.preparation!;let first=true;
   f.io.preparation=(source,authority)=>{
     const io=preparation(source,authority);

tests/macos-update-independent-runtime.test.ts

@@ -6,6 +6,8 @@ import { createServer } from "node:net";
 import { acquireProxyLifecycleAuthority } from "../src/server/proxy-lifecycle-authority";
 import { assertMacosUpdateAllowsRuntimeStart, MacosUpdateTransactionStore } from "../src/server/macos-update-transaction";
 import { assertMacosUpdateAllowsServiceStart, type ServiceDiagnostic, type ServiceInstallState } from "../src/service";
+// These macOS fixtures require POSIX permissions, directory fsync, and bundle paths.
+// Keep Linux coverage; Windows cannot represent the durability/provenance contract.
 const roots: string[] = [];
 afterEach(() => { for (const root of roots.splice(0)) rmSync(root,{recursive:true,force:true}); });
 async function fixture() {
@@ -20,7 +22,7 @@ async function fixture() {
   store.transition(authority,"independent","prepared"); store.transition(authority,"independent","armed"); authority.releaseAll();
   return {root,config,codex,home,store,bundlePath};
 }
-test("physical start uses actual paths and refuses bundle, mixed, missing provenance", async () => {
+test.skipIf(process.platform === "win32")("physical start uses actual paths and refuses bundle, mixed, missing provenance", async () => {
   const f = await fixture();
   const external = join(f.root,"external.ts"); writeFileSync(external,"");
   const bundled = join(f.bundlePath,"Contents","Resources","runtime.ts"); mkdirSync(join(f.bundlePath,"Contents","Resources"),{recursive:true}); writeFileSync(bundled,"");
@@ -29,7 +31,7 @@ test("physical start uses actual paths and refuses bundle, mixed, missing proven
   expect(()=>assertMacosUpdateAllowsRuntimeStart(f.store,{modulePath:external,executablePath:bundled})).toThrow();
   expect(()=>assertMacosUpdateAllowsRuntimeStart(f.store,{modulePath:join(f.root,"missing"),executablePath:external})).toThrow();
 });
-test("registered service target is checked independently of the caller", async () => {
+test.skipIf(process.platform === "win32")("registered service target is checked independently of the caller", async () => {
   const f = await fixture();
   const diagnostic: ServiceDiagnostic = {supported:true,registrationState:"present",supervisorState:"inactive",installed:true,enabled:true,running:false,viable:false,startable:true,stale:false,conflict:false,backend:"launchd",summary:""};
   const state: ServiceInstallState = {version:3,codexHome:f.codex,codexCommanderHome:f.config,bunPath:"/outside/bun",cliPath:"/outside/ccx",backend:"scheduler"};
@@ -38,7 +40,7 @@ test("registered service target is checked independently of the caller", async (
   expect(()=>check({...state,bunPath:`${f.bundlePath}/Contents/Resources/bun`,cliPath:`${f.bundlePath}/Contents/Resources/cli`})).toThrow();
   expect(()=>check({...state,bunPath:`${f.bundlePath}/Contents/Resources/bun`})).toThrow();
 });
-test("independent autonomous service child serves during armed update without rewriting routing", async () => {
+test.skipIf(process.platform === "win32")("independent autonomous service child serves during armed update without rewriting routing", async () => {
   const f = await fixture();
   const port = await new Promise<number>((resolve,reject)=>{const server=createServer(); server.once("error",reject); server.listen(0,"127.0.0.1",()=>{const value=server.address();const port=typeof value === "object" && value ? value.port : 0;server.close(error=>error?reject(error):resolve(port));});});
   const settings = JSON.stringify({port,hostname:"127.0.0.1",codexAutoStart:true,multiAgentGuidanceEnabled:true,clientIntegrations:{codex:true},defaultProvider:"mock",providers:{mock:{adapter:"openai-chat",baseUrl:"http://127.0.0.1:9/v1",allowPrivateNetwork:true,models:["test"],defaultModel:"test"}}});
@@ -87,7 +89,7 @@ test("independent service command starts without routing preparation or converge
   expect(starts).toBe(1); expect(writes).toBe(0);
 });
 
-test("independent Ensure preserves routing and cannot start a registered bundled service", async () => {
+test.skipIf(process.platform === "win32")("independent Ensure preserves routing and cannot start a registered bundled service", async () => {
   const { ensureProxyLifecycleUnderLock } = await import("../src/cli/proxy-lifecycle");
   const { getDefaultConfig } = await import("../src/config");
   const f = await fixture(); const previous = process.env.CODEXCOMMANDER_HOME;

tests/macos-update-transaction.test.ts

@@ -8,6 +8,8 @@ import { handleMacosUpdateAdmission, inspectMacosRuntimeBundleProvenance } from
 import { proxyLifecycleLockLeaseHeaders } from "../src/server/proxy-lifecycle-protocol";
 import { getDefaultConfig } from "../src/config";
 import { acquireTemporaryDrain, getActiveTurnCount, tryAdmitTurn, resetLifecycleDrainStateForTests } from "../src/server/lifecycle";
+// These macOS fixtures require POSIX permissions, directory fsync, and bundle paths.
+// Keep Linux coverage; Windows cannot represent the durability/provenance contract.
 const roots: string[] = [];
 afterEach(() => {
   resetLifecycleDrainStateForTests();
@@ -41,7 +43,7 @@ async function fixture() {
     store, authority, snapshot, request
   };
 }
-describe("macOS durable update exclusion", () => {
+describe.skipIf(process.platform === "win32")("macOS durable update exclusion", () => {
   test("persists before stopping and retains original snapshot across retries and helper exit", async () => {
     const f = await fixture();
     let stopped = 0;
@@ -114,7 +116,7 @@ describe("macOS durable update exclusion", () => {
     expect(() => f.store.read()).toThrow();
   });
 });
-test("admission seal cannot interrupt work without durable Update Anyway authorization", async () => {
+test.skipIf(process.platform === "win32")("admission seal cannot interrupt work without durable Update Anyway authorization", async () => {
   const f = await fixture();
   f.store.begin(f.authority, f.request, {
     ...f.snapshot, process: {
@@ -149,7 +151,7 @@ test("admission seal cannot interrupt work without durable Update Anyway authori
   expect(getActiveTurnCount()).toBe(0);
   expect(tryAdmitTurn()).toBeNull();
 });
-test("recovery scope is explicit and retry never forgets prior installer arm", async () => {
+test.skipIf(process.platform === "win32")("recovery scope is explicit and retry never forgets prior installer arm", async () => {
   const f = await fixture();
   f.store.begin(f.authority, f.request, f.snapshot);
   f.store.transition(f.authority, f.request.transactionId, "prepared");
@@ -164,15 +166,15 @@ test("recovery scope is explicit and retry never forgets prior installer arm", a
   expect(f.store.read()?.latestIntent?.running).toBeNull();
   expect(f.store.read()?.original.running).toBe(true);
 });
-test("shared mutations remain excluded after helper exit", async () => {
+test.skipIf(process.platform === "win32")("shared mutations remain excluded after helper exit", async () => {
   const f = await fixture();
   f.store.begin(f.authority, f.request, f.snapshot);
   f.authority.releaseAll();
   expect(() => assertMacosUpdateAllowsMutation(f.store)).toThrow("Finish Update");
   expect(f.store.read()?.phase).toBe("preparing");
 });
 
-test("seal success followed by failed stop preserves durable recovery and closed admission", async () => {
+test.skipIf(process.platform === "win32")("seal success followed by failed stop preserves durable recovery and closed admission", async () => {
   const f = await fixture();
   const result = await prepareMacosUpdate(f.store, f.authority, f.request, {
     capture: async () => ({
@@ -205,7 +207,7 @@ test("seal success followed by failed stop preserves durable recovery and closed
   expect(() => assertMacosUpdateAllowsMutation(f.store)).toThrow();
 });
 
-test("a runtime with only one executable dependency inside the bundle is never independent", async () => {
+test.skipIf(process.platform === "win32")("a runtime with only one executable dependency inside the bundle is never independent", async () => {
   await fixture();
   const root = roots.at(-1)!;
   const resources = join(root, "Test.app", "Contents", "Resources");
@@ -218,7 +220,7 @@ test("a runtime with only one executable dependency inside the bundle is never i
   expect(inspectMacosRuntimeBundleProvenance(external, external).kind).toBe("independent");
 });
 
-test("pre-stop supersession is durable and does not mistake partial stop writes for newer intent",async()=>{
+test.skipIf(process.platform === "win32")("pre-stop supersession is durable and does not mistake partial stop writes for newer intent",async()=>{
   for(const changed of [false,true]) for(const retryEdit of [false,true]) {
     const f=await fixture();let fingerprint=changed?"user-edit":"original";let attempts=0;
     const io={
@@ -241,7 +243,7 @@ test("pre-stop supersession is durable and does not mistake partial stop writes
   }
 });
 
-test("schema v1 accepts legacy records and strictly validates optional preparation and cancellation markers",async()=>{
+test.skipIf(process.platform === "win32")("schema v1 accepts legacy records and strictly validates optional preparation and cancellation markers",async()=>{
   const f=await fixture();
   const legacy=f.store.begin(f.authority,f.request,f.snapshot);
   expect(f.store.read()).toEqual(legacy);
@@ -256,7 +258,7 @@ test("schema v1 accepts legacy records and strictly validates optional preparati
   f.authority.releaseAll();
 });
 
-test("a crash without a post-stop baseline conservatively supersedes restoration on retry",async()=>{
+test.skipIf(process.platform === "win32")("a crash without a post-stop baseline conservatively supersedes restoration on retry",async()=>{
   const f=await fixture();
   f.store.begin(f.authority,f.request,{...f.snapshot,intentFingerprint:"original"});
   f.store.recordPreparationIntent(f.authority,f.request.transactionId,"original");