start-command 0.32.0 → 0.33.0

package/test/failure-handler.js

@@ -6,8 +6,56 @@
 
 const { describe, it } = require('node:test');
 const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execFileSync } = require('child_process');
 const { parseGitUrl, handleFailure } = require('../src/lib/failure-handler');
 
+/**
+ * Run `createIssue` in a child process whose PATH starts with a fake `gh`
+ * recording its argv (NUL-separated). A child process is required because the
+ * runtime resolves PATH at startup, so mutating `process.env.PATH` in-process
+ * does not affect command lookup under Bun.
+ */
+function createIssueWithFakeGh(fullCommand) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'fake-gh-'));
+  try {
+    const argvFile = path.join(dir, 'argv');
+    const ghPath = path.join(dir, 'gh');
+    fs.writeFileSync(
+      ghPath,
+      [
+        '#!/bin/sh',
+        `printf '%s\\0' "$@" > "${argvFile}"`,
+        'echo https://github.com/owner/repo/issues/1',
+        '',
+      ].join('\n')
+    );
+    fs.chmodSync(ghPath, 0o755);
+
+    const modulePath = require.resolve('../src/lib/failure-handler');
+    const script = `
+      const { createIssue } = require(${JSON.stringify(modulePath)});
+      const repo = { owner: 'owner', repo: 'repo', url: 'https://github.com/owner/repo' };
+      process.stdout.write(
+        String(createIssue(repo, ${JSON.stringify(fullCommand)}, 1, null))
+      );
+    `;
+    const result = execFileSync(process.execPath, ['-e', script], {
+      encoding: 'utf8',
+      env: {
+        ...process.env,
+        PATH: `${dir}${path.delimiter}${process.env.PATH}`,
+      },
+    });
+    const argv = fs.readFileSync(argvFile, 'utf8').split('\0').slice(0, -1);
+    return { result, argv };
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+}
+
 describe('failure-handler', () => {
   describe('parseGitUrl', () => {
     it('should parse HTTPS GitHub URL', () => {
@@ -82,6 +130,65 @@ describe('failure-handler', () => {
     });
   });
 
+  describe('createIssue', () => {
+    // Regression for issue #168: the command was interpolated into a shell
+    // string and only `"` was escaped, so a backtick or $(...) in the failing
+    // command ran, and every newline of the body arrived as a literal "\\n".
+    const runCreateIssue = () =>
+      createIssueWithFakeGh('echo "quoted" $(id) `hostname`');
+
+    it('passes the title and body to gh as separate arguments', () => {
+      if (process.platform === 'win32') {
+        return; // /bin/sh stub is POSIX-only
+      }
+      const { result, argv } = runCreateIssue();
+      assert.strictEqual(result, 'https://github.com/owner/repo/issues/1');
+      assert.deepStrictEqual(argv.slice(0, 4), [
+        'issue',
+        'create',
+        '--repo',
+        'owner/repo',
+      ]);
+      assert.strictEqual(argv[4], '--title');
+      assert.strictEqual(argv[6], '--body');
+      assert.strictEqual(argv.length, 8);
+    });
+
+    it('keeps the failing command verbatim and does not escape it', () => {
+      if (process.platform === 'win32') {
+        return;
+      }
+      const { argv } = runCreateIssue();
+      const [title, body] = [argv[5], argv[7]];
+      assert.ok(
+        title.includes('echo "quoted" $(id) `hostname`'),
+        `title must quote the command verbatim, got: ${title}`
+      );
+      assert.ok(
+        body.includes('echo "quoted" $(id) `hostname`'),
+        'body must quote the command verbatim'
+      );
+      assert.ok(
+        !title.includes('\\"'),
+        'title must not contain escaped quotes'
+      );
+      assert.ok(!body.includes('\\"'), 'body must not contain escaped quotes');
+    });
+
+    it('writes real newlines into the issue body', () => {
+      if (process.platform === 'win32') {
+        return;
+      }
+      const { argv } = runCreateIssue();
+      const body = argv[7];
+      assert.ok(body.includes('\n'), 'body must contain real newlines');
+      assert.ok(
+        !body.includes('\\n'),
+        'body must not contain literal backslash-n sequences'
+      );
+    });
+  });
+
   describe('handleFailure', () => {
     it('should return early when disableAutoIssue is true', () => {
       // This should not throw and should return without calling external processes

package/test/load-command-stream.mjs

@@ -0,0 +1,83 @@
+import { describe, expect, it } from 'bun:test';
+
+import {
+  loadCommandStream,
+  resolveNamedExport,
+} from '../../scripts/load-command-stream.mjs';
+
+const $ = () => {};
+
+/**
+ * Namespace shape produced by `import()` of a CommonJS file on Node < 22.12,
+ * before `use-m` unwraps it. use-m returns `default` here, so `const { $ }`
+ * works.
+ */
+const NODE_20_NAMESPACE = { default: Object.assign($, { $, exec: () => {} }) };
+
+/**
+ * Same file on Node >= 22.12. Node adds a `module.exports` named export when
+ * cjs-module-lexer cannot infer the real names, so use-m sees two keys, skips
+ * the unwrap and hands the raw namespace to the caller (issue #168).
+ */
+const NODE_24_NAMESPACE = {
+  default: Object.assign($, { $, exec: () => {} }),
+  'module.exports': Object.assign($, { $, exec: () => {} }),
+};
+
+/** Shape use-m returns when it did unwrap: the `$` function itself. */
+const UNWRAPPED = Object.assign($, { $, exec: () => {} });
+
+describe('load-command-stream', () => {
+  it('reproduces the Node 24 namespace that broke the release jobs', () => {
+    // Regression guard for the actual failure: destructuring the raw
+    // namespace yields undefined, hence "$ is not a function".
+    const { $: destructured } = NODE_24_NAMESPACE;
+    expect(destructured).toBeUndefined();
+  });
+
+  it('resolves $ from the Node >= 22.12 CommonJS namespace', () => {
+    expect(typeof resolveNamedExport(NODE_24_NAMESPACE, '$', 'x').$).toBe(
+      'function'
+    );
+  });
+
+  it('resolves $ from the Node < 22.12 CommonJS namespace', () => {
+    expect(typeof resolveNamedExport(NODE_20_NAMESPACE, '$', 'x').$).toBe(
+      'function'
+    );
+  });
+
+  it('resolves $ when use-m already unwrapped the module', () => {
+    expect(typeof resolveNamedExport(UNWRAPPED, '$', 'x').$).toBe('function');
+  });
+
+  it('resolves $ from an ESM namespace with named exports', () => {
+    const namespace = { $, exec: () => {}, default: $ };
+    expect(typeof resolveNamedExport(namespace, '$', 'x').$).toBe('function');
+  });
+
+  it('throws an actionable error instead of "$ is not a function"', () => {
+    expect(() =>
+      resolveNamedExport({ nope: 1 }, '$', 'command-stream')
+    ).toThrow(
+      /use\('command-stream'\) did not expose a callable "\$".*keys \[nope\]/s
+    );
+  });
+
+  it('reports the received value when use-m resolved nothing', () => {
+    expect(() => resolveNamedExport(undefined, '$', 'command-stream')).toThrow(
+      /Received undefined/
+    );
+  });
+
+  it('loads command-stream through an injected use() implementation', async () => {
+    const calls = [];
+    const use = async (name) => {
+      calls.push(name);
+      return NODE_24_NAMESPACE;
+    };
+    const module = await loadCommandStream(use);
+    expect(calls).toEqual(['command-stream']);
+    expect(typeof module.$).toBe('function');
+  });
+});

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);
+    });
+  });
+});