start-command 0.37.9 → 0.39.0

package/src/lib/execution-store.js

@@ -25,6 +25,7 @@ const os = require('os');
 const { execFileSync, spawnSync } = require('child_process');
 const crypto = require('crypto');
 const { atomicWrite } = require('./atomic-write');
+const { decodeStoreContent } = require('./store-decode-cache');
 
 // Synchronous wrapper using Bun's native ESM support
 // This works because Bun handles ESM/CJS interop
@@ -38,6 +39,12 @@ function encodeSync(data) {
   }
 }
 
+const DECODE_LOG = {
+  memory: () => 'Reused the decoded store: the file is unchanged',
+  copy: () => 'Read the decoded copy of the store: the file is unchanged',
+  decode: (content) => `Decoded the store (${content.length} characters)`,
+};
+
 function decodeSync(notation) {
   try {
     const codec = require('lino-objects-codec');
@@ -52,6 +59,8 @@ const DEFAULT_APP_FOLDER = path.join(os.homedir(), '.start-command');
 const LINO_DB_FILE = 'executions.lino';
 const LINKS_DB_FILE = 'executions.links';
 const LOCK_FILE = 'executions.lock';
+// Decoded records as JSON, for the next process (issue #243)
+const DECODED_COPY_FILE = 'executions.decoded.js.json';
 const { LockManager } = require('./store-lock');
 
 /**
@@ -77,6 +86,8 @@ class ExecutionRecord {
     this.endTime = options.endTime || null;
     this.attempt = options.attempt;
     this.attemptHistory = options.attemptHistory;
+    // UUID of the execution this one continues (`--continues`, issue #231).
+    this.continues = options.continues || undefined;
     // Provenance of `endTime` (issue #170.2). `--status` used to fabricate a
     // finish time with `new Date()` whenever the record had none, which made an
     // observation indistinguishable from a real finish time. One of
@@ -172,6 +183,9 @@ class ExecutionRecord {
     if (this.attemptHistory) {
       obj.attemptHistory = this.attemptHistory;
     }
+    if (this.continues) {
+      obj.continues = this.continues;
+    }
     if (this.endTimeSource !== undefined && this.endTimeSource !== null) {
       obj.endTimeSource = this.endTimeSource;
     }
@@ -257,6 +271,7 @@ class ExecutionStore {
     this.linoDbPath = path.join(this.appFolder, LINO_DB_FILE);
     this.linksDbPath = path.join(this.appFolder, LINKS_DB_FILE);
     this.lockFilePath = path.join(this.appFolder, LOCK_FILE);
+    this.decodedCopyPath = path.join(this.appFolder, DECODED_COPY_FILE);
     this.useLinks = options.useLinks !== false && isClinkInstalled();
     this.verbose = options.verbose || false;
 
@@ -297,7 +312,14 @@ class ExecutionStore {
         return [];
       }
 
-      const data = decodeSync(content);
+      // Decoded once per content, not once per call (issue #243).
+      const { data, source } = decodeStoreContent(
+        this.linoDbPath,
+        content,
+        decodeSync,
+        { copyPath: this.decodedCopyPath }
+      );
+      this.log(DECODE_LOG[source](content));
       if (!Array.isArray(data)) {
         return [];
       }
@@ -544,33 +566,17 @@ class ExecutionStore {
   /**
    * Get an execution record by UUID or session name
    * First tries exact UUID match, then the current session name, then any
-   * session name the execution used before it was resumed
+   * session name the execution used before it was resumed, then the display
+   * name and aliases
    * @param {string} identifier - UUID or session name
    * @returns {ExecutionRecord|null}
    */
   get(identifier) {
-    const records = this.readLinoRecords();
-    // First try exact UUID match
-    const byUuid = records.find((r) => r.uuid === identifier);
-    if (byUuid) {
-      return byUuid;
-    }
-    // Fall back to session name lookup (stored in options.sessionName)
-    const bySessionName = records.find(
-      (r) => r.options && r.options.sessionName === identifier
-    );
-    if (bySessionName) {
-      return bySessionName;
-    }
-    // Finally, honor session names this record used before it was resumed, so
-    // one logical session stays addressable across restarts (issue #162).
-    const byPreviousSessionName = records.find(
-      (r) =>
-        r.options &&
-        Array.isArray(r.options.sessionNameHistory) &&
-        r.options.sessionNameHistory.includes(identifier)
+    // Names, display names and aliases resolve too (issues #162, #231).
+    return require('./execution-identity').findRecord(
+      this.readLinoRecords(),
+      identifier
     );
-    return byPreviousSessionName || null;
   }
 
   /**
@@ -926,4 +932,5 @@ module.exports = {
   LINO_DB_FILE,
   LINKS_DB_FILE,
   LOCK_FILE,
+  DECODED_COPY_FILE,
 };

package/src/lib/exit-evidence.js

@@ -5,6 +5,16 @@ const MAIN_OOM = 'Exit evidence: main-oom (recent cgroup oom_kill delta)';
 const DOCKER_OOM = 'Exit evidence: main-oom (recent Docker oom event)';
 const DAEMON_RESTART =
   'Exit evidence: docker-daemon-restart (Docker service journal)';
+const DAEMON_RESTART_API =
+  'Exit evidence: docker-daemon-restart (Docker API: containers finished together)';
+const DAEMON_RESTART_PREFIX = 'Exit evidence: docker-daemon-restart';
+// dockerd gives every container its stop timeout and kills the rest within its
+// 15 s shutdown timeout, so the containers of one restart finish this close.
+const DAEMON_RESTART_WINDOW_MS = 15000;
+const CONTAINER_STATE_FORMAT =
+  '{{.Id}} {{.State.FinishedAt}} {{.State.StartedAt}} {{.State.ExitCode}} {{.State.OOMKilled}}';
+// Bounds one `docker inspect` call on hosts with many stopped containers.
+const MAX_PEER_CONTAINERS = 256;
 
 function recentOomDelta(sample, finishedAt) {
   const fields = String(sample || '')
@@ -39,6 +49,42 @@ function daemonRestartEvidence(journal, containerId) {
   return Boolean(exited && forced);
 }
 
+/**
+ * Socket-only daemon-restart evidence (issue #241): another container that
+ * finished within the same shutdown window, was not OOM-killed, and was either
+ * stopped by a signal (137/143) or started again afterwards (restart policy;
+ * moby resets its ExitCode to 0 but keeps FinishedAt). `docker events` cannot
+ * be used: its buffer does not survive the restart, while State does.
+ * @param {string} states - `CONTAINER_STATE_FORMAT` lines, one per container
+ */
+function daemonRestartApiEvidence(states, containerId, finishedAt) {
+  const finished = Date.parse(finishedAt);
+  return (
+    Number.isFinite(finished) &&
+    String(states || '')
+      .split('\n')
+      .some((line) => {
+        const [id, peerFinished, peerStarted, exit, oom] = line
+          .trim()
+          .split(/\s+/);
+        const end = Date.parse(peerFinished);
+        if (
+          !/^[a-f0-9]{64}$/.test(id || '') ||
+          id === containerId ||
+          oom !== 'false' ||
+          !Number.isFinite(end) ||
+          end <= 0 ||
+          Math.abs(end - finished) > DAEMON_RESTART_WINDOW_MS
+        ) {
+          return false;
+        }
+        return (
+          exit === '137' || exit === '143' || Date.parse(peerStarted) > end
+        );
+      })
+  );
+}
+
 function recentDockerOom(events, finishedAt) {
   const finished = Date.parse(finishedAt) / 1000;
   return (
@@ -68,6 +114,10 @@ function collectExitEvidence(
   // A local journal cannot diagnose a remote daemon. Require a local socket.
   const local =
     !process.env.DOCKER_HOST || process.env.DOCKER_HOST.startsWith('unix://');
+  const sampledOom =
+    (oomKilled === true || oomKilled === 'true') &&
+    (Number(exitCode) === 137 || Number(exitCode) < 0) &&
+    recentOomDelta(sample, finishedAt);
   if (
     Number(exitCode) === 137 &&
     containerName &&
@@ -114,18 +164,35 @@ function collectExitEvidence(
       if (events.success && recentDockerOom(events.stdout, finishedAt)) {
         return DOCKER_OOM;
       }
+      // Without a host journal (a mounted docker.sock, a remote daemon) the
+      // only record of the restart is the state of the other containers.
+      const peers = sampledOom
+        ? { success: false, stdout: '' }
+        : run(docker, ['ps', '-a', '-q', '--no-trunc']);
+      const ids = peers.stdout
+        .split(/\s+/)
+        .filter(
+          (peer) => /^[a-f0-9]{64}$/.test(peer) && peer !== id.stdout.trim()
+        )
+        .slice(0, MAX_PEER_CONTAINERS);
+      // A container removed after `docker ps` fails inspect with status 1 but
+      // the others are still printed, so the output is used either way.
+      const states = ids.length
+        ? run(docker, ['inspect', '-f', CONTAINER_STATE_FORMAT, ...ids])
+        : { success: false, stdout: '' };
+      if (
+        daemonRestartApiEvidence(states.stdout, id.stdout.trim(), finishedAt)
+      ) {
+        return DAEMON_RESTART_API;
+      }
       if (process.env.START_DEBUG === '1') {
         console.error(
-          `[DEBUG] Exit evidence: container=${id.stdout.trim()} finishedAt=${finishedAt} eventsAvailable=${events.success} oomEvents=${JSON.stringify(events.stdout)} sample=${JSON.stringify(sample || '')}`
+          `[DEBUG] Exit evidence: container=${id.stdout.trim()} finishedAt=${finishedAt} eventsAvailable=${events.success} oomEvents=${JSON.stringify(events.stdout)} peerContainers=${ids.length} peerStates=${JSON.stringify(states.stdout)} sample=${JSON.stringify(sample || '')}`
         );
       }
     }
   }
-  if (
-    (oomKilled === true || oomKilled === 'true') &&
-    (Number(exitCode) === 137 || Number(exitCode) < 0) &&
-    recentOomDelta(sample, finishedAt)
-  ) {
+  if (sampledOom) {
     return MAIN_OOM;
   }
   return 'Exit evidence: unavailable (no attributed exit-time OOM or daemon restart evidence)';
@@ -134,12 +201,72 @@ function collectExitEvidence(
 function fromLog(log) {
   const lines = String(log || '').split('\n');
   const last = lines.filter((line) => line.startsWith('Exit evidence:')).at(-1);
+  const daemonRestart = Boolean(last?.startsWith(DAEMON_RESTART_PREFIX));
   return {
     mainOom: last === MAIN_OOM || last === DOCKER_OOM,
-    daemonRestart: last === DAEMON_RESTART,
+    daemonRestart,
+    // Which source attributed the restart: the host journal or the API.
+    ...(daemonRestart
+      ? { daemonRestartSource: last === DAEMON_RESTART_API ? 'api' : 'journal' }
+      : {}),
   };
 }
 
+/** The stored `daemonRestartSource`, kept only when a restart was attributed. */
+function sourceOf(logged) {
+  return logged?.daemonRestart && logged.daemonRestartSource
+    ? { daemonRestartSource: logged.daemonRestartSource }
+    : {};
+}
+
+// A watcher that shares the daemon with its task (a mounted docker.sock) dies
+// in the same restart and never logs evidence, so `--status` collects it from
+// the container state that survived, once per process (issue #241).
+const lostWatcherEvidence = new Map();
+function collectLostWatcherEvidence(record, state, runner) {
+  const name = record?.options?.sessionName;
+  if (
+    !name ||
+    record.options.exitEvidence ||
+    state?.running !== false ||
+    state.exitCode !== 137 ||
+    !state.finishedAt
+  ) {
+    return null;
+  }
+  const key = `${name}\0${state.finishedAt}`;
+  if (!lostWatcherEvidence.has(key)) {
+    const logged = fromLog(
+      collectExitEvidence(
+        {
+          containerName: name,
+          finishedAt: state.finishedAt,
+          exitCode: state.exitCode,
+          oomKilled: state.oomKilled,
+        },
+        runner
+      )
+    );
+    lostWatcherEvidence.set(key, {
+      mainOom: logged.mainOom,
+      daemonRestart: logged.daemonRestart,
+      ...sourceOf(logged),
+    });
+  }
+  return { ...lostWatcherEvidence.get(key) };
+}
+
+/** Stores the lost watcher's evidence when the log tail carries none. */
+function addLostWatcherEvidence(enriched, record, state, logTail) {
+  const lost =
+    state && !/^Exit evidence:/m.test(logTail || '')
+      ? collectLostWatcherEvidence(record, state)
+      : null;
+  if (lost) {
+    enriched.options = { ...enriched.options, exitEvidence: lost };
+  }
+}
+
 function buildExitEvidenceSnippet(containerName, quotedLogPath) {
   const stderr = process.env.START_DEBUG === '1' ? '2>&1' : '2>/dev/null';
   return `${shellQuote(process.execPath)} ${shellQuote(__filename)} ${shellQuote(containerName)} "$__start_command_cgroup" "$__start_command_finished" "$__start_command_exit" "$__start_command_oom" >> ${quotedLogPath} ${stderr}`;
@@ -149,11 +276,16 @@ module.exports = {
   MAIN_OOM,
   DOCKER_OOM,
   DAEMON_RESTART,
+  DAEMON_RESTART_API,
   recentOomDelta,
+  daemonRestartApiEvidence,
   recentDockerOom,
   daemonRestartEvidence,
   collectExitEvidence,
   fromLog,
+  sourceOf,
+  collectLostWatcherEvidence,
+  addLostWatcherEvidence,
   buildExitEvidenceSnippet,
 };
 if (require.main === module) {

package/src/lib/isolation.js

@@ -201,7 +201,8 @@ function runScreenWithLogCapture(
   sessionName,
   shellInfo,
   user = null,
-  logPath = null
+  logPath = null,
+  env = null
 ) {
   return _runScreenWithLogCapture(
     command,
@@ -210,7 +211,8 @@ function runScreenWithLogCapture(
     user,
     wrapCommandWithUser,
     isInteractiveShellCommand,
-    logPath
+    logPath,
+    env
   );
 }
 
@@ -241,6 +243,7 @@ function runInScreen(command, options = {}) {
           keepAlive: options.keepAlive,
           logPath: options.logPath,
           wrapCommandWithUser,
+          env: options.executionEnv,
         })
       );
     } else {
@@ -249,7 +252,8 @@ function runInScreen(command, options = {}) {
         sessionName,
         shellInfo,
         options.user,
-        options.logPath
+        options.logPath,
+        options.executionEnv
       );
     }
   } catch (err) {
@@ -909,6 +913,20 @@ function runIsolated(backend, command, options = {}) {
     session: options.sessionStack ? options.sessionStack[0] : options.session,
     logPath: options.logPath,
   };
+  // START_* identity (issue #230): docker passes it with `-e`; a bare screen
+  // shell inherits the spawn env; everything else gets an `export` prefix.
+  const identity = require('./execution-env');
+  currentOptions.executionEnv =
+    identity.executionEnvFromOptions(currentOptions);
+  if (
+    backend !== 'docker' &&
+    !(backend === 'screen' && isInteractiveShellCommand(effectiveCommand))
+  ) {
+    effectiveCommand = identity.prefixWithExecutionEnv(
+      effectiveCommand,
+      currentOptions.executionEnv
+    );
+  }
 
   switch (backend) {
     case 'screen':

package/src/lib/launch-identity-options.js

@@ -0,0 +1,81 @@
+/**
+ * Launch options about the identity of a new execution:
+ *   --append-attempt    run as the next attempt of the tracked execution named
+ *                       by --session-id instead of being refused (issue #229)
+ *   --continues <id>    record that this execution continues an earlier one,
+ *                       which `--status` and `--upload-log` follow (issue #231)
+ *
+ * Both only apply when a command is launched, not to the query modes.
+ */
+const { activeQueryModes } = require('./args-parser-queries');
+
+function createLaunchIdentityOptionDefaults() {
+  return {
+    appendAttempt: false,
+    continues: null,
+  };
+}
+
+/**
+ * Parse one launch identity option.
+ * @param {string[]} args - Arguments array
+ * @param {number} index - Current index
+ * @param {object} options - Options object to populate
+ * @returns {number} Number of arguments consumed (0 if not recognized)
+ */
+function parse(args, index, options) {
+  const arg = args[index];
+  if (arg === '--append-attempt') {
+    options.appendAttempt = true;
+    return 1;
+  }
+  if (arg === '--continues') {
+    if (index + 1 < args.length && !args[index + 1].startsWith('-')) {
+      options.continues = args[index + 1];
+      return 2;
+    }
+    throw new Error(
+      'Option --continues requires a UUID or session name argument'
+    );
+  }
+  if (arg.startsWith('--continues=')) {
+    const value = arg.slice('--continues='.length);
+    if (!value) {
+      throw new Error(
+        'Option --continues requires a UUID or session name argument'
+      );
+    }
+    options.continues = value;
+    return 1;
+  }
+  return 0;
+}
+
+/**
+ * Validate the launch identity options.
+ * @param {object} options - Parsed wrapper options
+ * @throws {Error} When the combination is not supported
+ */
+function validate(options) {
+  const used = [
+    ...(options.appendAttempt ? ['--append-attempt'] : []),
+    ...(options.continues !== null && options.continues !== undefined
+      ? ['--continues']
+      : []),
+  ];
+  if (used.length === 0) {
+    return;
+  }
+  if (activeQueryModes(options).length > 0) {
+    throw new Error(`${used[0]} option is only valid when launching a command`);
+  }
+  if (options.appendAttempt && !options.sessionId) {
+    throw new Error('--append-attempt option requires --session-id <uuid>');
+  }
+}
+
+module.exports = {
+  createLaunchIdentityOptionDefaults,
+  parse,
+  validate,
+};