fix: recognize the offckb daemon when its CLI path contains spaces

.changeset/daemon-stop-spaced-path.md

@@ -0,0 +1,5 @@
+---
+'@offckb/cli': patch
+---
+
+- daemon: identify a running offckb daemon by anchoring the node executable and CLI script path in the process command line, so `offckb node stop` works when the CLI path contains spaces (e.g. macOS `~/Library/Application Support/...`)

src/util/daemon.ts

@@ -375,37 +375,96 @@ export async function getProcessCommandLine(pid: number): Promise<string | null>
   return info.cmdline;
 }
 
-// Split a flat command line into tokens, honoring single/double quotes. Used
-// on platforms without /proc; the first two tokens (executable, script) are
-// all the identity check consumes, and both are spawned by us without shell
-// metacharacters, so a simple tokenizer suffices.
-function splitCommandLine(cmdline: string): string[] {
-  const tokens: string[] = [];
-  const pattern = /"([^"]*)"|'([^']*)'|(\S+)/g;
-  let match: RegExpExecArray | null;
-  while ((match = pattern.exec(cmdline)) !== null) {
-    tokens.push(match[1] ?? match[2] ?? match[3]);
+// Path rules for comparing process paths. `platform` is only passed by unit
+// tests that exercise another OS's command lines; by default the host's own
+// `path` module is used (not process.platform, which tests may override).
+type PathRules = { api: path.PlatformPath; native: boolean; caseInsensitive: boolean };
+
+function pathRules(platform?: NodeJS.Platform): PathRules {
+  if (platform == null) {
+    return { api: path, native: true, caseInsensitive: path.sep === '\\' };
   }
-  return tokens;
+  const api = platform === 'win32' ? path.win32 : path.posix;
+  return { api, native: (platform === 'win32') === (path.sep === '\\'), caseInsensitive: platform === 'win32' };
 }
 
 // Resolve symlinks on both sides before comparing (nvm shims,
 // /usr/bin/node → /etc/alternatives, symlinked install prefixes). A path
-// that cannot be resolved still compares by its absolute form.
-function normalizePathForCompare(candidate: string): string {
-  const resolved = path.resolve(candidate);
+// that cannot be resolved still compares by its absolute form. Paths of
+// another OS (unit tests) are only resolved lexically.
+function normalizePathForCompare(candidate: string, rules: PathRules = pathRules()): string {
+  const resolved = rules.api.resolve(candidate);
+  if (!rules.native) return resolved;
   try {
     return fs.realpathSync(resolved);
   } catch {
     return resolved;
   }
 }
 
-function executableLooksLikeNode(executable: string): boolean {
-  if (normalizePathForCompare(executable) === normalizePathForCompare(process.execPath)) {
+// Windows file systems are case-insensitive.
+function samePath(a: string, b: string, rules: PathRules): boolean {
+  return rules.caseInsensitive ? a.toLowerCase() === b.toLowerCase() : a === b;
+}
+
+function executableLooksLikeNode(executable: string, rules: PathRules = pathRules()): boolean {
+  if (rules.native && samePath(normalizePathForCompare(executable), normalizePathForCompare(process.execPath), rules)) {
     return true;
   }
-  return NODE_EXECUTABLE_NAMES.has(path.basename(executable).toLowerCase());
+  return NODE_EXECUTABLE_NAMES.has(rules.api.basename(executable).toLowerCase());
+}
+
+// A piece of a flat command line, optionally wrapped in one pair of quotes
+// (Windows quotes arguments that contain spaces). Stray quotes inside an
+// unquoted piece mean the split point is not a real argument boundary.
+function unquoteCommandLinePiece(piece: string): string | null {
+  if (
+    piece.length >= 2 &&
+    ((piece.startsWith('"') && piece.endsWith('"')) || (piece.startsWith("'") && piece.endsWith("'")))
+  ) {
+    return piece.slice(1, -1);
+  }
+  if (piece.length === 0 || piece.includes('"')) return null;
+  return piece;
+}
+
+// Bounds the split search on a hostile or unusually long command line; real
+// executable + script paths have far fewer spaces.
+const MAX_COMMAND_LINE_SPLIT_POINTS = 64;
+
+/**
+ * Whether a flat command line — `ps -o args=` (argv joined by single spaces,
+ * never quoted) or a Windows CommandLine (arguments with spaces quoted) —
+ * starts with `<node executable> <expectedScript>`, followed by the end or a
+ * space.
+ *
+ * The line is NOT tokenized: unquoted paths may contain spaces (macOS
+ * `~/Library/Application Support/...`), so splitting at the first space
+ * would cut the executable or the script apart. Instead every space is tried
+ * as the executable/script boundary and every later space (or the end) as
+ * the script's end. A split only matches when the executable is a Node
+ * runtime and the script resolves to exactly `expectedScript` — the same
+ * strict identity as for an exact argv, without guessing token boundaries.
+ */
+export function commandLineRunsScript(cmdline: string, expectedScript: string, platform?: NodeJS.Platform): boolean {
+  const rules = pathRules(platform);
+  const text = cmdline.trim();
+  const expected = normalizePathForCompare(expectedScript, rules);
+  const spaces: number[] = [];
+  for (let i = 0; i < text.length && spaces.length < MAX_COMMAND_LINE_SPLIT_POINTS; i++) {
+    if (text[i] === ' ') spaces.push(i);
+  }
+  const scriptEnds = [...spaces, text.length];
+  for (const executableEnd of spaces) {
+    const executable = unquoteCommandLinePiece(text.slice(0, executableEnd));
+    if (executable == null || !executableLooksLikeNode(executable, rules)) continue;
+    for (const scriptEnd of scriptEnds) {
+      if (scriptEnd <= executableEnd + 1) continue;
+      const script = unquoteCommandLinePiece(text.slice(executableEnd + 1, scriptEnd));
+      if (script != null && samePath(normalizePathForCompare(script, rules), expected, rules)) return true;
+    }
+  }
+  return false;
 }
 
 /**
@@ -417,7 +476,10 @@ function executableLooksLikeNode(executable: string): boolean {
  *   2. its first argument must be THIS installation's CLI entry script
  *      (resolveCliEntry of the verifying process, realpath-normalized) —
  *      the pid file's scriptPath is never consulted, so a stale or forged
- *      pid file cannot lend our identity to an unrelated process;
+ *      pid file cannot lend our identity to an unrelated process. When only
+ *      a flat cmdline is available (ps / Windows), that is matched by
+ *      commandLineRunsScript rather than by tokenizing, so paths that
+ *      contain spaces still resolve;
  *   3. when the pid file carries a real startedAt (everything written by
  *      current versions does), the process start time must match it, which
  *      defeats PID reuse. If the process start time cannot be determined
@@ -432,21 +494,19 @@ export async function verifyDaemonIdentity(pid: number, metadata: PidMetadata):
     // Without our own entry point we cannot establish identity at all.
     return false;
   }
-  const expectedScript = normalizePathForCompare(cliEntry);
-
   const info = await getProcessInfo(pid);
   if (!info) return false;
 
-  let tokens: string[] | null = null;
   if (info.argv != null) {
-    tokens = info.argv;
-  } else if (info.cmdline != null) {
-    tokens = splitCommandLine(info.cmdline);
+    // Exact argv (Linux /proc): compare the first two arguments directly.
+    if (info.argv.length < 2) return false;
+    if (!executableLooksLikeNode(info.argv[0])) return false;
+    if (!samePath(normalizePathForCompare(info.argv[1]), normalizePathForCompare(cliEntry), pathRules())) {
+      return false;
+    }
+  } else if (info.cmdline == null || !commandLineRunsScript(info.cmdline, cliEntry)) {
+    return false;
   }
-  if (tokens == null || tokens.length < 2) return false;
-
-  if (!executableLooksLikeNode(tokens[0])) return false;
-  if (normalizePathForCompare(tokens[1]) !== expectedScript) return false;
 
   const recordedMs = Date.parse(metadata.startedAt);
   if (Number.isFinite(recordedMs) && recordedMs > 0) {

tests/daemon-command-line.test.ts

@@ -0,0 +1,75 @@
+import path from 'path';
+import { commandLineRunsScript } from '../src/util/daemon';
+
+const POSIX_NODE = '/usr/local/bin/node';
+const WIN_NODE = 'C:\\Program Files\\nodejs\\node.exe';
+
+describe('commandLineRunsScript (posix)', () => {
+  const script = '/Users/dev/Library/Application Support/offckb-nodejs/build/index.js';
+
+  it('matches an unquoted ps -o args= line whose paths contain spaces', () => {
+    expect(commandLineRunsScript(`${POSIX_NODE} ${script} node --daemon`, script, 'darwin')).toBe(true);
+    expect(commandLineRunsScript(`/usr/bin/node ${script}`, script, 'linux')).toBe(true);
+    expect(commandLineRunsScript(`nodejs ${script} fiber start --daemon`, script, 'linux')).toBe(true);
+  });
+
+  it('matches when the node executable itself also lives under a spaced path', () => {
+    const node = '/Users/dev/Library/Application Support/fnm/node';
+    expect(commandLineRunsScript(`${node} ${script} node`, script, 'darwin')).toBe(true);
+  });
+
+  it('rejects a foreign script, a truncated script and a non-node host', () => {
+    expect(commandLineRunsScript(`${POSIX_NODE} ${script}-other node`, script, 'darwin')).toBe(false);
+    expect(commandLineRunsScript(`${POSIX_NODE} ${script.slice(0, -3)} node`, script, 'darwin')).toBe(false);
+    expect(commandLineRunsScript(`/bin/bash ${script}`, script, 'darwin')).toBe(false);
+    expect(commandLineRunsScript(`${POSIX_NODE}`, script, 'darwin')).toBe(false);
+    expect(commandLineRunsScript('', script, 'darwin')).toBe(false);
+  });
+
+  it('rejects a path that only shares a prefix with the expected script', () => {
+    expect(
+      commandLineRunsScript(
+        `${POSIX_NODE} /Users/dev/Library/Application Support/offckb-nodejs/build/index.js.bak node`,
+        script,
+        'darwin',
+      ),
+    ).toBe(false);
+  });
+});
+
+describe('commandLineRunsScript (windows)', () => {
+  const script = 'C:\\Users\\Jane Doe\\AppData\\Local\\offckb-nodejs\\build\\index.js';
+
+  it('matches a Win32_Process CommandLine that quotes arguments containing spaces', () => {
+    expect(commandLineRunsScript(`"${WIN_NODE}" "${script}" node --daemon`, script, 'win32')).toBe(true);
+    expect(commandLineRunsScript(`"${WIN_NODE}" "${script}"`, script, 'win32')).toBe(true);
+  });
+
+  it('matches when only the script needs quoting', () => {
+    expect(commandLineRunsScript(`C:\\nodejs\\node.exe "${script}" node`, script, 'win32')).toBe(true);
+  });
+
+  it('matches an unquoted Windows command line when neither path has spaces', () => {
+    const plain = 'C:\\offckb\\build\\index.js';
+    expect(commandLineRunsScript(`C:\\nodejs\\node.exe ${plain} node --daemon`, plain, 'win32')).toBe(true);
+  });
+
+  it('rejects a foreign script and a non-node host, case-insensitively for the script', () => {
+    expect(commandLineRunsScript(`"${WIN_NODE}" "${script}.bak"`, script, 'win32')).toBe(false);
+    expect(commandLineRunsScript(`"C:\\Windows\\System32\\cmd.exe" "${script}"`, script, 'win32')).toBe(false);
+    expect(
+      commandLineRunsScript(
+        `"${WIN_NODE}" "C:\\Users\\Jane Doe\\AppData\\Local\\offckb-nodejs\\build\\INDEX.JS" node`,
+        script,
+        'win32',
+      ),
+    ).toBe(true);
+  });
+});
+
+describe('commandLineRunsScript (posix absolute paths without spaces still work)', () => {
+  it('matches a simple absolute path', () => {
+    const script = path.posix.join('/opt', 'offckb', 'build', 'index.js');
+    expect(commandLineRunsScript(`${POSIX_NODE} ${script} node`, script, 'linux')).toBe(true);
+  });
+});

tests/daemon-locale.test.ts

@@ -153,4 +153,57 @@ describe('daemon locale and process probing', () => {
     const verified = await verifyDaemonIdentity(12345, metadata);
     expect(verified).toBe(false);
   });
+
+  it('verifies a daemon whose CLI path contains spaces (unquoted ps -o args= output)', async () => {
+    // Use a temporary absolute path with a space as the CLI entry so the
+    // live OFFCKB_CLI_PATH matches the command line we feed the probe.
+    const fs = require('fs') as typeof import('fs');
+    const path = require('path') as typeof import('path');
+    const os = require('os') as typeof import('os');
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'offckb spaced-'));
+    const script = path.join(dir, 'index.js');
+    fs.writeFileSync(script, '');
+    process.env.OFFCKB_CLI_PATH = script;
+    const startedAt = new Date(2026, 7, 13, 12, 36, 26);
+
+    mockExecFile.mockImplementation((file: string, args: string[], options: any, callback?: any) => {
+      const cb = typeof options === 'function' ? options : callback;
+      if (file === 'ps') {
+        if (args.includes('args=')) {
+          // ps never quotes: the space in the script path is a bare space.
+          cb(null, `${process.execPath} ${script} node --daemon`, '');
+          return;
+        }
+        if (args.includes('lstart=')) {
+          cb(null, 'Wed Aug 13 12:36:26 2026', '');
+          return;
+        }
+      }
+      cb(new Error(`Unexpected command: ${file}`), '', '');
+    });
+
+    const metadata: PidMetadata = {
+      pid: 12345,
+      scriptPath: script,
+      startedAt: startedAt.toISOString(),
+    };
+    expect(await verifyDaemonIdentity(12345, metadata)).toBe(true);
+
+    // A foreign script under a sibling spaced directory must not match.
+    mockExecFile.mockImplementation((file: string, args: string[], options: any, callback?: any) => {
+      const cb = typeof options === 'function' ? options : callback;
+      if (file === 'ps' && args.includes('args=')) {
+        cb(null, `${process.execPath} ${script}-other node --daemon`, '');
+        return;
+      }
+      if (file === 'ps' && args.includes('lstart=')) {
+        cb(null, 'Wed Aug 13 12:36:26 2026', '');
+        return;
+      }
+      cb(new Error(`Unexpected command: ${file}`), '', '');
+    });
+    expect(await verifyDaemonIdentity(12345, metadata)).toBe(false);
+
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
 });

tests/node-command.test.ts

@@ -14,6 +14,14 @@ const mockStatSync = jest.fn();
 const mockCloseSync = jest.fn();
 const mockWaitForNodeReady = jest.fn();
 
+// The stale-miner reaper lists real OS processes (PowerShell CIM on Windows,
+// which alone can take seconds); it has its own tests, so keep it out of
+// these command-flow unit tests.
+jest.mock('../src/devnet/stale-miner', () => ({
+  ...jest.requireActual('../src/devnet/stale-miner'),
+  reapStaleMiners: jest.fn().mockResolvedValue([]),
+}));
+
 jest.mock('child_process', () => ({
   ...jest.requireActual('child_process'),
   spawn: (...args: unknown[]) => mockSpawn(...args),

tests/node-quiet-mode.test.ts

@@ -8,6 +8,14 @@ const mockTcpListenAddress = jest.fn();
 const loggerInfo = jest.fn();
 const loggerWarn = jest.fn();
 
+// The stale-miner reaper lists real OS processes (PowerShell CIM on Windows,
+// which alone can take seconds); it has its own tests, so keep it out of
+// these command-flow unit tests.
+jest.mock('../src/devnet/stale-miner', () => ({
+  ...jest.requireActual('../src/devnet/stale-miner'),
+  reapStaleMiners: jest.fn().mockResolvedValue([]),
+}));
+
 jest.mock('child_process', () => ({
   ...jest.requireActual('child_process'),
   spawn: (...args: unknown[]) => mockSpawn(...args),

tests/node-terminal-rpc.test.ts

@@ -9,6 +9,14 @@ const mockInitChainIfNeeded = jest.fn();
 const mockDevnetConfigHasTerminalRpc = jest.fn();
 const mockWaitForNodeReady = jest.fn();
 
+// The stale-miner reaper lists real OS processes (PowerShell CIM on Windows,
+// which alone can take seconds); it has its own tests, so keep it out of
+// these command-flow unit tests.
+jest.mock('../src/devnet/stale-miner', () => ({
+  ...jest.requireActual('../src/devnet/stale-miner'),
+  reapStaleMiners: jest.fn().mockResolvedValue([]),
+}));
+
 jest.mock('child_process', () => ({
   ...jest.requireActual('child_process'),
   spawn: (...args: unknown[]) => mockSpawn(...args),