start-command 0.24.1 → 0.24.2

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # start-command
 
+## 0.24.2
+
+### Patch Changes
+
+- f870146: perf: skip shell detection probe when command is a bare shell invocation
+
+  When running `$ --isolated docker -- bash`, the tool previously ran a probe
+  container (`docker run --rm image sh -c 'command -v bash'`) to detect which
+  shell to use, even though the result was unused for bare shell commands.
+
+  Now `isInteractiveShellCommand(command)` is evaluated first, and
+  `detectShellInEnvironment` is only called when the command is not a bare shell.
+  This avoids up to three unnecessary container starts per invocation and eliminates
+  spurious failures when the probe itself fails on images with complex entrypoints.
+
+  Also caches the `isInteractiveShellCommand(command)` result in `isBareShell` to
+  avoid redundant calls in both attached and detached code paths.
+
 ## 0.24.1
 
 ### Patch Changes

package/package.json

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

package/src/lib/isolation.js

@@ -766,7 +766,10 @@ function runInDocker(command, options = {}) {
     }
   }
 
-  const shellToUse = detectShellInEnvironment('docker', options, options.shell);
+  const isBareShell = isInteractiveShellCommand(command);
+  const shellToUse = isBareShell
+    ? 'sh'
+    : detectShellInEnvironment('docker', options, options.shell);
   const shellInteractiveFlag = getShellInteractiveFlag(shellToUse);
 
   // Print the user command (this appears after any virtual commands like docker pull)
@@ -777,9 +780,6 @@ function runInDocker(command, options = {}) {
   try {
     if (options.detached) {
       // Detached mode: docker run -d --name <name> [--user <user>] <image> <shell> -c '<command>'
-      const effectiveCommand = options.keepAlive
-        ? `${command}; exec ${shellToUse}`
-        : command;
       const dockerArgs = ['run', '-d', '--name', containerName];
 
       // --rm must come before the image name
@@ -792,10 +792,13 @@ function runInDocker(command, options = {}) {
         dockerArgs.push('--user', options.user);
       }
 
+      const effectiveCommand = options.keepAlive
+        ? `${command}; exec ${shellToUse}`
+        : command;
       const shellArgs = shellInteractiveFlag
         ? [shellToUse, shellInteractiveFlag]
         : [shellToUse];
-      const cmdArgs = isInteractiveShellCommand(command)
+      const cmdArgs = isBareShell
         ? command.trim().split(/\s+/)
         : [...shellArgs, '-c', effectiveCommand];
       dockerArgs.push(options.image, ...cmdArgs);
@@ -847,7 +850,7 @@ function runInDocker(command, options = {}) {
       const shellCmdArgs = shellInteractiveFlag
         ? [shellToUse, shellInteractiveFlag]
         : [shellToUse];
-      const attachedCmdArgs = isInteractiveShellCommand(command)
+      const attachedCmdArgs = isBareShell
         ? command.trim().split(/\s+/)
         : [...shellCmdArgs, '-c', command];
       dockerArgs.push(options.image, ...attachedCmdArgs);

package/test/regression-84.test.js

@@ -0,0 +1,159 @@
+#!/usr/bin/env bun
+/**
+ * Regression tests for issue #84: "We should not run bash inside bash"
+ *
+ * These tests guard against the shell-inside-shell regression where
+ * `$ --isolated docker -- bash` caused:
+ *   docker run ... image /bin/bash -i -c bash   (WRONG: bash inside bash)
+ * instead of:
+ *   docker run ... image bash                    (CORRECT: bare shell)
+ *
+ * The same regression applies to zsh, sh, and all other isolation backends.
+ *
+ * Reference: https://github.com/link-foundation/start/issues/84
+ * Fixed in: PR #85 (v0.24.1) via isInteractiveShellCommand()
+ */
+
+const { describe, it } = require('node:test');
+const assert = require('assert');
+const { isInteractiveShellCommand } = require('../src/lib/isolation');
+
+// Helper: mirrors the command-args construction logic used in
+// runInDocker (attached + detached), runInScreen, and runInSsh.
+// If this helper returns args containing '-c' for a bare shell command,
+// the shell-inside-shell bug is present.
+function buildCmdArgs(command, shellToUse = '/bin/bash') {
+  const shellName = shellToUse.split('/').pop();
+  const shellInteractiveFlag =
+    shellName === 'bash' || shellName === 'zsh' ? '-i' : null;
+  const shellArgs = shellInteractiveFlag
+    ? [shellToUse, shellInteractiveFlag]
+    : [shellToUse];
+  return isInteractiveShellCommand(command)
+    ? command.trim().split(/\s+/)
+    : [...shellArgs, '-c', command];
+}
+
+describe('isInteractiveShellCommand additional cases (issue #84)', () => {
+  // These cover edge cases not in the base isInteractiveShellCommand test suite.
+
+  // Workaround: bash --norc skips .bashrc sourcing (post-fix regression workaround)
+  it('should return true for "bash --norc"', () => {
+    assert.strictEqual(isInteractiveShellCommand('bash --norc'), true);
+  });
+
+  it('should return true for "zsh --no-rcs"', () => {
+    assert.strictEqual(isInteractiveShellCommand('zsh --no-rcs'), true);
+  });
+
+  it('should return true for "bash -i" (interactive flag, no -c)', () => {
+    assert.strictEqual(isInteractiveShellCommand('bash -i'), true);
+  });
+
+  it('should return true for "fish"', () => {
+    assert.strictEqual(isInteractiveShellCommand('fish'), true);
+  });
+
+  it('should return true for "dash"', () => {
+    assert.strictEqual(isInteractiveShellCommand('dash'), true);
+  });
+
+  it('should return true for "/usr/local/bin/bash"', () => {
+    assert.strictEqual(isInteractiveShellCommand('/usr/local/bin/bash'), true);
+  });
+
+  it('should return false for \'bash -c "echo hello"\'', () => {
+    assert.strictEqual(
+      isInteractiveShellCommand('bash -c "echo hello"'),
+      false
+    );
+  });
+});
+
+describe('Regression: No Shell-Inside-Shell (issue #84)', () => {
+  // Each test verifies that the command-arg construction logic does NOT
+  // wrap a bare shell invocation inside another shell with `-c`.
+  //
+  // Before fix: buildCmdArgs('bash') → ['/bin/bash', '-i', '-c', 'bash']
+  // After fix:  buildCmdArgs('bash') → ['bash']
+
+  it('should pass "bash" directly, not wrap in shell -c', () => {
+    const args = buildCmdArgs('bash');
+    assert.deepStrictEqual(
+      args,
+      ['bash'],
+      `Expected ["bash"], got: ${JSON.stringify(args)}`
+    );
+    assert.ok(
+      !args.includes('-c'),
+      'Must not contain -c flag (shell-inside-shell)'
+    );
+  });
+
+  it('should pass "zsh" directly, not wrap in shell -c', () => {
+    const args = buildCmdArgs('zsh');
+    assert.deepStrictEqual(args, ['zsh']);
+    assert.ok(
+      !args.includes('-c'),
+      'Must not contain -c flag (shell-inside-shell)'
+    );
+  });
+
+  it('should pass "sh" directly, not wrap in shell -c', () => {
+    const args = buildCmdArgs('sh', 'sh');
+    assert.deepStrictEqual(args, ['sh']);
+    assert.ok(
+      !args.includes('-c'),
+      'Must not contain -c flag (shell-inside-shell)'
+    );
+  });
+
+  it('should pass "/bin/bash" directly, not wrap in shell -c', () => {
+    const args = buildCmdArgs('/bin/bash');
+    assert.deepStrictEqual(args, ['/bin/bash']);
+    assert.ok(
+      !args.includes('-c'),
+      'Must not contain -c flag (shell-inside-shell)'
+    );
+  });
+
+  it('should pass "bash --norc" directly (workaround for broken .bashrc)', () => {
+    const args = buildCmdArgs('bash --norc');
+    assert.deepStrictEqual(args, ['bash', '--norc']);
+    assert.ok(!args.includes('-c'), 'Must not contain -c flag');
+  });
+
+  it('should pass "bash -l" directly (login shell)', () => {
+    const args = buildCmdArgs('bash -l');
+    assert.deepStrictEqual(args, ['bash', '-l']);
+    assert.ok(!args.includes('-c'), 'Must not contain -c flag');
+  });
+
+  it('should still wrap non-shell commands in shell -c (guard against over-broad fix)', () => {
+    const args = buildCmdArgs('echo hello', '/bin/bash');
+    assert.deepStrictEqual(args, ['/bin/bash', '-i', '-c', 'echo hello']);
+    assert.ok(
+      args.includes('-c'),
+      'Non-shell commands must still use -c wrapper'
+    );
+  });
+
+  it('should still wrap "npm test" in shell -c (guard against over-broad fix)', () => {
+    const args = buildCmdArgs('npm test', '/bin/bash');
+    assert.deepStrictEqual(args, ['/bin/bash', '-i', '-c', 'npm test']);
+    assert.ok(
+      args.includes('-c'),
+      'Non-shell commands must still use -c wrapper'
+    );
+  });
+
+  it('should not treat "bash -c something" as bare shell', () => {
+    // bash -c ... has -c, so isInteractiveShellCommand returns false
+    // The command gets wrapped: ['/bin/bash', '-i', '-c', 'bash -c "echo hi"']
+    const args = buildCmdArgs('bash -c "echo hi"', '/bin/bash');
+    assert.ok(
+      args.includes('-c'),
+      'bash -c commands should be treated as regular commands'
+    );
+  });
+});