start-command 0.24.0 → 0.24.2

package/CHANGELOG.md

@@ -1,5 +1,40 @@
 # 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
+
+- 2cb0101: fix: avoid running shell inside shell when command is a bare shell invocation
+
+  When running `$ --isolated docker --image <image> -- bash`, the tool was
+  wrapping the bare `bash` command inside `bash -i -c bash`, causing `.bashrc`
+  to be sourced twice and printing errors twice. Same issue affected `zsh`, `sh`,
+  and other shells.
+
+  Added `isInteractiveShellCommand()` helper that detects when the user's command
+  is a bare interactive shell invocation (e.g. `bash`, `/bin/zsh`, `bash -l`).
+  When detected, the command is passed directly to the isolation environment
+  instead of being wrapped in another shell. Applies to Docker (attached and
+  detached), SSH (attached and detached), and Screen (attached and detached).
+
 ## 0.24.0
 
 ### Minor Changes

package/package.json

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

@@ -216,21 +216,19 @@ function getShellInteractiveFlag(shellPath) {
   const shellName = shellPath.split('/').pop();
   return shellName === 'bash' || shellName === 'zsh' ? '-i' : null;
 }
+/** True if command is a bare shell invocation (no -c); avoids bash-inside-bash (issue #84). */
+function isInteractiveShellCommand(command) {
+  const parts = command.trim().split(/\s+/);
+  const shells = ['bash', 'zsh', 'sh', 'fish', 'ksh', 'csh', 'tcsh', 'dash'];
+  return shells.includes(path.basename(parts[0])) && !parts.includes('-c');
+}
 
-/**
- * Check if the current process has a TTY attached
- * @returns {boolean} True if TTY is available
- */
+/** Returns true if the current process has a TTY attached. */
 function hasTTY() {
   return Boolean(process.stdin.isTTY && process.stdout.isTTY);
 }
 
-/**
- * Wrap command with sudo -u if user option is specified
- * @param {string} command - Original command
- * @param {string|null} user - Username to run as (or null)
- * @returns {string} Wrapped command
- */
+/** Wraps command with sudo -u if user is specified; returns command unchanged otherwise. */
 function wrapCommandWithUser(command, user) {
   if (!user) {
     return command;
@@ -242,13 +240,8 @@ function wrapCommandWithUser(command, user) {
 }
 
 /**
- * Run command in GNU Screen using detached mode with log capture
- * This is a workaround for environments without TTY
- *
- * Supports two methods based on screen version:
- * - screen >= 4.5.1: Uses -L -Logfile option for native log capture
- * - screen < 4.5.1: Uses tee command within the wrapped command for output capture
- *
+ * Run command in GNU Screen using detached mode with log capture.
+ * Supports screen >= 4.5.1 (native -Logfile) and older versions (tee fallback).
  * @param {string} command - Command to execute
  * @param {string} sessionName - Session name
  * @param {object} shellInfo - Shell info from getShell()
@@ -271,16 +264,10 @@ function runScreenWithLogCapture(command, sessionName, shellInfo, user = null) {
       if (useNativeLogging) {
         // Modern screen (>= 4.5.1): Use -L -Logfile option for native log capture
         // screen -dmS <session> -L -Logfile <logfile> <shell> -c '<command>'
-        screenArgs = [
-          '-dmS',
-          sessionName,
-          '-L',
-          '-Logfile',
-          logFile,
-          shell,
-          shellArg,
-          effectiveCommand,
-        ];
+        const logArgs = ['-dmS', sessionName, '-L', '-Logfile', logFile];
+        screenArgs = isInteractiveShellCommand(command)
+          ? [...logArgs, ...command.trim().split(/\s+/)]
+          : [...logArgs, shell, shellArg, effectiveCommand];
 
         if (DEBUG) {
           console.log(
@@ -289,10 +276,14 @@ function runScreenWithLogCapture(command, sessionName, shellInfo, user = null) {
         }
       } else {
         // Older screen (< 4.5.1, e.g., macOS bundled 4.0.3): Use tee fallback
-        // Wrap the command to capture output using tee
         // The parentheses ensure proper grouping of the command and its stderr
-        effectiveCommand = `(${effectiveCommand}) 2>&1 | tee "${logFile}"`;
-        screenArgs = ['-dmS', sessionName, shell, shellArg, effectiveCommand];
+        const isBareShell = isInteractiveShellCommand(command);
+        if (!isBareShell) {
+          effectiveCommand = `(${effectiveCommand}) 2>&1 | tee "${logFile}"`;
+        }
+        screenArgs = isBareShell
+          ? ['-dmS', sessionName, ...command.trim().split(/\s+/)]
+          : ['-dmS', sessionName, shell, shellArg, effectiveCommand];
 
         if (DEBUG) {
           console.log(
@@ -451,13 +442,9 @@ function runInScreen(command, options = {}) {
       }
       // Without keep-alive: command runs and session exits naturally when done
 
-      const screenArgs = [
-        '-dmS',
-        sessionName,
-        shell,
-        shellArg,
-        effectiveCommand,
-      ];
+      const screenArgs = isInteractiveShellCommand(command)
+        ? ['-dmS', sessionName, ...command.trim().split(/\s+/)]
+        : ['-dmS', sessionName, shell, shellArg, effectiveCommand];
 
       if (DEBUG) {
         console.log(`[DEBUG] Running: screen ${screenArgs.join(' ')}`);
@@ -670,7 +657,9 @@ function runInSsh(command, options = {}) {
       const shellInvocation = shellInteractiveFlag
         ? `${remoteShell} ${shellInteractiveFlag}`
         : remoteShell;
-      const remoteCommand = `nohup ${shellInvocation} -c ${JSON.stringify(command)} > /tmp/${sessionName}.log 2>&1 &`;
+      const remoteCommand = isInteractiveShellCommand(command)
+        ? `nohup ${command} > /tmp/${sessionName}.log 2>&1 &`
+        : `nohup ${shellInvocation} -c ${JSON.stringify(command)} > /tmp/${sessionName}.log 2>&1 &`;
       const sshArgs = [sshTarget, remoteCommand];
 
       if (DEBUG) {
@@ -692,9 +681,11 @@ function runInSsh(command, options = {}) {
     } else {
       // Attached mode: pass command directly (auto) or wrap with explicit shell + -i flag (bash/zsh).
       const extraFlags = shellInteractiveFlag ? [shellInteractiveFlag] : [];
-      const sshArgs = useExplicitShell
-        ? [sshTarget, useExplicitShell, ...extraFlags, '-c', command]
-        : [sshTarget, command];
+      const sshArgs = isInteractiveShellCommand(command)
+        ? [sshTarget, ...command.trim().split(/\s+/)]
+        : useExplicitShell
+          ? [sshTarget, useExplicitShell, ...extraFlags, '-c', command]
+          : [sshTarget, command];
 
       if (DEBUG) {
         console.log(`[DEBUG] Running: ssh ${sshArgs.join(' ')}`);
@@ -775,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)
@@ -786,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
@@ -801,10 +792,16 @@ function runInDocker(command, options = {}) {
         dockerArgs.push('--user', options.user);
       }
 
+      const effectiveCommand = options.keepAlive
+        ? `${command}; exec ${shellToUse}`
+        : command;
       const shellArgs = shellInteractiveFlag
         ? [shellToUse, shellInteractiveFlag]
         : [shellToUse];
-      dockerArgs.push(options.image, ...shellArgs, '-c', effectiveCommand);
+      const cmdArgs = isBareShell
+        ? command.trim().split(/\s+/)
+        : [...shellArgs, '-c', effectiveCommand];
+      dockerArgs.push(options.image, ...cmdArgs);
 
       if (DEBUG) {
         console.log(`[DEBUG] Running: docker ${dockerArgs.join(' ')}`);
@@ -853,7 +850,10 @@ function runInDocker(command, options = {}) {
       const shellCmdArgs = shellInteractiveFlag
         ? [shellToUse, shellInteractiveFlag]
         : [shellToUse];
-      dockerArgs.push(options.image, ...shellCmdArgs, '-c', command);
+      const attachedCmdArgs = isBareShell
+        ? command.trim().split(/\s+/)
+        : [...shellCmdArgs, '-c', command];
+      dockerArgs.push(options.image, ...attachedCmdArgs);
 
       if (DEBUG) {
         console.log(`[DEBUG] Running: docker ${dockerArgs.join(' ')}`);
@@ -972,6 +972,7 @@ const {
 module.exports = {
   isCommandAvailable,
   hasTTY,
+  isInteractiveShellCommand,
   detectShellInEnvironment,
   runInScreen,
   runInTmux,

package/test/isolation.test.js

@@ -896,3 +896,59 @@ describe('Shell option forwarding to isolation runners', () => {
     });
   });
 });
+
+describe('isInteractiveShellCommand (issue #84)', () => {
+  const { isInteractiveShellCommand } = require('../src/lib/isolation');
+
+  it('should return true for "bash"', () => {
+    assert.strictEqual(isInteractiveShellCommand('bash'), true);
+  });
+
+  it('should return true for "zsh"', () => {
+    assert.strictEqual(isInteractiveShellCommand('zsh'), true);
+  });
+
+  it('should return true for "sh"', () => {
+    assert.strictEqual(isInteractiveShellCommand('sh'), true);
+  });
+
+  it('should return true for "/bin/bash"', () => {
+    assert.strictEqual(isInteractiveShellCommand('/bin/bash'), true);
+  });
+
+  it('should return true for "/usr/bin/zsh"', () => {
+    assert.strictEqual(isInteractiveShellCommand('/usr/bin/zsh'), true);
+  });
+
+  it('should return true for "bash -l" (login flag, no -c)', () => {
+    assert.strictEqual(isInteractiveShellCommand('bash -l'), true);
+  });
+
+  it('should return false for "bash -c echo"', () => {
+    assert.strictEqual(isInteractiveShellCommand('bash -c echo'), false);
+  });
+
+  it('should return false for "bash -c \'echo hi\'"', () => {
+    assert.strictEqual(isInteractiveShellCommand("bash -c 'echo hi'"), false);
+  });
+
+  it('should return false for "npm test"', () => {
+    assert.strictEqual(isInteractiveShellCommand('npm test'), false);
+  });
+
+  it('should return false for "echo hello"', () => {
+    assert.strictEqual(isInteractiveShellCommand('echo hello'), false);
+  });
+
+  it('should return false for "ls -la"', () => {
+    assert.strictEqual(isInteractiveShellCommand('ls -la'), false);
+  });
+
+  it('should return false for empty string', () => {
+    assert.strictEqual(isInteractiveShellCommand(''), false);
+  });
+
+  it('should return false for "  "', () => {
+    assert.strictEqual(isInteractiveShellCommand('  '), false);
+  });
+});

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'
+    );
+  });
+});