start-command 0.32.1 → 0.34.0

package/test/regression-162.js

@@ -0,0 +1,320 @@
+/**
+ * Regression tests for issue #162.
+ *
+ * A detached docker session used to be a dead end: once it stopped there was
+ * no way to re-enter it, continue it, or run a different command inside the
+ * same container, and a supervisor restart left records stuck in "executing"
+ * forever. `exitCode 139` with `oomKilled false` also hid the real cause.
+ *
+ * These tests drive the CLI end to end, so they cover the wiring between the
+ * argument parser, the execution store and the new attach/resume verbs.
+ */
+
+const { describe, it, expect, beforeEach, afterEach } = require('bun:test');
+const { spawnSync } = require('child_process');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const {
+  ExecutionRecord,
+  ExecutionStore,
+} = require('../src/lib/execution-store');
+
+const TEST_APP_FOLDER = path.join(
+  os.tmpdir(),
+  `regression-162-${process.pid}-${Date.now()}`
+);
+const CLI_PATH = path.join(__dirname, '../src/bin/cli.js');
+const LINO_DB_PATH = path.join(TEST_APP_FOLDER, 'executions.lino');
+
+function cleanupTestDir() {
+  fs.rmSync(TEST_APP_FOLDER, { recursive: true, force: true });
+}
+
+function runCli(args) {
+  // Reading the store back first is both a precondition check (the record
+  // really is persisted) and a guarantee that the CLI child sees it.
+  const persisted = fs.existsSync(LINO_DB_PATH)
+    ? fs.readFileSync(LINO_DB_PATH, 'utf8')
+    : '';
+  const result = spawnSync(process.execPath, [CLI_PATH, ...args], {
+    encoding: 'utf8',
+    env: { ...process.env, START_APP_FOLDER: TEST_APP_FOLDER },
+    timeout: 20000,
+  });
+  return {
+    persisted,
+    stdout: result.stdout || '',
+    stderr: result.stderr || '',
+    exitCode: result.status,
+  };
+}
+
+function saveRecord(store, overrides = {}) {
+  const record = new ExecutionRecord({
+    command: overrides.command || 'echo hi',
+    pid: overrides.pid || 4242,
+    logPath: overrides.logPath || null,
+    workingDirectory: '/tmp',
+    shell: '/bin/bash',
+    options: overrides.options || {},
+  });
+  if (overrides.exitCode !== undefined) {
+    record.complete(overrides.exitCode);
+  }
+  store.save(record);
+  return record;
+}
+
+describe('Issue #162: attach, resume and exit reasons', () => {
+  let store;
+
+  beforeEach(() => {
+    cleanupTestDir();
+    fs.mkdirSync(TEST_APP_FOLDER, { recursive: true });
+    store = new ExecutionStore({
+      appFolder: TEST_APP_FOLDER,
+      useLinks: false,
+    });
+  });
+
+  afterEach(() => {
+    cleanupTestDir();
+  });
+
+  describe('--list --running', () => {
+    it('reports only executions that are still running', () => {
+      const finished = saveRecord(store, {
+        command: 'echo finished',
+        exitCode: 0,
+      });
+      const running = saveRecord(store, { command: 'echo running' });
+
+      const result = runCli(['--list', '--running', '--output-format', 'json']);
+
+      expect(result.exitCode).toBe(0);
+      const parsed = JSON.parse(result.stdout);
+      const uuids = parsed.executions.map((record) => record.uuid);
+      expect(uuids).toContain(running.uuid);
+      expect(uuids).not.toContain(finished.uuid);
+    });
+
+    it('is rejected without --list', () => {
+      const result = runCli(['--running', '--', 'echo hi']);
+
+      expect(result.exitCode).not.toBe(0);
+      expect(result.stderr).toContain(
+        '--running option is only valid with --list'
+      );
+    });
+  });
+
+  describe('--attach', () => {
+    it('fails with a clear error for an unknown identifier', () => {
+      const result = runCli(['--attach', 'does-not-exist']);
+
+      expect(result.exitCode).toBe(1);
+      expect(result.stderr).toContain(
+        'No execution found with UUID or session name: does-not-exist'
+      );
+    });
+
+    it('refuses to attach to a non-isolated execution', () => {
+      const record = saveRecord(store, { command: 'echo local' });
+
+      const result = runCli(['--attach', record.uuid]);
+
+      expect(result.exitCode).toBe(1);
+      expect(result.stderr).toContain(
+        'Execution record does not contain an isolation session name'
+      );
+    });
+
+    it('points at --resume when the session is already gone', () => {
+      const record = saveRecord(store, {
+        command: 'echo gone',
+        options: {
+          isolated: 'docker',
+          isolationMode: 'detached',
+          sessionName: 'start-command-162-missing',
+        },
+      });
+
+      const result = runCli(['--attach', record.uuid]);
+
+      expect(result.exitCode).toBe(1);
+      expect(result.stderr).toContain('--resume');
+    });
+  });
+
+  describe('--resume', () => {
+    it('fails with a clear error for an unknown identifier', () => {
+      const result = runCli(['--resume', 'does-not-exist']);
+
+      expect(result.exitCode).toBe(1);
+      expect(result.stderr).toContain(
+        'No execution found with UUID or session name: does-not-exist'
+      );
+    });
+
+    it('refuses to resume a non-isolated execution', () => {
+      const record = saveRecord(store, { command: 'echo local' });
+
+      const result = runCli(['--resume', record.uuid]);
+
+      expect(result.exitCode).toBe(1);
+      expect(result.stderr).toContain(
+        'Execution record does not contain an isolation session name'
+      );
+    });
+
+    it('accepts a replacement command after --', () => {
+      const result = runCli(['--resume', 'does-not-exist', '--', 'echo', 'hi']);
+
+      // The identifier is still resolved first, so this reports the missing
+      // record rather than treating "echo hi" as a fresh command.
+      expect(result.exitCode).toBe(1);
+      expect(result.stderr).toContain(
+        'No execution found with UUID or session name: does-not-exist'
+      );
+    });
+  });
+
+  describe('--resume-all', () => {
+    it('succeeds with an empty report when nothing is running', () => {
+      saveRecord(store, { command: 'echo finished', exitCode: 0 });
+
+      const result = runCli(['--resume-all', '--output-format', 'json']);
+
+      expect(result.exitCode).toBe(0);
+      const parsed = JSON.parse(result.stdout);
+      expect(parsed.count).toBe(0);
+      expect(parsed.executions).toEqual([]);
+    });
+
+    it('reconciles executions whose session no longer exists', () => {
+      const logPath = path.join(TEST_APP_FOLDER, 'orphan.log');
+      fs.writeFileSync(
+        logPath,
+        [
+          'working...',
+          '==================================================',
+          'Finished: 2026-09-03 10:00:00.000',
+          'Exit Code: 0',
+          '',
+        ].join('\n'),
+        'utf8'
+      );
+      const record = saveRecord(store, {
+        command: 'echo orphan',
+        logPath,
+        options: {
+          isolated: 'docker',
+          isolationMode: 'detached',
+          sessionName: 'start-command-162-orphan',
+        },
+      });
+
+      const result = runCli(['--resume-all', '--output-format', 'json']);
+
+      expect(result.exitCode).toBe(0);
+      const parsed = JSON.parse(result.stdout);
+      expect(parsed.count).toBe(1);
+      expect(parsed.executions[0].uuid).toBe(record.uuid);
+      expect(parsed.executions[0].action).toBe('reconciled');
+
+      // The stuck "executing" record is now finalized in the store.
+      const reloaded = new ExecutionStore({
+        appFolder: TEST_APP_FOLDER,
+        useLinks: false,
+      }).get(record.uuid);
+      expect(reloaded.status).toBe('executed');
+    });
+  });
+
+  describe('exit reason hint', () => {
+    it('explains a 139 exit caused by heap exhaustion', () => {
+      const logPath = path.join(TEST_APP_FOLDER, 'oom.log');
+      fs.writeFileSync(
+        logPath,
+        [
+          'building...',
+          '',
+          '<--- Last few GCs --->',
+          'FATAL ERROR: Reached heap limit Allocation failed - JavaScript heap out of memory',
+          '',
+          '==================================================',
+          'Finished: 2026-09-03 10:00:00.000',
+          'Exit Code: 139',
+          '',
+        ].join('\n'),
+        'utf8'
+      );
+      const record = saveRecord(store, {
+        command: 'bun run build',
+        logPath,
+        exitCode: 139,
+      });
+
+      const result = runCli([
+        '--status',
+        record.uuid,
+        '--output-format',
+        'json',
+      ]);
+
+      expect(result.exitCode).toBe(0);
+      const parsed = JSON.parse(result.stdout);
+      expect(parsed.exitCode).toBe(139);
+      expect(parsed.oomKilled).toBeUndefined();
+      expect(parsed.exitReason).toBe('memory-exhaustion (v8-heap-limit)');
+    });
+
+    it('does not invent a reason for a clean exit', () => {
+      const logPath = path.join(TEST_APP_FOLDER, 'clean.log');
+      fs.writeFileSync(logPath, 'all good\n', 'utf8');
+      const record = saveRecord(store, {
+        command: 'echo ok',
+        logPath,
+        exitCode: 0,
+      });
+
+      const result = runCli([
+        '--status',
+        record.uuid,
+        '--output-format',
+        'json',
+      ]);
+
+      expect(result.exitCode).toBe(0);
+      const parsed = JSON.parse(result.stdout);
+      expect(parsed.exitReason).toBeUndefined();
+    });
+  });
+
+  describe('session identity across resumes', () => {
+    it('keeps addressing one logical session by its previous name', () => {
+      const record = saveRecord(store, {
+        command: 'echo resumed',
+        options: {
+          isolated: 'docker',
+          isolationMode: 'detached',
+          sessionName: 'start-command-162-b',
+          sessionNameHistory: ['start-command-162-a'],
+        },
+      });
+
+      const result = runCli([
+        '--status',
+        'start-command-162-a',
+        '--output-format',
+        'json',
+      ]);
+
+      expect(result.exitCode).toBe(0);
+      const parsed = JSON.parse(result.stdout);
+      expect(parsed.uuid).toBe(record.uuid);
+    });
+  });
+});

package/test/regression-164.js

@@ -0,0 +1,308 @@
+/**
+ * Regression tests for issue #164:
+ * "Command argv is flattened with join(' '), so quoted arguments are re-parsed
+ *  by the inner shell (`$ node -e \"console.log('hi')\"` fails)"
+ *
+ * Root cause:
+ *   parseArgs() returned `commandArgs.join(' ')`, so every argument boundary and
+ *   every quote the user typed was destroyed before the command reached
+ *   `sh -c`. `node -e "console.log('hi')"` became `node -e console.log('hi')`
+ *   (a syntax error), and `echo "a  b"` became `echo a  b` (re-split into two
+ *   words). `buildShellWithArgsCmdArgs()` repaired only the `<shell> -c …`
+ *   shape (issue #91) and only on the isolation code paths.
+ *
+ * Fix:
+ *   parseArgs() rebuilds the command with buildCommandString(): a single
+ *   argument is a shell script the user quoted as a whole and stays verbatim,
+ *   while multiple arguments are each shell-quoted so the inner shell sees the
+ *   argv the user typed.
+ *
+ * Reference: https://github.com/link-foundation/start/issues/164
+ */
+
+const { describe, it, expect } = require('bun:test');
+const { spawnSync } = require('child_process');
+const os = require('os');
+const path = require('path');
+
+const { parseArgs } = require('../src/lib/args-parser');
+const {
+  buildCommandString,
+  defaultShellQuotingStyle,
+  buildDisplayCommand,
+  buildShellWithArgsCmdArgs,
+  getCommandName,
+  isInteractiveShellCommand,
+  isShellInvocationWithArgs,
+  quoteShellArg,
+  splitShellWords,
+  toShellWords,
+} = require('../src/lib/shell-utils');
+
+const CLI_PATH = path.join(__dirname, '../src/bin/cli.js');
+// PowerShell (the host shell on Windows) escapes a quote by doubling it, so the
+// rebuilt command line differs from the POSIX one (issue #164).
+const IS_POWERSHELL = defaultShellQuotingStyle() === 'powershell';
+const TEST_APP_FOLDER = path.join(
+  os.tmpdir(),
+  `regression-164-${process.pid}-${Date.now()}`
+);
+
+/** Run the CLI the way a shell would: one process argument per argv element. */
+function runCli(argv) {
+  const result = spawnSync(process.execPath, [CLI_PATH, ...argv], {
+    encoding: 'utf8',
+    env: {
+      ...process.env,
+      START_APP_FOLDER: TEST_APP_FOLDER,
+      START_DISABLE_AUTO_ISSUE: '1',
+    },
+    timeout: 20000,
+  });
+  return {
+    stdout: result.stdout || '',
+    stderr: result.stderr || '',
+    exitCode: result.status,
+  };
+}
+
+/** The command output sits between the start block and the finish block. */
+function commandOutput(stdout) {
+  // PowerShell prefixes its output with a UTF-8 BOM and ends its lines with a
+  // carriage return on Windows, and the finish block is preceded by one more
+  // blank line there, so trailing blank lines are trimmed (issue #164).
+  const lines = stdout
+    .replace(/\uFEFF/g, '')
+    .replace(/\r/g, '')
+    .split('\n');
+  const start = lines.findIndex((line) => line.startsWith('$ '));
+  const finish = lines.findIndex((line) => line === '✓' || line === '✗');
+  return lines
+    .slice(start + 2, finish - 1)
+    .join('\n')
+    .replace(/\n+$/, '');
+}
+
+function displayedCommand(stdout) {
+  return (stdout.split('\n').find((line) => line.startsWith('$ ')) || '').slice(
+    2
+  );
+}
+
+describe('parseArgs keeps argv boundaries (issue #164)', () => {
+  it('quotes an argument that contains a shell metacharacter', () => {
+    const { command, rawCommand } = parseArgs([
+      'node',
+      '-e',
+      "console.log('hi')",
+    ]);
+    expect(command).toBe(
+      IS_POWERSHELL
+        ? "node -e 'console.log(''hi'')'"
+        : "node -e 'console.log('\\''hi'\\'')'"
+    );
+    expect(rawCommand).toEqual(['node', '-e', "console.log('hi')"]);
+  });
+
+  it('quotes an argument that contains repeated spaces', () => {
+    expect(parseArgs(['echo', 'a  b']).command).toBe("echo 'a  b'");
+  });
+
+  it('keeps a single argument verbatim so shell scripts still work', () => {
+    expect(parseArgs(['ls | wc -l']).command).toBe('ls | wc -l');
+  });
+
+  it('leaves ordinary arguments unquoted', () => {
+    // `%` is an alias for ForEach-Object in PowerShell, so it has to be quoted
+    // there while a POSIX shell leaves it alone.
+    expect(parseArgs(['git', 'log', '-1', '--pretty=%s']).command).toBe(
+      IS_POWERSHELL ? "git log -1 '--pretty=%s'" : 'git log -1 --pretty=%s'
+    );
+  });
+
+  it('keeps boundaries after the -- separator', () => {
+    const { command } = parseArgs([
+      '--isolated',
+      'docker',
+      '--',
+      'git',
+      'commit',
+      '-m',
+      'msg with spaces',
+    ]);
+    expect(command).toBe("git commit -m 'msg with spaces'");
+  });
+
+  it('returns an empty command when no command was given', () => {
+    expect(parseArgs(['--list']).command).toBe('');
+  });
+});
+
+describe('buildCommandString and quoteShellArg (issue #164)', () => {
+  it('returns an empty string for empty argv', () => {
+    expect(buildCommandString([])).toBe('');
+  });
+
+  it('escapes embedded single quotes for a POSIX shell', () => {
+    expect(quoteShellArg("it's", 'posix')).toBe("'it'\\''s'");
+  });
+
+  it('escapes embedded single quotes for PowerShell by doubling them', () => {
+    expect(quoteShellArg("it's", 'powershell')).toBe("'it''s'");
+  });
+
+  it('quotes characters PowerShell treats specially but a POSIX shell does not', () => {
+    expect(quoteShellArg('a,b', 'posix')).toBe('a,b');
+    expect(quoteShellArg('a,b', 'powershell')).toBe("'a,b'");
+  });
+
+  it('uses the host shell dialect by default', () => {
+    expect(quoteShellArg("it's")).toBe(
+      quoteShellArg("it's", defaultShellQuotingStyle())
+    );
+  });
+
+  it('quotes an empty argument so it survives as an argument', () => {
+    expect(buildCommandString(['echo', ''])).toBe("echo ''");
+  });
+
+  it('round-trips through splitShellWords in both dialects', () => {
+    const argv = ['node', '-e', "console.log('a  b')", 'x$y', ''];
+    for (const style of ['posix', 'powershell']) {
+      expect(splitShellWords(buildCommandString(argv, style), style)).toEqual(
+        argv
+      );
+    }
+  });
+});
+
+describe('splitShellWords (issue #164)', () => {
+  it('splits on unquoted whitespace', () => {
+    expect(splitShellWords('echo a b')).toEqual(['echo', 'a', 'b']);
+  });
+
+  it('keeps double-quoted words together', () => {
+    expect(splitShellWords('echo "a  b"')).toEqual(['echo', 'a  b']);
+  });
+
+  it('keeps single-quoted words together', () => {
+    expect(splitShellWords("echo 'a  b'")).toEqual(['echo', 'a  b']);
+  });
+
+  it('honours backslash escapes in a POSIX shell', () => {
+    expect(splitShellWords('echo a\\ b', 'posix')).toEqual(['echo', 'a b']);
+  });
+
+  it('keeps backslashes literal for PowerShell, where they are separators', () => {
+    expect(splitShellWords('echo C:\\tmp', 'powershell')).toEqual([
+      'echo',
+      'C:\\tmp',
+    ]);
+  });
+
+  it('reads a doubled quote inside a PowerShell string as one quote', () => {
+    expect(splitShellWords("echo 'it''s'", 'powershell')).toEqual([
+      'echo',
+      "it's",
+    ]);
+  });
+
+  it('returns null when quoting is unbalanced', () => {
+    expect(splitShellWords('echo "a')).toBe(null);
+  });
+});
+
+describe('toShellWords (issue #164)', () => {
+  it('keeps a quoted bare-shell argument in one argv element', () => {
+    expect(toShellWords("bash --rcfile 'my file'")).toEqual([
+      'bash',
+      '--rcfile',
+      'my file',
+    ]);
+  });
+
+  it('falls back to whitespace splitting when quoting is unbalanced', () => {
+    expect(toShellWords('echo "a b')).toEqual(['echo', '"a', 'b']);
+  });
+});
+
+describe('shell detection stays correct for quoted commands (issue #164)', () => {
+  it('still detects a bare shell invocation', () => {
+    expect(isInteractiveShellCommand('bash')).toBe(true);
+    expect(isInteractiveShellCommand("bash -c 'echo hi'")).toBe(false);
+  });
+
+  it('detects a shell invocation whose script argument is quoted', () => {
+    expect(isShellInvocationWithArgs("bash -c 'echo hi'")).toBe(true);
+  });
+
+  it('passes the quoted script through as a single argv element', () => {
+    expect(buildShellWithArgsCmdArgs("bash -i -c 'nvm --version'")).toEqual([
+      'bash',
+      '-i',
+      '-c',
+      'nvm --version',
+    ]);
+  });
+
+  it('reads the command name from the first shell word', () => {
+    expect(getCommandName("'my command' --flag")).toBe('my command');
+  });
+});
+
+describe('buildDisplayCommand shows the argv the user typed (issue #164)', () => {
+  it('re-quotes an argument that was quoted by the parser', () => {
+    expect(buildDisplayCommand(parseArgs(['echo', 'a  b']).command)).toBe(
+      'echo "a  b"'
+    );
+  });
+
+  it('re-quotes an argument containing shell metacharacters', () => {
+    expect(
+      buildDisplayCommand(
+        parseArgs(['node', '-e', "console.log('hi')"]).command
+      )
+    ).toBe('node -e "console.log(\'hi\')"');
+  });
+
+  it('shows a single-argument shell script verbatim', () => {
+    expect(buildDisplayCommand('ls | wc -l')).toBe('ls | wc -l');
+  });
+});
+
+describe('CLI end to end (issue #164)', () => {
+  it('runs node -e with a quoted script', () => {
+    const result = runCli(['node', '-e', "console.log('hi')"]);
+    expect(result.exitCode).toBe(0);
+    expect(commandOutput(result.stdout)).toBe('hi');
+  });
+
+  it('preserves repeated spaces inside a quoted argument', () => {
+    const result = runCli(['echo', 'a  b']);
+    expect(result.exitCode).toBe(0);
+    expect(commandOutput(result.stdout)).toBe('a  b');
+  });
+
+  it('keeps `bash -c` scripts intact on the direct path (issue #91 shape)', () => {
+    const result = runCli(['bash', '-c', 'echo hello world']);
+    expect(result.exitCode).toBe(0);
+    expect(commandOutput(result.stdout)).toBe('hello world');
+  });
+
+  it('keeps arithmetic expansion inside `bash -c` intact', () => {
+    const result = runCli(['bash', '-c', 'echo $((1+1))']);
+    expect(result.exitCode).toBe(0);
+    expect(commandOutput(result.stdout)).toBe('2');
+  });
+
+  it('still runs a single quoted argument as a shell script', () => {
+    const result = runCli(['echo one | tr a-z A-Z']);
+    expect(result.exitCode).toBe(0);
+    expect(commandOutput(result.stdout)).toBe('ONE');
+  });
+
+  it('displays the command with the quoting the user typed', () => {
+    const result = runCli(['echo', 'a  b']);
+    expect(displayedCommand(result.stdout)).toBe('echo "a  b"');
+  });
+});