start-command 0.32.1 → 0.34.0

package/test/exit-reason.js

@@ -0,0 +1,209 @@
+#!/usr/bin/env bun
+/**
+ * Unit tests for exit-reason detection (issue #162).
+ *
+ * `exitCode 139` with `oomKilled false` is not actionable on its own: the
+ * kernel/cgroup OOM flag is unset when the process aborts itself after hitting
+ * a runtime memory limit. The log almost always carries the real cause, so the
+ * footer scan surfaces it as `exitReason`.
+ */
+
+const { describe, it } = require('node:test');
+const assert = require('assert');
+
+const {
+  detectExitReason,
+  detectMemoryMarker,
+  resolveExitReason,
+  resolveMemoryExhaustion,
+  signalNameForExitCode,
+} = require('../src/lib/exit-reason');
+
+describe('detectExitReason', () => {
+  it('should detect the V8 heap limit marker from the incident log', () => {
+    const tail = [
+      'some command output',
+      '',
+      '<--- Last few GCs --->',
+      '',
+      'FATAL ERROR: Reached heap limit Allocation failed - JavaScript heap out of memory',
+      '',
+      '==================================================',
+      'Finished: 2026-09-01 12:00:00.000',
+      'Exit Code: 139',
+    ].join('\n');
+
+    assert.strictEqual(
+      detectExitReason(tail),
+      'memory-exhaustion (v8-heap-limit)'
+    );
+  });
+
+  it('should detect a bare JavaScript heap out of memory line', () => {
+    assert.strictEqual(
+      detectExitReason('JavaScript heap out of memory\n'),
+      'memory-exhaustion (v8-heap-limit)'
+    );
+  });
+
+  it('should detect other runtimes reporting their own exhaustion', () => {
+    assert.strictEqual(
+      detectExitReason('fatal error: runtime: out of memory'),
+      'memory-exhaustion (go-runtime)'
+    );
+    assert.strictEqual(
+      detectExitReason('Array buffer allocation failed'),
+      'memory-exhaustion (allocation-failure)'
+    );
+  });
+
+  it('should detect the kernel OOM killer marker', () => {
+    assert.strictEqual(
+      detectExitReason('Out of memory: Killed process 4242 (bun)\n'),
+      'memory-exhaustion (kernel-oom-killer)'
+    );
+  });
+
+  it('should detect allocation failures', () => {
+    assert.strictEqual(
+      detectExitReason('terminate called after throwing std::bad_alloc'),
+      'memory-exhaustion (allocation-failure)'
+    );
+    assert.strictEqual(
+      detectExitReason('memory allocation of 1048576 bytes failed'),
+      'memory-exhaustion (allocation-failure)'
+    );
+  });
+
+  it('should not invent a reason for ordinary output', () => {
+    assert.strictEqual(detectExitReason('all tests passed\n'), null);
+    assert.strictEqual(detectExitReason(''), null);
+    assert.strictEqual(detectExitReason(null), null);
+  });
+});
+
+describe('signalNameForExitCode', () => {
+  it('should map 139 to SIGSEGV', () => {
+    assert.strictEqual(signalNameForExitCode(139), 'SIGSEGV');
+  });
+
+  it('should map 137 to SIGKILL', () => {
+    assert.strictEqual(signalNameForExitCode(137), 'SIGKILL');
+  });
+
+  it('should ignore ordinary exit codes', () => {
+    assert.strictEqual(signalNameForExitCode(0), null);
+    assert.strictEqual(signalNameForExitCode(1), null);
+    assert.strictEqual(signalNameForExitCode(-1), null);
+    assert.strictEqual(signalNameForExitCode(null), null);
+  });
+});
+
+describe('resolveExitReason', () => {
+  it('should prefer the log marker over the signal fallback', () => {
+    const reason = resolveExitReason({
+      exitCode: 139,
+      logTail:
+        'FATAL ERROR: Reached heap limit Allocation failed - JavaScript heap out of memory',
+      oomKilled: false,
+    });
+    assert.strictEqual(reason, 'memory-exhaustion (v8-heap-limit)');
+  });
+
+  it('should report the cgroup OOM observation when there is no marker', () => {
+    const reason = resolveExitReason({ exitCode: 137, oomKilled: true });
+    assert.strictEqual(reason, 'memory-exhaustion (cgroup-oom-killer)');
+  });
+
+  it('should fall back to the signal name for signal exit codes', () => {
+    assert.strictEqual(
+      resolveExitReason({ exitCode: 139, oomKilled: false }),
+      'signal (SIGSEGV)'
+    );
+  });
+
+  it('should return null when nothing is known', () => {
+    assert.strictEqual(resolveExitReason({ exitCode: 0 }), null);
+    assert.strictEqual(resolveExitReason({}), null);
+    assert.strictEqual(resolveExitReason(null), null);
+  });
+});
+
+describe('detectMemoryMarker', () => {
+  it('should return the whole line carrying the marker', () => {
+    const tail = [
+      '<--- Last few GCs --->',
+      'FATAL ERROR: Reached heap limit Allocation failed - JavaScript heap out of memory',
+      '----- Native stack trace -----',
+    ].join('\n');
+
+    assert.deepStrictEqual(detectMemoryMarker(tail), {
+      reason: 'memory-exhaustion (v8-heap-limit)',
+      line: 'FATAL ERROR: Reached heap limit Allocation failed - JavaScript heap out of memory',
+    });
+  });
+
+  it('should bound an absurdly long line', () => {
+    const marker = detectMemoryMarker(
+      `${'x'.repeat(5000)} JavaScript heap out of memory`
+    );
+
+    assert.ok(marker.line.length <= 304);
+    assert.ok(marker.line.endsWith('...'));
+  });
+});
+
+describe('resolveMemoryExhaustion', () => {
+  const marker =
+    'FATAL ERROR: Reached heap limit Allocation failed - JavaScript heap out of memory';
+
+  it('should report the evidence for an abnormal exit', () => {
+    assert.deepStrictEqual(
+      resolveMemoryExhaustion({
+        exitCode: 139,
+        logTail: `working\n${marker}\n`,
+        oomKilled: false,
+      }),
+      { memoryExhausted: true, memoryExhaustedReason: marker }
+    );
+  });
+
+  it('should fall back to the container flag when the log says nothing', () => {
+    assert.deepStrictEqual(
+      resolveMemoryExhaustion({
+        exitCode: 137,
+        logTail: 'killed\n',
+        oomKilled: true,
+      }),
+      {
+        memoryExhausted: true,
+        memoryExhaustedReason: 'Docker reported State.OOMKilled=true',
+      }
+    );
+  });
+
+  it('should stay silent for a clean or unfinished run', () => {
+    // An observation, never a verdict (#151): a log that merely quotes the
+    // marker cannot turn a successful run into a memory failure.
+    assert.strictEqual(
+      resolveMemoryExhaustion({ exitCode: 0, logTail: marker }),
+      null
+    );
+    assert.strictEqual(
+      resolveMemoryExhaustion({ exitCode: null, logTail: marker }),
+      null
+    );
+  });
+
+  it('should stay silent for an ordinary failure', () => {
+    assert.strictEqual(
+      resolveMemoryExhaustion({
+        exitCode: 1,
+        logTail: 'error: file not found\n',
+        oomKilled: false,
+      }),
+      null
+    );
+    assert.strictEqual(resolveMemoryExhaustion(null), null);
+  });
+});

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