start-command 0.36.0 → 0.37.1

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # start-command
 
+## 0.37.1
+
+### Patch Changes
+
+- c67c92f: Observe Docker CPU limits applied after launch, restore the remembered base on lift and resume, and recover CPU penalty monitors after crashes, zombie/reused-PID locks and transient tick failures.
+
+## 0.37.0
+
+### Minor Changes
+
+- 94db203: Add copy-free Docker command resumes with guarded legacy snapshots, persistent
+  task labels, wrapper help flags, private sanitized log uploads, and faithful shell
+  argument and exit-code handling. Enforce JavaScript-first CI and shared Rust parity.
+
 ## 0.36.0
 
 ### Minor Changes

package/README.md

@@ -24,6 +24,8 @@ $ ls -la
 $ bun test
 $ git status
 $ --list
+$ --help
+$ -i docker -d --label task.tool=codex -- my-task
 $ --attach <id>
 $ --resume <id> -- <command>
 $ --resume-all
@@ -34,6 +36,10 @@ See the project-wide [README](../README.md), [docs/USAGE.md](../docs/USAGE.md),
 [docs/EXAMPLES.md](../docs/EXAMPLES.md) for the full user-facing guide and
 checked examples.
 
+`-h` also prints usage. Labels persist across Docker resumes. New detached
+containers support copy-free command handoff; legacy snapshots require capacity
+preflight. Log uploads are private and sanitized; manual `--no-sanitize` opts out.
+
 ## Development
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "start-command",
-  "version": "0.36.0",
+  "version": "0.37.1",
   "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

@@ -192,6 +192,10 @@ try {
 }
 
 const { wrapperOptions, command: parsedCommand } = parsedArgs;
+if (wrapperOptions.help) {
+  printUsage();
+  process.exit(0);
+}
 
 // Query/control modes (--status, --list, --attach, --resume, ...) address an
 // execution that already exists, so they never need a command of their own.
@@ -479,6 +483,7 @@ async function runWithIsolation(
     result = await runIsolated(environment, cmd, {
       ...options,
       session: sessionName,
+      sessionId,
       image: effectiveImage,
       endpoint: options.endpoint,
       detached: mode === 'detached',

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

@@ -26,6 +26,8 @@ function createQueryOptionDefaults() {
     list: false, // List all tracked execution records
     running: false, // Restrict --list to executions that are still running
     uploadLog: null, // UUID/session name whose stored log should be uploaded
+    noSanitize: false,
+    removeOriginal: false,
     outputFormat: null, // Output format (links-notation, json, text)
     stop: null, // UUID/session name to stop gracefully
     terminate: null, // UUID/session name to terminate immediately
@@ -55,6 +57,12 @@ const IDENTIFIER_OPTIONS = {
  * Boolean flags with no argument.
  */
 const FLAG_OPTIONS = {
+  '--no-sanitize': (options) => {
+    options.noSanitize = true;
+  },
+  '--remove-original': (options) => {
+    options.removeOriginal = true;
+  },
   '--list': (options) => {
     options.list = true;
   },
@@ -185,6 +193,12 @@ const OUTPUT_FORMAT_MODES = ['--status', '--list', '--resume', '--resume-all'];
  * @throws {Error} When the combination is not supported
  */
 function validateQueryOptions(options) {
+  if (options.noSanitize && !hasValue(options.uploadLog)) {
+    throw new Error('--no-sanitize is only valid with --upload-log');
+  }
+  if (options.removeOriginal && !hasValue(options.resume)) {
+    throw new Error('--remove-original is only valid with --resume');
+  }
   if (hasValue(options.outputFormat)) {
     if (!VALID_OUTPUT_FORMATS.includes(options.outputFormat)) {
       throw new Error(

package/src/lib/args-parser.js

@@ -193,6 +193,8 @@ function parseArgs(args) {
     volumes: [], // Docker bind mounts/volumes (-v/--volume), applied to docker levels
     mounts: [], // Docker --mount specs, applied to docker levels
     env: [], // Docker environment variables (-e/--env, KEY=VALUE), applied to docker levels
+    labels: [], // Caller attribution, applied to every Docker level
+    help: false,
     privileged: false, // Run docker container in privileged mode
     network: null, // First Docker network name (compatibility accessor)
     networks: [], // Ordered Docker network names
@@ -247,7 +249,9 @@ function parseArgs(args) {
   }
 
   // Validate options
-  validateOptions(wrapperOptions);
+  if (!wrapperOptions.help) {
+    validateOptions(wrapperOptions);
+  }
 
   return {
     wrapperOptions,
@@ -288,6 +292,16 @@ function parseWrapperArgs(args, options) {
  */
 function parseOption(args, index, options) {
   const arg = args[index];
+  if (arg === '--help' || arg === '-h') {
+    options.help = true;
+    return 1;
+  }
+  if (arg === '--label' || arg.startsWith('--label=')) {
+    const label = arg === '--label' ? args[index + 1] : arg.slice(8);
+    require('./docker-labels').validateLabel(label);
+    options.labels.push(label);
+    return arg === '--label' ? 2 : 1;
+  }
 
   // --isolated, --isolation, or -i
   if (arg === '--isolated' || arg === '--isolation' || arg === '-i') {
@@ -568,6 +582,11 @@ function parseOption(args, index, options) {
  * @throws {Error} If a docker-only option is set without docker isolation
  */
 function validateDockerRuntimeOptionsRequireDocker(options) {
+  if (options.labels?.length > 0 && !options.resume) {
+    throw new Error(
+      '--label option is only valid with docker isolation or --resume'
+    );
+  }
   if (options.volumes && options.volumes.length > 0) {
     throw new Error(
       '--volume option is only valid when isolation stack includes docker'

package/src/lib/command-builder.js

@@ -106,6 +106,9 @@ function buildNextLevelCommand(options, command) {
     for (const envVar of options.env || []) {
       parts.push(`--env "${envVar}"`);
     }
+    for (const label of options.labels || []) {
+      parts.push(`--label ${require('./shell-utils').quoteShellArg(label)}`);
+    }
     if (options.privileged) {
       parts.push('--privileged');
     }

package/src/lib/cpu-penalty-monitor.js

@@ -2,10 +2,20 @@
 const fs = require('fs');
 const path = require('path');
 const { spawnSync } = require('child_process');
-const { initialState, evaluate } = require('./cpu-penalty');
+const {
+  initialState,
+  evaluate,
+  observeBase,
+  transitionLog,
+} = require('./cpu-penalty');
 const { LockManager } = require('./store-lock');
 const { shellQuote } = require('./isolation-log-utils');
-const { cpuCount, cpuUpdateArgs } = require('./docker-resource-limits');
+const {
+  cpuCount,
+  cpuUpdateArgs,
+  normalizeResourceLimits,
+  readDockerResourceLimits,
+} = require('./docker-resource-limits');
 function statePath(record) {
   return `${record.logPath}.cpu-penalty.json`;
 }
@@ -40,9 +50,21 @@ function publicState(state) {
 }
 function run(command, args) {
   const result = spawnSync(command, args, { encoding: 'utf8' });
-  return { success: result.status === 0, stdout: result.stdout || '' };
+  return {
+    success: result.status === 0,
+    stdout: result.stdout || '',
+    stderr: result.stderr || '',
+  };
 }
-async function monitor(uuid, name, attemptNumber, standalone) {
+async function monitor(
+  uuid,
+  name,
+  attemptNumber,
+  standalone,
+  dependencies = {}
+) {
+  const filesystem = dependencies.fs || fs;
+  const runner = dependencies.run || run;
   const { ExecutionStore } = require('./execution-store');
   const store = uuid
     ? new ExecutionStore(
@@ -60,36 +82,40 @@ async function monitor(uuid, name, attemptNumber, standalone) {
     return;
   }
   const config = record.options.cpuPenaltyConfig;
-  const lock = new LockManager(`${statePath(record)}.lock`);
+  if ((record.attempt?.number || 1) !== Number(attemptNumber)) {
+    return;
+  }
+  const lock = new LockManager(`${statePath(record)}.lock`, filesystem, true);
   if (!lock.acquire(100)) {
     return;
   }
   const docker = require('./docker-cleanup').getDockerCommand();
-  const baseFlags =
-    record.options.baseResourceLimits || record.options.resourceLimits || [];
+  let baseFlags = normalizeResourceLimits(
+    record.options.baseResourceLimits || record.options.resourceLimits
+  );
   const baseCpus = cpuCount(baseFlags);
   let state = initialState(baseCpus, Date.now(), readState(record));
   const interval = Math.min(
     30000,
     Math.max(50, Math.min(config.triggerWindowMs, config.releaseWindowMs) / 8)
   );
-  const publish = () => {
+  const publish = (value = state) => {
     const file = statePath(record),
       tmp = `${file}.${process.pid}.tmp`;
     try {
-      fs.writeFileSync(
+      filesystem.writeFileSync(
         tmp,
         JSON.stringify({
-          ...publicState(state),
+          ...publicState(value),
           containerName: name,
           attemptNumber: Number(attemptNumber),
           updatedAt: Date.now(),
         })
       );
-      fs.renameSync(tmp, file);
+      filesystem.renameSync(tmp, file);
     } finally {
       try {
-        fs.unlinkSync(tmp);
+        filesystem.unlinkSync(tmp);
       } catch {
         /* Optional diagnostics are best effort. */
       }
@@ -97,95 +123,188 @@ async function monitor(uuid, name, attemptNumber, standalone) {
   };
   const log = (text) => {
     try {
-      fs.appendFileSync(record.logPath, `${text}\n`);
+      filesystem.appendFileSync(record.logPath, `${text}\n`);
     } catch {
       /* Optional diagnostics are best effort. */
     }
   };
-  const started = Date.now();
+  const debug = (error) => {
+    if (process.env.START_DEBUG === '1') {
+      const message = `[DEBUG] CPU monitor: ${error.stack || error}`;
+      console.error(message);
+      log(message);
+    }
+  };
+  let stopping = false,
+    wake;
+  const stop = () => {
+    stopping = true;
+    wake?.();
+  };
+  process.on('SIGTERM', stop);
+  process.on('SIGINT', stop);
   try {
-    publish();
-    while (true) {
-      const current = store ? store.get(uuid) : record;
-      if (
-        !current ||
-        current.options.sessionName !== name ||
-        (current.attempt?.number || 1) !== Number(attemptNumber)
-      ) {
-        break;
-      }
-      const live = run(docker, ['inspect', '-f', '{{.State.Running}}', name]);
-      if (live.success && live.stdout.trim() === 'false') {
-        break;
-      }
-      if (!live.success && Date.now() - started > 30000) {
-        break;
-      }
-      const info = run(docker, ['info', '--format', '{{json .}}']);
-      const stats = run(docker, [
-        'stats',
-        '--no-stream',
-        '--format',
-        '{{json .}}',
-      ]);
-      let daemonCpus = NaN,
-        cores = NaN;
+    while (!stopping) {
       try {
-        if (info.success) {
-          daemonCpus = JSON.parse(info.stdout).NCPU;
+        const current = store ? store.get(uuid) : record;
+        if (
+          !current ||
+          current.options.sessionName !== name ||
+          (current.attempt?.number || 1) !== Number(attemptNumber)
+        ) {
+          break;
+        }
+        const live = runner(docker, [
+          'inspect',
+          '-f',
+          '{{.State.Running}}',
+          name,
+        ]);
+        if (live.success && live.stdout.trim() === 'false') {
+          break;
+        }
+        if (
+          !live.success &&
+          /No such (object|container)/i.test(live.stderr || '')
+        ) {
+          break;
+        }
+        const observed = readDockerResourceLimits(name, runner);
+        if (observed !== null) {
+          baseFlags = observed;
+          state = observeBase(state, cpuCount(observed), Date.now());
         }
-        if (stats.success) {
-          const row = stats.stdout
-            .trim()
-            .split('\n')
-            .map((s) => JSON.parse(s))
-            .find((s) => s.Name === name);
-          if (row && /^\d+(?:\.\d+)?%$/.test(row.CPUPerc)) {
-            cores = Number(row.CPUPerc.slice(0, -1)) / 100;
+        const info = runner(docker, ['info', '--format', '{{json .}}']);
+        const stats = runner(docker, [
+          'stats',
+          '--no-stream',
+          '--format',
+          '{{json .}}',
+        ]);
+        let daemonCpus = NaN,
+          cores = NaN;
+        try {
+          if (info.success) {
+            daemonCpus = JSON.parse(info.stdout).NCPU;
+          }
+          if (stats.success && live.success && observed !== null) {
+            const row = stats.stdout
+              .trim()
+              .split('\n')
+              .map((s) => JSON.parse(s))
+              .find((s) => s.Name === name);
+            if (row && /^\d+(?:\.\d+)?%$/.test(row.CPUPerc)) {
+              cores = Number(row.CPUPerc.slice(0, -1)) / 100;
+            }
           }
+        } catch (error) {
+          debug(error);
         }
-      } catch {
-        /* Optional diagnostics are best effort. */
+        debug(
+          `sample: phase=${state.phase} base=${state.baseCpus} limit=${state.limitCpus} cores=${cores} daemon=${daemonCpus}`
+        );
+        const decision = evaluate(
+          state,
+          {
+            now: Date.now(),
+            cores,
+            daemonCpus,
+            maxGapMs: Math.max(5000, interval * 3),
+          },
+          config
+        );
+        if (decision.action) {
+          const action = decision.action;
+          // Persist the base and intent before applying a cap. If this fails,
+          // leave Docker alone; a killed monitor can always recover its base.
+          if (action.kind === 'apply') {
+            publish(decision.state);
+          }
+          const update = runner(docker, [
+            'update',
+            ...cpuUpdateArgs(baseFlags, action.cpus),
+            name,
+          ]);
+          if (update.success) {
+            state = decision.state;
+            log(transitionLog(action, config));
+          } else {
+            debug(update.stderr || 'docker update failed');
+            state = {
+              ...decision.state,
+              phase: state.phase,
+              since: state.since,
+              limitCpus: state.limitCpus,
+              penaltyCount: state.penaltyCount,
+              samples: [],
+            };
+          }
+        } else {
+          state = decision.state;
+        }
+        publish();
+      } catch (error) {
+        state.samples = [];
+        debug(`tick failed: ${error.stack || error}`);
       }
-      const decision = evaluate(
-        state,
-        {
-          now: Date.now(),
-          cores,
-          daemonCpus,
-          maxGapMs: Math.max(5000, interval * 3),
-        },
-        config
-      );
-      if (decision.action) {
-        const action = decision.action;
-        const update = run(docker, [
-          'update',
-          ...cpuUpdateArgs(baseFlags, action.cpus),
+      await new Promise((resolve) => {
+        const timer = globalThis.setTimeout(resolve, interval);
+        wake = () => {
+          globalThis.clearTimeout(timer);
+          resolve();
+        };
+        if (stopping) {
+          wake();
+        }
+      });
+    }
+  } finally {
+    try {
+      const current = store ? store.get(uuid) : record;
+      if (
+        state.phase === 'penalized' &&
+        current?.options.sessionName === name &&
+        (current.attempt?.number || 1) === Number(attemptNumber)
+      ) {
+        const live = runner(docker, [
+          'inspect',
+          '-f',
+          '{{.State.Running}}',
           name,
         ]);
-        if (update.success) {
-          state = decision.state;
-          log(
-            `[start] CPU penalty ${action.kind === 'apply' ? 'applied' : 'lifted'}: ${action.cpus} CPUs (${action.average === null || action.average === undefined ? 'capacity changed' : `${action.average.toFixed(2)} of ${action.capacity} CPUs`})`
-          );
-        } else {
-          state = {
-            ...decision.state,
-            phase: state.phase,
-            since: state.since,
-            limitCpus: state.limitCpus,
-            penaltyCount: state.penaltyCount,
-            samples: [],
-          };
+        const observed = readDockerResourceLimits(name, runner);
+        const info = runner(docker, ['info', '--format', '{{json .}}']);
+        const capacity = info.success ? JSON.parse(info.stdout).NCPU : NaN;
+        if (
+          live.success &&
+          live.stdout.trim() === 'true' &&
+          observed !== null &&
+          cpuCount(observed) === state.limitCpus &&
+          capacity > 0
+        ) {
+          const cpus = Math.min(state.baseCpus || capacity, capacity);
+          const update = runner(docker, [
+            'update',
+            ...cpuUpdateArgs(observed, cpus),
+            name,
+          ]);
+          if (update.success) {
+            state = {
+              ...state,
+              phase: 'observing',
+              limitCpus: cpus,
+              since: Date.now(),
+            };
+            log(`[start] CPU penalty lifted: ${cpus} CPUs (monitor stopped)`);
+            publish();
+          }
         }
-      } else {
-        state = decision.state;
       }
-      publish();
-      await new Promise((resolve) => globalThis.setTimeout(resolve, interval));
+    } catch (error) {
+      debug(error);
     }
-  } finally {
+    process.off('SIGTERM', stop);
+    process.off('SIGINT', stop);
     lock.release();
   }
 }
@@ -204,7 +323,9 @@ function startSnippet(uuid, name, attempt = 1, options = null) {
   if (!uuid && !standalone) {
     return '';
   }
-  return `${shellQuote(process.execPath)} ${shellQuote(__filename)} ${shellQuote(uuid || '')} ${shellQuote(name)} ${Number(attempt)} ${shellQuote(standalone || '')} >/dev/null 2>&1 & __start_cpu_monitor=$!`;
+  const command = `${shellQuote(process.execPath)} ${shellQuote(__filename)} ${shellQuote(uuid || '')} ${shellQuote(name)} ${Number(attempt)} ${shellQuote(standalone || '')}`;
+  // wait reaps a crashed child even in containers whose PID 1 never reaps.
+  return `( __start_cpu_child=; trap 'if [ -n "$__start_cpu_child" ]; then kill "$__start_cpu_child" 2>/dev/null; wait "$__start_cpu_child" 2>/dev/null; fi; exit 0' TERM INT HUP; while :; do ${command} >/dev/null 2>&1 & __start_cpu_child=$!; wait "$__start_cpu_child"; __start_cpu_code=$?; [ "$__start_cpu_code" -eq 0 ] && break; sleep 1 & __start_cpu_child=$!; wait "$__start_cpu_child"; done ) & __start_cpu_monitor=$!`;
 }
 function stopSnippet() {
   return 'if [ -n "$__start_cpu_monitor" ]; then kill "$__start_cpu_monitor" 2>/dev/null; wait "$__start_cpu_monitor" 2>/dev/null; fi';
@@ -219,6 +340,7 @@ module.exports = {
 };
 if (require.main === module) {
   monitor(...process.argv.slice(2)).catch((error) => {
+    process.exitCode = 1;
     if (process.env.START_DEBUG === '1') {
       console.error(`[DEBUG] CPU monitor: ${error.stack}`);
     }

package/src/lib/cpu-penalty.js

@@ -70,10 +70,13 @@ function validate(options) {
   options.cpuPenaltyConfig = { ...DEFAULTS, ...options.cpuPenaltyConfig };
 }
 function initialState(baseCpus = null, now = Date.now(), saved = null) {
+  baseCpus =
+    saved && Object.hasOwn(saved, 'baseCpus') ? saved.baseCpus : baseCpus;
   return {
     phase: saved?.phase === 'penalized' ? 'penalized' : 'observing',
     since: saved?.phase === 'penalized' ? saved.since : now,
-    limitCpus: saved?.phase === 'penalized' ? saved.limitCpus : baseCpus,
+    limitCpus:
+      saved && Object.hasOwn(saved, 'limitCpus') ? saved.limitCpus : baseCpus,
     baseCpus,
     penaltyCount: saved?.penaltyCount || 0,
     penalizedMs: saved?.penalizedMs || 0,
@@ -82,6 +85,30 @@ function initialState(baseCpus = null, now = Date.now(), saved = null) {
     capacity: null,
   };
 }
+// A quota different from our cap is a supervisor override, not our penalty.
+function observeBase(state, baseCpus, now) {
+  if (baseCpus === state.limitCpus) {
+    return state;
+  }
+  return {
+    ...state,
+    phase: 'observing',
+    baseCpus,
+    limitCpus: baseCpus,
+    since: now,
+    samples: [],
+  };
+}
+function transitionLog(action, config) {
+  const applying = action.kind === 'apply';
+  const window = applying ? config.triggerWindowMs : config.releaseWindowMs;
+  const duration = window % 60000 === 0 ? `${window / 60000}m` : `${window}ms`;
+  const measured =
+    action.average === null || action.average === undefined
+      ? 'capacity changed'
+      : `${action.average.toFixed(2)} of ${applying ? action.capacity : config.cpus} CPUs for ${duration}`;
+  return `[start] CPU penalty ${applying ? 'applied' : 'lifted'}: ${action.cpus} CPUs (${measured})`;
+}
 function average(samples, now, window) {
   const start = now - window;
   if (
@@ -170,6 +197,8 @@ module.exports = {
   validate,
   duration,
   initialState,
+  observeBase,
+  transitionLog,
   average,
   evaluate,
 };

package/src/lib/docker-cleanup.js

@@ -83,7 +83,7 @@ function getDockerContainerCleanupInstructions(containerName) {
     `Container kept for investigation: ${containerName}`,
     `Re-enter while running: $ --attach ${containerName}`,
     `Continue the stored command: $ --resume ${containerName}`,
-    `Run another command in the same container: $ --resume ${containerName} -- <command>`,
+    `Run another command (legacy containers snapshot the filesystem into a new container): $ --resume ${containerName} -- <command>`,
     `Remove when done: docker rm -f ${containerName}`,
   ].join('\n');
 }
@@ -306,7 +306,7 @@ function buildDockerKeptLogSnippet(containerName, quotedLogPath) {
     `printf '\\nContainer kept for investigation: %s\\nReason: %s\\n` +
     `Re-enter while running: $ --attach %s\\n` +
     `Continue the stored command: $ --resume %s\\n` +
-    `Run another command in the same container: $ --resume %s -- <command>\\n` +
+    `Run another command (legacy containers snapshot the filesystem into a new container): $ --resume %s -- <command>\\n` +
     `Remove when done: docker rm -f %s\\n' ` +
     `${quotedName} "$__start_command_reason" ` +
     `${quotedName} ${quotedName} ${quotedName} ${quotedName} >> ${quotedLogPath}`
@@ -361,6 +361,11 @@ function buildDetachedDockerCompletionScript(
   watcherOptions = {}
 ) {
   const quotedName = shellQuote(containerName);
+  const imageCleanup =
+    require('./docker-snapshot-safety').snapshotImageCleanupSnippet(
+      containerName,
+      logPath ? `>> ${shellQuote(logPath)} 2>&1` : '>/dev/null 2>&1'
+    );
   // The container's cgroup disappears with it, so its memory counters are
   // sampled while it runs (issue #182).
   const cpuMonitor = require('./cpu-penalty-monitor');
@@ -389,7 +394,7 @@ function buildDetachedDockerCompletionScript(
       quotedLogPath
     );
     const memory = buildCgroupMemoryLogSnippet(quotedLogPath);
-    const remove = `docker rm -f ${quotedName} >> ${quotedLogPath} 2>&1 || true; ${removalNote}; ${memory}`;
+    const remove = `${imageCleanup.capture}; if docker rm -f ${quotedName} >> ${quotedLogPath} 2>&1; then ${imageCleanup.remove}; fi; ${removalNote}; ${memory}`;
     const keep = `${postMortem}; ${memory}; ${buildDockerKeptLogSnippet(containerName, quotedLogPath)}`;
 
     const since = watcherOptions.since
@@ -438,13 +443,15 @@ function buildDetachedDockerCompletionScript(
     parts.push(buildCgroupSamplerStopSnippet());
     parts.push(buildDockerStateSnippet(containerName));
     if (policy === DOCKER_CONTAINER_CLEANUP_POLICY.ALWAYS) {
-      exited.push(`docker rm -f ${quotedName} >/dev/null 2>&1 || true`);
+      exited.push(
+        `${imageCleanup.capture}; if docker rm -f ${quotedName} >/dev/null 2>&1; then ${imageCleanup.remove}; fi`
+      );
     } else if (
       policy === DOCKER_CONTAINER_CLEANUP_POLICY.DEFAULT ||
       policy === DOCKER_CONTAINER_CLEANUP_POLICY.KEEP_ON_FAIL
     ) {
       exited.push(
-        `if ${buildSuccessfulNonOomCondition()}; then docker rm -f ${quotedName} >/dev/null 2>&1 || true; fi`
+        `if ${buildSuccessfulNonOomCondition()}; then ${imageCleanup.capture}; if docker rm -f ${quotedName} >/dev/null 2>&1; then ${imageCleanup.remove}; fi; fi`
       );
     }
   }