fix: finish Windows CI portability

Author: vitry

scripts/zcode-broker.mjs

@@ -3,6 +3,7 @@
 import { createHash, randomBytes, timingSafeEqual } from 'node:crypto';
 import { chmod, readFile, unlink } from 'node:fs/promises';
 import net from 'node:net';
+import { tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
@@ -105,7 +106,11 @@ export async function ensureZCodeBroker(options) {
     if ((options.platform ?? process.platform) !== 'win32') await unlink(endpoint).catch(() => {});
     const configPath = join(brokerDirectory, `config-${instanceId}.json`);
     await atomicWriteJson(configPath, { endpoint, instanceId, brokerToken, launch: options.launch, workspace: storage.workspacePath, idleTimeoutMs: options.idleTimeoutMs, maxFrameBytes: options.maxFrameBytes, maxOutboundBytes: options.maxOutboundBytes, drainTimeoutMs: options.drainTimeoutMs, ownershipPath: join(brokerDirectory, profile ? `session-owners-${profile}.json` : 'session-owners.json'), identityPath });
-    const child = await spawnDaemon({ command: process.execPath, args: [fileURLToPath(import.meta.url)], target: fileURLToPath(import.meta.url) }, { args: [configPath], cwd: storage.workspacePath, env: options.env });
+    // Keep the daemon's process cwd outside the workspace. Windows holds the
+    // cwd directory open for the lifetime of the process, which otherwise
+    // prevents callers from removing short-lived workspace fixtures (and can
+    // make a real workspace impossible to rename or delete).
+    const child = await spawnDaemon({ command: process.execPath, args: [fileURLToPath(import.meta.url)], target: fileURLToPath(import.meta.url) }, { args: [configPath], cwd: tmpdir(), env: options.env });
     const record = await writeBrokerIdentity(identityPath, { endpoint, pid: child.pid, instanceId, brokerToken });
     const deadline = Date.now() + 5_000;
     while (Date.now() < deadline) {

tests/fixtures/lock-holder.mjs

@@ -0,0 +1,18 @@
+// @ts-nocheck
+import process from 'node:process';
+
+import { withFileLock } from '../../scripts/lib/fs.mjs';
+
+const lockPath = process.argv[2];
+if (!lockPath) throw new Error('lock path required');
+
+try {
+  await withFileLock(lockPath, async () => {
+    process.stdout.write('acquired\n');
+    await new Promise((resolve) => process.stdin.once('data', resolve));
+  }, { pollIntervalMs: 5, timeoutMs: 1_000 });
+  process.stdout.write('released\n');
+} catch (error) {
+  process.stderr.write(`${error?.stack ?? error}\n`);
+  process.exitCode = 1;
+}

tests/fixtures/stop-gate-with-timeout.mjs

@@ -8,4 +8,8 @@ const dataRoot = process.env.PLUGIN_DATA;
 if (!dataRoot) throw new Error('PLUGIN_DATA required');
 const discoveryCode = process.env.FAKE_GATE_DISCOVERY_ERROR;
 const discoverZCode = discoveryCode ? async () => { throw Object.assign(new Error('fixture discovery failure'), { code: discoveryCode }); } : undefined;
-process.stdout.write(JSON.stringify(await runStopReviewGate(input, { dataRoot, env: process.env, timeoutMs: 100, ...(discoverZCode ? { discoverZCode } : {}) })));
+// Windows child startup can consume most of a 100 ms budget under CI. Keep
+// the deliberately suppressed completion as the timeout trigger while leaving
+// enough time for the fake protocol process to create its session.
+const timeoutMs = process.platform === 'win32' ? 2_000 : 100;
+process.stdout.write(JSON.stringify(await runStopReviewGate(input, { dataRoot, env: process.env, timeoutMs, ...(discoverZCode ? { discoverZCode } : {}) })));

tests/integration/skills.test.mjs

@@ -228,7 +228,10 @@ test('direct background invocation keeps capabilities private and production own
   const jobId = /Reserved background job ([a-f0-9]{64})\./.exec(launched.stdout)?.[1];
   assert.ok(jobId, launched.stdout); assert.doesNotMatch(`${launched.stdout}${launched.stderr}${launched.spawnargs.join(' ')}`, /executionCapability|callerContext|privateInvocation/);
   const store = createStateStore({ dataRoot: ctx.env.PLUGIN_DATA }); let job;
-  const deadline = Date.now() + (process.platform === 'win32' ? 15_000 : 5_000);
+  // Windows CI can be heavily contended while several independent fixtures
+  // start brokers and native lock probes. Keep the worker bounded, but leave
+  // enough room for that startup/lock contention before declaring it stuck.
+  const deadline = Date.now() + (process.platform === 'win32' ? 30_000 : 5_000);
   do { job = await store.readJob(ctx.workspace, jobId); if (['succeeded', 'failed', 'cancelled'].includes(job.status)) break; await new Promise((resolvePromise) => setTimeout(resolvePromise, 20)); } while (Date.now() < deadline);
   await ensureWorkerStopped(job.childPid);
   assert.equal(job.status, 'succeeded', JSON.stringify(job.error));

tests/state.test.mjs

@@ -14,6 +14,7 @@ import {
 } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import test from 'node:test';
 
 import { PluginError } from '../scripts/lib/errors.mjs';
@@ -38,27 +39,14 @@ const jobInput = {
 };
 
 const fsModuleUrl = new URL('../scripts/lib/fs.mjs', import.meta.url).href;
+const lockHolder = fileURLToPath(new URL('./fixtures/lock-holder.mjs', import.meta.url));
 
 /** @param {string} lockPath */
 function startLockHolder(lockPath) {
-  const source = `
-    import { withFileLock } from ${JSON.stringify(fsModuleUrl)};
-    const lockPath = process.argv[1];
-    try {
-      await withFileLock(lockPath, async () => {
-        process.stdout.write('acquired\\n');
-        await new Promise((resolve) => process.stdin.once('data', resolve));
-      }, {
-        pollIntervalMs: 5,
-        timeoutMs: 1_000,
-      });
-      process.stdout.write('released\\n');
-    } catch (error) {
-      process.stdout.write(\`error:\${error.code}\\n\`);
-    }
-  `;
-  return spawn(process.execPath, ['--input-type=module', '--eval', source, lockPath], {
+  return spawn(process.execPath, [lockHolder, lockPath], {
     stdio: ['pipe', 'pipe', 'pipe'],
+    shell: false,
+    windowsHide: true,
   });
 }
 
@@ -95,11 +83,11 @@ function startTimedLockAttempt(lockPath) {
 
 /** @param {import('node:child_process').ChildProcess} child @param {string} expected */
 async function waitForOutput(child, expected) {
-  let output = '';
+  let output = ''; let stderr = '';
   await new Promise((resolve, reject) => {
     const timeout = setTimeout(() => {
       cleanup();
-      reject(new Error(`Timed out waiting for child output: ${expected}; received: ${output}`));
+      reject(new Error(`Timed out waiting for child output: ${expected}; received: ${output}; stderr: ${stderr}`));
     }, 2_000);
     function cleanup() {
       clearTimeout(timeout);
@@ -117,9 +105,10 @@ async function waitForOutput(child, expected) {
     /** @param {number | null} code */
     function onExit(code) {
       cleanup();
-      reject(new Error(`Child exited with ${code}; output: ${output}`));
+      reject(new Error(`Child exited with ${code}; output: ${output}; stderr: ${stderr}`));
     }
     child.stdout?.on('data', onData);
+    child.stderr?.on('data', (chunk) => { stderr += chunk.toString(); });
     child.once('exit', onExit);
   });
 }

tests/zcode-client.test.mjs

@@ -330,7 +330,7 @@ test('actual 0.16.1 snapshot and list required fields are enforced', async (t) =
 });
 
 test('invented and malformed nested 0.16.1 response fields are rejected', async (t) => {
-  for (const variant of ['invented-session-kind', 'invented-subagent-kind', 'bad-protocol', 'missing-model-label', 'string-message-model', 'bad-goal-stats', 'bad-permission-origin', 'bad-runtime-cache', 'bad-timeline-trigger', 'bad-provider-options']) await t.test(variant, () => withClient(async (client) => { await assert.rejects(client.createSession({ workspace: '/repo' }), { code: 'ZCODE_OUTPUT_INVALID' }); }, { FAKE_ZCODE_BAD_SNAPSHOT: variant }));
+  for (const variant of ['invented-session-kind', 'invented-subagent-kind', 'bad-protocol', 'missing-model-label', 'string-message-model', 'bad-goal-stats', 'bad-permission-origin', 'bad-runtime-cache', 'bad-timeline-trigger', 'bad-provider-options']) await t.test(variant, () => withClient(async (client) => { await assert.rejects(client.createSession({ workspace: '/repo' }), { code: 'ZCODE_OUTPUT_INVALID' }); }, { FAKE_ZCODE_BAD_SNAPSHOT: variant }, process.platform === 'win32' ? { requestTimeoutMs: 2_000, completionTimeoutMs: 2_000 } : {}));
 });
 
 test('harmless additive response fields are accepted with wire protocol version 1', async () => {