start-command 0.23.0 → 0.24.1

package/CHANGELOG.md

@@ -1,5 +1,46 @@
 # start-command
 
+## 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
+
+- 2ea7f43: feat: Use interactive shell mode in isolation environments to source startup files
+
+  In docker and ssh isolation environments, bash and zsh are now invoked with
+  the `-i` (interactive) flag when executing commands. This ensures that startup
+  files like `.bashrc` and `.zshrc` are sourced, making environment-dependent
+  tools like `nvm`, `rbenv`, `pyenv`, and similar version managers available
+  in isolated commands.
+
+  Previously, even though bash was correctly detected and used over sh, running
+  `nvm --version` in a Docker container would fail with "command not found"
+  because bash was started in non-interactive mode and did not source `.bashrc`.
+
+  With this fix:
+  - Docker: `docker run <image> bash -i -c "nvm --version"` sources `.bashrc`
+  - SSH: `ssh <host> bash -i -c "nvm --version"` sources `.bashrc` on the remote host
+  - `zsh` also gets the `-i` flag for the same reason
+  - `sh` does not get `-i` as it is used as a fallback for minimal containers
+
+  Fixes #79
+
 ## 0.23.0
 
 ### Minor Changes

package/package.json

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

@@ -211,20 +211,24 @@ function detectShellInEnvironment(
   return 'sh';
 }
 
-/**
- * Check if the current process has a TTY attached
- * @returns {boolean} True if TTY is available
- */
+/** Returns "-i" for bash/zsh (enables .bashrc sourcing), null otherwise. */
+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');
+}
+
+/** 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;
@@ -236,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()
@@ -265,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(
@@ -283,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(
@@ -445,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(' ')}`);
@@ -648,30 +641,33 @@ function runInSsh(command, options = {}) {
   const sessionName = options.session || generateSessionName('ssh');
   const sshTarget = options.endpoint;
 
-  // Detect the shell to use on the remote host
-  // In auto mode, detection may fall back to passing command directly to leverage
-  // the remote user's default login shell (which may already be bash)
   const shellToUse = detectShellInEnvironment('ssh', options, options.shell);
-  // Whether to wrap command with a shell (only when explicit shell is specified)
+  // In auto mode, SSH login shells already source startup files (.bashrc etc.);
+  // only wrap with an explicit shell when user requests one.
   const useExplicitShell =
     options.shell && options.shell !== 'auto' ? shellToUse : null;
+  const shellInteractiveFlag = useExplicitShell
+    ? getShellInteractiveFlag(useExplicitShell)
+    : null;
 
   try {
     if (options.detached) {
-      // Detached mode: Run command in background on remote server using nohup
-      // The command will continue running even after SSH connection closes
+      // Detached mode: Run command in background via nohup; continues after SSH closes
       const remoteShell = useExplicitShell || shellToUse;
-      const remoteCommand = `nohup ${remoteShell} -c ${JSON.stringify(command)} > /tmp/${sessionName}.log 2>&1 &`;
+      const shellInvocation = shellInteractiveFlag
+        ? `${remoteShell} ${shellInteractiveFlag}`
+        : remoteShell;
+      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) {
         console.log(`[DEBUG] Running: ssh ${sshArgs.join(' ')}`);
-        console.log(`[DEBUG] shell: ${remoteShell}`);
+        console.log(`[DEBUG] shell: ${shellInvocation}`);
       }
 
-      const result = spawnSync('ssh', sshArgs, {
-        stdio: 'inherit',
-      });
+      const result = spawnSync('ssh', sshArgs, { stdio: 'inherit' });
 
       if (result.error) {
         throw result.error;
@@ -683,12 +679,13 @@ function runInSsh(command, options = {}) {
         message: `Command started in detached SSH session on ${sshTarget}\nSession: ${sessionName}\nView logs: ssh ${sshTarget} "tail -f /tmp/${sessionName}.log"`,
       });
     } else {
-      // Attached mode: Run command interactively over SSH
-      // When a specific shell is requested, wrap the command with that shell.
-      // In auto mode, pass the command directly and let the remote's default shell handle it.
-      const sshArgs = useExplicitShell
-        ? [sshTarget, useExplicitShell, '-c', command]
-        : [sshTarget, command];
+      // Attached mode: pass command directly (auto) or wrap with explicit shell + -i flag (bash/zsh).
+      const extraFlags = shellInteractiveFlag ? [shellInteractiveFlag] : [];
+      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(' ')}`);
@@ -769,8 +766,8 @@ function runInDocker(command, options = {}) {
     }
   }
 
-  // Detect the shell to use in the container
   const shellToUse = detectShellInEnvironment('docker', options, options.shell);
+  const shellInteractiveFlag = getShellInteractiveFlag(shellToUse);
 
   // Print the user command (this appears after any virtual commands like docker pull)
   const { createCommandLine } = require('./output-blocks');
@@ -780,20 +777,12 @@ function runInDocker(command, options = {}) {
   try {
     if (options.detached) {
       // Detached mode: docker run -d --name <name> [--user <user>] <image> <shell> -c '<command>'
-      // By default (keepAlive=false), the container exits after command completes
-      // With keepAlive=true, we keep the container running with a shell
-      let effectiveCommand = command;
-
-      if (options.keepAlive) {
-        // With keep-alive: run command, then keep shell alive
-        effectiveCommand = `${command}; exec ${shellToUse}`;
-      }
-      // Without keep-alive: container exits naturally when command completes
-
+      const effectiveCommand = options.keepAlive
+        ? `${command}; exec ${shellToUse}`
+        : command;
       const dockerArgs = ['run', '-d', '--name', containerName];
 
-      // Add --rm flag if autoRemoveDockerContainer is true
-      // Note: --rm must come before the image name
+      // --rm must come before the image name
       if (options.autoRemoveDockerContainer) {
         dockerArgs.splice(2, 0, '--rm');
       }
@@ -803,7 +792,13 @@ function runInDocker(command, options = {}) {
         dockerArgs.push('--user', options.user);
       }
 
-      dockerArgs.push(options.image, shellToUse, '-c', effectiveCommand);
+      const shellArgs = shellInteractiveFlag
+        ? [shellToUse, shellInteractiveFlag]
+        : [shellToUse];
+      const cmdArgs = isInteractiveShellCommand(command)
+        ? command.trim().split(/\s+/)
+        : [...shellArgs, '-c', effectiveCommand];
+      dockerArgs.push(options.image, ...cmdArgs);
 
       if (DEBUG) {
         console.log(`[DEBUG] Running: docker ${dockerArgs.join(' ')}`);
@@ -840,19 +835,22 @@ function runInDocker(command, options = {}) {
         message,
       });
     } else {
-      // Attached mode: docker run -it --name <name> [--user <user>] <image> <shell> -c '<command>'
+      // Attached mode: docker run -it --rm --name <name> [--user <user>] <image> <shell> -c '<cmd>'
       const dockerArgs = ['run', '-it', '--rm', '--name', containerName];
-
-      // Add --user flag if specified
       if (options.user) {
         dockerArgs.push('--user', options.user);
       }
-
       if (DEBUG) {
         console.log(`[DEBUG] shell: ${shellToUse}`);
       }
 
-      dockerArgs.push(options.image, shellToUse, '-c', command);
+      const shellCmdArgs = shellInteractiveFlag
+        ? [shellToUse, shellInteractiveFlag]
+        : [shellToUse];
+      const attachedCmdArgs = isInteractiveShellCommand(command)
+        ? command.trim().split(/\s+/)
+        : [...shellCmdArgs, '-c', command];
+      dockerArgs.push(options.image, ...attachedCmdArgs);
 
       if (DEBUG) {
         console.log(`[DEBUG] Running: docker ${dockerArgs.join(' ')}`);
@@ -971,6 +969,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);
+  });
+});