start-command 0.37.7 → 0.37.9

package/src/lib/status-links-notation.js

@@ -0,0 +1,97 @@
+/**
+ * Links-notation and text rendering of nested `--status` values.
+ *
+ * `--status` stores structured option values such as `launchOwner`,
+ * `exitEvidence`, `resolvedLimits` and `resourceLimitSpecs`. They used to be
+ * passed through `escapeForLinksNotation` (and a template string in the text
+ * format), which printed `"[object Object]"` and lost the values (issue #226).
+ * These helpers render nested objects and arrays the same way the Rust
+ * formatter's `append_links_value` does, so both implementations print the
+ * same layout.
+ */
+
+const { escapeForLinksNotation } = require('./output-blocks');
+
+function isPresent(value) {
+  return value !== null && value !== undefined;
+}
+
+/**
+ * Append an array as a `(` … `)` block.
+ * @param {string[]} lines - Output lines
+ * @param {Array} values - Array to render
+ * @param {number} indent - Indentation of the parentheses
+ */
+function appendLinksArray(lines, values, indent) {
+  const prefix = ' '.repeat(indent);
+  if (values.length === 0) {
+    lines.push(`${prefix}()`);
+    return;
+  }
+  lines.push(`${prefix}(`);
+  for (const value of values) {
+    if (Array.isArray(value)) {
+      appendLinksArray(lines, value, indent + 2);
+    } else if (isPresent(value) && typeof value === 'object') {
+      for (const [childKey, childValue] of Object.entries(value)) {
+        if (isPresent(childValue)) {
+          appendLinksValue(lines, childKey, childValue, indent + 2);
+        }
+      }
+    } else {
+      lines.push(`${' '.repeat(indent + 2)}${escapeForLinksNotation(value)}`);
+    }
+  }
+  lines.push(`${prefix})`);
+}
+
+/**
+ * Append `key value`, or `key` followed by its nested children.
+ * Children of an object are indented by four more spaces, matching the
+ * top-level `  key` / `      child` layout `--status` has always used.
+ * @param {string[]} lines - Output lines
+ * @param {string} key - Field name
+ * @param {*} value - Field value
+ * @param {number} indent - Indentation of the key
+ */
+function appendLinksValue(lines, key, value, indent) {
+  const prefix = ' '.repeat(indent);
+  if (Array.isArray(value)) {
+    lines.push(`${prefix}${key}`);
+    appendLinksArray(lines, value, indent + 2);
+    return;
+  }
+  if (isPresent(value) && typeof value === 'object') {
+    const entries = Object.entries(value);
+    if (entries.length === 0) {
+      return;
+    }
+    lines.push(`${prefix}${key}`);
+    for (const [childKey, childValue] of entries) {
+      if (isPresent(childValue)) {
+        appendLinksValue(lines, childKey, childValue, indent + 4);
+      }
+    }
+    return;
+  }
+  lines.push(`${prefix}${key} ${escapeForLinksNotation(value)}`);
+}
+
+/**
+ * Render an option value for the text format: scalars as-is, structured
+ * values as compact JSON (the Rust formatter uses `serde_json::to_string`).
+ * @param {*} value - Option value
+ * @returns {string} Rendered value
+ */
+function formatTextOptionValue(value) {
+  if (isPresent(value) && typeof value === 'object') {
+    return JSON.stringify(value);
+  }
+  return String(value);
+}
+
+module.exports = {
+  appendLinksArray,
+  appendLinksValue,
+  formatTextOptionValue,
+};

package/src/lib/store-lock.js

@@ -14,6 +14,8 @@ class LockManager {
     this.identity = null;
     this.token = null;
     this.monitorOwner = monitorOwner;
+    // Extra fields published in the lock file, for example who holds it.
+    this.metadata = {};
   }
 
   acquire(timeout = LOCK_TIMEOUT_MS) {
@@ -44,6 +46,7 @@ class LockManager {
         this.fs.writeFileSync(
           temp,
           JSON.stringify({
+            ...this.metadata,
             pid: process.pid,
             timestamp: Date.now(),
             hostname: os.hostname(),

package/src/lib/usage.js

@@ -54,9 +54,16 @@ Options:
   --resume <id>         Restart a stopped detached execution in the same environment
                         (append -- <command> to run a different command there)
   --remove-original    With legacy snapshot resume, remove the stopped original after launch
+  --remove-original-after <s>  Remove it only if the replacement still runs after <s> seconds
+  --snapshot-wait <s>   Wait up to <s> seconds for another snapshot on this host (exit 75 after)
+  --snapshot-disk-wait <s>  Wait up to <s> seconds for free disk instead of refusing (exit 75 after)
+  --snapshot-size-hint <bytes>  Use this writable-layer size instead of docker inspect --size
+  --snapshot-prepare <cmd>  docker exec <cmd> in the started original before it is snapshotted
   --resume-all          Re-attach or reconcile every execution still marked running
   --cleanup             Clean up stale "executing" records (crashed/killed processes)
   --cleanup-dry-run     Show stale records that would be cleaned up (without cleaning)
+  --cleanup <id>        Remove a Docker execution's containers and snapshot images (never forced)
+  --cleanup-dry-run <id>  Show the containers and images --cleanup <id> would remove
   --version, -v         Show version information
 
 Examples:

package/test/regression-222.js

@@ -0,0 +1,61 @@
+const { describe, it, expect } = require('bun:test');
+const { spawn } = require('child_process');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const CLI = path.join(__dirname, '../src/bin/cli.js');
+
+// Run the CLI with the read ends of the given output pipes closed before it
+// starts writing, like `$ --version | head -1` once `head` has exited.
+function runWithClosedPipes(args, closed) {
+  return new Promise((resolve) => {
+    const child = spawn(process.execPath, [CLI, ...args], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: {
+        ...process.env,
+        START_APP_FOLDER: fs.mkdtempSync(path.join(os.tmpdir(), 'start-222-')),
+        START_DISABLE_AUTO_ISSUE: '1',
+        START_DISABLE_LOG_UPLOAD: '1',
+      },
+    });
+    let stderr = '';
+    for (const name of ['stdout', 'stderr']) {
+      if (closed.includes(name)) {
+        child[name].destroy();
+      } else {
+        child[name].on('data', (chunk) => (stderr += chunk));
+      }
+    }
+    child.on('close', (code) => resolve({ code, stderr }));
+  });
+}
+
+describe('closed output pipes (#222)', () => {
+  if (process.platform === 'win32') {
+    return;
+  }
+  const big = 'seq 1 200000';
+  for (const args of [['--version'], ['-v'], ['--help']]) {
+    it(`${args[0]} exits 0 when stdout is closed`, async () => {
+      const result = await runWithClosedPipes(args, ['stdout']);
+      expect(result.stderr).not.toContain('EPIPE');
+      expect(result.code).toBe(0);
+    }, 15000);
+  }
+  it('a command keeps its exit code when stdout is closed', async () => {
+    const result = await runWithClosedPipes(
+      ['--', 'sh', '-c', `${big}; exit 3`],
+      ['stdout']
+    );
+    expect(result.stderr).not.toContain('EPIPE');
+    expect(result.code).toBe(3);
+  }, 15000);
+  it('a command keeps its exit code when stdout and stderr are closed', async () => {
+    const result = await runWithClosedPipes(
+      ['--', 'sh', '-c', `${big}; ${big} >&2; exit 3`],
+      ['stdout', 'stderr']
+    );
+    expect(result.code).toBe(3);
+  }, 15000);
+});