start-command 0.37.9 → 0.38.0

package/test/args-parser-attach-resume.js

@@ -142,7 +142,7 @@ describe('query mode exclusivity', () => {
     test(`rejects ${args.join(' ')}`, () => {
       assert.throws(() => {
         parse(args);
-      }, /Cannot combine --status, --list, --upload-log, --stop, --terminate, --attach, --resume, --resume-all, or --cleanup/);
+      }, /Cannot combine --status, --list, --upload-log, --stop, --terminate, --attach, --resume, --resume-all, --cleanup, --alias, or --rename/);
     });
   }
 });

package/test/args-parser-control.js

@@ -54,13 +54,13 @@ describe('control options', () => {
   it('should reject combining query and control modes', () => {
     assert.throws(() => {
       parseArgs(['--status', 'uuid-here', '--stop', 'my-session']);
-    }, /Cannot combine --status, --list, --upload-log, --stop, --terminate, --attach, --resume, --resume-all, or --cleanup/);
+    }, /Cannot combine --status, --list, --upload-log, --stop, --terminate, --attach, --resume, --resume-all, --cleanup, --alias, or --rename/);
   });
 
   it('should reject combining upload-log with control modes', () => {
     assert.throws(() => {
       parseArgs(['--upload-log', 'uuid-here', '--terminate', 'my-session']);
-    }, /Cannot combine --status, --list, --upload-log, --stop, --terminate, --attach, --resume, --resume-all, or --cleanup/);
+    }, /Cannot combine --status, --list, --upload-log, --stop, --terminate, --attach, --resume, --resume-all, --cleanup, --alias, or --rename/);
   });
 
   it('should reject output-format with control modes', () => {

package/test/regression-229.js

@@ -0,0 +1,267 @@
+/**
+ * Issue #229: a new launch with an existing --session-id used to replace the
+ * execution record and truncate its log. It is now refused unless
+ * --append-attempt is given, which keeps the record and appends the new
+ * attempt to the same log.
+ */
+const { describe, it, expect } = require('bun:test');
+const { spawnSync } = require('child_process');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { parseArgs } = require('../src/lib/args-parser');
+const {
+  ExecutionStore,
+  ExecutionRecord,
+} = require('../src/lib/execution-store');
+const {
+  LaunchRefusedError,
+  alreadyExistsMessage,
+  claimLaunch,
+  mergeAppendedAttempt,
+  preflightLaunch,
+} = require('../src/lib/launch-identity');
+
+const CLI = path.join(__dirname, '../src/bin/cli.js');
+const UUID = '22900000-0000-4000-8000-000000000229';
+
+function sandbox() {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'start-229-'));
+  const app = path.join(root, 'app');
+  const logs = path.join(root, 'logs');
+  return {
+    root,
+    app,
+    logs,
+    env: {
+      ...process.env,
+      START_APP_FOLDER: app,
+      START_LOG_DIR: logs,
+      START_DISABLE_AUTO_ISSUE: '1',
+      START_DISABLE_LOG_UPLOAD: '1',
+      START_EXECUTION_ID: '',
+    },
+  };
+}
+
+function run(box, args) {
+  return spawnSync(process.execPath, [CLI, ...args], {
+    env: box.env,
+    encoding: 'utf8',
+    timeout: 20000,
+  });
+}
+
+function storeOf(box) {
+  return new ExecutionStore({ appFolder: box.app });
+}
+
+describe('issue #229: an existing --session-id is never overwritten', () => {
+  if (process.platform === 'win32') {
+    return;
+  }
+
+  it('refuses a second launch and keeps the first log intact', () => {
+    const box = sandbox();
+    const first = run(box, ['--session-id', UUID, '--', 'echo', 'first-run']);
+    expect(first.status).toBe(0);
+    const logPath = storeOf(box).get(UUID).logPath;
+    const before = fs.readFileSync(logPath, 'utf8');
+
+    const second = run(box, ['--session-id', UUID, '--', 'echo', 'second']);
+    expect(second.status).toBe(1);
+    expect(second.stderr).toContain(alreadyExistsMessage(UUID));
+    expect(second.stdout).not.toContain('second');
+    expect(fs.readFileSync(logPath, 'utf8')).toBe(before);
+    const record = storeOf(box).get(UUID);
+    expect(record.command).toBe('echo first-run');
+    expect(record.attemptHistory || []).toEqual([]);
+  });
+
+  it('--append-attempt keeps the record and appends to the same log', () => {
+    const box = sandbox();
+    run(box, ['--session-id', UUID, '--', 'echo', 'first-run']);
+    const logPath = storeOf(box).get(UUID).logPath;
+    const firstSize = fs.statSync(logPath).size;
+
+    const appended = run(box, [
+      '--session-id',
+      UUID,
+      '--append-attempt',
+      '--',
+      'sh',
+      '-c',
+      'echo second-run $START_ATTEMPT',
+    ]);
+    expect(appended.status).toBe(0);
+    expect(appended.stdout).toContain('second-run 2');
+
+    const log = fs.readFileSync(logPath, 'utf8');
+    expect(log).toContain('first-run');
+    expect(log).toContain('second-run 2');
+    expect(log.split('=== Start Command Log ===').length - 1).toBe(2);
+    expect(log).toContain('"event":"attempt-appended"');
+
+    const record = storeOf(box).get(UUID);
+    expect(record.attempt.number).toBe(2);
+    expect(record.attempt.mode).toBe('append-attempt');
+    expect(record.attempt.logOffset).toBe(firstSize);
+    expect(record.attemptHistory).toHaveLength(1);
+    expect(record.attemptHistory[0]).toMatchObject({
+      number: 1,
+      logOffset: 0,
+      command: 'echo first-run',
+      exitCode: 0,
+    });
+    expect(record.logPath).toBe(logPath);
+  });
+
+  it('refuses an id that is the name of another execution', () => {
+    const box = sandbox();
+    const other = '22900000-0000-4000-8000-000000000001';
+    run(box, ['--session-id', other, '--', 'echo', 'x']);
+    expect(run(box, ['--alias', other, UUID]).status).toBe(0);
+    const launch = run(box, ['--session-id', UUID, '--', 'echo', 'y']);
+    expect(launch.status).toBe(1);
+    expect(launch.stderr).toContain(
+      `execution id ${UUID} is already used as a name of execution ${other}`
+    );
+  });
+
+  it('recognises an untracked execution by its log file', () => {
+    const box = sandbox();
+    box.env.START_DISABLE_TRACKING = '1';
+    const logPath = path.join(box.logs, 'direct', `${UUID}.log`);
+    fs.mkdirSync(path.dirname(logPath), { recursive: true });
+    fs.writeFileSync(logPath, '=== Start Command Log ===\nold\n');
+    const store = { get: () => null };
+    expect(() =>
+      preflightLaunch({
+        store,
+        sessionId: UUID,
+        explicitSessionId: true,
+        logPath,
+        env: {},
+      })
+    ).toThrow(LaunchRefusedError);
+    const launch = preflightLaunch({
+      store,
+      sessionId: UUID,
+      explicitSessionId: true,
+      appendAttempt: true,
+      logPath,
+      env: {},
+    });
+    expect(launch).toMatchObject({ append: true, attemptNumber: 2 });
+  });
+
+  it('refuses --append-attempt while the execution is still running', () => {
+    const record = new ExecutionRecord({ uuid: UUID, command: 'sleep 9' });
+    record.pid = process.pid;
+    expect(() =>
+      preflightLaunch({
+        store: { get: () => record },
+        sessionId: UUID,
+        explicitSessionId: true,
+        appendAttempt: true,
+        logPath: '/nonexistent',
+        env: {},
+      })
+    ).toThrow(/is still running/);
+  });
+
+  it('lets the next level of a stacked isolation reuse the id', () => {
+    const record = new ExecutionRecord({ uuid: UUID, command: 'x' });
+    const launch = preflightLaunch({
+      store: { get: () => record },
+      sessionId: UUID,
+      explicitSessionId: true,
+      logPath: '/nonexistent',
+      env: { START_EXECUTION_ID: UUID, START_ATTEMPT: '3' },
+    });
+    expect(launch).toMatchObject({ nested: true, attemptNumber: 3 });
+  });
+
+  it('a generated id is never checked', () => {
+    const launch = preflightLaunch({
+      store: {
+        get: () => {
+          throw new Error('must not be read');
+        },
+      },
+      sessionId: UUID,
+      explicitSessionId: false,
+      logPath: '/nonexistent',
+    });
+    expect(launch).toMatchObject({ append: false, checked: false });
+  });
+
+  it('claimLaunch refuses a launch that lost the race for the id', () => {
+    const box = sandbox();
+    const store = storeOf(box);
+    const launch = preflightLaunch({
+      store,
+      sessionId: UUID,
+      explicitSessionId: true,
+      logPath: path.join(box.root, 'none.log'),
+      env: {},
+    });
+    store.save(new ExecutionRecord({ uuid: UUID, command: 'winner' }));
+    expect(() =>
+      claimLaunch(
+        store,
+        new ExecutionRecord({ uuid: UUID, command: 'loser' }),
+        launch
+      )
+    ).toThrow(LaunchRefusedError);
+    expect(store.get(UUID).command).toBe('winner');
+  });
+
+  it('mergeAppendedAttempt keeps names, continuation and history', () => {
+    const previous = new ExecutionRecord({
+      uuid: UUID,
+      command: 'old',
+      logPath: '/nonexistent.log',
+      options: { sessionName: 'old-s', aliases: ['a'], name: 'n' },
+    });
+    previous.continues = '22900000-0000-4000-8000-000000000002';
+    previous.complete(3);
+    const record = new ExecutionRecord({
+      uuid: UUID,
+      command: 'new',
+      options: { sessionName: 'new-s' },
+    });
+    mergeAppendedAttempt(record, previous);
+    expect(record.startTime).toBe(previous.startTime);
+    expect(record.continues).toBe(previous.continues);
+    expect(record.options).toMatchObject({
+      sessionName: 'new-s',
+      sessionNameHistory: ['old-s'],
+      aliases: ['a'],
+      name: 'n',
+    });
+    expect(record.attempt.number).toBe(2);
+    expect(record.attemptHistory[0]).toMatchObject({
+      number: 1,
+      exitCode: 3,
+      sessionName: 'old-s',
+    });
+  });
+
+  it('parses --append-attempt and requires --session-id', () => {
+    const parsed = parseArgs([
+      '--session-id',
+      UUID,
+      '--append-attempt',
+      '--',
+      'echo',
+    ]);
+    expect(parsed.wrapperOptions.appendAttempt).toBe(true);
+    expect(() => parseArgs(['--append-attempt', '--', 'echo'])).toThrow(
+      '--append-attempt option requires --session-id <uuid>'
+    );
+    expect(() => parseArgs(['--status', UUID, '--append-attempt'])).toThrow(
+      '--append-attempt option is only valid when launching a command'
+    );
+  });
+});

package/test/regression-230.js

@@ -0,0 +1,234 @@
+/**
+ * Issue #230: every backend exports START_EXECUTION_ID, START_SESSION_NAME and
+ * START_ATTEMPT to the command it runs, so a supervisor can recognise its
+ * own executions without parsing the start block.
+ */
+const { describe, it, expect } = require('bun:test');
+const { spawnSync } = require('child_process');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const {
+  buildExecutionEnv,
+  buildExecutionEnvExport,
+  executionEnvFromOptions,
+  isNestedLaunchOf,
+  prefixWithExecutionEnv,
+} = require('../src/lib/execution-env');
+const { buildDockerRuntimeArgs } = require('../src/lib/docker-runtime-args');
+const {
+  buildCommandHandoffArgs,
+  writeExecutionEnvHandoff,
+} = require('../src/lib/docker-command-handoff');
+const { nextAttemptNumber } = require('../src/lib/execution-attempt');
+const { isolatedUserCommand } = require('../src/lib/launch-identity');
+
+const CLI = path.join(__dirname, '../src/bin/cli.js');
+const UUID = '23000000-0000-4000-8000-000000000230';
+const PRINT =
+  'echo "ID=$START_EXECUTION_ID S=$START_SESSION_NAME A=$START_ATTEMPT"';
+
+function run(args, extraEnv = {}) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'start-230-'));
+  return spawnSync(process.execPath, [CLI, ...args], {
+    env: {
+      ...process.env,
+      START_APP_FOLDER: path.join(root, 'app'),
+      START_LOG_DIR: path.join(root, 'logs'),
+      START_DISABLE_AUTO_ISSUE: '1',
+      START_DISABLE_LOG_UPLOAD: '1',
+      START_EXECUTION_ID: '',
+      ...extraEnv,
+    },
+    encoding: 'utf8',
+    timeout: 30000,
+  });
+}
+
+function hasCommand(name) {
+  return spawnSync('sh', ['-c', `command -v ${name}`]).status === 0;
+}
+
+describe('issue #230: START_* execution identity variables', () => {
+  it('builds the three variables, attempt 1 by default', () => {
+    expect(buildExecutionEnv({ executionId: UUID, sessionName: 's' })).toEqual({
+      START_EXECUTION_ID: UUID,
+      START_SESSION_NAME: 's',
+      START_ATTEMPT: '1',
+    });
+    expect(buildExecutionEnv({})).toEqual({});
+    expect(
+      executionEnvFromOptions({
+        sessionId: UUID,
+        session: 'tmux-1',
+        attemptNumber: 4,
+      })
+    ).toMatchObject({ START_SESSION_NAME: 'tmux-1', START_ATTEMPT: '4' });
+  });
+
+  it('quotes the export prefix used by screen, tmux and ssh', () => {
+    const env = buildExecutionEnv({
+      executionId: UUID,
+      sessionName: "it's",
+      attempt: 2,
+    });
+    expect(buildExecutionEnvExport(env)).toBe(
+      `export START_EXECUTION_ID='${UUID}' START_SESSION_NAME='it'\\''s' START_ATTEMPT='2'`
+    );
+    const out = spawnSync('sh', ['-c', prefixWithExecutionEnv(PRINT, env)], {
+      encoding: 'utf8',
+    }).stdout;
+    expect(out.trim()).toBe(`ID=${UUID} S=it's A=2`);
+  });
+
+  it('passes them to docker run after the user --env, so they win', () => {
+    const args = buildDockerRuntimeArgs({
+      env: [`START_EXECUTION_ID=spoofed`],
+      sessionId: UUID,
+      containerName: 'box',
+      attemptNumber: 3,
+    });
+    const envs = args.filter((_, i) => args[i - 1] === '-e');
+    expect(envs).toEqual([
+      'START_EXECUTION_ID=spoofed',
+      `START_EXECUTION_ID=${UUID}`,
+      'START_SESSION_NAME=box',
+      'START_ATTEMPT=3',
+    ]);
+  });
+
+  it('the docker handoff selector sources the next attempt variables', () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'start-230-handoff-'));
+    const marker = path.join(dir, 'marker');
+    const calls = [];
+    writeExecutionEnvHandoff(
+      'box',
+      buildExecutionEnv({ executionId: UUID, sessionName: 'box', attempt: 2 }),
+      (cmd, argv) => {
+        calls.push(argv);
+        fs.copyFileSync(argv[1], `${marker}.env`);
+        return { status: 0 };
+      }
+    );
+    expect(calls[0][2]).toBe('box:/.start-command-resume-box.env');
+    const [shell, ...rest] = buildCommandHandoffArgs(
+      ['sh', '-c', PRINT],
+      marker
+    );
+    const out = spawnSync(shell, rest, {
+      encoding: 'utf8',
+      env: { ...process.env, START_ATTEMPT: '1' },
+    }).stdout;
+    expect(out.trim()).toBe(`ID=${UUID} S=box A=2`);
+  });
+
+  it('numbers the next attempt after resumes and recoveries', () => {
+    expect(nextAttemptNumber({})).toBe(2);
+    expect(nextAttemptNumber({ attempt: { number: 3 } })).toBe(4);
+    expect(nextAttemptNumber({ options: { resumeCount: 1 } })).toBe(3);
+  });
+
+  it('recognises the next level of a stacked isolation', () => {
+    expect(isNestedLaunchOf(UUID, { START_EXECUTION_ID: UUID })).toBe(true);
+    expect(isNestedLaunchOf(UUID, { START_EXECUTION_ID: 'other' })).toBe(false);
+    expect(isNestedLaunchOf(UUID, {})).toBe(false);
+  });
+
+  if (process.platform === 'win32') {
+    return;
+  }
+
+  it('an --isolated-user run exports them with an empty session name', () => {
+    const command = isolatedUserCommand(PRINT, UUID, { attemptNumber: 2 });
+    expect(command).toStartWith('export START_EXECUTION_ID=');
+    const result = spawnSync('sh', ['-c', command], { encoding: 'utf8' });
+    expect(result.stdout.trim()).toBe(`ID=${UUID} S= A=2`);
+  });
+
+  it("$ --session-id X -- sh -c 'echo $START_EXECUTION_ID' prints X", () => {
+    const result = run([
+      '--session-id',
+      UUID,
+      '--',
+      'sh',
+      '-c',
+      'echo $START_EXECUTION_ID',
+    ]);
+    expect(result.status).toBe(0);
+    expect(result.stdout).toContain(`\n${UUID}\n`);
+  });
+
+  it('a direct run exports an empty session name and attempt 1', () => {
+    const result = run(['--session-id', UUID, '--', 'sh', '-c', PRINT]);
+    expect(result.stdout).toContain(`ID=${UUID} S= A=1`);
+  });
+
+  it('a generated execution id is exported too', () => {
+    const result = run(['--', 'sh', '-c', PRINT]);
+    const match = /ID=([0-9a-f-]{36}) S= A=1/.exec(result.stdout);
+    expect(match).not.toBeNull();
+    expect(result.stdout).toContain(match[1]);
+  });
+
+  it('the command-stream runner exports them', () => {
+    const result = run(
+      ['--session-id', UUID, '--use-command-stream', '--', 'sh', '-c', PRINT],
+      {}
+    );
+    expect(result.stdout).toContain(`ID=${UUID} S= A=1`);
+  });
+
+  it.skipIf(!hasCommand('screen'))(
+    'screen exports them with the session name',
+    () => {
+      const session = `start-230-${process.pid}`;
+      const result = run([
+        '-i',
+        'screen',
+        '--session',
+        session,
+        '--session-id',
+        UUID,
+        '--',
+        'sh',
+        '-c',
+        PRINT,
+      ]);
+      expect(result.stdout).toContain(`ID=${UUID} S=${session} A=1`);
+    },
+    30000
+  );
+
+  // Attached tmux needs a terminal, which CI and test runners do not have,
+  // so this runs detached and reads the command output from the log.
+  it.skipIf(!hasCommand('tmux'))(
+    'tmux exports them with the session name',
+    () => {
+      const session = `start-230-tmux-${process.pid}`;
+      const result = run([
+        '-i',
+        'tmux',
+        '--detached',
+        '--session',
+        session,
+        '--session-id',
+        UUID,
+        '--',
+        'sh',
+        '-c',
+        PRINT,
+      ]);
+      expect(result.status).toBe(0);
+      const logPath = result.stdout.match(/^│ log\s+(.+)$/m)[1].trim();
+      const expected = `ID=${UUID} S=${session} A=1`;
+      let log = '';
+      for (let i = 0; i < 100 && !log.includes(expected); i++) {
+        spawnSync('sleep', ['0.1']);
+        log = fs.existsSync(logPath) ? fs.readFileSync(logPath, 'utf8') : '';
+      }
+      spawnSync('tmux', ['kill-session', '-t', session]);
+      expect(log).toContain(expected);
+    },
+    30000
+  );
+});