start-command 0.39.2 → 0.41.0

package/test/fixtures/formal-ai/replay.cjs

@@ -0,0 +1,144 @@
+/**
+ * Replies of the offline Formal AI stand-in (issue #255), shared by the fake
+ * runtime process (fake-server.cjs) and in-process tests.
+ *
+ * A request gets its recorded response number k from receipts.json, where k
+ * is the number of assistant turns already in the conversation. Unknown
+ * requests get the runtime's "did not understand" reply. SYNTHETIC scenarios
+ * (requests starting with `synthetic:`) cover states a real runtime cannot be
+ * made to produce on demand. A number reply is an HTTP error status.
+ */
+
+const fs = require('fs');
+const http = require('http');
+const path = require('path');
+
+const { receipts } = JSON.parse(
+  fs.readFileSync(path.join(__dirname, 'receipts.json'), 'utf8')
+);
+
+function toolCall(command, id = `call_${Math.random().toString(16).slice(2)}`) {
+  return {
+    role: 'assistant',
+    content: 'Let me run the requested command to get that for you.',
+    tool_calls: [
+      {
+        id,
+        type: 'function',
+        function: { name: 'bash', arguments: JSON.stringify({ command }) },
+      },
+    ],
+  };
+}
+
+const answer = (content) => ({ role: 'assistant', content });
+
+/**
+ * SYNTHETIC scenarios: request -> (assistantTurns, messages) -> message|status.
+ * A constant list matched by string equality: request text only selects among
+ * these entries and is never used as a property key, so `constructor`,
+ * `toString` and similar names reach the "did not understand" reply.
+ */
+const SYNTHETIC = Object.freeze(
+  Object.entries({
+    // Never stops asking for more reads: exhausts the step budget.
+    'synthetic: loop forever': () => toolCall('pwd'),
+    // A tool start must not run.
+    'synthetic: call an unknown tool': () => ({
+      role: 'assistant',
+      content: '',
+      tool_calls: [
+        {
+          id: 'call_x',
+          type: 'function',
+          function: { name: 'python', arguments: '{"code":"1"}' },
+        },
+      ],
+    }),
+    // A long-running read (a fake `cat` from the test PATH sleeps).
+    'synthetic: read slowly': (turns) =>
+      turns === 0 ? toolCall('cat slow.txt') : answer('done'),
+    // A tool that does not exist on PATH.
+    'synthetic: run a missing tool': (turns) =>
+      turns === 0 ? toolCall('tree') : answer('The `tree` command failed.'),
+    // Writes outside the observed workspace.
+    'synthetic: overwrite without looking': () => toolCall('touch README.md'),
+    'synthetic: write outside': () => toolCall('touch ../escape.txt'),
+    // A server error on every request.
+    'synthetic: server error': () => 500,
+    // A write that claims success but leaves no trace (fake `mkdir` on PATH).
+    'synthetic: unverified mkdir': (turns) =>
+      turns === 0 ? toolCall('test ! -e out') : toolCall('mkdir out'),
+  })
+);
+
+function reply(body) {
+  const messages = Array.isArray(body.messages) ? body.messages : [];
+  const request = (messages.find((m) => m.role === 'user') || {}).content || '';
+  const turns = messages.filter((m) => m.role === 'assistant').length;
+  const scenario = SYNTHETIC.find(([name]) => name === request);
+  if (scenario) {
+    const [, respond] = scenario;
+    return respond(turns, messages);
+  }
+  const receipt = receipts.find((r) => r.request === request);
+  if (receipt && receipt.responses[turns]) {
+    return receipt.responses[turns].message;
+  }
+  return {
+    role: 'assistant',
+    content: "I didn't understand you. Could you rephrase?",
+    thinking_steps: [{ step: 'dispatch_handler', detail: 'unknown' }],
+  };
+}
+
+/**
+ * HTTP server speaking the agent-mode subset start uses.
+ * @param {string} [log] - File that receives every request body as a JSON line
+ * @returns {import('http').Server}
+ */
+function createFakeServer(log) {
+  return http.createServer((req, res) => {
+    let text = '';
+    req.on('data', (chunk) => {
+      text += chunk;
+    });
+    req.on('end', () => {
+      const send = (status, payload) => {
+        res.writeHead(status, { 'content-type': 'application/json' });
+        res.end(JSON.stringify(payload));
+      };
+      if (req.method === 'GET' && req.url.endsWith('/models')) {
+        send(200, { object: 'list', data: [{ id: 'formal-ai' }] });
+        return;
+      }
+      if (req.method !== 'POST' || !req.url.endsWith('/chat/completions')) {
+        send(404, { error: 'not found' });
+        return;
+      }
+      const body = JSON.parse(text);
+      if (log) {
+        fs.appendFileSync(log, `${JSON.stringify(body)}\n`);
+      }
+      const message = reply(body);
+      if (typeof message === 'number') {
+        send(message, { error: 'synthetic failure' });
+        return;
+      }
+      send(200, {
+        id: 'chatcmpl_fake',
+        object: 'chat.completion',
+        model: 'formal-ai',
+        choices: [
+          {
+            index: 0,
+            message,
+            finish_reason: message.tool_calls ? 'tool_calls' : 'stop',
+          },
+        ],
+      });
+    });
+  });
+}
+
+module.exports = { SYNTHETIC, createFakeServer, receipts, reply };

package/test/javascript-first-ci.js

@@ -233,6 +233,35 @@ describe('JavaScript first CI gate', () => {
     );
   });
 
+  it('treats generated Rust regenerated by a translator bump as no change', () => {
+    const features = [
+      {
+        id: 'generated',
+        javascript: { implementation: ['js/source.mjs'], tests: [] },
+        rust: { implementation: ['rust/generated.rs'], tests: [] },
+      },
+    ];
+    const generated = [
+      { javascript: 'js/source.mjs', rust: 'rust/generated.rs' },
+    ];
+    assert.deepEqual(
+      checkFeatureChanges(features, ['rust/generated.rs'], generated),
+      []
+    );
+    assert.deepEqual(
+      checkFeatureChanges(
+        features,
+        ['js/source.mjs', 'rust/generated.rs'],
+        generated
+      ),
+      []
+    );
+    assert.equal(
+      checkFeatureChanges(features, ['rust/generated.rs']).length,
+      1
+    );
+  });
+
   it('keeps both halves of a regression test under one feature', () => {
     const feature = (id, js, rust) => ({
       id,

package/test/log-sanitizer.js

@@ -5,8 +5,8 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const { execFileSync } = require('child_process');
+const { createHash } = require('node:crypto');
 const {
-  AuthorizationHeaderMask,
   SanitizationError,
   resolveSanitizerCommand,
   sanitizeLogToTemp,
@@ -59,17 +59,6 @@ function sanitizeFile(content, env = testEnv()) {
   });
 }
 
-function mask(input, blockSize) {
-  const authorization = new AuthorizationHeaderMask();
-  const blocks = [];
-  for (let offset = 0; offset < input.length; offset += blockSize) {
-    blocks.push(authorization.push(input.subarray(offset, offset + blockSize)));
-    assert.ok(authorization.pending.length <= blockSize + 160);
-  }
-  blocks.push(authorization.push(Buffer.alloc(0), true));
-  return Buffer.concat(blocks).toString();
-}
-
 // The three lines from issue #249, which the old rules truncated.
 const ISSUE_249_LINES = [
   "Command: gate='/tmp/hive-mind-disk-baseline-0ce9e170-e6d3-494d-91e1-0d820245d34b'",
@@ -98,6 +87,30 @@ function credentials() {
 }
 
 describe('log sanitization', () => {
+  it('requires the sanitizer release the Rust installer asks for', () => {
+    // An older CLI rejects --allow-binary (ERR_ARGUMENT), so the bundled
+    // dependency and the Rust installer and version check agree.
+    const range =
+      require('../package.json').dependencies[
+        '@link-foundation/sensitive-data-sanitizer'
+      ];
+    const rust = fs.readFileSync(
+      path.join(__dirname, '../../rust/src/lib/log_sanitizer.rs'),
+      'utf8'
+    );
+    const [, major, minor, patch] = range.match(/^\^(\d+)\.(\d+)\.(\d+)$/);
+    assert.ok(
+      rust.includes(
+        `PACKAGE: &str = "@link-foundation/sensitive-data-sanitizer@${range}";`
+      )
+    );
+    assert.ok(
+      rust.includes(
+        `MINIMUM_VERSION: (u64, u64, u64) = (${major}, ${minor}, ${patch});`
+      )
+    );
+  });
+
   it('keeps every line from issue #249 and public account details', () => {
     const input = `${ISSUE_249_LINES.join('\n')}\n`;
     assert.strictEqual(sanitizeFile(input).toString(), input);
@@ -154,35 +167,87 @@ describe('log sanitization', () => {
         'Authorization: token $(gh auth token) and ${GITHUB_TOKEN}',
         'Authorization: token $(gh auth token) and ${GITHUB_TOKEN}',
       ],
+      // Since 0.12.2, placeholders and their scheme remain unchanged.
       ['Authorization: Bearer <token>', 'Authorization: Bearer <token>'],
     ];
+    // sensitive-data-sanitizer 0.12.1 does this itself (#45), without the
+    // pre-pass start used to run (#253).
     const input = cases.map(([line]) => line).join('\n');
     const expected = cases.map(([, line]) => line).join('\n');
-    for (const size of [1, 7, 31, 256, 65536]) {
-      assert.strictEqual(mask(Buffer.from(input), size), expected);
-    }
-    // The library itself masks the scheme before a placeholder; nothing is lost.
-    assert.strictEqual(
-      sanitizeFile(input).toString(),
-      expected.replace('Bearer <token>', '[REDACTED] <token>')
-    );
+    assert.strictEqual(sanitizeFile(input).toString(), expected);
+    assert.strictEqual(sanitizeText(input, { env: testEnv() }), expected);
   });
 
-  it('masks long Authorization tokens across blocks with bounded memory', () => {
+  it('masks long Authorization tokens across stream blocks', () => {
     const input = Buffer.from(
       `Authorization: Bearer ${'a'.repeat(200000)} tail\nordinary\n`
     );
-    assert.strictEqual(
-      mask(input, 65536),
-      'Authorization: [REDACTED] tail\nordinary\n'
-    );
     assert.strictEqual(
       sanitizeFile(input).toString(),
       'Authorization: [REDACTED] tail\nordinary\n'
     );
   });
 
-  it('preserves invalid UTF-8 bytes and line endings', () => {
+  it('preserves Authorization placeholders and control bytes when sanitizing twice (#253)', () => {
+    const input = [
+      'Authorization: Bearer [REDACTED] already',
+      'Authorization: Bearer {{token}} x',
+      'Authorization: Bearer <token> x',
+      'Authorization: Bearer $GITHUB_TOKEN x',
+      'Authorization: Bearer abc\0 tail',
+      'Authorization: Bearer abc\x1b[0m tail',
+      '{"header":"Authorization: Bearer ab[c]d","next":"keep"}',
+    ].join('\n');
+    const expected = [
+      'Authorization: Bearer [REDACTED] already',
+      // Arbitrary bracketed values are credentials; known references above
+      // stay intact, but every bracket of this value must be removed (#50).
+      'Authorization: [REDACTED] x',
+      'Authorization: Bearer <token> x',
+      'Authorization: Bearer $GITHUB_TOKEN x',
+      'Authorization: [REDACTED]\0 tail',
+      'Authorization: [REDACTED]\x1b[0m tail',
+      '{"header":"Authorization: [REDACTED]","next":"keep"}',
+    ].join('\n');
+    const output = sanitizeFile(input);
+    assert.strictEqual(output.toString(), expected);
+    assert.deepStrictEqual(sanitizeFile(output), output);
+  });
+
+  it(
+    'sanitizes dense credentials within a bounded process (#253, sanitizer #51)',
+    { timeout: 25000 },
+    () => {
+      const count = 5700;
+      const input = Array.from({ length: count }, (_, index) => {
+        const token = createHash('sha256').update(String(index)).digest('hex');
+        return `gh${'p_'}${token.slice(0, 36)} keep\n`;
+      }).join('');
+      const { command, args } = resolveSanitizerCommand({});
+      const output = execFileSync(
+        command,
+        [
+          '--max-old-space-size=384',
+          ...args,
+          'redact',
+          '-',
+          '--stream',
+          '--credentials-only',
+          '--allow-binary',
+        ],
+        {
+          input,
+          env: testEnv(),
+          timeout: 20000,
+          killSignal: 'SIGKILL',
+          maxBuffer: 1024 * 1024,
+        }
+      );
+      assert.strictEqual(output.toString(), '[REDACTED] keep\n'.repeat(count));
+    }
+  );
+
+  it('preserves invalid UTF-8 bytes, NUL bytes and line endings', () => {
     const input = Buffer.concat([
       Buffer.from('bad '),
       Buffer.from([0xff, 0xfe, 0xc3]),
@@ -195,6 +260,12 @@ describe('log sanitization', () => {
     ]);
     assert.deepStrictEqual(sanitizeFile(input), expected);
     assert.deepStrictEqual(sanitizeFile(Buffer.alloc(0)), Buffer.alloc(0));
+    // --allow-binary: a NUL byte in a terminal transcript no longer blocks
+    // the upload with ERR_BINARY (#253), and credentials next to it are masked.
+    assert.strictEqual(
+      sanitizeFile(`line\0one gh${'p_'}${'x'.repeat(36)}\0two\n`).toString(),
+      'line\0one [REDACTED]\0two\n'
+    );
   });
 
   it('sanitizes issue text with the same rules', () => {
@@ -255,27 +326,15 @@ describe('log sanitization', () => {
     if (process.platform === 'win32') {
       return;
     }
-    const originalOpen = fs.openSync;
     const originalUmask = process.umask(0);
-    let creationChecked = false;
-    fs.openSync = (...args) => {
-      if (args[1] !== 'wx') {
-        return originalOpen(...args);
-      }
-      assert.strictEqual(
-        fs.statSync(path.dirname(args[0])).mode & 0o777,
-        0o700
-      );
-      const descriptor = originalOpen(...args);
-      assert.strictEqual(fs.fstatSync(descriptor).mode & 0o777, 0o600);
-      creationChecked = true;
-      return descriptor;
-    };
     try {
       withLog('ordinary output', (source) => {
         const copy = sanitizeLogToTemp(source, { env: testEnv() });
         try {
-          assert.ok(creationChecked);
+          assert.strictEqual(
+            fs.statSync(path.dirname(copy.path)).mode & 0o777,
+            0o700
+          );
           assert.strictEqual(fs.statSync(copy.path).mode & 0o777, 0o600);
           assert.strictEqual(
             fs.readFileSync(copy.path, 'utf8'),
@@ -286,7 +345,6 @@ describe('log sanitization', () => {
         }
       });
     } finally {
-      fs.openSync = originalOpen;
       process.umask(originalUmask);
     }
   });
@@ -323,9 +381,7 @@ describe('log sanitization', () => {
     };
     assert.match(attempt('/does-not-exist').message, /\(ERR_SOURCE\)/);
     assert.match(attempt(os.tmpdir()).message, /\(ERR_SOURCE\)/);
-    withLog('secret\0binary', (source, dir) => {
-      // The library rejects NUL bytes rather than guessing at binary content.
-      assert.strictEqual(attempt(source).code, 'ERR_BINARY');
+    withLog('ordinary log', (source, dir) => {
       assert.strictEqual(
         attempt(
           source,
@@ -376,13 +432,24 @@ describe('log sanitization', () => {
     const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sanitize-errors-'));
     const source = path.join(dir, 'source.log');
     fs.writeFileSync(source, 'ordinary log');
+    // A fake uploader, so a regression can never publish the log for real.
+    const uploaded = path.join(dir, 'uploaded');
+    fs.writeFileSync(
+      path.join(dir, 'gh-upload-log'),
+      `#!/bin/sh\ntouch "${uploaded}"\necho https://gist.github.com/test/id\n`,
+      { mode: 0o755 }
+    );
+    const originalPath = process.env.PATH;
+    process.env.PATH = `${dir}${path.delimiter}${originalPath}`;
     const { uploadLogPath } = require('../src/lib/log-uploader');
     const { uploadLog } = require('../src/lib/failure-handler');
     const messages = [];
     const originalLog = console.log;
     console.log = (message) => messages.push(message);
     try {
-      for (const method of ['readSync', 'writeSync', 'fsyncSync']) {
+      // The sanitizer child reads and writes the files itself; start only
+      // opens and checks the source.
+      for (const method of ['openSync', 'fstatSync']) {
         const original = fs[method];
         fs[method] = () => {
           throw new Error('sensitive error details');
@@ -409,8 +476,10 @@ describe('log sanitization', () => {
           'Warning: Log sanitization failed (ERR_SOURCE); upload blocked.'
         )
       );
+      assert.ok(!fs.existsSync(uploaded));
     } finally {
       console.log = originalLog;
+      process.env.PATH = originalPath;
       fs.rmSync(dir, { recursive: true, force: true });
     }
   });

package/test/regression-187.js

@@ -78,6 +78,8 @@ function fixture() {
 }
 
 const stopped = () => ({ alive: false, state: SessionState.STOPPED });
+// The snapshot preflight must not depend on the free disk of the test host.
+const plentyOfDisk = { freeBytes: () => 100 * 1024 ** 3 };
 const accepted = (_bin, args = []) => ({
   success: true,
   stdout: args.includes('--size')
@@ -102,6 +104,7 @@ describe('issue #187: explicit resume attempts', () => {
             ? () => ({ alive: false, state: SessionState.MISSING })
             : stopped,
         runner: accepted,
+        snapshotOptions: plentyOfDisk,
         runIsolated: () => ({ success: true, containerId: 'new-container' }),
         startWatcher: (_name, _policy, _log, _uuid, options) => {
           expect(options.recoverOnKill).toBe(mode !== 'docker-snapshot');
@@ -357,6 +360,7 @@ esac
       command: 'replacement',
       probe: stopped,
       runner: accepted,
+      snapshotOptions: plentyOfDisk,
       startWatcher: () => {},
     });
     expect(result.success).toBe(true);

package/test/regression-224.js

@@ -59,6 +59,8 @@ afterEach(() => {
 const SAFETY = require.resolve('../src/lib/docker-snapshot-safety');
 
 /** Hold the snapshot lock in another process for `holdMs`. */
+// A waiter polls for 1 s before it reads the holder's name, so tests that
+// expect the name hold the lock well past that, even on a slow runner.
 async function holdLockElsewhere(lockPath, holder, holdMs) {
   const ready = `${lockPath}.ready`;
   const child = spawn(
@@ -264,7 +266,7 @@ describe('issue #224 item 1: waiting for the snapshot lock', () => {
 
   it('waits for the holder with --snapshot-wait and says so once', async () => {
     const lockPath = path.join(makeTempDir('lock-224-'), 'snapshot.lock');
-    await holdLockElsewhere(lockPath, 'task-a', 1500);
+    await holdLockElsewhere(lockPath, 'task-a', 3000);
     const lines = [];
     const started = Date.now();
     const lock = acquireSnapshotLock({
@@ -307,7 +309,7 @@ describe('issue #224 item 1: waiting for the snapshot lock', () => {
 
   it('serializes two concurrent CLI resumes instead of failing the second', async () => {
     const lockPath = path.join(makeTempDir('lock-224-'), 'snapshot.lock');
-    await holdLockElsewhere(lockPath, 'task-a', 1200);
+    await holdLockElsewhere(lockPath, 'task-a', 3000);
     const { store } = snapshotRecord();
     const calls = [];
     const lines = [];

package/test/regression-231.js

@@ -12,6 +12,7 @@ const { parseArgs } = require('../src/lib/args-parser');
 const {
   ExecutionStore,
   ExecutionRecord,
+  isClinkInstalled,
 } = require('../src/lib/execution-store');
 const {
   executionAliases,
@@ -126,6 +127,25 @@ describe('issue #231: execution names', () => {
     ]);
   });
 
+  // Issue #253: the rename used to reach only the lino store; clink 4.x
+  // rejected every links query the store built.
+  it.skipIf(!isClinkInstalled())(
+    '--rename reaches the links database',
+    () => {
+      const { store } = sandbox();
+      store.save(record(A, { sessionName: 'screen-a' }));
+      nameExecution(store, A, 'first', { rename: true });
+      const links = store.execClink('((($id: $s $t)) (($id: $s $t)))', [
+        '--changes',
+      ]).output;
+      expect(links).toContain(
+        `${A}.options: ${A} 'options={"sessionName":"screen-a","name":"first"}'`
+      );
+      expect(store.verifyConsistency().errors).toEqual([]);
+    },
+    30000
+  );
+
   it('a UUID-shaped alias resolves like any other name', () => {
     const { store } = sandbox();
     store.save(record(A));