start-command 0.7.1 → 0.7.4

package/experiments/test-screen-tee-debug.js

@@ -0,0 +1,237 @@
+#!/usr/bin/env bun
+/**
+ * Debug experiment to find the root cause of issue #25
+ * We're testing different ways of running screen commands with tee
+ */
+
+const { execSync, spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+async function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function testDebug() {
+  console.log('=== Debugging Screen Tee Fallback ===\n');
+
+  // Test 1: Simple command without quotes issues
+  console.log('Test 1: Simple command (no spaces in the command)');
+  const sessionName1 = `debug1-${Date.now()}`;
+  const logFile1 = path.join(os.tmpdir(), `debug1-${sessionName1}.log`);
+
+  try {
+    // Direct screen command with tee
+    const cmd = `screen -dmS "${sessionName1}" /bin/sh -c "(echo hello) 2>&1 | tee \\"${logFile1}\\""`;
+    console.log(`  Command: ${cmd}`);
+
+    execSync(cmd, { stdio: 'inherit' });
+    await sleep(500);
+
+    if (fs.existsSync(logFile1)) {
+      console.log(
+        `  Log content: "${fs.readFileSync(logFile1, 'utf8').trim()}"`
+      );
+      console.log(`  Result: SUCCESS ✓`);
+      fs.unlinkSync(logFile1);
+    } else {
+      console.log(`  Result: FAILED - No log file ✗`);
+    }
+  } catch (e) {
+    console.log(`  Error: ${e.message}`);
+  }
+  console.log('');
+
+  // Test 2: Command with nested quotes
+  console.log('Test 2: Command with "hello" (has quotes)');
+  const sessionName2 = `debug2-${Date.now()}`;
+  const logFile2 = path.join(os.tmpdir(), `debug2-${sessionName2}.log`);
+
+  try {
+    // Note: The original command has quotes: echo "hello"
+    // When we wrap it with tee, the quoting becomes complex
+    const cmd = `screen -dmS "${sessionName2}" /bin/sh -c "(echo \\"hello\\") 2>&1 | tee \\"${logFile2}\\""`;
+    console.log(`  Command: ${cmd}`);
+
+    execSync(cmd, { stdio: 'inherit' });
+    await sleep(500);
+
+    if (fs.existsSync(logFile2)) {
+      console.log(
+        `  Log content: "${fs.readFileSync(logFile2, 'utf8').trim()}"`
+      );
+      console.log(`  Result: SUCCESS ✓`);
+      fs.unlinkSync(logFile2);
+    } else {
+      console.log(`  Result: FAILED - No log file ✗`);
+    }
+  } catch (e) {
+    console.log(`  Error: ${e.message}`);
+  }
+  console.log('');
+
+  // Test 3: Using array-based command (like the current implementation)
+  console.log('Test 3: Using array-based args (current implementation style)');
+  const sessionName3 = `debug3-${Date.now()}`;
+  const logFile3 = path.join(os.tmpdir(), `debug3-${sessionName3}.log`);
+
+  try {
+    // This is what the current code does
+    const command = 'echo "hello"';
+    const effectiveCommand = `(${command}) 2>&1 | tee "${logFile3}"`;
+    const screenArgs = [
+      '-dmS',
+      sessionName3,
+      '/bin/sh',
+      '-c',
+      effectiveCommand,
+    ];
+
+    // Construct the command string as the code does
+    const cmdStr = `screen ${screenArgs.map((a) => `"${a}"`).join(' ')}`;
+    console.log(`  Constructed command: ${cmdStr}`);
+
+    execSync(cmdStr, { stdio: 'inherit' });
+    await sleep(500);
+
+    if (fs.existsSync(logFile3)) {
+      console.log(
+        `  Log content: "${fs.readFileSync(logFile3, 'utf8').trim()}"`
+      );
+      console.log(`  Result: SUCCESS ✓`);
+      fs.unlinkSync(logFile3);
+    } else {
+      console.log(`  Result: FAILED - No log file ✗`);
+    }
+  } catch (e) {
+    console.log(`  Error: ${e.message}`);
+  }
+  console.log('');
+
+  // Test 4: Check what happens with the nested quotes
+  console.log('Test 4: Checking quote escaping issue');
+  const sessionName4 = `debug4-${Date.now()}`;
+  const logFile4 = path.join(os.tmpdir(), `debug4-${sessionName4}.log`);
+
+  try {
+    const command = 'echo "hello from attached mode"';
+    const effectiveCommand = `(${command}) 2>&1 | tee "${logFile4}"`;
+    console.log(`  effectiveCommand: ${effectiveCommand}`);
+
+    // When we quote each arg with `"${a}"`, the command becomes double-quoted
+    // which can cause issues with nested quotes
+    const screenArgs = [
+      '-dmS',
+      sessionName4,
+      '/bin/sh',
+      '-c',
+      effectiveCommand,
+    ];
+    const cmdStr = `screen ${screenArgs.map((a) => `"${a}"`).join(' ')}`;
+    console.log(`  Full command: ${cmdStr}`);
+
+    // The problem: effectiveCommand has double quotes inside,
+    // and we're wrapping it with MORE double quotes
+    // This results in: screen "-dmS" "debug4-xxx" "/bin/sh" "-c" "(echo "hello from attached mode") 2>&1 | tee "...""
+    // The nested double quotes break the shell parsing!
+
+    execSync(cmdStr, { stdio: 'inherit' });
+    await sleep(500);
+
+    if (fs.existsSync(logFile4)) {
+      console.log(
+        `  Log content: "${fs.readFileSync(logFile4, 'utf8').trim()}"`
+      );
+      console.log(`  Result: SUCCESS ✓`);
+      fs.unlinkSync(logFile4);
+    } else {
+      console.log(`  Result: FAILED - No log file ✗`);
+    }
+  } catch (e) {
+    console.log(`  Error: ${e.message}`);
+  }
+  console.log('');
+
+  // Test 5: Proper escaping
+  console.log('Test 5: With proper quote escaping');
+  const sessionName5 = `debug5-${Date.now()}`;
+  const logFile5 = path.join(os.tmpdir(), `debug5-${sessionName5}.log`);
+
+  try {
+    const command = 'echo "hello from attached mode"';
+    // Escape the inner quotes
+    const escapedCommand = command.replace(/"/g, '\\"');
+    const effectiveCommand = `(${escapedCommand}) 2>&1 | tee "${logFile5}"`;
+    console.log(`  effectiveCommand: ${effectiveCommand}`);
+
+    const screenArgs = [
+      '-dmS',
+      sessionName5,
+      '/bin/sh',
+      '-c',
+      effectiveCommand,
+    ];
+    const cmdStr = `screen ${screenArgs.map((a) => `"${a}"`).join(' ')}`;
+    console.log(`  Full command: ${cmdStr}`);
+
+    execSync(cmdStr, { stdio: 'inherit' });
+    await sleep(500);
+
+    if (fs.existsSync(logFile5)) {
+      console.log(
+        `  Log content: "${fs.readFileSync(logFile5, 'utf8').trim()}"`
+      );
+      console.log(`  Result: SUCCESS ✓`);
+      fs.unlinkSync(logFile5);
+    } else {
+      console.log(`  Result: FAILED - No log file ✗`);
+    }
+  } catch (e) {
+    console.log(`  Error: ${e.message}`);
+  }
+  console.log('');
+
+  // Test 6: Use spawnSync instead of execSync with constructed string
+  console.log('Test 6: Using spawnSync with array (better approach)');
+  const sessionName6 = `debug6-${Date.now()}`;
+  const logFile6 = path.join(os.tmpdir(), `debug6-${sessionName6}.log`);
+
+  try {
+    const command = 'echo "hello from attached mode"';
+    const effectiveCommand = `(${command}) 2>&1 | tee "${logFile6}"`;
+    console.log(`  effectiveCommand: ${effectiveCommand}`);
+
+    const { spawnSync } = require('child_process');
+    const screenArgs = [
+      '-dmS',
+      sessionName6,
+      '/bin/sh',
+      '-c',
+      effectiveCommand,
+    ];
+    console.log(`  spawnSync args: screen ${screenArgs.join(' ')}`);
+
+    const result = spawnSync('screen', screenArgs, { stdio: 'inherit' });
+    console.log(`  spawnSync exit code: ${result.status}`);
+
+    await sleep(500);
+
+    if (fs.existsSync(logFile6)) {
+      console.log(
+        `  Log content: "${fs.readFileSync(logFile6, 'utf8').trim()}"`
+      );
+      console.log(`  Result: SUCCESS ✓`);
+      fs.unlinkSync(logFile6);
+    } else {
+      console.log(`  Result: FAILED - No log file ✗`);
+    }
+  } catch (e) {
+    console.log(`  Error: ${e.message}`);
+  }
+  console.log('');
+
+  console.log('=== Debug Tests Complete ===');
+}
+
+testDebug();

package/experiments/test-screen-tee-fallback.js

@@ -0,0 +1,230 @@
+#!/usr/bin/env bun
+/**
+ * Experiment to test screen's tee fallback functionality
+ * This simulates the behavior on macOS with older screen (< 4.5.1)
+ * which doesn't support -Logfile option
+ *
+ * Issue #25: We don't get `Hello` output from `$ --isolated screen --verbose -- echo "hello"` command
+ */
+
+const { execSync, spawnSync, spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+async function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function testTeeFallback() {
+  console.log('=== Testing Screen Tee Fallback (macOS 4.0.3 simulation) ===\n');
+
+  // Test environment info
+  console.log('Environment:');
+  console.log(`  Platform: ${process.platform}`);
+  console.log(`  Node: ${process.version}`);
+  try {
+    const screenVersion = execSync('screen --version', {
+      encoding: 'utf8',
+    }).trim();
+    console.log(`  Screen: ${screenVersion}`);
+  } catch (e) {
+    console.log(`  Screen: Not available - ${e.message}`);
+    return;
+  }
+  console.log(
+    `  TTY: stdin=${process.stdin.isTTY}, stdout=${process.stdout.isTTY}`
+  );
+  console.log('');
+
+  // Test 1: The tee fallback approach (current implementation for macOS)
+  console.log('Test 1: Tee fallback approach (current implementation)');
+  const sessionName1 = `tee-test-${Date.now()}`;
+  const logFile1 = path.join(os.tmpdir(), `screen-tee-${sessionName1}.log`);
+  const command = 'echo "hello"';
+
+  try {
+    // This is the current implementation for older screen versions
+    const effectiveCommand = `(${command}) 2>&1 | tee "${logFile1}"`;
+    const shell = '/bin/sh';
+    const shellArg = '-c';
+    const screenArgs = [
+      '-dmS',
+      sessionName1,
+      shell,
+      shellArg,
+      effectiveCommand,
+    ];
+
+    console.log(`  Command: screen ${screenArgs.join(' ')}`);
+    console.log(`  Effective command inside screen: ${effectiveCommand}`);
+
+    execSync(`screen ${screenArgs.map((a) => `"${a}"`).join(' ')}`, {
+      stdio: 'inherit',
+    });
+
+    // Wait for completion and poll for session
+    let waited = 0;
+    const maxWait = 5000;
+    const interval = 100;
+
+    while (waited < maxWait) {
+      await sleep(interval);
+      waited += interval;
+
+      try {
+        const sessions = execSync('screen -ls', {
+          encoding: 'utf8',
+          stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        if (!sessions.includes(sessionName1)) {
+          console.log(`  Session ended after ${waited}ms`);
+          break;
+        }
+      } catch {
+        // screen -ls returns non-zero if no sessions
+        console.log(`  Session ended after ${waited}ms (no sessions)`);
+        break;
+      }
+    }
+
+    // Check log file
+    if (fs.existsSync(logFile1)) {
+      const content = fs.readFileSync(logFile1, 'utf8');
+      console.log(`  Log file exists: YES`);
+      console.log(`  Log file size: ${content.length} bytes`);
+      console.log(`  Log content: "${content.trim()}"`);
+      console.log(
+        `  Contains expected output: ${content.includes('hello') ? 'YES ✓' : 'NO ✗'}`
+      );
+      fs.unlinkSync(logFile1);
+    } else {
+      console.log(`  Log file exists: NO ✗`);
+      console.log(`  Expected path: ${logFile1}`);
+    }
+
+    // Cleanup
+    try {
+      execSync(`screen -S ${sessionName1} -X quit 2>/dev/null`);
+    } catch {}
+  } catch (e) {
+    console.log(`  Error: ${e.message}`);
+  }
+  console.log('');
+
+  // Test 2: Test the attached mode WITHOUT TTY (hasTTY() returns false)
+  console.log(
+    'Test 2: Simulating attached mode without TTY (current code path)'
+  );
+  const sessionName2 = `tee-notty-${Date.now()}`;
+  const logFile2 = path.join(os.tmpdir(), `screen-tee-${sessionName2}.log`);
+
+  try {
+    // Simulate the runScreenWithLogCapture function behavior for older screen
+    const command2 = 'echo "hello from attached mode"';
+    const effectiveCommand2 = `(${command2}) 2>&1 | tee "${logFile2}"`;
+    const shell = '/bin/sh';
+    const shellArg = '-c';
+    const screenArgs = [
+      '-dmS',
+      sessionName2,
+      shell,
+      shellArg,
+      effectiveCommand2,
+    ];
+
+    console.log(`  Screen args: ${screenArgs.join(' ')}`);
+
+    execSync(`screen ${screenArgs.map((a) => `"${a}"`).join(' ')}`, {
+      stdio: 'inherit',
+    });
+
+    // Poll for session completion (as done in current implementation)
+    const checkInterval = 100;
+    const maxWait = 5000;
+    let waited = 0;
+
+    const checkCompletion = async () => {
+      while (waited < maxWait) {
+        await sleep(checkInterval);
+        waited += checkInterval;
+
+        try {
+          const sessions = execSync('screen -ls', {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+          });
+          if (!sessions.includes(sessionName2)) {
+            break;
+          }
+        } catch {
+          break;
+        }
+      }
+    };
+
+    await checkCompletion();
+    console.log(`  Session ended after ${waited}ms`);
+
+    // Read output
+    if (fs.existsSync(logFile2)) {
+      const content = fs.readFileSync(logFile2, 'utf8');
+      console.log(`  Log file exists: YES`);
+      console.log(`  Log content: "${content.trim()}"`);
+      console.log(
+        `  Contains expected: ${content.includes('hello from attached mode') ? 'YES ✓' : 'NO ✗'}`
+      );
+      fs.unlinkSync(logFile2);
+    } else {
+      console.log(`  Log file exists: NO ✗`);
+    }
+
+    try {
+      execSync(`screen -S ${sessionName2} -X quit 2>/dev/null`);
+    } catch {}
+  } catch (e) {
+    console.log(`  Error: ${e.message}`);
+  }
+  console.log('');
+
+  // Test 3: What happens if we have a TTY?
+  console.log('Test 3: Test with attached mode WITH TTY (spawn with inherit)');
+  const sessionName3 = `tty-test-${Date.now()}`;
+
+  try {
+    const command3 = 'echo "hello TTY"';
+    const screenArgs = ['-S', sessionName3, '/bin/sh', '-c', command3];
+
+    console.log(`  Screen args for attached mode: ${screenArgs.join(' ')}`);
+    console.log(
+      `  hasTTY: stdin=${process.stdin.isTTY}, stdout=${process.stdout.isTTY}`
+    );
+
+    // This mimics what the current code does when hasTTY() returns true
+    return new Promise((resolve) => {
+      const child = spawn('screen', screenArgs, {
+        stdio: 'inherit',
+      });
+
+      child.on('exit', (code) => {
+        console.log(`  Exit code: ${code}`);
+        console.log(
+          `  Note: In attached mode with TTY, output goes directly to terminal`
+        );
+        resolve();
+      });
+
+      child.on('error', (err) => {
+        console.log(`  Error: ${err.message}`);
+        resolve();
+      });
+    });
+  } catch (e) {
+    console.log(`  Error: ${e.message}`);
+  }
+  console.log('');
+
+  console.log('=== Tests Complete ===');
+}
+
+testTeeFallback();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "start-command",
-  "version": "0.7.1",
+  "version": "0.7.4",
   "description": "Gamification of coding, execute any command with ability to auto-report issues on GitHub",
   "main": "index.js",
   "bin": {
@@ -30,7 +30,7 @@
   "author": "",
   "license": "MIT",
   "engines": {
-    "node": ">=20.0.0"
+    "bun": ">=1.0.0"
   },
   "repository": {
     "type": "git",

package/src/bin/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env bun
 
-const { spawn, execSync } = require('child_process');
+const { spawn, execSync, spawnSync } = require('child_process');
 const process = require('process');
 const os = require('os');
 const fs = require('fs');
@@ -51,13 +51,26 @@ const args = process.argv.slice(2);
 // Handle --version flag
 // Support: $ --version, $ -v, $ --version --
 // The trailing -- should be ignored for version check
+// Also support --verbose flag for debugging: $ --version --verbose
 const hasVersionFlag =
   args.length >= 1 && (args[0] === '--version' || args[0] === '-v');
+
+// Check for --verbose flag in version context
+const hasVerboseWithVersion =
+  hasVersionFlag &&
+  args.some((arg) => arg === '--verbose' || arg === '--debug');
+
+// Determine if this is a version-only call
+// Allow: --version, -v, --version --, --version --verbose, etc.
+const versionRelatedArgs = ['--version', '-v', '--', '--verbose', '--debug'];
 const isVersionOnly =
-  args.length === 1 || (args.length === 2 && args[1] === '--');
+  hasVersionFlag &&
+  args.every(
+    (arg) => versionRelatedArgs.includes(arg) || arg === args[0] // Allow the version flag itself
+  );
 
 if (hasVersionFlag && isVersionOnly) {
-  printVersion();
+  printVersion(hasVerboseWithVersion || config.verbose);
   process.exit(0);
 }
 
@@ -68,8 +81,9 @@ if (args.length === 0) {
 
 /**
  * Print version information
+ * @param {boolean} verbose - Whether to show verbose debugging info
  */
-function printVersion() {
+function printVersion(verbose = false) {
   // Get package version
   const packageJson = require('../../package.json');
   const startCommandVersion = packageJson.version;
@@ -93,9 +107,17 @@ function printVersion() {
         encoding: 'utf8',
         timeout: 5000,
       }).trim();
+      if (verbose) {
+        console.log(`[verbose] macOS version from sw_vers: ${osVersion}`);
+      }
     } catch {
       // Fallback to kernel version if sw_vers fails
       osVersion = os.release();
+      if (verbose) {
+        console.log(
+          `[verbose] sw_vers failed, using kernel version: ${osVersion}`
+        );
+      }
     }
   }
 
@@ -107,8 +129,12 @@ function printVersion() {
   // Check for installed isolation tools
   console.log('Isolation tools:');
 
-  // Check screen
-  const screenVersion = getToolVersion('screen', '--version');
+  if (verbose) {
+    console.log('[verbose] Checking isolation tools...');
+  }
+
+  // Check screen (use -v flag for compatibility with older versions)
+  const screenVersion = getToolVersion('screen', '-v', verbose);
   if (screenVersion) {
     console.log(`  screen: ${screenVersion}`);
   } else {
@@ -116,7 +142,7 @@ function printVersion() {
   }
 
   // Check tmux
-  const tmuxVersion = getToolVersion('tmux', '-V');
+  const tmuxVersion = getToolVersion('tmux', '-V', verbose);
   if (tmuxVersion) {
     console.log(`  tmux: ${tmuxVersion}`);
   } else {
@@ -124,7 +150,7 @@ function printVersion() {
   }
 
   // Check docker
-  const dockerVersion = getToolVersion('docker', '--version');
+  const dockerVersion = getToolVersion('docker', '--version', verbose);
   if (dockerVersion) {
     console.log(`  docker: ${dockerVersion}`);
   } else {
@@ -136,24 +162,53 @@ function printVersion() {
  * Get version of an installed tool
  * @param {string} toolName - Name of the tool
  * @param {string} versionFlag - Flag to get version (e.g., '--version', '-V')
+ * @param {boolean} verbose - Whether to log verbose information
  * @returns {string|null} Version string or null if not installed
  */
-function getToolVersion(toolName, versionFlag) {
+function getToolVersion(toolName, versionFlag, verbose = false) {
+  const isWindows = process.platform === 'win32';
+  const whichCmd = isWindows ? 'where' : 'which';
+
+  // First, check if the tool exists in PATH
   try {
-    // Redirect stderr to stdout (2>&1) to capture version info from stderr
-    // Some tools like screen output version to stderr instead of stdout
-    const result = execSync(`${toolName} ${versionFlag} 2>&1`, {
+    execSync(`${whichCmd} ${toolName}`, {
       encoding: 'utf8',
       timeout: 5000,
-    }).trim();
-
-    // Extract version number from output
-    // Most tools output version in various formats, so we'll return the first line
-    const firstLine = result.split('\n')[0];
-    return firstLine;
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
   } catch {
+    // Tool not found in PATH
+    if (verbose) {
+      console.log(`[verbose] ${toolName}: not found in PATH`);
+    }
     return null;
   }
+
+  // Tool exists, try to get version using spawnSync
+  // This captures output regardless of exit code (some tools like older screen
+  // versions return non-zero exit code even when showing version successfully)
+  const result = spawnSync(toolName, [versionFlag], {
+    encoding: 'utf8',
+    timeout: 5000,
+    shell: false,
+  });
+
+  // Combine stdout and stderr (some tools output version to stderr)
+  const output = ((result.stdout || '') + (result.stderr || '')).trim();
+
+  if (verbose) {
+    console.log(
+      `[verbose] ${toolName} ${versionFlag}: exit=${result.status}, output="${output.substring(0, 100)}"`
+    );
+  }
+
+  if (!output) {
+    return null;
+  }
+
+  // Return the first line of output
+  const firstLine = output.split('\n')[0];
+  return firstLine || null;
 }
 
 /**

package/src/lib/isolation.js

@@ -7,7 +7,7 @@
  * - docker: Docker containers
  */
 
-const { execSync, spawn } = require('child_process');
+const { execSync, spawn, spawnSync } = require('child_process');
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
@@ -189,10 +189,18 @@ function runScreenWithLogCapture(command, sessionName, shellInfo) {
         }
       }
 
-      execSync(`screen ${screenArgs.map((a) => `"${a}"`).join(' ')}`, {
+      // Use spawnSync with array arguments to avoid shell quoting issues
+      // This is critical for commands containing quotes (e.g., echo "hello")
+      // Using execSync with a constructed string would break on nested quotes
+      // See issue #25 for details
+      const result = spawnSync('screen', screenArgs, {
         stdio: 'inherit',
       });
 
+      if (result.error) {
+        throw result.error;
+      }
+
       // Poll for session completion
       const checkInterval = 100; // ms
       const maxWait = 300000; // 5 minutes max
@@ -317,10 +325,17 @@ function runInScreen(command, options = {}) {
         console.log(`[DEBUG] Running: screen ${screenArgs.join(' ')}`);
       }
 
-      execSync(`screen ${screenArgs.map((a) => `"${a}"`).join(' ')}`, {
+      // Use spawnSync with array arguments to avoid shell quoting issues
+      // This is critical for commands containing quotes (e.g., echo "hello")
+      // See issue #25 for details
+      const result = spawnSync('screen', screenArgs, {
         stdio: 'inherit',
       });
 
+      if (result.error) {
+        throw result.error;
+      }
+
       return Promise.resolve({
         success: true,
         sessionName,