start-command 0.36.0 → 0.37.0

package/src/lib/log-uploader.js

@@ -6,6 +6,7 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const { spawnSync } = require('child_process');
+const { sanitizeLogToTemp } = require('./log-sanitizer');
 
 function isExecutable(filePath) {
   try {
@@ -135,7 +136,7 @@ function ensureGhUploadLogAvailable() {
   };
 }
 
-function uploadLogPath(logPath) {
+function uploadLogPath(logPath, options = {}) {
   if (!logPath) {
     return {
       success: false,
@@ -146,29 +147,47 @@ function uploadLogPath(logPath) {
     return { success: false, error: `Log file not found: ${logPath}` };
   }
 
-  const availability = ensureGhUploadLogAvailable();
-  if (!availability.success) {
-    return availability;
-  }
-
-  const result = runCommand(availability.command, [logPath], {
-    stdio: 'inherit',
-  });
-
-  const exitCode =
-    result.status !== null && result.status !== undefined ? result.status : 1;
-  if (exitCode !== 0) {
+  let prepared;
+  try {
+    if (!options.noSanitize) {
+      // Wrapper options.env holds Docker arguments, not the process secrets.
+      prepared = sanitizeLogToTemp(logPath, { verbose: options.verbose });
+    }
+    const availability = ensureGhUploadLogAvailable();
+    if (!availability.success) {
+      return availability;
+    }
+    const result = runCommand(
+      availability.command,
+      [prepared ? prepared.path : logPath, '--private'],
+      {
+        stdio: 'inherit',
+      }
+    );
+    const exitCode =
+      result.status !== null && result.status !== undefined ? result.status : 1;
+    if (exitCode !== 0) {
+      return {
+        success: false,
+        exitCode,
+        error: `gh-upload-log exited with code ${exitCode}`,
+      };
+    }
+    return { success: true, exitCode: 0 };
+  } catch {
     return {
       success: false,
-      exitCode,
-      error: `gh-upload-log exited with code ${exitCode}`,
+      exitCode: 1,
+      error: 'Log preparation or upload failed; upload blocked.',
     };
+  } finally {
+    if (prepared) {
+      prepared.cleanup();
+    }
   }
-
-  return { success: true, exitCode: 0 };
 }
 
-function uploadExecutionLog(store, identifier) {
+function uploadExecutionLog(store, identifier, options = {}) {
   if (!store) {
     return { success: false, error: 'Execution tracking is disabled.' };
   }
@@ -181,7 +200,7 @@ function uploadExecutionLog(store, identifier) {
     };
   }
 
-  return uploadLogPath(record.logPath);
+  return uploadLogPath(record.logPath, options);
 }
 
 module.exports = {

package/src/lib/query-commands.js

@@ -38,8 +38,8 @@ function handleListQuery(store, outputFormat, options = {}) {
   return reportResult(listExecutions(store, outputFormat, options));
 }
 
-function handleUploadLogQuery(store, identifier) {
-  const result = uploadExecutionLog(store, identifier);
+function handleUploadLogQuery(store, identifier, options = {}) {
+  const result = uploadExecutionLog(store, identifier, options);
   if (result.success) {
     return result.exitCode || 0;
   }
@@ -67,6 +67,7 @@ async function handleResumeQuery(
       command,
       outputFormat,
       resourceOptions,
+      removeOriginal: resourceOptions.removeOriginal === true,
     })
   );
 }
@@ -164,7 +165,7 @@ async function dispatchQueryCommand(options, context = {}) {
     return handleListQuery(store, outputFormat, { running: options.running });
   }
   if (hasValue(options.uploadLog)) {
-    return handleUploadLogQuery(store, options.uploadLog);
+    return handleUploadLogQuery(store, options.uploadLog, options);
   }
   if (hasValue(options.stop)) {
     return handleControlQuery(store, options.stop, ControlAction.STOP);

package/src/lib/shell-utils.js

@@ -86,6 +86,10 @@ function splitShellWords(command, style = defaultShellQuotingStyle()) {
       if (i + 1 >= command.length) {
         return null;
       }
+      if (quote === '"' && !'$`"\\\n'.includes(command[i + 1])) {
+        current += char;
+        continue;
+      }
       current += command[++i];
       continue;
     }
@@ -121,10 +125,69 @@ function toShellWords(command) {
   );
 }
 
+/**
+ * Return literal argv only when no outer shell evaluation is needed. Operators,
+ * expansions and comments belong to the outer command line, not the -c script.
+ * Single quotes protect their contents; double quotes still permit expansion.
+ */
+function simpleShellWords(command) {
+  let quote = null;
+  for (let i = 0; i < command.length; i++) {
+    const char = command[i];
+    if (char === '\\' && quote !== "'") {
+      if (command[i + 1] === '\n') {
+        return null;
+      }
+      if (quote !== '"' || '$`"\\\n'.includes(command[i + 1])) {
+        i++;
+      }
+      continue;
+    }
+    if (quote === "'") {
+      if (char === "'") {
+        quote = null;
+      }
+      continue;
+    }
+    if (char === '$' || char === '`') {
+      return null;
+    }
+    if (quote === '"') {
+      if (char === '"') {
+        quote = null;
+      }
+      continue;
+    }
+    if (';&|<>(){}\n\r*?[]~#'.includes(char)) {
+      return null;
+    }
+    if (/\s/.test(char) && !' \t'.includes(char)) {
+      return null;
+    }
+    if (char === "'" || char === '"') {
+      quote = char;
+    }
+  }
+  return splitShellWords(command, 'posix');
+}
+
+function shellScriptIndex(parts) {
+  if (!parts || !SHELL_NAMES.includes(path.basename(parts[0] || ''))) {
+    return -1;
+  }
+  const index = parts.indexOf('-c');
+  return index > 0 &&
+    index + 1 < parts.length &&
+    parts.slice(1, index).every((part) => /^--?[a-zA-Z][a-zA-Z-]*$/.test(part))
+    ? index
+    : -1;
+}
+
 /** True if command is a bare shell invocation (no -c); avoids bash-inside-bash (issue #84). */
 function isInteractiveShellCommand(command) {
-  const parts = toShellWords(command);
+  const parts = simpleShellWords(command);
   return (
+    parts !== null &&
     parts.length > 0 &&
     SHELL_NAMES.includes(path.basename(parts[0])) &&
     !parts.includes('-c')
@@ -133,25 +196,12 @@ function isInteractiveShellCommand(command) {
 
 /** True if command is a shell invocation with -c (e.g. `bash -i -c "cmd"`); avoids double-wrapping (issue #91). */
 function isShellInvocationWithArgs(command) {
-  const parts = toShellWords(command);
-  return (
-    parts.length > 0 &&
-    SHELL_NAMES.includes(path.basename(parts[0])) &&
-    parts.includes('-c')
-  );
+  return shellScriptIndex(simpleShellWords(command)) !== -1;
 }
 
-/** Build argv for shell-with-c command; everything after -c is one script argument. */
+/** Preserve the script word and every positional argument as separate argv. */
 function buildShellWithArgsCmdArgs(command) {
-  const parts = toShellWords(command);
-  const cIdx = parts.indexOf('-c');
-  if (cIdx === -1) {
-    return parts;
-  }
-  const scriptArg = parts.slice(cIdx + 1).join(' ');
-  return scriptArg.length > 0
-    ? [...parts.slice(0, cIdx + 1), scriptArg]
-    : parts.slice(0, cIdx + 1);
+  return simpleShellWords(command) || toShellWords(command);
 }
 
 /** Quote an argument for display only, keeping the user-facing double-quoted form (issue #91). */

package/src/lib/usage.js

@@ -3,6 +3,7 @@ function printUsage() {
   console.log(`Usage: $ [options] [--] <command> | $ --status <uuid> [--output-format <fmt>] | $ --list [--running] [--output-format <fmt>] | $ --upload-log <id> | $ --stop <id> | $ --terminate <id> | $ --attach <id> [--read-only] | $ --resume <id> [-- <command>] | $ --resume-all
 
 Options:
+  --help, -h           Show this usage and exit successfully
   --isolated, --isolation, -i <env>  Run in isolated environment (screen, tmux, docker, ssh)
   --attached, -a        Run in attached mode (foreground)
   --detached, -d        Run in detached mode (background)
@@ -13,6 +14,7 @@ Options:
   --volume, -v <spec>   Docker bind mount/volume host:container[:mode] (repeatable, docker only)
   --mount <spec>        Docker --mount spec (repeatable, docker only)
   --env, -e <KEY=VALUE> Environment variable for docker container (repeatable, docker only)
+  --label <KEY=VALUE>   Container attribution (repeatable, docker only; start-command.* reserved)
   --privileged          Run docker container in privileged mode (docker only)
   --network <name>      Connect to a named network (repeatable, docker only)
   --network-alias <alias> Add alias to the first network (repeatable, docker only)
@@ -43,13 +45,15 @@ Options:
   --status <id>         Show status of execution by UUID or session name (--output-format: links-notation|json|text)
   --list                List all tracked executions (--output-format: links-notation|json|text)
   --running             With --list, only report executions that are still running
-  --upload-log <id>     Upload the stored log for an execution UUID or session name
+  --upload-log <id>     Upload a sanitized copy of the stored log privately
+  --no-sanitize        With --upload-log, explicitly upload without secret redaction
   --stop <id>           Ask a detached isolated execution to stop gracefully
   --terminate <id>      Terminate a detached isolated execution immediately
   --attach <id>         Attach to a running detached isolated execution
   --read-only           With --attach, follow output without sending input
   --resume <id>         Restart a stopped detached execution in the same environment
                         (append -- <command> to run a different command there)
+  --remove-original    With legacy snapshot resume, remove the stopped original after launch
   --resume-all          Re-attach or reconcile every execution still marked running
   --cleanup             Clean up stale "executing" records (crashed/killed processes)
   --cleanup-dry-run     Show stale records that would be cleaned up (without cleaning)

package/test/ci-workflow-invariants.js

@@ -156,6 +156,10 @@ describe('CI workflow invariants', () => {
   it('gives every job a timeout', () => {
     for (const name of workflows) {
       for (const job of parseJobs(readWorkflow(name))) {
+        if (jobKey(job.body, 'uses')) {
+          // Reusable-workflow callers cannot declare a timeout; their jobs do.
+          continue;
+        }
         assert.ok(
           jobKey(job.body, 'timeout-minutes'),
           `${name}: job "${job.name}" has no timeout-minutes`
@@ -186,7 +190,7 @@ describe('CI workflow invariants', () => {
     }
   });
 
-  it('makes writers non-cancellable and read-only checks cancellable', () => {
+  it('protects main and the gated Rust stage from cancellation', () => {
     for (const name of workflows) {
       for (const job of parseJobs(readWorkflow(name))) {
         const group = concurrencyKey(job.body, 'group');
@@ -212,8 +216,10 @@ describe('CI workflow invariants', () => {
           );
           assert.strictEqual(
             cancel,
-            'true',
-            `${name}: superseded check "${job.name}" should be cancelled`
+            name === 'rust.yml' || job.name === 'rust-stage'
+              ? 'false'
+              : "${{ github.ref != 'refs/heads/main' }}",
+            `${name}: checks must preserve main and the gated Rust stage`
           );
         }
       }
@@ -223,7 +229,7 @@ describe('CI workflow invariants', () => {
   it('uses !cancelled() rather than always() outside the status job', () => {
     for (const name of workflows) {
       for (const job of parseJobs(readWorkflow(name))) {
-        if (job.name === 'pipeline-status') {
+        if (job.name === 'pipeline-status' || job.name === 'rust-stage') {
           continue;
         }
         assert.doesNotMatch(
@@ -246,7 +252,7 @@ describe('CI workflow invariants', () => {
         `${name}: pipeline-status must run even when jobs are cancelled`
       );
       for (const job of jobs) {
-        if (job.name === 'pipeline-status') {
+        if (job.name === 'pipeline-status' || job.name === 'rust-stage') {
           continue;
         }
         assert.match(
@@ -395,15 +401,10 @@ describe('CI workflow invariants', () => {
 
   it('audits both dependency graphs for advisories', () => {
     const security = readWorkflow('security.yml');
-    const jobs = parseJobs(security).map((job) => job.name);
-    for (const job of ['cargo-audit', 'npm-audit']) {
-      assert.ok(jobs.includes(job), `security.yml has no ${job} job`);
-    }
-    assert.match(
-      security,
-      /cargo audit/,
-      'cargo-audit job must run cargo audit'
-    );
+    const rust = readWorkflow('rust.yml');
+    assert.ok(parseJobs(security).some((job) => job.name === 'npm-audit'));
+    assert.ok(parseJobs(rust).some((job) => job.name === 'cargo-audit'));
+    assert.match(rust, /cargo audit/, 'cargo-audit job must run cargo audit');
     assert.match(security, /npm audit/, 'npm-audit job must run npm audit');
   });
 

package/test/docker-command-handoff.js

@@ -0,0 +1,107 @@
+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 {
+  buildCommandHandoffArgs,
+  buildCommandHandoffScript,
+  commandHandoffPath,
+  writeCommandHandoff,
+} = require('../src/lib/docker-command-handoff');
+const { buildResumePlan, ResumeMode } = require('../src/lib/execution-resume');
+const { SessionState } = require('../src/lib/session-probe');
+
+test('new stopped containers choose a copy-free command handoff', () => {
+  const plan = buildResumePlan(
+    {
+      uuid: 'uuid',
+      command: 'old-command',
+      options: {
+        isolated: 'docker',
+        isolationMode: 'detached',
+        sessionName: 'box',
+        commandHandoff: true,
+      },
+    },
+    'printf new-command',
+    { state: SessionState.STOPPED, alive: false }
+  );
+  assert.equal(plan.mode, ResumeMode.DOCKER_START);
+  assert.equal(plan.handoffCommand, 'printf new-command');
+  assert.deepEqual(
+    plan.steps.map((step) => step.args),
+    [['start', 'box']]
+  );
+  assert.equal(plan.snapshotImage, undefined);
+});
+
+test('handoff preserves argv and accepts a replacement without executing it on the host', () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'handoff-test-'));
+  const marker = path.join(dir, 'command');
+  try {
+    const args = buildCommandHandoffArgs(
+      ['sh', '-c', 'printf original'],
+      'command'
+    );
+    const shellOptions = { cwd: dir, encoding: 'utf8' };
+    assert.equal(
+      spawnSync(args[0], args.slice(1), shellOptions).stdout,
+      'original'
+    );
+    let script;
+    const copied = writeCommandHandoff(
+      'box',
+      "printf '%s' 'new $value'",
+      (_bin, argv) => {
+        assert.equal(argv[0], 'cp');
+        assert.equal(argv[2], `box:${commandHandoffPath('box')}`);
+        script = fs.readFileSync(argv[1], 'utf8');
+        fs.copyFileSync(argv[1], marker);
+        fs.accessSync(argv[1], fs.constants.R_OK);
+        // Windows chmod supports write permission, not Unix mode bits.
+        if (process.platform !== 'win32') {
+          assert.equal(fs.statSync(argv[1]).mode & 0o777, 0o644);
+        }
+        return { success: true };
+      },
+      { shell: 'sh' }
+    );
+    assert.equal(copied.success, true);
+    assert.ok(script.includes('new $value'));
+    assert.equal(
+      spawnSync(args[0], args.slice(1), shellOptions).stdout,
+      'new $value'
+    );
+    // docker start without another replacement runs the current stored command.
+    assert.equal(
+      spawnSync(args[0], args.slice(1), shellOptions).stdout,
+      'new $value'
+    );
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('handoff preserves direct shell positional argv and evaluates compound commands as scripts', () => {
+  for (const [command, expected] of [
+    ['sh -c \'printf "%s:%s" "$0" "$1"\' tag \'two words\'', 'tag:two words'],
+    ["sh -c 'exit 7'; printf 'after%s' \"$?\"", 'after7'],
+  ]) {
+    const script = buildCommandHandoffScript(command, { shell: 'sh' });
+    const result = spawnSync('sh', ['-c', script], { encoding: 'utf8' });
+    assert.equal(result.status, 0, result.stderr);
+    assert.equal(result.stdout, expected);
+  }
+});
+
+test('auto handoff chooses an installed shell inside the existing container', () => {
+  const script = buildCommandHandoffScript('printf auto');
+  assert.ok(
+    script.includes('command -v bash || command -v zsh || command -v sh')
+  );
+  const result = spawnSync('sh', ['-c', script], { encoding: 'utf8' });
+  assert.equal(result.status, 0, result.stderr);
+  assert.equal(result.stdout, 'auto');
+});

package/test/docker-runtime-options.js

@@ -300,6 +300,8 @@ describe('buildDockerRuntimeMetadata', () => {
       volumes: null,
       mounts: null,
       env: null,
+      labels: null,
+      commandHandoff: null,
       privileged: null,
       network: null,
       networks: null,
@@ -334,6 +336,8 @@ describe('buildDockerRuntimeMetadata', () => {
         networks: ['hive-formal-ai', 'public-egress'],
         networkAliases: ['formal-ai', 'checker'],
         resourceLimits: null,
+        labels: null,
+        commandHandoff: null,
         resolvedLimits: null,
         resourceLimitSpecs: null,
         onKillResumeMemory: null,

package/test/docker-snapshot-safety.js

@@ -0,0 +1,106 @@
+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 {
+  preflightSnapshot,
+  acquireSnapshotLock,
+  containerdRoot,
+} = require('../src/lib/docker-snapshot-safety');
+
+const GiB = 1024 ** 3;
+function runner(size, containerd = false) {
+  return (_bin, args) => ({
+    success: true,
+    stdout:
+      args[0] === 'info'
+        ? JSON.stringify({
+            DockerRootDir: '/docker',
+            DriverStatus: containerd
+              ? [['driver-type', 'io.containerd.snapshotter.v1']]
+              : [],
+          })
+        : String(size),
+  });
+}
+
+test('preflight refuses insufficient space before any snapshot', () => {
+  assert.throws(
+    () =>
+      preflightSnapshot('box', runner(12 * GiB), {
+        freeBytes: () => 20 * GiB,
+      }),
+    /Insufficient disk.*34\.00 GiB/
+  );
+});
+
+test('containerd image store checks Docker and containerd filesystems separately', () => {
+  const checked = [];
+  assert.throws(
+    () =>
+      preflightSnapshot('box', runner(8 * GiB, true), {
+        containerdRoot: '/containerd',
+        freeBytes: (root) => {
+          checked.push(root);
+          return root === '/docker' ? 100 * GiB : 25 * GiB;
+        },
+      }),
+    /\/containerd/
+  );
+  assert.deepEqual(checked, ['/docker', '/containerd']);
+});
+
+test('preflight logs the layer size and rejects unknown sizes or roots', () => {
+  assert.match(
+    preflightSnapshot('box', runner(GiB), { freeBytes: () => 100 * GiB })
+      .message,
+    /snapshotting 1\.00 GiB/
+  );
+  assert.throws(
+    () => preflightSnapshot('box', runner('unknown')),
+    /writable layer/
+  );
+  assert.equal(
+    containerdRoot('version = 2\nroot = "/custom"\n[plugins]\nroot = "/wrong"'),
+    '/custom'
+  );
+});
+
+test('snapshot lock is separate from store locks and excludes concurrent processes', () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'snapshot-lock-'));
+  const lockPath = path.join(dir, 'snapshot.lock');
+  try {
+    const lock = acquireSnapshotLock({ lockPath });
+    assert.throws(
+      () => acquireSnapshotLock({ lockPath }),
+      /snapshot.*in progress/
+    );
+    const child = spawnSync(
+      process.execPath,
+      [
+        '-e',
+        `
+      try {
+        require(${JSON.stringify(require.resolve('../src/lib/docker-snapshot-safety'))}).acquireSnapshotLock();
+        process.exitCode = 3;
+      } catch (error) {
+        console.log(error.message);
+        process.exitCode = 2;
+      }
+    `,
+      ],
+      {
+        encoding: 'utf8',
+        env: { ...process.env, START_SNAPSHOT_LOCK: lockPath },
+      }
+    );
+    assert.equal(child.status, 2, child.stderr);
+    assert.match(child.stdout, /snapshot.*in progress/);
+    lock.release();
+    acquireSnapshotLock({ lockPath }).release();
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});

package/test/execution-resume.js

@@ -101,12 +101,8 @@ describe('buildResumePlan', () => {
       '--name',
       'box-resume-1',
     ]);
-    assert.deepStrictEqual(runArgs.slice(-4), [
-      'start-command-resume/box:1',
-      'sh',
-      '-c',
-      'npm run build',
-    ]);
+    assert.ok(runArgs.includes('start-command-resume/box:1'));
+    assert.deepStrictEqual(runArgs.slice(-3), ['sh', '-c', 'npm run build']);
   });
 
   test('carries stored docker runtime options into the snapshot run', () => {
@@ -289,9 +285,15 @@ describe('resumeExecution', () => {
     const result = await resumeExecution(store, 'box', {
       command: 'npm run build',
       probe: () => probeWith(SessionState.STOPPED, 'exited'),
-      runner: () => ({
+      snapshotOptions: { freeBytes: () => 100 * 1024 ** 3 },
+      runner: (_bin, args) => ({
         success: true,
-        stdout: 'deadbeef\n',
+        stdout:
+          args[0] === 'info'
+            ? JSON.stringify({ DockerRootDir: '/docker' })
+            : args.includes('--size')
+              ? '1024'
+              : 'deadbeef\n',
         stderr: '',
         status: 0,
       }),

package/test/failure-handler.js

@@ -175,6 +175,17 @@ describe('failure-handler', () => {
       assert.ok(!body.includes('\\"'), 'body must not contain escaped quotes');
     });
 
+    it('sanitizes credentials in the issue title and body', () => {
+      if (process.platform === 'win32') {
+        return;
+      }
+      const token = `gh${'p_'}${'a'.repeat(36)}`;
+      const { argv } = createIssueWithFakeGh(`echo ${token}`);
+      assert.ok(!argv[5].includes(token));
+      assert.ok(!argv[7].includes(token));
+      assert.ok(argv[7].includes('[REDACTED]'));
+    });
+
     it('writes real newlines into the issue body', () => {
       if (process.platform === 'win32') {
         return;