start-command 0.37.9 → 0.38.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # start-command
 
+## 0.38.0
+
+### Minor Changes
+
+- 8e62079: Executions now carry a stable identity a supervisor can rely on. A launch with an explicit `--session-id` that already exists is refused with exit 1 (`execution <uuid> already exists; use $ --resume <uuid> -- <command> to continue it, or pass --append-attempt`) instead of replacing the record and truncating its log; `--append-attempt` keeps the record, archives the previous attempt in `attemptHistory` and appends the new attempt to the same log (#229). Every backend (direct, `--isolated-user`, screen, tmux, docker, ssh, and docker resumes of stopped containers) exports `START_EXECUTION_ID`, `START_SESSION_NAME` and `START_ATTEMPT` to the command it runs (#230). `$ --alias <id> <name>` adds a name and `$ --rename <id> <name>` sets the display name of an execution, `--continues <id>` records the execution a fresh launch continues, `--status` reports `aliases` and the continuation `chain`, and `--upload-log` uploads the logs of the whole chain, oldest first (#231).
+
 ## 0.37.9
 
 ### Patch Changes

package/README.md

@@ -29,6 +29,9 @@ $ -i docker -d --label task.tool=codex -- my-task
 $ --attach <id>
 $ --resume <id> -- <command>
 $ --resume-all
+$ --session-id <uuid> --append-attempt -- <command>
+$ --continues <id> -- <command>
+$ --rename <id> <name>
 ```
 
 See the project-wide [README](../README.md), [docs/USAGE.md](../docs/USAGE.md),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "start-command",
-  "version": "0.37.9",
+  "version": "0.38.0",
   "description": "Gamification of coding, execute any command with ability to auto-report issues on GitHub",
   "main": "src/bin/cli.js",
   "exports": {

package/src/bin/cli.js

@@ -18,7 +18,6 @@ const {
   getTimestamp,
   createLogHeader,
   createLogFooter,
-  writeLogFile,
   appendLogFile,
   createLogPath,
   getDefaultDockerImage,
@@ -41,6 +40,7 @@ const { runWithBunSpawn, runWithNodeSpawn } = require('../lib/spawn-helpers');
 const { resolveChildExitCode } = require('../lib/exit-reason');
 const { printUsage } = require('../lib/usage');
 const { buildDisplayCommand, getCommandName } = require('../lib/shell-utils');
+const launchIdentity = require('../lib/launch-identity');
 
 // A closed stdout/stderr pipe (`$ --version | head -1`) must neither crash
 // start nor replace the command's exit code: drop the failed output and keep
@@ -245,6 +245,8 @@ const useCommandStream =
 
 // Generate session ID if not provided (auto-generate UUID)
 const sessionId = wrapperOptions.sessionId || generateUUID();
+// How this launch uses its execution id (issue #229), set before dispatch
+let launch = null;
 
 // Main execution
 (async () => {
@@ -256,6 +258,19 @@ const sessionId = wrapperOptions.sessionId || generateUUID();
     process.exit(queryExitCode === null ? 0 : queryExitCode);
   }
 
+  // An explicit --session-id must not overwrite a tracked execution (#229).
+  try {
+    launch = launchIdentity.prepareLaunch(
+      getExecutionStore(),
+      wrapperOptions,
+      sessionId,
+      createLogPath(wrapperOptions.isolated || 'direct', sessionId)
+    );
+  } catch (error) {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+  }
+
   if (wrapperOptions.isolated === 'docker') {
     const {
       resolveResourceOptions,
@@ -314,8 +329,8 @@ async function runWithIsolation(
     effectiveImage = getDefaultDockerImage();
   }
 
-  // Create log file path
-  const logFilePath = createLogPath(environment || 'direct', sessionId);
+  // Create log file path (an appended attempt keeps the execution's log)
+  const logFilePath = launch.logPath;
 
   // Get session name (will be generated by runIsolated if not provided)
   const sessionName =
@@ -424,6 +439,7 @@ async function runWithIsolation(
         useCommandStream,
       },
     });
+    launchIdentity.applyLaunch(executionRecord, launch);
   }
 
   // Print start block with session ID and isolation info
@@ -448,8 +464,13 @@ async function runWithIsolation(
     currentExecutionRecord = executionRecord;
     require('../lib/launch-owner').markLaunch(executionRecord);
     try {
-      store.save(executionRecord);
+      launchIdentity.claimLaunch(store, executionRecord, launch);
     } catch (err) {
+      if (err instanceof launchIdentity.LaunchRefusedError) {
+        console.error(`Error: ${err.message}`);
+        currentExecutionRecord = null;
+        process.exit(1);
+      }
       console.error(
         JSON.stringify({
           code: 'LAUNCH_RESERVATION_FAILED',
@@ -483,7 +504,12 @@ async function runWithIsolation(
     );
   }
 
-  writeLogFile(logFilePath, logContent);
+  launchIdentity.writeLaunchLog(
+    logFilePath,
+    logContent,
+    launch,
+    executionRecord
+  );
 
   let result;
 
@@ -495,6 +521,7 @@ async function runWithIsolation(
       ...options,
       session: sessionName,
       sessionId,
+      attemptNumber: launch.attemptNumber,
       image: effectiveImage,
       endpoint: options.endpoint,
       detached: mode === 'detached',
@@ -513,7 +540,10 @@ async function runWithIsolation(
     });
   } else if (createdUser) {
     // Run directly as the created user (no isolation environment)
-    result = await runAsIsolatedUser(cmd, createdUser);
+    result = await runAsIsolatedUser(
+      launchIdentity.isolatedUserCommand(cmd, sessionId, launch),
+      createdUser
+    );
   } else {
     // This shouldn't happen in isolation mode, but handle gracefully
     result = { success: false, message: 'No isolation configuration provided' };
@@ -637,8 +667,8 @@ async function runDirect(cmd, sessionId) {
   const shell = isWindows ? 'powershell.exe' : process.env.SHELL || '/bin/sh';
   const shellArgs = isWindows ? ['-Command', cmd] : ['-c', cmd];
 
-  // Setup logging
-  const logFilePath = createLogPath('direct', sessionId);
+  // Setup logging (an appended attempt keeps the execution's log)
+  const logFilePath = launch.logPath;
 
   let logContent = '';
   const startTime = getTimestamp();
@@ -666,6 +696,8 @@ async function runDirect(cmd, sessionId) {
         runtimeVersion,
       },
     });
+    launchIdentity.applyLaunch(executionRecord, launch);
+    launchIdentity.claimDirectLaunch(store, executionRecord, launch, config);
     // Set global reference for signal cleanup
     currentExecutionRecord = executionRecord;
   }
@@ -746,7 +778,13 @@ async function runDirect(cmd, sessionId) {
     shell,
     shellArgs,
     logFilePath,
-    logContent,
+    logContent: launchIdentity.launchLogContent(
+      logContent,
+      launch,
+      executionRecord
+    ),
+    appendLog: launch.append,
+    env: launchIdentity.directLaunchEnv(sessionId, launch),
     startTimeMs,
     executionRecord,
     store,
@@ -786,8 +824,8 @@ async function runDirectWithCommandStream(
   const isWindows = process.platform === 'win32';
   const shell = isWindows ? 'powershell.exe' : process.env.SHELL || '/bin/sh';
 
-  // Setup logging
-  const logFilePath = createLogPath('direct', sessionId);
+  // Setup logging (an appended attempt keeps the execution's log)
+  const logFilePath = launch.logPath;
 
   let logContent = '';
   const startTime = getTimestamp();
@@ -816,6 +854,8 @@ async function runDirectWithCommandStream(
         executionMode: 'command-stream',
       },
     });
+    launchIdentity.applyLaunch(executionRecord, launch);
+    launchIdentity.claimDirectLaunch(store, executionRecord, launch, config);
     // Set global reference for signal cleanup
     currentExecutionRecord = executionRecord;
   }
@@ -853,27 +893,23 @@ async function runDirectWithCommandStream(
   console.log('[command-stream] Using command-stream library');
   console.log('');
 
-  // Save initial execution record (PID will be updated later if available)
-  if (executionRecord && store) {
-    try {
-      store.save(executionRecord);
-    } catch (err) {
-      if (config.verbose) {
-        console.error(
-          `[Tracking] Warning: Could not save execution record: ${err.message}`
-        );
-      }
-    }
-  }
-
   // Execute the command using command-stream with real-time output
   // Using mirror: true to show output in real-time, capture: true to collect it
   // Using raw() to avoid auto-escaping that might interfere with complex shell commands
-  const $cmd = $({ mirror: true, capture: true });
+  const $cmd = $({
+    mirror: true,
+    capture: true,
+    env: launchIdentity.directLaunchEnv(sessionId, launch),
+  });
 
   let exitCode;
   try {
-    writeLogFile(logFilePath, logContent);
+    launchIdentity.writeLaunchLog(
+      logFilePath,
+      logContent,
+      launch,
+      executionRecord
+    );
     // Use raw() to pass the command without auto-escaping
     // This is important for complex commands with pipes, redirects, etc.
     const result = await $cmd`${raw(cmd)}`;

package/src/lib/args-parser-queries.js

@@ -9,6 +9,7 @@
  * Control modes: --upload-log, --stop, --terminate, --attach [--read-only],
  *                --resume [-- <command>], --resume-all,
  *                --cleanup [<uuid-or-session-name>]
+ * Naming modes:  --alias <id> <name>, --rename <id> <name> (issue #231)
  */
 
 /**
@@ -39,6 +40,9 @@ function createQueryOptionDefaults() {
     cleanup: false, // Clean up stale "executing" records
     cleanupDryRun: false, // Show what would be cleaned without cleaning
     cleanupTarget: null, // UUID/session name whose containers and images --cleanup removes
+    alias: null, // Execution that --alias adds a name to
+    rename: null, // Execution that --rename renames
+    newName: null, // Name given by --alias/--rename
   };
 }
 
@@ -120,6 +124,35 @@ function hasValue(value) {
   return value !== null && value !== undefined;
 }
 
+/**
+ * `--alias <id> <name>` and `--rename <id> <name>` take two arguments.
+ */
+const NAMING_OPTIONS = {
+  '--alias': 'alias',
+  '--rename': 'rename',
+};
+
+function parseNamingOption(args, index, options) {
+  const key = NAMING_OPTIONS[args[index]];
+  if (!key) {
+    return 0;
+  }
+  const [identifier, name] = args.slice(index + 1, index + 3);
+  if (
+    identifier === undefined ||
+    name === undefined ||
+    identifier.startsWith('-') ||
+    name.startsWith('-')
+  ) {
+    throw new Error(
+      `Option ${args[index]} requires a UUID or session name and a new name`
+    );
+  }
+  options[key] = identifier;
+  options.newName = name;
+  return 3;
+}
+
 /**
  * Parse a single query/control option.
  * @param {string[]} args - Arguments array
@@ -135,6 +168,11 @@ function parseQueryOption(args, index, options) {
     return cleanupConsumed;
   }
 
+  const namingConsumed = parseNamingOption(args, index, options);
+  if (namingConsumed > 0) {
+    return namingConsumed;
+  }
+
   const flag = FLAG_OPTIONS[arg];
   if (flag) {
     flag(options);
@@ -216,6 +254,12 @@ function activeQueryModes(options) {
   if (options.cleanup) {
     modes.push('--cleanup');
   }
+  if (hasValue(options.alias)) {
+    modes.push('--alias');
+  }
+  if (hasValue(options.rename)) {
+    modes.push('--rename');
+  }
   return modes;
 }
 
@@ -248,7 +292,7 @@ function validateQueryOptions(options) {
 
   if (modes.length > 1) {
     throw new Error(
-      'Cannot combine --status, --list, --upload-log, --stop, --terminate, --attach, --resume, --resume-all, or --cleanup in the same invocation'
+      'Cannot combine --status, --list, --upload-log, --stop, --terminate, --attach, --resume, --resume-all, --cleanup, --alias, or --rename in the same invocation'
     );
   }
 

package/src/lib/args-parser.js

@@ -39,6 +39,7 @@
  * --resume-all                     Re-attach or reconcile every execution still marked running
  * --cleanup [<uuid-or-session>]    Clean up stale "executing" records, or one execution's containers and snapshot images
  * --cleanup-dry-run                Show stale records that would be cleaned up (without actually cleaning)
+ * --alias <id> <name>, --rename <id> <name>, --append-attempt, --continues <id>: see args-parser-queries.js, launch-identity-options.js
  */
 
 const { getDefaultDockerImage } = require('./docker-utils');
@@ -47,6 +48,7 @@ const dockerRecoveryOptions = require('./docker-recovery-options');
 const cpuPenalty = require('./cpu-penalty');
 const dockerResourceOptions = require('./docker-resource-options');
 const snapshotResumeOptions = require('./snapshot-resume-options');
+const launchIdentityOptions = require('./launch-identity-options');
 const { parseSequence, isSequence } = require('./sequence-parser');
 const { buildCommandString } = require('./shell-utils');
 const {
@@ -217,6 +219,7 @@ function parseArgs(args) {
     useCommandStream: false, // Use command-stream library for command execution
     ...createQueryOptionDefaults(),
     ...snapshotResumeOptions.createSnapshotOptionDefaults(),
+    ...launchIdentityOptions.createLaunchIdentityOptionDefaults(),
   };
 
   let commandArgs = [];
@@ -580,6 +583,12 @@ function parseOption(args, index, options) {
     return queryConsumed;
   }
 
+  // --append-attempt, --continues <id> (issues #229, #231)
+  const identityConsumed = launchIdentityOptions.parse(args, index, options);
+  if (identityConsumed > 0) {
+    return identityConsumed;
+  }
+
   // Not a recognized wrapper option
   return 0;
 }
@@ -830,6 +839,7 @@ function validateOptions(options) {
 
   snapshotResumeOptions.validate(options);
   validateQueryOptions(options);
+  launchIdentityOptions.validate(options);
 
   // Validate shell option
   if (options.shell !== null && options.shell !== undefined) {

package/src/lib/docker-command-handoff.js

@@ -12,7 +12,9 @@ function buildCommandHandoffArgs(mainArgs, markerPath) {
   return [
     'sh',
     '-c',
-    'p=$1; shift; if [ -f "$p" ]; then exec sh "$p"; fi; exec "$@"',
+    // `$p.env` refreshes the START_* variables a `docker start` cannot
+    // change (issue #230) before either command runs.
+    'p=$1; shift; if [ -f "$p.env" ]; then . "$p.env"; fi; if [ -f "$p" ]; then exec sh "$p"; fi; exec "$@"',
     'start-command-handoff',
     markerPath,
     ...mainArgs,
@@ -49,27 +51,53 @@ function buildCommandHandoffScript(command, options = {}) {
   return `exec ${shellQuote(shell)}${interactive} -c ${shellQuote(effective)}\n`;
 }
 
-function writeCommandHandoff(containerName, command, runner, options = {}) {
+function copyIntoContainer(containerName, target, content, runner) {
   const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'start-handoff-'));
   const file = path.join(dir, 'command');
   try {
-    fs.writeFileSync(file, buildCommandHandoffScript(command, options), {
-      mode: 0o644,
-    });
+    fs.writeFileSync(file, content, { mode: 0o644 });
     fs.chmodSync(file, 0o644);
     return runner(require('./docker-cleanup').getDockerCommand(), [
       'cp',
       file,
-      `${containerName}:${commandHandoffPath(containerName)}`,
+      `${containerName}:${target}`,
     ]);
   } finally {
     fs.rmSync(dir, { recursive: true, force: true });
   }
 }
 
+function writeCommandHandoff(containerName, command, runner, options = {}) {
+  return copyIntoContainer(
+    containerName,
+    commandHandoffPath(containerName),
+    buildCommandHandoffScript(command, options),
+    runner
+  );
+}
+
+/**
+ * Copy the START_* variables of the next attempt into a stopped container
+ * that was created with the handoff selector (issue #230).
+ * @param {string} containerName - Container name
+ * @param {object} env - Variables from `buildExecutionEnv`
+ * @param {Function} runner - Command runner
+ * @returns {object} Runner result
+ */
+function writeExecutionEnvHandoff(containerName, env, runner) {
+  const statement = require('./execution-env').buildExecutionEnvExport(env);
+  return copyIntoContainer(
+    containerName,
+    `${commandHandoffPath(containerName)}.env`,
+    statement ? `${statement}\n` : '',
+    runner
+  );
+}
+
 module.exports = {
   commandHandoffPath,
   buildCommandHandoffArgs,
   buildCommandHandoffScript,
   writeCommandHandoff,
+  writeExecutionEnvHandoff,
 };

package/src/lib/docker-runtime-args.js

@@ -42,6 +42,13 @@ function buildDockerRuntimeArgs(options = {}) {
   for (const envVar of options.env || []) {
     args.push('-e', envVar);
   }
+  // Execution identity (issue #230); last, so a user `--env` cannot spoof it.
+  const executionEnv = require('./execution-env');
+  for (const envVar of executionEnv.executionEnvAssignments(
+    executionEnv.executionEnvFromOptions(options)
+  )) {
+    args.push('-e', envVar);
+  }
   for (const label of require('./docker-labels').dockerLabels(options)) {
     args.push('--label', label);
   }

package/src/lib/execution-attempt.js

@@ -46,6 +46,21 @@ function readAttemptActivity(record) {
   return record;
 }
 
+/** Number of the record's current attempt: 1 until it is resumed. */
+function currentAttemptNumber(record) {
+  return (
+    record?.attempt?.number ||
+    (Number(record?.options?.resumeCount) || 0) +
+      (Number(record?.options?.recoveryAttempts) || 0) +
+      1
+  );
+}
+
+/** Number the next attempt of `record` gets (`START_ATTEMPT`, issue #230). */
+function nextAttemptNumber(record) {
+  return currentAttemptNumber(record) + 1;
+}
+
 function createAttempt(record, plan) {
   let logOffset = null;
   if (record.logPath) {
@@ -58,11 +73,7 @@ function createAttempt(record, plan) {
     }
   }
   return {
-    number:
-      (record.attempt?.number ||
-        (Number(record.options?.resumeCount) || 0) +
-          (Number(record.options?.recoveryAttempts) || 0) +
-          1) + 1,
+    number: nextAttemptNumber(record),
     startedAt: new Date().toISOString(),
     logOffset,
     lastOutputAt: null,
@@ -78,10 +89,7 @@ function archiveAttempt(record) {
   readAttemptActivity(record);
   const snapshot = {
     ...(record.attempt || {
-      number:
-        (Number(record.options?.resumeCount) || 0) +
-        (Number(record.options?.recoveryAttempts) || 0) +
-        1,
+      number: currentAttemptNumber(record),
       startedAt: record.options?.resumedAt || record.startTime,
       logOffset: null,
     }),
@@ -176,6 +184,8 @@ module.exports = {
   appendLifecycle,
   archiveAttempt,
   createAttempt,
+  currentAttemptNumber,
+  nextAttemptNumber,
   patchAttempt,
   readAttemptActivity,
   readAttemptLogTail,

package/src/lib/execution-chain.js

@@ -0,0 +1,182 @@
+/**
+ * Continuation chains (issue #231): a launch with `--continues <id>` stores
+ * the UUID it continues, so a supervisor that relaunches fresh instead of
+ * `--resume`-ing in place can still treat every execution of one task as a
+ * whole. `--status` prints the chain and `--upload-log` uploads one file with
+ * every execution of it, oldest first.
+ */
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { executionAliases, hasUserNames } = require('./execution-identity');
+
+/**
+ * UUIDs of the chain `record` belongs to, oldest first. Backward links come
+ * from `continues`; forward, the most recently started record that continues
+ * the current one is followed. Cycles stop the walk.
+ * @param {object[]} records - Stored records
+ * @param {object} record - Any member of the chain
+ * @returns {object[]} Records of the chain, oldest first
+ */
+function buildChain(records, record) {
+  const seen = new Set([record.uuid]);
+  const chain = [record];
+  for (let cur = record; cur.continues; ) {
+    const prev = records.find((r) => r.uuid === cur.continues);
+    if (!prev || seen.has(prev.uuid)) {
+      break;
+    }
+    seen.add(prev.uuid);
+    chain.unshift(prev);
+    cur = prev;
+  }
+  for (let cur = record; ; ) {
+    const next = records
+      .filter((r) => r.continues === cur.uuid && !seen.has(r.uuid))
+      .sort((a, b) => Date.parse(b.startTime) - Date.parse(a.startTime))[0];
+    if (!next) {
+      break;
+    }
+    seen.add(next.uuid);
+    chain.push(next);
+    cur = next;
+  }
+  return chain;
+}
+
+/**
+ * Resolve `--continues <id>` for a new launch to the UUID it stores.
+ * @param {object|null} store - ExecutionStore
+ * @param {string} identifier - Any name of the earlier execution
+ * @param {string} sessionId - UUID of the new launch
+ * @returns {string} UUID of the continued execution
+ * @throws {Error} When it cannot be resolved
+ */
+function resolveContinues(store, identifier, sessionId) {
+  if (!store) {
+    throw new Error('--continues requires execution tracking.');
+  }
+  const target = store.get(identifier);
+  if (!target) {
+    throw new Error(
+      `No execution found with UUID or session name: ${identifier}`
+    );
+  }
+  if (target.uuid === sessionId) {
+    throw new Error(`Execution ${sessionId} cannot continue itself`);
+  }
+  return target.uuid;
+}
+
+/**
+ * Wrap a status record so `toObject()` also reports the names it answers to
+ * (`aliases`, once `--alias`/`--rename` gave it one) and its continuation
+ * `chain`, right after `uuid`.
+ * @param {object} record - Record-like object with toObject()
+ * @param {object|null} store - ExecutionStore
+ * @returns {object} The record, or a wrapper with the extra fields
+ */
+function attachIdentity(record, store) {
+  const aliases = hasUserNames(record) ? executionAliases(record) : null;
+  const chain =
+    store &&
+    (record.continues ||
+      store.getAll().some((r) => r.continues === record.uuid))
+      ? buildChain(store.getAll(), record).map((r) => r.uuid)
+      : null;
+  if (!aliases && !(chain && chain.length > 1)) {
+    return record;
+  }
+  const wrapped = Object.create(Object.getPrototypeOf(record));
+  Object.assign(wrapped, record);
+  const source = record.toObject.bind(record);
+  wrapped.toObject = function () {
+    const ordered = {};
+    for (const [key, value] of Object.entries(source())) {
+      ordered[key] = value;
+      if (key === 'uuid') {
+        if (aliases) {
+          ordered.aliases = aliases;
+        }
+        if (chain && chain.length > 1) {
+          ordered.chain = chain;
+        }
+      }
+    }
+    return ordered;
+  };
+  return wrapped;
+}
+
+/**
+ * Text-format lines for the identity fields of a status object.
+ * @param {object} obj - Output of toObject()
+ * @returns {string[]} Lines
+ */
+function identityTextLines(obj) {
+  return [
+    ...(obj.aliases ? [`Aliases:           ${obj.aliases.join(', ')}`] : []),
+    ...(obj.continues ? [`Continues:         ${obj.continues}`] : []),
+    ...(obj.chain ? [`Chain:             ${obj.chain.join(' -> ')}`] : []),
+  ];
+}
+
+/**
+ * Concatenate the logs of a chain into one temporary file, oldest first,
+ * each preceded by a lifecycle header in the format `--resume` writes.
+ * @param {object[]} chain - Records, oldest first
+ * @returns {{path: string, cleanup: Function}} Combined log
+ */
+function writeChainLog(chain) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'start-chain-log-'));
+  const file = path.join(dir, `${chain[chain.length - 1].uuid}.chain.log`);
+  chain.forEach((record, index) => {
+    const header = {
+      event: 'continuation',
+      uuid: record.uuid,
+      chainIndex: index + 1,
+      chainLength: chain.length,
+      continues: record.continues || null,
+      command: record.command,
+      startTime: record.startTime,
+      logPath: record.logPath || null,
+    };
+    fs.appendFileSync(
+      file,
+      `\n[Start Command Lifecycle] ${JSON.stringify(header)}\n`
+    );
+    if (record.logPath && fs.existsSync(record.logPath)) {
+      fs.appendFileSync(file, fs.readFileSync(record.logPath));
+    } else {
+      fs.appendFileSync(file, `Log file not found: ${record.logPath}\n`);
+    }
+  });
+  return {
+    path: file,
+    cleanup: () => fs.rmSync(dir, { recursive: true, force: true }),
+  };
+}
+
+/**
+ * Log path `--upload-log` should upload for `record`: its own log, or a
+ * combined log when it belongs to a chain of more than one execution.
+ * @param {object} store - ExecutionStore
+ * @param {object} record - Resolved record
+ * @returns {{path: string, cleanup: Function}} Log to upload
+ */
+function prepareUploadLog(store, record) {
+  const chain = buildChain(store.getAll(), record);
+  if (chain.length < 2) {
+    return { path: record.logPath, cleanup: () => {} };
+  }
+  return writeChainLog(chain);
+}
+
+module.exports = {
+  attachIdentity,
+  buildChain,
+  identityTextLines,
+  prepareUploadLog,
+  resolveContinues,
+  writeChainLog,
+};