start-command 0.37.8 → 0.38.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # 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
+
+- 55ed66d: A Docker snapshot resume can now be supervised safely. `--snapshot-wait <seconds>` (or `START_SNAPSHOT_LOCK_WAIT`) waits for another resume's snapshot on the host and says once which container it is waiting for. `--snapshot-disk-wait <seconds>` (or `START_SNAPSHOT_DISK_WAIT`) re-checks free disk instead of refusing at once. A busy lock and disk that is still short now exit 75 (`EX_TEMPFAIL`), so a caller can tell "retry later" from a real failure. `--remove-original-after <seconds>` removes the original only if the replacement is still running after the delay. `--snapshot-size-hint <bytes>` skips the `docker inspect --size` walk, and `--snapshot-prepare <command>` runs a cleanup command in the started original before the commit. A long `docker commit` writes its elapsed time to the log every minute. The `start-command.snapshot-image` label is documented as a stable interface, and `$ --cleanup <uuid-or-session-name>` removes an execution's containers and then their snapshot images, never forcing a removal (#224).
+
+  `$ --status` now reports `containerState removed` and `containerRemovedObservedAt` when the docker container of a finished detached execution no longer exists, instead of showing the old `containerId` as if the container still held its disk. The removal is recorded when start's own cleanup policy removes the container and when `--status` finds it gone; `containerId` is kept for history, and a docker daemon that cannot be reached is not mistaken for a removed container (#225).
+
+  `$ --status` no longer prints `[object Object]` for nested option values such as `launchOwner`, `exitEvidence`, `resolvedLimits` and `resourceLimitSpecs`: the links-notation output nests them like other objects and the text output prints them as compact JSON (#226).
+
 ## 0.37.8
 
 ### 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),
@@ -40,6 +43,11 @@ checked examples.
 containers support copy-free command handoff; legacy snapshots require capacity
 preflight. Log uploads are private and sanitized; manual `--no-sanitize` opts out.
 
+Snapshot resumes take `--snapshot-wait`, `--snapshot-disk-wait`,
+`--remove-original-after`, `--snapshot-size-hint` and `--snapshot-prepare`, and
+exit 75 when they should be retried later; `--cleanup <id>` removes one
+execution's containers and snapshot images without forcing.
+
 ## Development
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "start-command",
-  "version": "0.37.8",
+  "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' };
@@ -549,6 +579,10 @@ async function runWithIsolation(
     if (mode !== 'detached') {
       executionRecord.complete(exitCode);
     }
+    if (result.containerRemoved) {
+      // The cleanup policy removed the container (issue #225).
+      require('../lib/container-removal').markContainerRemoved(executionRecord);
+    }
     try {
       store.save(
         mode === 'detached'
@@ -633,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();
@@ -662,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;
   }
@@ -742,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,
@@ -782,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();
@@ -812,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;
   }
@@ -849,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

@@ -7,7 +7,9 @@
  *
  * Query modes:   --status, --list [--running]
  * Control modes: --upload-log, --stop, --terminate, --attach [--read-only],
- *                --resume [-- <command>], --resume-all, --cleanup
+ *                --resume [-- <command>], --resume-all,
+ *                --cleanup [<uuid-or-session-name>]
+ * Naming modes:  --alias <id> <name>, --rename <id> <name> (issue #231)
  */
 
 /**
@@ -37,6 +39,10 @@ function createQueryOptionDefaults() {
     resumeAll: false, // Re-attach/resume every execution still marked running
     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
   };
 }
 
@@ -75,19 +81,78 @@ const FLAG_OPTIONS = {
   '--resume-all': (options) => {
     options.resumeAll = true;
   },
-  '--cleanup': (options) => {
-    options.cleanup = true;
-  },
-  '--cleanup-dry-run': (options) => {
-    options.cleanup = true;
-    options.cleanupDryRun = true;
-  },
 };
 
+/**
+ * `--cleanup` and `--cleanup-dry-run` take an optional execution: without one
+ * they clean up stale records, with one they remove that execution's Docker
+ * containers and snapshot images (issue #224).
+ */
+const CLEANUP_OPTIONS = {
+  '--cleanup': false,
+  '--cleanup-dry-run': true,
+};
+
+function parseCleanupOption(args, index, options) {
+  const arg = args[index];
+  const equals = arg.indexOf('=');
+  const name = equals === -1 ? arg : arg.slice(0, equals);
+  if (!(name in CLEANUP_OPTIONS)) {
+    return 0;
+  }
+  options.cleanup = true;
+  options.cleanupDryRun = options.cleanupDryRun || CLEANUP_OPTIONS[name];
+  if (equals !== -1) {
+    const value = arg.slice(equals + 1);
+    if (!value) {
+      throw new Error(
+        `Option ${name} requires a UUID or session name argument`
+      );
+    }
+    options.cleanupTarget = value;
+    return 1;
+  }
+  const next = args[index + 1];
+  if (next !== undefined && !next.startsWith('-')) {
+    options.cleanupTarget = next;
+    return 2;
+  }
+  return 1;
+}
+
 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
@@ -98,6 +163,16 @@ function hasValue(value) {
 function parseQueryOption(args, index, options) {
   const arg = args[index];
 
+  const cleanupConsumed = parseCleanupOption(args, index, options);
+  if (cleanupConsumed > 0) {
+    return cleanupConsumed;
+  }
+
+  const namingConsumed = parseNamingOption(args, index, options);
+  if (namingConsumed > 0) {
+    return namingConsumed;
+  }
+
   const flag = FLAG_OPTIONS[arg];
   if (flag) {
     flag(options);
@@ -179,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;
 }
 
@@ -211,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

@@ -37,8 +37,9 @@
  * --read-only                      Follow --attach output without forwarding stdin
  * --resume <uuid-or-session> [-- cmd] Resume a stored execution (optionally with a new command)
  * --resume-all                     Re-attach or reconcile every execution still marked running
- * --cleanup                        Clean up stale "executing" records (processes that crashed or were killed)
+ * --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');
@@ -46,6 +47,8 @@ const dockerNetworkOptions = require('./docker-network-options');
 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 {
@@ -215,6 +218,8 @@ function parseArgs(args) {
     shell: 'auto', // Shell to use in isolation environments: auto, bash, zsh, sh
     useCommandStream: false, // Use command-stream library for command execution
     ...createQueryOptionDefaults(),
+    ...snapshotResumeOptions.createSnapshotOptionDefaults(),
+    ...launchIdentityOptions.createLaunchIdentityOptionDefaults(),
   };
 
   let commandArgs = [];
@@ -566,12 +571,24 @@ function parseOption(args, index, options) {
     return 1;
   }
 
+  // Snapshot resume options (--snapshot-wait, --remove-original-after, ...)
+  const snapshotConsumed = snapshotResumeOptions.parse(args, index, options);
+  if (snapshotConsumed > 0) {
+    return snapshotConsumed;
+  }
+
   // Query/control options (--status, --list, --attach, --resume, ...)
   const queryConsumed = parseQueryOption(args, index, options);
   if (queryConsumed > 0) {
     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;
 }
@@ -820,7 +837,9 @@ function validateOptions(options) {
     throw new Error('--keep-user option is only valid with --isolated-user');
   }
 
+  snapshotResumeOptions.validate(options);
   validateQueryOptions(options);
+  launchIdentityOptions.validate(options);
 
   // Validate shell option
   if (options.shell !== null && options.shell !== undefined) {

package/src/lib/container-removal.js

@@ -0,0 +1,163 @@
+/**
+ * Removed-container bookkeeping for `--status` (issue #225).
+ *
+ * A kept docker container can be removed later (by hand, by an orchestrator,
+ * or by start-command's own cleanup policy). `docker inspect` then exits 1
+ * with `No such object` / `No such container`, which used to be folded into
+ * the same `null` as "docker could not be queried at all", so `--status` kept
+ * reporting the old `containerId` as if the container still held its disk.
+ *
+ * This module tells the two failures apart and records the removal on the
+ * execution record as `containerState: removed` plus
+ * `containerRemovedObservedAt`. `containerId` is kept for history.
+ */
+
+const { spawnSync } = require('child_process');
+
+/** `containerState` of a record whose container no longer exists. */
+const CONTAINER_STATE_REMOVED = 'removed';
+
+/**
+ * Docker's answer for a container that does not exist:
+ * `Error: No such object: <name>` (`docker inspect`, Docker 29 prints it
+ * lower-case) and `Error response from daemon: No such container: <name>`
+ * (`docker container inspect`). A daemon that cannot be reached prints
+ * "Cannot connect" / "failed to connect", which must not match.
+ */
+const DOCKER_NOT_FOUND_PATTERN = /no such (object|container)/i;
+
+/**
+ * Environment variable the detached watcher sets for the finalizer when its
+ * own `docker rm -f` removed the container.
+ */
+const CONTAINER_REMOVED_ENV = 'START_INTERNAL_CONTAINER_REMOVED';
+
+/**
+ * @param {{status?: number|null, stderr?: string|Buffer, error?: Error}} result
+ *   `spawnSync` result of a `docker inspect`
+ * @returns {boolean} True only when docker answered that the object is unknown
+ */
+function isDockerNotFound(result) {
+  if (!result || result.error || result.status === 0) {
+    return false;
+  }
+  return DOCKER_NOT_FOUND_PATTERN.test(String(result.stderr || ''));
+}
+
+/**
+ * Run `docker inspect -f <format> <target>`.
+ * @returns {{stdout: string|null, notFound: boolean}} `stdout` is null when
+ *   the inspect failed; `notFound` says the failure was "no such container"
+ */
+function dockerInspect(dockerCommand, spawnOptions, format, target) {
+  const result = spawnSync(
+    dockerCommand,
+    ['inspect', '-f', format, target],
+    spawnOptions
+  );
+  if (result.error || result.status !== 0 || !result.stdout) {
+    return { stdout: null, notFound: isDockerNotFound(result) };
+  }
+  return { stdout: String(result.stdout), notFound: false };
+}
+
+/**
+ * Set `containerState: removed` on a record, keeping an earlier observation
+ * time when there is one.
+ * @param {Object} record - Execution record (mutated)
+ * @param {string} [observedAt] - When the removal was observed
+ * @returns {Object} The same record
+ */
+function markContainerRemoved(record, observedAt = new Date().toISOString()) {
+  record.containerState = CONTAINER_STATE_REMOVED;
+  record.containerRemovedObservedAt =
+    record.containerRemovedObservedAt || observedAt;
+  return record;
+}
+
+/**
+ * Whether a finished detached docker record should be checked for removal.
+ * Executing records are never touched: a container that is not visible yet
+ * on a slow Docker-in-Docker host is not a removed one (issue #136).
+ */
+function shouldProbeRemoval(record) {
+  const opts = (record && record.options) || {};
+  return (
+    record.status === 'executed' &&
+    opts.isolated === 'docker' &&
+    opts.isolationMode === 'detached' &&
+    Boolean(opts.sessionName || opts.containerId) &&
+    record.containerState !== CONTAINER_STATE_REMOVED
+  );
+}
+
+/**
+ * Attach `containerState: removed` to a finished detached docker record whose
+ * container no longer exists. The container id is preferred over the session
+ * name, so a later container that reuses the name is not mistaken for it.
+ *
+ * @param {Object} record - Enriched execution record
+ * @param {{dockerCommand: string, spawnOptions: Object,
+ *   sessionNotFound?: boolean}} probe - How to run docker, and whether the
+ *   status probe by session name already answered "no such container"
+ * @returns {Object} The record, or a copy carrying the removal
+ */
+function attachContainerRemoval(record, probe) {
+  if (!shouldProbeRemoval(record)) {
+    return record;
+  }
+  const containerId = record.options.containerId;
+  const notFound = containerId
+    ? dockerInspect(
+        probe.dockerCommand,
+        probe.spawnOptions,
+        '{{.Id}}',
+        containerId
+      ).notFound
+    : probe.sessionNotFound === true;
+  if (!notFound) {
+    return record;
+  }
+  const copy = Object.assign(
+    Object.create(Object.getPrototypeOf(record)),
+    record
+  );
+  return markContainerRemoved(copy);
+}
+
+/**
+ * Persist a removal `--status` observed, best effort: a read-only query must
+ * never fail because the store could not be written.
+ * @param {Object} store - ExecutionStore
+ * @param {Object} stored - Record as read from the store
+ * @param {Object} enriched - Record as reported
+ */
+function persistContainerRemoval(store, stored, enriched) {
+  if (
+    !store ||
+    enriched.containerState !== CONTAINER_STATE_REMOVED ||
+    stored.containerState === CONTAINER_STATE_REMOVED ||
+    typeof store.markContainerRemoved !== 'function'
+  ) {
+    return;
+  }
+  try {
+    store.markContainerRemoved(
+      stored.uuid,
+      enriched.containerRemovedObservedAt
+    );
+  } catch {
+    // The removal is still reported; it is simply observed again next time.
+  }
+}
+
+module.exports = {
+  CONTAINER_REMOVED_ENV,
+  CONTAINER_STATE_REMOVED,
+  DOCKER_NOT_FOUND_PATTERN,
+  attachContainerRemoval,
+  dockerInspect,
+  isDockerNotFound,
+  markContainerRemoved,
+  persistContainerRemoval,
+};