start-command 0.39.2 → 0.40.0

package/test/execution-store.js

@@ -367,13 +367,12 @@ describe('ExecutionStore', () => {
     const linoPath = path.join(TEST_APP_FOLDER, LINO_DB_FILE);
     expect(fs.existsSync(linoPath)).toBe(true);
 
-    // Read and verify content - lino format uses base64 encoding for strings
+    // lino-objects-codec 0.9 writes readable links notation (#253)
     const content = fs.readFileSync(linoPath, 'utf8');
     expect(content.length).toBeGreaterThan(0);
-    // Verify content has array structure
-    expect(content).toContain('(array');
-    // Verify PID is stored (as int)
-    expect(content).toContain('(int 12345)');
+    expect(content).toContain('command "echo hello"');
+    // Verify PID is stored as a bare integer
+    expect(content).toContain('pid 12345');
   });
 });
 
@@ -449,6 +448,51 @@ describe('ExecutionStore with lino-objects-codec', () => {
     expect(retrieved.command).toBe('echo "Hello 世界 🌍"');
     expect(retrieved.logPath).toBe('/tmp/unicode-日本語.log');
   });
+
+  it('reads a store written by lino-objects-codec 0.4.0 and rewrites it readable (#253)', () => {
+    fs.mkdirSync(TEST_APP_FOLDER, { recursive: true });
+    fs.copyFileSync(
+      path.join(__dirname, 'fixtures/executions-lino-objects-codec-0.4.0.lino'),
+      path.join(TEST_APP_FOLDER, LINO_DB_FILE)
+    );
+    const uuid = '25300000-0000-4000-8000-000000000253';
+
+    const legacy = store.get(uuid);
+    expect(legacy.pid).toBe(4242);
+    expect(legacy.exitCode).toBe(0);
+    expect(legacy.command).toBe('echo "legacy store"');
+
+    store.save(new ExecutionRecord({ command: 'echo next' }));
+    const content = fs.readFileSync(
+      path.join(TEST_APP_FOLDER, LINO_DB_FILE),
+      'utf8'
+    );
+    expect(content).toContain('command "echo next"');
+    expect(content).not.toContain('(str ');
+    expect(store.get(uuid).command).toBe('echo "legacy store"');
+  });
+
+  it('reads a readable store written by lino-objects-codec 0.9 (#253)', () => {
+    // rust/tests/regression_253.rs reads the same fixture
+    fs.mkdirSync(TEST_APP_FOLDER, { recursive: true });
+    fs.copyFileSync(
+      path.join(__dirname, 'fixtures/executions-lino-objects-codec-0.9.3.lino'),
+      path.join(TEST_APP_FOLDER, LINO_DB_FILE)
+    );
+
+    const record = store.get('25300000-0000-4000-8000-000000000930');
+    expect(record.pid).toBe(4242);
+    expect(record.exitCode).toBe(0);
+    expect(record.command).toBe(
+      `echo "readable store" (with) \\ odd chars 'q' 世界`
+    );
+    expect(record.endTime).toBe('2026-10-01T00:00:01.000Z');
+    expect(record.options).toEqual({
+      isolated: 'docker',
+      keepAlive: false,
+      nested: { list: [1, 'two', null] },
+    });
+  });
 });
 
 describe('ExecutionStore verifyConsistency', () => {

package/test/fixtures/executions-lino-objects-codec-0.4.0.lino

@@ -0,0 +1 @@
+(array (object ((str dXVpZA==) (str MjUzMDAwMDAtMDAwMC00MDAwLTgwMDAtMDAwMDAwMDAwMjUz)) ((str cGlk) (int 4242)) ((str c3RhdHVz) (str ZXhlY3V0ZWQ=)) ((str ZXhpdENvZGU=) (int 0)) ((str Y29tbWFuZA==) (str ZWNobyAibGVnYWN5IHN0b3JlIg==)) ((str bG9nUGF0aA==) (str L3RtcC9zdGFydC0yNTMubG9n)) ((str c3RhcnRUaW1l) (str MjAyNi0xMC0wMVQwMDowMDowMC4wMDBa)) ((str ZW5kVGltZQ==) (str MjAyNi0xMC0wMVQwMDowMDowMS4wMDBa)) ((str d29ya2luZ0RpcmVjdG9yeQ==) (str L3RtcA==)) ((str c2hlbGw=) (str L2Jpbi9zaA==)) ((str cGxhdGZvcm0=) (str bGludXg=)) ((str b3B0aW9ucw==) (object ((str aXNvbGF0ZWQ=) (null))))))

package/test/fixtures/executions-lino-objects-codec-0.9.3.lino

@@ -0,0 +1,26 @@
+(
+  (
+    uuid "25300000-0000-4000-8000-000000000930"
+    pid 4242
+    status "executed"
+    exitCode 0
+    command """echo "readable store" (with) \ odd chars 'q' 世界"""
+    logPath "/tmp/start-253-readable.log"
+    startTime "2026-10-01T00:00:00.000Z"
+    endTime "2026-10-01T00:00:01.000Z"
+    workingDirectory "/tmp"
+    shell "/bin/sh"
+    platform "linux"
+    options (
+      isolated "docker"
+      keepAlive false
+      nested (
+        list (
+          1
+          "two"
+          null
+        )
+      )
+    )
+  )
+)

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

package/test/release-git.mjs

@@ -87,7 +87,8 @@ describe('release-git (#211)', () => {
     await withRepo({ reject: true }, async () => {
       const result = await $`git push origin main`.run(quiet);
       expect(result.code).not.toBe(0);
-      expect(result.stderr).toContain('GH013');
+      // command-stream 2.x returns stderr as a readable snapshot (#253).
+      expect(String(result.stderr)).toContain('GH013');
     });
   });