test(o63): fix main Windows CI (rebase onto 93ef58a9)

bench/device-tasks/sim/bin/dpkg

@@ -30,7 +30,8 @@ case "$cmd" in
   -i | --install)
     deb="${1:?deb path required}"
     tmp="$(mktemp -d)"
-    tar -C "$tmp" -xf "$deb"
+    # Stream via stdin. GNU tar treats "D:/..." as host:path, so -f "$deb" never reads the archive on Windows.
+    tar -C "$tmp" -xf - < "$deb"
     control="$tmp/DEBIAN/control"
     pkg="$(awk -F': ' '/^Package:/{print $2; exit}' "$control")"
     ver="$(awk -F': ' '/^Version:/{print $2; exit}' "$control")"

bench/device-tasks/sim/bin/dpkg-deb

@@ -8,4 +8,5 @@ fi
 dir="$2"
 dest="${3:-$dir.deb}"
 mkdir -p "$(dirname "$dest")"
-tar -C "$dir" -cf "$dest" .
+# Stream via stdout. GNU tar treats "D:/..." as host:path, so -f "$dest" never writes the archive on Windows.
+tar -C "$dir" -cf - . > "$dest"

src/cli/hooks.ts

@@ -8,9 +8,32 @@ import { safeChildEnv } from '../utils/safe-child-env.js';
 import { errorMessage } from '../errors.js';
 import { ProcessError, runProcess } from '../utils/run-process.js';
 
-const IS_WIN = process.platform === 'win32';
 const DEFAULT_HOOK_TIMEOUT_MS = 30_000;
 
+/**
+ * Shell invocation for a user hook command.
+ *
+ * On Windows, Node's default spawn quoting escapes embedded `"` as `\"`.
+ * `cmd.exe` does not treat that backslash as an escape, so a command such as
+ * `"C:\node.exe" "C:\x\dump.mjs"` never starts. Match `child_process.exec`:
+ * wrap the command in one extra pair of quotes, pass `/s` so cmd strips only
+ * that wrapper, and set `windowsVerbatimArguments` so the quotes stay quotes.
+ * POSIX stays `/bin/sh -c` with the command unchanged.
+ */
+export function hookShell(
+  command: string,
+  platform: NodeJS.Platform = process.platform
+): { cmd: string; args: string[]; windowsVerbatimArguments?: boolean } {
+  if (platform === 'win32') {
+    return {
+      cmd: process.env.COMSPEC || 'cmd.exe',
+      args: ['/d', '/s', '/c', `"${command}"`],
+      windowsVerbatimArguments: true,
+    };
+  }
+  return { cmd: '/bin/sh', args: ['-c', command] };
+}
+
 interface HookRunResult {
   exitCode: number;
   stdout: string;
@@ -63,20 +86,20 @@ function runHookCommand(
   cwd: string,
   timeoutMs: number
 ): Promise<HookRunResult> {
-  const shell = IS_WIN ? process.env.COMSPEC || 'cmd.exe' : '/bin/sh';
-  const args = IS_WIN ? ['/c', command] : ['-c', command];
+  const shell = hookShell(command);
   const env = safeChildEnv({
     LANG: process.env.LANG || 'en_US.UTF-8',
     MOSS_HOOK_EVENT: payload.event,
     MOSS_TOOL_NAME: payload.toolName ?? '',
     MOSS_WORKSPACE: cwd,
   });
-  return runProcess(shell, {
-    args,
+  return runProcess(shell.cmd, {
+    args: shell.args,
     cwd,
     env,
     timeout: timeoutMs,
     stdin: JSON.stringify(payload),
+    ...(shell.windowsVerbatimArguments ? { windowsVerbatimArguments: true } : {}),
   })
     .then(({ exitCode, stdout, stderr }) => ({ exitCode, stdout, stderr }))
     .catch((err) => {

src/cli/oneshot.ts

@@ -26,6 +26,7 @@ import { createCliSessionKey } from './session.js';
 import { loadCliConfigFile } from './config.js';
 import { configuredBaseUrl, pricingOverridesFromConfig } from './model-pricing.js';
 import { buildGitStatusSnapshot } from '../context/git-status-snapshot.js';
+import { acceptanceShell } from '../core/task/acceptance-command.js';
 import { runStopHooks, type StopHookResult } from './hooks.js';
 import { runProcess } from '../utils/run-process.js';
 
@@ -656,15 +657,12 @@ export async function runOneShot(
       }
     };
     try {
-      const shell = process.platform === 'win32' ? (process.env.COMSPEC ?? 'cmd.exe') : 'bash';
-      const shellArgs =
-        process.platform === 'win32'
-          ? ['/d', '/s', '/c', process.env.MOSS_GOAL_VERIFY_CMD]
-          : ['-c', process.env.MOSS_GOAL_VERIFY_CMD];
-      const verify = await runProcess(shell, {
-        args: shellArgs,
+      const shell = acceptanceShell(process.env.MOSS_GOAL_VERIFY_CMD);
+      const verify = await runProcess(shell.cmd, {
+        args: shell.args,
         cwd: workspaceDir,
         timeout: 5 * 60_000,
+        ...(shell.windowsVerbatimArguments ? { windowsVerbatimArguments: true } : {}),
       });
       if (verify.exitCode !== 0) {
         const tail = `${verify.stdout}\n${verify.stderr}`.trim().slice(-2000);

test/background-exec.spec.mjs

@@ -206,10 +206,33 @@ async function waitForProcessExit(pid, timeoutMs = 3000) {
   assert.match(out, /block/i, 'dangerous command is blocked by the safety gate');
 }
 
-async function stopAndConfirmGone(out, stopCtx, label) {
+async function stopAndConfirmGone(out, stopCtx, label, pidFile) {
   const id = extractBgId(out);
   assert.ok(id, `${label}: no background id in ${out}`);
   const pid = Number(out.match(/pid (\d+)/)?.[1]);
+  // On Windows, cmd.exe can publish the shell pid before it starts the node
+  // grandchild. Stop only after that grandchild has written its pid, or the
+  // exit check races a process that was never started.
+  let scriptPid = 0;
+  if (pidFile) {
+    const deadline = Date.now() + 10000;
+    while (scriptPid <= 0) {
+      if (fs.existsSync(pidFile)) {
+        try {
+          const parsed = Number(fs.readFileSync(pidFile, 'utf8').trim());
+          if (Number.isInteger(parsed) && parsed > 0) scriptPid = parsed;
+        } catch {
+          // The writer may still hold the file. Keep polling until the deadline.
+        }
+      }
+      if (scriptPid > 0 || Date.now() >= deadline) break;
+      await new Promise((resolve) => setTimeout(resolve, 20));
+    }
+    assert.ok(
+      Number.isInteger(scriptPid) && scriptPid > 0,
+      `${label}: script never wrote its pid before exec_stop`
+    );
+  }
   await execStopTool.execute({ id }, stopCtx);
   if (Number.isFinite(pid) && pid > 0) {
     assert.equal(
@@ -218,16 +241,47 @@ async function stopAndConfirmGone(out, stopCtx, label) {
       `${label}: pid ${pid} survived exec_stop`
     );
   }
+  if (pidFile) {
+    assert.equal(
+      await waitForProcessExit(scriptPid, 15000),
+      true,
+      `${label}: script pid ${scriptPid} survived exec_stop`
+    );
+  }
 }
 
 // ─── 6. /goal waits only when this run injected goalExecWait ──────────────
 {
   clearBackgroundRegistryForTests();
   const ws = fs.mkdtempSync(path.join(process.cwd(), '.moss-goal-exec-wait-'));
   const sleepMs = 2000;
-  const script = path.join(ws, 'sleep.cjs');
-  fs.writeFileSync(script, `setTimeout(() => process.exit(0), ${sleepMs});\n`);
-  const command = `node ${quote(script)}`;
+  const writeNodeScript = (name, source) => {
+    const file = path.join(ws, name);
+    fs.writeFileSync(file, source);
+    return `node ${quote(file)}`;
+  };
+  // Pid files live in ws and are unique per stopped command. The shared
+  // sleepScript at the top of this file stays untouched for the other sections.
+  const pidScript = (name, afterWrite) => {
+    const pidFile = path.join(ws, `${name}.pid`);
+    const command = writeNodeScript(
+      `${name}.cjs`,
+      [
+        "const fs = require('node:fs');",
+        `fs.writeFileSync(${JSON.stringify(pidFile)}, String(process.pid));`,
+        afterWrite,
+        '',
+      ].join('\n')
+    );
+    return { command, pidFile };
+  };
+  const exitAfterSleep = `setTimeout(() => process.exit(0), ${sleepMs});`;
+  const runForever = 'setInterval(() => {}, 1000);';
+  const commandProc = pidScript('command', exitAfterSleep);
+  const command = commandProc.command;
+  const idleProc = pidScript('idle', runForever);
+  const optOutProc = pidScript('opt-out', runForever);
+  const settleProc = pidScript('settle', runForever);
   const { taskId } = await createDraftTask(ws, 'diagnosing on disk is not a goal run');
   await appendTaskEvent(ws, taskId, 'execution_started');
   await appendTaskEvent(ws, taskId, 'verification_started');
@@ -236,11 +290,11 @@ async function stopAndConfirmGone(out, stopCtx, label) {
   const goalCtx = { ...diskCtx, goalExecWait: true };
 
   const idleStarted = Date.now();
-  const idle = await execBackgroundTool.execute({ command: `node ${quote(sleepScript)}` }, diskCtx);
+  const idle = await execBackgroundTool.execute({ command: idleProc.command }, diskCtx);
   const idleElapsed = Date.now() - idleStarted;
   assert.match(idle, /Still running after/, 'a diagnosing task on disk does not make exec wait');
   assert.ok(idleElapsed < 1700, `no wait outside /goal, elapsed ${idleElapsed}`);
-  await stopAndConfirmGone(idle, diskCtx, 'idle');
+  await stopAndConfirmGone(idle, diskCtx, 'idle', idleProc.pidFile);
 
   const goalStarted = Date.now();
   const waited = await execTool.execute({ command, run_in_background: true }, goalCtx);
@@ -251,7 +305,7 @@ async function stopAndConfirmGone(out, stopCtx, label) {
 
   const optOutStarted = Date.now();
   const optedOut = await execBackgroundTool.execute(
-    { command: `node ${quote(sleepScript)}`, wait: false },
+    { command: optOutProc.command, wait: false },
     goalCtx
   );
   const optOutElapsed = Date.now() - optOutStarted;
@@ -260,36 +314,29 @@ async function stopAndConfirmGone(out, stopCtx, label) {
     optOutElapsed < 1700,
     `dev server with wait:false returns fast, elapsed ${optOutElapsed}`
   );
-  await stopAndConfirmGone(optedOut, goalCtx, 'wait:false');
+  await stopAndConfirmGone(optedOut, goalCtx, 'wait:false', optOutProc.pidFile);
 
   const settleStarted = Date.now();
   const settled = await execTool.execute(
-    { command: `node ${quote(sleepScript)}`, run_in_background: true, settle_ms: 200 },
+    { command: settleProc.command, run_in_background: true, settle_ms: 200 },
     goalCtx
   );
   const settleElapsed = Date.now() - settleStarted;
   assert.match(settled, /Still running after/, `explicit settle_ms stays backgrounded: ${settled}`);
   assert.ok(settleElapsed < 1000, `settle_ms during a goal returns fast, elapsed ${settleElapsed}`);
-  await stopAndConfirmGone(settled, goalCtx, 'settle_ms');
+  await stopAndConfirmGone(settled, goalCtx, 'settle_ms', settleProc.pidFile);
 
+  // command already ran to exit above and left command.pid. Remove it so the
+  // stop check below can only observe the process started here.
+  fs.rmSync(commandProc.pidFile, { force: true });
   const capStarted = Date.now();
   const capped = await execBackgroundTool.execute({ command, timeout_ms: 300 }, goalCtx);
   const capElapsed = Date.now() - capStarted;
   assert.match(capped, /exec_wait/, `timeout tells the model how to await: ${capped}`);
   assert.match(capped, /Still running after/, `timeout still returns a handle: ${capped}`);
   assert.ok(capElapsed < 1000, `timeout_ms bounds the wait, elapsed ${capElapsed}`);
-  await stopAndConfirmGone(capped, goalCtx, 'timeout_ms cap');
-  // Windows can still hold the stopped child's handles on ws for a moment
-  // (EBUSY or EPERM); rmSync's maxRetries does not cover EPERM.
-  for (let attempt = 0; ; attempt += 1) {
-    try {
-      fs.rmSync(ws, { recursive: true, force: true });
-      break;
-    } catch (error) {
-      if (attempt >= 25 || !['EBUSY', 'EPERM'].includes(error?.code)) throw error;
-      await new Promise((resolve) => setTimeout(resolve, 200));
-    }
-  }
+  await stopAndConfirmGone(capped, goalCtx, 'timeout_ms cap', commandProc.pidFile);
+  fs.rmSync(ws, { recursive: true, force: true, maxRetries: 10, retryDelay: 200 });
 }
 
 // ─── 7. Esc during a goal wait kills the command immediately ───────────────

test/cli-first-run-e2e.spec.mjs

@@ -18,6 +18,13 @@ const repoRoot = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
 const cli = path.join(repoRoot, 'dist', 'cli.js');
 const SECRET = 'sk-firstrun-e2e-secret';
 
+if (process.platform === 'win32') {
+  console.log(
+    '[SKIP] fresh-home first-run e2e: needs a POSIX pty (Python pty/fcntl/termios); not available on win32'
+  );
+  process.exit(0);
+}
+
 function tempDir(prefix) {
   return trackTempDir(fs.mkdtempSync(path.join(os.tmpdir(), prefix)));
 }

test/cli-update-command.spec.mjs

@@ -176,7 +176,7 @@ const repo = { url: 'git+https://github.com/D-Robotics/moss.git' };
 }
 
 {
-  const elsewhere = '/opt/moss-src';
+  const elsewhere = path.resolve('/opt/moss-src');
   const root = path.join('/usr', 'lib', 'node_modules', '@rdk-moss', 'agent');
   const advice = adviseMossUpdate({
     packageRoot: root,

test/device-bench.spec.mjs

@@ -582,6 +582,11 @@ test('provider config dir is removed on process exit and SIGTERM', async () => {
     fs.rmSync(exited.root, { recursive: true, force: true });
   }
 
+  if (process.platform === 'win32') {
+    // Windows kill(SIGTERM) terminates without running handlers; stale provider-config cleanup tracked as backlog item
+    return;
+  }
+
   const signaled = runProviderHold('wait');
   try {
     const info = await waitForMarker(signaled.marker);

test/device-credential-trust.spec.mjs

@@ -222,8 +222,9 @@ async function runCase(c) {
     );
   }
   const store = {};
-  if (c.trust) store[fs.realpathSync(ws)] = true;
-  if (c.trustParent) store[fs.realpathSync(parent)] = true;
+  // Must match folderPathKey (fs.realpathSync.native).
+  if (c.trust) store[fs.realpathSync.native(ws)] = true;
+  if (c.trustParent) store[fs.realpathSync.native(parent)] = true;
   if (Object.keys(store).length > 0) {
     fs.writeFileSync(path.join(configDir, 'workspace-trust.json'), JSON.stringify(store));
   }

test/dotenv-safety-env.spec.mjs

@@ -408,8 +408,6 @@ sys.stdout.buffer.write(data)
 }
 
 function goalCommand(script) {
-  const quoted = `"${process.execPath}" "${script}"`;
-  if (process.platform === 'win32') return `"${quoted}"`;
   return `${shellQuote(process.execPath)} ${shellQuote(script)}`;
 }
 

test/hooks-shell-win32.spec.mjs

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+/**
+ * Hook commands with quoted paths. On Windows, Node's default spawn quoting
+ * turns " into \" and cmd.exe treats the backslash as a literal, so the
+ * SessionStart hook never starts. The invocation must match child_process.exec:
+ * one extra quote wrapper and windowsVerbatimArguments, so /s strips only
+ * that wrapper. POSIX stays /bin/sh -c with the command unchanged.
+ */
+import assert from 'node:assert/strict';
+
+import { hookShell } from '../dist/cli/hooks.js';
+
+const command = '"C:\\node.exe" "C:\\x\\dump.mjs"';
+
+{
+  const win = hookShell(command, 'win32');
+  assert.equal(win.windowsVerbatimArguments, true);
+  assert.equal(win.cmd, process.env.COMSPEC || 'cmd.exe');
+  assert.deepEqual(win.args, ['/d', '/s', '/c', `"${command}"`]);
+}
+
+{
+  const linux = hookShell(command, 'linux');
+  assert.deepEqual(linux, { cmd: '/bin/sh', args: ['-c', command] });
+}
+
+console.log('[PASS] hooks-shell-win32');

test/workspace-trust.spec.mjs

@@ -504,7 +504,8 @@ async function assertDotenvSkipped(label, dotenv, drop) {
   put(path.join(ws, '.moss', 'config.json'), {
     hooks: { SessionStart: [{ command: 'node hook.mjs' }] },
   });
-  const key = fs.realpathSync(ws);
+  // Must match folderPathKey (fs.realpathSync.native), or the forged entry is vacuous on win32.
+  const key = fs.realpathSync.native(ws);
   for (const configDir of [
     'moss',
     path.join('.config', 'moss'),