start-command 0.22.0 → 0.24.0

package/CHANGELOG.md

@@ -1,5 +1,47 @@
 # start-command
 
+## 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
+
+- b85d3cb: feat: Add shell auto-detection and --shell option for isolation environments
+
+  In docker and ssh isolation environments, the shell is now automatically
+  selected in order of preference: bash, zsh, sh (auto mode). A new `--shell`
+  option allows explicitly specifying the shell to use.
+  - Auto mode (default): probes the environment for the best available shell
+  - `--shell bash/zsh/sh`: forces a specific shell
+  - `--shell auto`: explicitly selects auto-detection mode
+
+  This enables tools like `nvm` to work correctly in Docker containers where
+  bash is available but sh does not source the necessary profile scripts.
+
+  Fixes #79
+
 ## 0.22.0
 
 ### Minor Changes

package/package.json

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

package/src/bin/cli.js

@@ -331,6 +331,7 @@ Options:
   --keep-user           Keep isolated user after command completes
   --keep-alive, -k      Keep isolation environment alive after command exits
   --auto-remove-docker-container  Auto-remove docker container after exit
+  --shell <shell>       Shell to use in isolation environments: auto, bash, zsh, sh (default: auto)
   --use-command-stream  Use command-stream library for execution (experimental)
   --status <uuid>       Show status of execution by UUID (--output-format: links-notation|json|text)
   --cleanup             Clean up stale "executing" records (crashed/killed processes)
@@ -575,6 +576,7 @@ async function runWithIsolation(
       user: createdUser,
       keepAlive: options.keepAlive,
       autoRemoveDockerContainer: options.autoRemoveDockerContainer,
+      shell: options.shell,
     });
   } else if (createdUser) {
     // Run directly as the created user (no isolation environment)

package/src/lib/isolation.js

@@ -211,6 +211,12 @@ function detectShellInEnvironment(
   return 'sh';
 }
 
+/** 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;
+}
+
 /**
  * Check if the current process has a TTY attached
  * @returns {boolean} True if TTY is available
@@ -648,30 +654,31 @@ 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 = `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,11 +690,10 @@ 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.
+      // Attached mode: pass command directly (auto) or wrap with explicit shell + -i flag (bash/zsh).
+      const extraFlags = shellInteractiveFlag ? [shellInteractiveFlag] : [];
       const sshArgs = useExplicitShell
-        ? [sshTarget, useExplicitShell, '-c', command]
+        ? [sshTarget, useExplicitShell, ...extraFlags, '-c', command]
         : [sshTarget, command];
 
       if (DEBUG) {
@@ -769,8 +775,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 +786,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 +801,10 @@ function runInDocker(command, options = {}) {
         dockerArgs.push('--user', options.user);
       }
 
-      dockerArgs.push(options.image, shellToUse, '-c', effectiveCommand);
+      const shellArgs = shellInteractiveFlag
+        ? [shellToUse, shellInteractiveFlag]
+        : [shellToUse];
+      dockerArgs.push(options.image, ...shellArgs, '-c', effectiveCommand);
 
       if (DEBUG) {
         console.log(`[DEBUG] Running: docker ${dockerArgs.join(' ')}`);
@@ -840,19 +841,19 @@ 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];
+      dockerArgs.push(options.image, ...shellCmdArgs, '-c', command);
 
       if (DEBUG) {
         console.log(`[DEBUG] Running: docker ${dockerArgs.join(' ')}`);

package/test/isolation.test.js

@@ -824,4 +824,75 @@ describe('detectShellInEnvironment', () => {
     );
     console.log(`  Detected shell in alpine:latest: ${result}`);
   });
+
+  it('should read shell preference from options.shell', () => {
+    // Test that detectShellInEnvironment respects options.shell field
+    const result = detectShellInEnvironment(
+      'docker',
+      { image: 'alpine:latest', shell: 'bash' },
+      'bash'
+    );
+    assert.strictEqual(result, 'bash');
+  });
+});
+
+describe('Shell option forwarding to isolation runners', () => {
+  // These tests verify that the shell option is properly forwarded
+  // through the call chain: cli.js -> runIsolated -> runInDocker/runInSsh
+
+  const { runInDocker, runInSsh } = require('../src/lib/isolation');
+
+  describe('runInDocker shell option', () => {
+    it('should accept shell option in options object', async () => {
+      if (!isCommandAvailable('docker')) {
+        console.log('  Skipping: docker not installed');
+        return;
+      }
+
+      // Test with explicit shell option - just verify the option is accepted
+      // and the function runs (it may fail if image is not available)
+      const result = await runInDocker('echo test', {
+        image: 'alpine:latest',
+        detached: true,
+        shell: 'sh',
+      });
+      // If docker is available, verify the result
+      console.log(`  runInDocker with --shell sh result: ${result.success}`);
+      // The result can be success or failure depending on docker availability
+      // The important thing is no crash due to missing shell option
+      assert.ok(typeof result.success === 'boolean');
+    });
+  });
+
+  describe('runInSsh shell option', () => {
+    it('should accept shell option in options object', async () => {
+      // SSH requires endpoint, so without it we get expected error
+      const result = await runInSsh('echo test', {
+        detached: true,
+        shell: 'bash',
+      });
+      assert.strictEqual(result.success, false);
+      // Should fail with endpoint error, not shell option error
+      assert.ok(
+        result.message.includes('endpoint') ||
+          result.message.includes('--endpoint') ||
+          result.message.includes('SSH isolation requires')
+      );
+    });
+
+    it('should use auto mode when shell option is auto', async () => {
+      // Verify auto mode doesn't crash
+      const result = await runInSsh('echo test', {
+        detached: true,
+        shell: 'auto',
+      });
+      assert.strictEqual(result.success, false);
+      // Should fail with endpoint error in auto mode
+      assert.ok(
+        result.message.includes('endpoint') ||
+          result.message.includes('--endpoint') ||
+          result.message.includes('SSH isolation requires')
+      );
+    });
+  });
 });