start-command 0.27.0 → 0.27.2

package/src/bin/cli.js

@@ -890,7 +890,7 @@ async function runDirectWithCommandStream(
   // Using raw() to avoid auto-escaping that might interfere with complex shell commands
   const $cmd = $({ mirror: true, capture: true });
 
-  let exitCode = 0;
+  let exitCode;
   try {
     writeLogFile(logFilePath, logContent);
     // Use raw() to pass the command without auto-escaping
@@ -905,34 +905,25 @@ async function runDirectWithCommandStream(
 
     // Collect output for log
     if (result.stdout) {
-      logContent += result.stdout;
       appendLogFile(logFilePath, result.stdout);
     }
     if (result.stderr) {
-      logContent += result.stderr;
       appendLogFile(logFilePath, result.stderr);
     }
   } catch (err) {
     exitCode = err.code || 1;
     const errorMessage = `Error executing command: ${err.message}`;
-    logContent += `\n${errorMessage}\n`;
     appendLogFile(logFilePath, `\n${errorMessage}\n`);
     console.error(`\n${errorMessage}`);
   }
 
   const endTime = getTimestamp();
 
-  // Log footer
-  logContent += `\n${'='.repeat(50)}\n`;
-  logContent += `Finished: ${endTime}\n`;
-  logContent += `Exit Code: ${exitCode}\n`;
+  const logFooter = `\n${'='.repeat(50)}\nFinished: ${endTime}\nExit Code: ${exitCode}\n`;
 
   // Write log file
   try {
-    appendLogFile(
-      logFilePath,
-      `\n${'='.repeat(50)}\nFinished: ${endTime}\nExit Code: ${exitCode}\n`
-    );
+    appendLogFile(logFilePath, logFooter);
   } catch (err) {
     console.error(`\nWarning: Could not save log file: ${err.message}`);
   }

package/src/lib/docker-utils.js

@@ -120,7 +120,7 @@ function dockerPullImage(image) {
   console.log();
 
   let output = '';
-  let success = false;
+  let success;
 
   try {
     // Run docker pull with inherited stdio for real-time output

package/src/lib/output-blocks.js

@@ -425,12 +425,13 @@ function formatAsNestedLinksNotation(obj, indent = 2, depth = 0) {
     if (obj.length === 0) {
       return '()';
     }
-    const indentStr = ' '.repeat(indent * (depth + 1));
+    const blockIndent = ' '.repeat(indent * depth);
+    const itemIndent = ' '.repeat(indent * (depth + 1));
     const items = obj.map((item) => {
       const formatted = formatAsNestedLinksNotation(item, indent, depth + 1);
-      return `${indentStr}${formatted}`;
+      return `${itemIndent}${formatted}`;
     });
-    return `(\n${items.join('\n')}\n${' '.repeat(indent * depth)})`;
+    return `${blockIndent}(\n${items.join('\n')}\n${blockIndent})`;
   }
 
   // Format objects
@@ -444,7 +445,8 @@ function formatAsNestedLinksNotation(obj, indent = 2, depth = 0) {
     .filter(([, value]) => value !== null && value !== undefined)
     .map(([key, value]) => {
       if (typeof value === 'object') {
-        const nested = formatAsNestedLinksNotation(value, indent, depth + 1);
+        const nestedDepth = Array.isArray(value) ? depth + 2 : depth + 1;
+        const nested = formatAsNestedLinksNotation(value, indent, nestedDepth);
         return `${indentStr}${key}\n${nested}`;
       }
       const formattedValue = escapeForLinksNotation(value);

package/src/lib/usage.js

@@ -9,7 +9,7 @@ Options:
   --session, -s <name>  Session name for isolation
   --session-id <uuid>   Session UUID for tracking (auto-generated if not provided)
   --session-name <uuid> Alias for --session-id
-  --image <image>       Docker image (required for docker isolation)
+  --image <image>       Docker image (optional, defaults to OS-matched image)
   --endpoint <endpoint> SSH endpoint (required for ssh isolation, e.g., user@host)
   --isolated-user, -u [name]  Create isolated user with same permissions
   --keep-user           Keep isolated user after command completes
@@ -30,7 +30,8 @@ Examples:
   $ bun test
   $ --isolated tmux -- bun start
   $ -i screen -d bun start
-  $ --isolated docker --image oven/bun:latest -- bun install
+  $ --isolated docker -- echo "hi"       # uses OS-matched default image
+  $ --isolated docker --image ghcr.io/link-foundation/box-js:latest -- bun --version
   $ --isolated ssh --endpoint user@remote.server -- ls -la
   $ --isolated-user -- npm test            # Create isolated user
   $ -u myuser -- npm start                 # Custom username
@@ -59,7 +60,7 @@ Examples:
     '  - Auto-reports failures for NPM packages (when gh is available)'
   );
   console.log('  - Natural language command aliases (via substitutions.lino)');
-  console.log('  - Process isolation via screen, tmux, or docker');
+  console.log('  - Process isolation via screen, tmux, docker, or ssh');
   console.log('');
   console.log('Alias examples:');
   console.log('  $ install lodash npm package           -> npm install lodash');

package/test/create-github-release.mjs

@@ -0,0 +1,118 @@
+import { describe, expect, it } from 'bun:test';
+import { spawnSync } from 'node:child_process';
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const testDir = dirname(fileURLToPath(import.meta.url));
+const repoRoot = resolve(testDir, '../..');
+const scriptPath = resolve(repoRoot, 'scripts/create-github-release.mjs');
+
+function createFakeGhBin(tempDir) {
+  const fakeGhJs = join(tempDir, 'fake-gh.cjs');
+  writeFileSync(
+    fakeGhJs,
+    `
+const fs = require('node:fs');
+
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', (chunk) => {
+  input += chunk;
+});
+process.stdin.on('end', () => {
+  fs.writeFileSync(process.env.FAKE_GH_PAYLOAD_PATH, input);
+
+  if (process.env.FAKE_GH_MODE === 'already_exists') {
+    console.error('gh: Validation Failed (HTTP 422)');
+    console.error(JSON.stringify({
+      message: 'Validation Failed',
+      errors: [{ resource: 'Release', code: 'already_exists', field: 'tag_name' }],
+    }));
+    process.exit(1);
+  }
+
+  if (process.env.FAKE_GH_MODE === 'failure') {
+    console.error('gh: server exploded');
+    process.exit(1);
+  }
+
+  console.log(JSON.stringify({ html_url: 'https://github.test/release' }));
+  process.exit(0);
+});
+`
+  );
+
+  return fakeGhJs;
+}
+
+function runScript(mode) {
+  const tempDir = mkdtempSync(join(tmpdir(), 'create-release-test-'));
+  const payloadPath = join(tempDir, 'payload.json');
+  const changelogPath = join(tempDir, 'CHANGELOG.md');
+  writeFileSync(
+    changelogPath,
+    '# Changelog\n\n## [1.2.3] - 2026-05-03\n\n- Release automation fix.\n'
+  );
+  const fakeGhJs = createFakeGhBin(tempDir);
+
+  const result = spawnSync(
+    'node',
+    [
+      scriptPath,
+      '--release-version',
+      '1.2.3',
+      '--repository',
+      'owner/repo',
+      '--prefix',
+      'rust-',
+      '--changelog-file',
+      changelogPath,
+      '--badge-type',
+      'crates',
+      '--package-name',
+      'start-command',
+    ],
+    {
+      encoding: 'utf8',
+      env: {
+        ...process.env,
+        FAKE_GH_MODE: mode,
+        FAKE_GH_PAYLOAD_PATH: payloadPath,
+        START_GH_COMMAND: process.execPath,
+        START_GH_COMMAND_ARGS: JSON.stringify([fakeGhJs]),
+      },
+    }
+  );
+
+  const payload = JSON.parse(readFileSync(payloadPath, 'utf8'));
+  rmSync(tempDir, { force: true, recursive: true });
+  return { result, payload };
+}
+
+describe('create-github-release script', () => {
+  it('treats an existing GitHub release as an idempotent skip', () => {
+    const { result, payload } = runScript('already_exists');
+
+    expect(result.status).toBe(0);
+    expect(result.stdout).toContain(
+      'GitHub release already exists: rust-v1.2.3'
+    );
+    expect(result.stdout).not.toContain('Created GitHub release');
+    expect(payload).toMatchObject({
+      tag_name: 'rust-v1.2.3',
+      name: '[Rust] 1.2.3',
+    });
+    expect(payload.body).toContain('Release automation fix.');
+    expect(payload.body).toContain('crates.io');
+  });
+
+  it('fails when gh api returns an unexpected error', () => {
+    const { result } = runScript('failure');
+
+    expect(result.status).not.toBe(0);
+    expect(result.stderr).toContain('server exploded');
+    expect(result.stderr).toContain('GitHub release creation failed');
+  });
+});

package/test/fixtures/issue-126-bin/pgrep

@@ -0,0 +1,4 @@
+#!/usr/bin/env sh
+if [ "$1" = "-P" ] && [ "$2" = "667120" ]; then
+  printf '667121\n667122\n'
+fi

package/test/fixtures/issue-126-bin/screen

@@ -0,0 +1,6 @@
+#!/usr/bin/env sh
+cat <<'EOF'
+There is a screen on:
+	667120.issue-126-screen	(Detached)
+1 Socket in /run/screen/S-box.
+EOF

package/test/isolation-cleanup.js

@@ -241,29 +241,116 @@ describe('Isolation Resource Cleanup Verification', () => {
     // Use the canRunLinuxDockerImages function from isolation module
     // to properly detect if Linux containers can run (handles Windows containers mode)
     const { canRunLinuxDockerImages } = require('../src/lib/isolation');
+    const DOCKER_TEST_TIMEOUT = process.platform === 'win32' ? 30000 : 20000;
+    const DOCKER_STATE_WAIT_TIMEOUT =
+      process.platform === 'win32' ? 20000 : 10000;
+
+    it(
+      'should show docker container as exited after command completes (auto-exit by default)',
+      { timeout: DOCKER_TEST_TIMEOUT },
+      async () => {
+        if (!canRunLinuxDockerImages()) {
+          console.log(
+            '  Skipping: docker not available, daemon not running, or Linux containers not supported'
+          );
+          return;
+        }
 
-    it('should show docker container as exited after command completes (auto-exit by default)', async () => {
-      if (!canRunLinuxDockerImages()) {
-        console.log(
-          '  Skipping: docker not available, daemon not running, or Linux containers not supported'
+        const containerName = `test-cleanup-docker-${Date.now()}`;
+
+        // Run a quick command in detached mode
+        const result = await runInDocker('echo "test" && sleep 0.1', {
+          image: 'alpine:latest',
+          session: containerName,
+          detached: true,
+          keepAlive: false,
+        });
+
+        assert.strictEqual(result.success, true);
+
+        // Wait for the container to exit
+        const containerExited = await waitFor(() => {
+          try {
+            const status = execSync(
+              `docker inspect -f '{{.State.Status}}' ${containerName}`,
+              {
+                encoding: 'utf8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+              }
+            ).trim();
+            return status === 'exited';
+          } catch {
+            return false;
+          }
+        }, DOCKER_STATE_WAIT_TIMEOUT);
+
+        assert.ok(
+          containerExited,
+          'Docker container should be in exited state after command completes (auto-exit by default)'
         );
-        return;
+
+        // Verify with docker ps -a that container is exited (not running)
+        try {
+          const allContainers = execSync('docker ps -a', {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+          });
+          assert.ok(
+            allContainers.includes(containerName),
+            'Container should appear in docker ps -a'
+          );
+
+          const runningContainers = execSync('docker ps', {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+          });
+          assert.ok(
+            !runningContainers.includes(containerName),
+            'Container should NOT appear in docker ps (not running)'
+          );
+          console.log(
+            '  ✓ Docker container auto-exited and stopped (resources released, filesystem preserved)'
+          );
+        } catch (err) {
+          assert.fail(`Failed to verify container status: ${err.message}`);
+        }
+
+        // Clean up
+        try {
+          execSync(`docker rm -f ${containerName}`, { stdio: 'ignore' });
+        } catch {
+          // Ignore cleanup errors
+        }
       }
+    );
+
+    it(
+      'should keep docker container running when keepAlive is true',
+      { timeout: DOCKER_TEST_TIMEOUT },
+      async () => {
+        if (!canRunLinuxDockerImages()) {
+          console.log(
+            '  Skipping: docker not available, daemon not running, or Linux containers not supported'
+          );
+          return;
+        }
 
-      const containerName = `test-cleanup-docker-${Date.now()}`;
+        const containerName = `test-keepalive-docker-${Date.now()}`;
 
-      // Run a quick command in detached mode
-      const result = await runInDocker('echo "test" && sleep 0.1', {
-        image: 'alpine:latest',
-        session: containerName,
-        detached: true,
-        keepAlive: false,
-      });
+        // Run command with keepAlive enabled
+        const result = await runInDocker('echo "test"', {
+          image: 'alpine:latest',
+          session: containerName,
+          detached: true,
+          keepAlive: true,
+        });
 
-      assert.strictEqual(result.success, true);
+        assert.strictEqual(result.success, true);
+
+        // Wait a bit for the command to complete
+        await new Promise((resolve) => setTimeout(resolve, 1000));
 
-      // Wait for the container to exit
-      const containerExited = await waitFor(() => {
+        // Container should still be running
         try {
           const status = execSync(
             `docker inspect -f '{{.State.Status}}' ${containerName}`,
@@ -272,101 +359,25 @@ describe('Isolation Resource Cleanup Verification', () => {
               stdio: ['pipe', 'pipe', 'pipe'],
             }
           ).trim();
-          return status === 'exited';
-        } catch {
-          return false;
+          assert.strictEqual(
+            status,
+            'running',
+            'Container should still be running with keepAlive=true'
+          );
+          console.log(
+            '  ✓ Docker container kept running as expected with --keep-alive'
+          );
+        } catch (err) {
+          assert.fail(`Failed to verify container is running: ${err.message}`);
         }
-      }, 10000);
-
-      assert.ok(
-        containerExited,
-        'Docker container should be in exited state after command completes (auto-exit by default)'
-      );
-
-      // Verify with docker ps -a that container is exited (not running)
-      try {
-        const allContainers = execSync('docker ps -a', {
-          encoding: 'utf8',
-          stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        assert.ok(
-          allContainers.includes(containerName),
-          'Container should appear in docker ps -a'
-        );
-
-        const runningContainers = execSync('docker ps', {
-          encoding: 'utf8',
-          stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        assert.ok(
-          !runningContainers.includes(containerName),
-          'Container should NOT appear in docker ps (not running)'
-        );
-        console.log(
-          '  ✓ Docker container auto-exited and stopped (resources released, filesystem preserved)'
-        );
-      } catch (err) {
-        assert.fail(`Failed to verify container status: ${err.message}`);
-      }
-
-      // Clean up
-      try {
-        execSync(`docker rm -f ${containerName}`, { stdio: 'ignore' });
-      } catch {
-        // Ignore cleanup errors
-      }
-    });
-
-    it('should keep docker container running when keepAlive is true', async () => {
-      if (!canRunLinuxDockerImages()) {
-        console.log(
-          '  Skipping: docker not available, daemon not running, or Linux containers not supported'
-        );
-        return;
-      }
-
-      const containerName = `test-keepalive-docker-${Date.now()}`;
-
-      // Run command with keepAlive enabled
-      const result = await runInDocker('echo "test"', {
-        image: 'alpine:latest',
-        session: containerName,
-        detached: true,
-        keepAlive: true,
-      });
-
-      assert.strictEqual(result.success, true);
-
-      // Wait a bit for the command to complete
-      await new Promise((resolve) => setTimeout(resolve, 1000));
 
-      // Container should still be running
-      try {
-        const status = execSync(
-          `docker inspect -f '{{.State.Status}}' ${containerName}`,
-          {
-            encoding: 'utf8',
-            stdio: ['pipe', 'pipe', 'pipe'],
-          }
-        ).trim();
-        assert.strictEqual(
-          status,
-          'running',
-          'Container should still be running with keepAlive=true'
-        );
-        console.log(
-          '  ✓ Docker container kept running as expected with --keep-alive'
-        );
-      } catch (err) {
-        assert.fail(`Failed to verify container is running: ${err.message}`);
-      }
-
-      // Clean up
-      try {
-        execSync(`docker rm -f ${containerName}`, { stdio: 'ignore' });
-      } catch {
-        // Ignore cleanup errors
+        // Clean up
+        try {
+          execSync(`docker rm -f ${containerName}`, { stdio: 'ignore' });
+        } catch {
+          // Ignore cleanup errors
+        }
       }
-    });
+    );
   });
 });

package/test/output-blocks.js

@@ -402,6 +402,31 @@ describe('output-blocks module', () => {
     it('should handle null', () => {
       expect(formatAsNestedLinksNotation(null)).toBe('null');
     });
+
+    it('should indent nested arrays under their parent key', () => {
+      const obj = {
+        processIds: {
+          wrapperPid: 667105,
+          screenPid: 667120,
+          commandPids: [667121, 667122],
+        },
+      };
+
+      const result = formatAsNestedLinksNotation(obj);
+
+      expect(result).toContain(
+        [
+          '  processIds',
+          '    wrapperPid 667105',
+          '    screenPid 667120',
+          '    commandPids',
+          '      (',
+          '        667121',
+          '        667122',
+          '      )',
+        ].join('\n')
+      );
+    });
   });
 
   describe('Virtual Command API', () => {