start-command 0.36.0 → 0.37.1

package/test/regression-198.js

@@ -0,0 +1,281 @@
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+const { resumeExecution } = require('../src/lib/execution-resume');
+const { recoverKilledExecution } = require('../src/lib/execution-recovery');
+const { SessionState } = require('../src/lib/session-probe');
+const {
+  buildDetachedDockerCompletionScript,
+  DOCKER_CONTAINER_CLEANUP_POLICY,
+} = require('../src/lib/docker-cleanup');
+
+function fixture(options = {}) {
+  let current = {
+    uuid: 'issue-198-uuid',
+    command: 'original',
+    status: 'executed',
+    exitCode: 137,
+    options: {
+      isolated: 'docker',
+      isolationMode: 'detached',
+      sessionName: 'box',
+      containerId: 'same-id',
+      ...options,
+    },
+  };
+  const store = {
+    get: () => globalThis.structuredClone(current),
+    save: (r) => {
+      current = globalThis.structuredClone(r);
+    },
+  };
+  return { store, current: () => current };
+}
+
+function mockDocker(calls, scripts = []) {
+  return (_bin, args) => {
+    calls.push(args);
+    if (args[0] === 'cp') {
+      scripts.push(fs.readFileSync(args[1], 'utf8'));
+    }
+    return {
+      success: true,
+      stdout:
+        args[0] === 'info'
+          ? JSON.stringify({ DockerRootDir: '/docker' })
+          : args.includes('--size')
+            ? '1024'
+            : args.includes('{{.State.Running}}')
+              ? 'true'
+              : args.includes('{{json .HostConfig}}')
+                ? '{}'
+                : args[0] === 'run'
+                  ? 'new-container-id'
+                  : '',
+      status: 0,
+    };
+  };
+}
+
+const stopped = () => ({ state: SessionState.STOPPED, alive: false });
+
+test('replacement command resumes the same container without a snapshot or changed ID', async () => {
+  const { store, current } = fixture({ commandHandoff: true });
+  const calls = [],
+    scripts = [];
+  const result = await resumeExecution(store, 'box', {
+    command: "printf '%s' 'new $command'",
+    probe: stopped,
+    runner: mockDocker(calls, scripts),
+    startWatcher: () => true,
+  });
+  assert.equal(result.success, true, result.error);
+  assert.ok(calls.some((args) => args[0] === 'cp'));
+  assert.ok(calls.some((args) => args[0] === 'start'));
+  assert.ok(
+    !calls.some((args) => ['commit', 'run', 'create'].includes(args[0]))
+  );
+  assert.equal(current().options.containerId, 'same-id');
+  assert.equal(current().options.sessionName, 'box');
+  assert.ok(scripts[0].includes('new $command'));
+});
+
+test('automatic recovery replaces a prior explicit handoff and exports its attempt', () => {
+  const { store } = fixture({
+    commandHandoff: true,
+    onKillResume: 1,
+    recoveryCommand: 'printf recovered',
+  });
+  const scripts = [];
+  const result = recoverKilledExecution({
+    store,
+    executionId: 'issue-198-uuid',
+    exitCode: 137,
+    oomKilled: false,
+    runner: mockDocker([], scripts),
+    startWatcher: () => true,
+  });
+  assert.equal(result.recovered, true, result.reason);
+  assert.ok(scripts[0].includes('START_COMMAND_RECOVERY_ATTEMPT=1'));
+  assert.ok(scripts[0].includes('printf recovered'));
+});
+
+test('legacy snapshots preflight before commit and remove originals only with non-forced rm after start', async () => {
+  const { store, current } = fixture();
+  const calls = [];
+  const result = await resumeExecution(store, 'box', {
+    command: 'new',
+    probe: stopped,
+    removeOriginal: true,
+    runner: mockDocker(calls),
+    snapshotOptions: { freeBytes: () => 100 * 1024 ** 3 },
+    startWatcher: () => true,
+  });
+  assert.equal(result.success, true, result.error);
+  assert.ok(
+    calls.findIndex((a) => a.includes('--size')) <
+      calls.findIndex((a) => a[0] === 'commit')
+  );
+  assert.ok(
+    calls.findIndex((a) => a[0] === 'run') <
+      calls.findIndex((a) => a[0] === 'rm')
+  );
+  assert.deepEqual(
+    calls.find((a) => a[0] === 'rm'),
+    ['rm', 'box']
+  );
+  assert.equal(current().options.commandHandoff, true);
+  assert.equal(current().options.snapshotImage, 'start-command-resume/box:1');
+  assert.match(result.output, /snapshotting/);
+});
+
+test('disk shortage rolls back the reservation without committing or removing the original', async () => {
+  const { store, current } = fixture();
+  const calls = [];
+  const result = await resumeExecution(store, 'box', {
+    command: 'new',
+    probe: stopped,
+    removeOriginal: true,
+    runner: mockDocker(calls),
+    snapshotOptions: { freeBytes: () => 0 },
+    startWatcher: () => true,
+  });
+  assert.equal(result.success, false);
+  assert.match(result.error, /Insufficient disk/);
+  assert.ok(!calls.some((a) => ['commit', 'rm', 'rmi'].includes(a[0])));
+  assert.equal(current().options.sessionName, 'box');
+  assert.equal(current().options.launchPending, undefined);
+});
+
+test('snapshot failure removes a completed image and restores the original execution', async () => {
+  const { store, current } = fixture();
+  const calls = [];
+  const base = mockDocker(calls);
+  const result = await resumeExecution(store, 'box', {
+    command: 'new',
+    probe: stopped,
+    runner: (bin, args) =>
+      args[0] === 'run'
+        ? { success: false, stderr: 'launch failed' }
+        : base(bin, args),
+    snapshotOptions: { freeBytes: () => 100 * 1024 ** 3 },
+    startWatcher: () => true,
+  });
+  assert.equal(result.success, false);
+  assert.ok(
+    calls.some((a) => a[0] === 'rmi' && a[1] === 'start-command-resume/box:1')
+  );
+  assert.equal(current().options.sessionName, 'box');
+});
+
+test('watcher removes its generated image after the cleanup policy removes its container', () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'cleanup-198-'));
+  const watcher = path.join(dir, 'watcher.sh');
+  const events = path.join(dir, 'events');
+  try {
+    fs.writeFileSync(
+      watcher,
+      `#!/bin/sh
+docker() {
+case "$1" in
+  wait) echo 0 ;;
+  inspect) case "$3" in
+    *State.Running*) echo false ;;
+    *State.ExitCode*) echo '0 false 2026-10-10T00:00:00Z 2026-10-10T00:00:01Z' ;;
+    *snapshot-image*) echo 'start-command-resume/box:1' ;;
+    *) echo '' ;;
+  esac ;;
+  rm|rmi) printf '%s\\n' "$*" >> events ;;
+esac
+}
+${buildDetachedDockerCompletionScript(
+  'box-resume-1',
+  DOCKER_CONTAINER_CLEANUP_POLICY.ALWAYS,
+  null
+)}
+`
+    );
+    // Keep POSIX quoting inside a file, out of Windows process argv/PATH.
+    const result = spawnSync('sh', ['watcher.sh'], {
+      cwd: dir,
+      encoding: 'utf8',
+    });
+    assert.equal(result.status, 0, result.stderr);
+    assert.deepEqual(fs.readFileSync(events, 'utf8').trim().split('\n'), [
+      'rm -f box-resume-1',
+      'rmi start-command-resume/box:1',
+    ]);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('changed caller labels use a guarded snapshot and reapply merged labels', async () => {
+  const { store, current } = fixture({
+    commandHandoff: true,
+    labels: ['role=old', 'team=runtime'],
+  });
+  const calls = [];
+  const result = await resumeExecution(store, 'box', {
+    probe: stopped,
+    resourceOptions: { labels: ['role=new'] },
+    runner: mockDocker(calls),
+    snapshotOptions: { freeBytes: () => 100 * 1024 ** 3 },
+    startWatcher: () => true,
+  });
+  assert.equal(result.success, true, result.error);
+  const run = calls.find((args) => args[0] === 'run');
+  assert.ok(run.includes('role=new'));
+  assert.ok(run.includes('team=runtime'));
+  assert.ok(!run.includes('role=old'));
+  assert.ok(calls.some((args) => args[0] === 'commit'));
+  assert.deepEqual(current().options.labels, ['role=new', 'team=runtime']);
+  assert.equal(current().options.commandHandoff, true);
+});
+
+test('original retained by default and when a successor has already stopped', async () => {
+  for (const removeOriginal of [false, true]) {
+    const { store } = fixture();
+    const calls = [];
+    const base = mockDocker(calls);
+    const result = await resumeExecution(store, 'box', {
+      command: 'new',
+      probe: stopped,
+      removeOriginal,
+      runner: (bin, args) =>
+        args.includes('{{.State.Running}}')
+          ? { success: true, stdout: 'false' }
+          : base(bin, args),
+      snapshotOptions: { freeBytes: () => 100 * 1024 ** 3 },
+      startWatcher: () => true,
+    });
+    assert.equal(result.success, true, result.error);
+    assert.ok(!calls.some((args) => args[0] === 'rm'));
+  }
+});
+
+test('repeated snapshot successors retain the original root-session attribution', async () => {
+  const { store, current } = fixture();
+  for (const role of ['first', 'second']) {
+    const calls = [];
+    const result = await resumeExecution(store, 'box', {
+      command: 'new',
+      probe: stopped,
+      resourceOptions: { labels: [`role=${role}`] },
+      runner: mockDocker(calls),
+      snapshotOptions: { freeBytes: () => 100 * 1024 ** 3 },
+      startWatcher: () => true,
+    });
+    assert.equal(result.success, true, result.error);
+    assert.ok(
+      calls
+        .find((args) => args[0] === 'run')
+        .includes('start-command.root-session=box')
+    );
+    assert.equal(current().options.rootSession, 'box');
+  }
+  assert.equal(current().options.resumeCount, 2);
+});

package/test/regression-199.js

@@ -0,0 +1,79 @@
+const { describe, it, expect } = require('bun:test');
+const { parseArgs } = require('../src/lib/args-parser');
+const {
+  buildDockerRuntimeArgs,
+  buildDockerRuntimeMetadata,
+} = require('../src/lib/docker-runtime-args');
+const { buildNextLevelCommand } = require('../src/lib/command-builder');
+
+describe('Docker attribution labels (#199)', () => {
+  it('attributes replacement containers to their stable root and execution', () => {
+    const { dockerLabels } = require('../src/lib/docker-labels');
+    expect(
+      dockerLabels({ session: 'demo-resume-1', sessionId: 'uuid' })
+    ).toContain('start-command.root-session=demo-resume-1');
+    expect(
+      dockerLabels({
+        session: 'demo-resume-1-resume-2',
+        sessionId: 'uuid',
+        resumeCount: 2,
+      })
+    ).toEqual([
+      'start-command.session=demo-resume-1-resume-2',
+      'start-command.root-session=demo',
+      'start-command.resume-count=2',
+      'start-command.uuid=uuid',
+    ]);
+  });
+  it('parses repeated labels and preserves equals signs and empty values', () => {
+    const { wrapperOptions } = parseArgs([
+      '-i',
+      'docker',
+      '--label',
+      'hive-mind.tool=codex',
+      '--label=task.url=https://github.com/o/r/issues/1?q=a=b',
+      '--label',
+      'empty=',
+      '--',
+      'echo',
+    ]);
+    expect(wrapperOptions.labels).toEqual([
+      'hive-mind.tool=codex',
+      'task.url=https://github.com/o/r/issues/1?q=a=b',
+      'empty=',
+    ]);
+    const args = buildDockerRuntimeArgs(wrapperOptions);
+    for (const label of wrapperOptions.labels) {
+      expect(args).toContain(label);
+    }
+    expect(buildDockerRuntimeMetadata(wrapperOptions).labels).toEqual(
+      wrapperOptions.labels
+    );
+  });
+  it('rejects malformed, reserved and non-Docker labels', () => {
+    for (const label of [
+      'missing-value',
+      '=empty-key',
+      'start-command.uuid=spoof',
+    ]) {
+      expect(() =>
+        parseArgs(['-i', 'docker', '--label', label, '--', 'true'])
+      ).toThrow();
+    }
+    expect(() => parseArgs(['--label', 'task=one', '--', 'true'])).toThrow();
+  });
+  it('forwards labels safely through nested Docker isolation', () => {
+    const command = buildNextLevelCommand(
+      {
+        isolatedStack: ['screen', 'docker'],
+        labels: ['task=a "quote" $value'],
+      },
+      'true'
+    );
+    expect(
+      parseArgs(
+        require('../src/lib/shell-utils').splitShellWords(command).slice(1)
+      ).wrapperOptions.labels
+    ).toEqual(['task=a "quote" $value']);
+  });
+});

package/test/regression-201.js

@@ -0,0 +1,25 @@
+const { describe, it, expect } = require('bun:test');
+const { spawnSync } = require('child_process');
+const path = require('path');
+const { parseArgs } = require('../src/lib/args-parser');
+
+describe('wrapper help (#201)', () => {
+  for (const flag of ['--help', '-h']) {
+    it(`${flag} prints the no-argument usage and exits successfully`, () => {
+      const cli = path.join(__dirname, '../src/bin/cli.js');
+      const usage = spawnSync(process.execPath, [cli], { encoding: 'utf8' });
+      const result = spawnSync(process.execPath, [cli, flag], {
+        encoding: 'utf8',
+      });
+      expect(result.status).toBe(0);
+      expect(result.stderr).toBe('');
+      expect(result.stdout).toBe(usage.stdout);
+      expect(parseArgs([flag]).wrapperOptions.help).toBe(true);
+    });
+    it(`${flag} after the separator remains part of the command`, () => {
+      const result = parseArgs(['--', 'grep', flag]);
+      expect(result.wrapperOptions.help).toBe(false);
+      expect(result.rawCommand).toEqual(['grep', flag]);
+    });
+  }
+});

package/test/regression-202.js

@@ -0,0 +1,92 @@
+const { describe, it, expect } = require('bun:test');
+const { spawnSync } = require('child_process');
+const {
+  isInteractiveShellCommand,
+  isShellInvocationWithArgs,
+  buildShellWithArgsCmdArgs,
+  buildDisplayCommand,
+} = require('../src/lib/shell-utils');
+
+describe('shell command semantics (#202)', () => {
+  for (const operator of [';', '&&', '||', '|', '&', '>', '<', '\n']) {
+    it(`keeps the whole command line when it contains ${JSON.stringify(operator)}`, () => {
+      const command = `sh -c 'exit 7'${operator} echo after $?`;
+      expect(isShellInvocationWithArgs(command)).toBe(false);
+      expect(buildDisplayCommand(command)).toBe(command);
+      expect(isInteractiveShellCommand(`sh ${operator} echo after`)).toBe(
+        false
+      );
+    });
+  }
+  it('preserves the script, empty positional argv, quotes, and quoted operators', () => {
+    const command = `sh -c 'printf "%s\\n" "$0" "$1" "$2"; echo "|"' a 'b c' ''`;
+    expect(isShellInvocationWithArgs(command)).toBe(true);
+    expect(buildShellWithArgsCmdArgs(command)).toEqual([
+      'sh',
+      '-c',
+      'printf "%s\\n" "$0" "$1" "$2"; echo "|"',
+      'a',
+      'b c',
+      '',
+    ]);
+  });
+  it('does not classify a missing script or a script-file argument as -c', () => {
+    expect(isShellInvocationWithArgs('sh -c')).toBe(false);
+    expect(isShellInvocationWithArgs("sh file -c 'echo hi'")).toBe(false);
+  });
+  it('retains direct bash -i -c behavior from #91', () => {
+    expect(buildShellWithArgsCmdArgs('bash -i -c "nvm --version"')).toEqual([
+      'bash',
+      '-i',
+      '-c',
+      'nvm --version',
+    ]);
+  });
+  it('leaves outer expansions, comments and globbing to the shell', () => {
+    for (const command of [
+      'sh -c "echo $$"',
+      'sh -c echo $HOME',
+      'sh -c echo *',
+      'sh -c echo # comment',
+      'sh -c echo {a,b}',
+      "sh -c 'echo hi'\u00a0arg",
+      'sh -c echo \\\nhi',
+    ]) {
+      expect(isShellInvocationWithArgs(command)).toBe(false);
+    }
+  });
+  it('preserves literal escapes within a directly executed script', () => {
+    expect(buildShellWithArgsCmdArgs('sh -c "printf \\q"')).toEqual([
+      'sh',
+      '-c',
+      'printf \\q',
+    ]);
+    expect(buildShellWithArgsCmdArgs('sh -c "echo \\$0" a')).toEqual([
+      'sh',
+      '-c',
+      'echo $0',
+      'a',
+    ]);
+    expect(buildShellWithArgsCmdArgs('sh -c echo a\\;b')).toEqual([
+      'sh',
+      '-c',
+      'echo',
+      'a;b',
+    ]);
+  });
+  const run = process.platform === 'win32' ? it.skip : it;
+  for (const [command, output, status] of [
+    ["sh -c 'exit 7'; echo after $?", 'after 7', 0],
+    ["sh -c 'echo $0 $1' a b", 'a b', 0],
+    ["sh -c 'kill -9 $$'; exit $?", '', 137],
+  ]) {
+    run(`executes ${command} with the expected output and exit`, () => {
+      const args = isShellInvocationWithArgs(command)
+        ? buildShellWithArgsCmdArgs(command)
+        : ['sh', '-c', command];
+      const result = spawnSync(args[0], args.slice(1), { encoding: 'utf8' });
+      expect(result.stdout.trim()).toBe(output);
+      expect(result.status).toBe(status);
+    });
+  }
+});