start-command 0.7.4 → 0.7.5

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # start-command
 
+## 0.7.5
+
+### Patch Changes
+
+- 31a67fc: fix: Screen isolation output always captured in attached mode
+
+  Changed attached mode to always use log capture instead of direct screen invocation.
+  This ensures command output is never lost, even for quick commands that would
+  otherwise have their output disappear when the screen session terminates rapidly.
+
+  Fixes #25: Output from `$ --isolated screen -- echo "hello"` is now properly
+  displayed instead of being lost with only "[screen is terminating]" shown.
+
 ## 0.7.4
 
 ### Patch Changes

package/docs/case-studies/issue-25/README.md

@@ -126,17 +126,11 @@ Node.js/Bun's `spawnSync` with array arguments:
 
 ## The Solution
 
-### Code Changes in `src/lib/isolation.js`
+The issue has two parts that were fixed:
 
-1. **Added `spawnSync` import:**
+### Part 1: Shell Quoting Issues (Already Fixed)
 
-```javascript
-const { execSync, spawn, spawnSync } = require('child_process');
-```
-
-2. **Replaced `execSync` with `spawnSync` in two locations:**
-
-**Location 1: `runScreenWithLogCapture` function (attached mode with log capture)**
+Replaced `execSync` with `spawnSync` for proper argument handling:
 
 ```javascript
 // Before (broken):
@@ -145,21 +139,34 @@ execSync(`screen ${screenArgs.map((a) => `"${a}"`).join(' ')}`, {
 });
 
 // After (fixed):
-const result = spawnSync('screen', screenArgs, {
-  stdio: 'inherit',
-});
-
-if (result.error) {
-  throw result.error;
-}
+const result = spawnSync('screen', screenArgs, { stdio: 'inherit' });
 ```
 
-**Location 2: `runInScreen` function (detached mode)**
+### Part 2: TTY Mode Output Loss (New Fix)
+
+The attached mode with TTY was using direct screen invocation which loses output for quick commands:
 
 ```javascript
-// Same pattern - replaced execSync with spawnSync
+// Before (broken) - in runInScreen attached mode with TTY:
+if (hasTTY()) {
+  const screenArgs = ['-S', sessionName, shell, shellArg, command];
+  const child = spawn('screen', screenArgs, { stdio: 'inherit' });
+  // Output goes to screen's virtual terminal, lost when session ends quickly
+}
+
+// After (fixed) - always use log capture for attached mode:
+// For attached mode, always use detached mode with log capture
+// This ensures output is captured and displayed correctly, even for quick commands
+return runScreenWithLogCapture(command, sessionName, shellInfo);
 ```
 
+**Why the TTY path was broken:**
+
+1. Screen creates a virtual terminal for the session
+2. Command output goes to that virtual terminal
+3. When the command exits quickly (like `echo "hello"`), screen shows `[screen is terminating]`
+4. The virtual terminal is destroyed and output is lost
+
 ## Testing Strategy
 
 ### New Regression Tests Added

package/experiments/screen-output-test.js

@@ -0,0 +1,265 @@
+#!/usr/bin/env node
+/**
+ * Experiment: Test screen output capture behavior
+ *
+ * This experiment tests different approaches to capture output from GNU screen
+ * sessions, specifically addressing issue #25 where output is lost on macOS
+ * with screen 4.00.03.
+ */
+
+const { execSync, spawn, spawnSync } = require('child_process');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+// Check if screen is available
+function isScreenAvailable() {
+  try {
+    execSync('which screen', { stdio: ['pipe', 'pipe', 'pipe'] });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// Get screen version
+function getScreenVersion() {
+  try {
+    const output = execSync('screen --version', {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    const match = output.match(/(\d+)\.(\d+)\.(\d+)/);
+    if (match) {
+      return {
+        major: parseInt(match[1], 10),
+        minor: parseInt(match[2], 10),
+        patch: parseInt(match[3], 10),
+        raw: output.trim(),
+      };
+    }
+  } catch {
+    // Ignore
+  }
+  return null;
+}
+
+// Check if -Logfile is supported (screen >= 4.5.1)
+function supportsLogfileOption(version) {
+  if (!version) {
+    return false;
+  }
+  if (version.major > 4) {
+    return true;
+  }
+  if (version.major < 4) {
+    return false;
+  }
+  if (version.minor > 5) {
+    return true;
+  }
+  if (version.minor < 5) {
+    return false;
+  }
+  return version.patch >= 1;
+}
+
+// Test 1: Direct screen invocation (current approach for TTY)
+async function testDirectScreen(command) {
+  console.log('\n=== Test 1: Direct screen invocation (TTY mode) ===');
+  const sessionName = `test-direct-${Date.now()}`;
+  const shell = process.env.SHELL || '/bin/sh';
+
+  console.log(`Command: screen -S ${sessionName} ${shell} -c '${command}'`);
+  console.log('Note: This approach loses output for quick commands');
+
+  // This is what happens currently with TTY
+  return new Promise((resolve) => {
+    const child = spawn('screen', ['-S', sessionName, shell, '-c', command], {
+      stdio: 'inherit',
+    });
+
+    child.on('exit', (code) => {
+      console.log(`Exit code: ${code}`);
+      resolve({ success: code === 0, output: '(output not captured)' });
+    });
+
+    child.on('error', (err) => {
+      console.error(`Error: ${err.message}`);
+      resolve({ success: false, output: '' });
+    });
+  });
+}
+
+// Test 2: Detached screen with log file (current approach for no-TTY)
+async function testDetachedWithLog(command) {
+  console.log('\n=== Test 2: Detached screen with log capture ===');
+  const sessionName = `test-detached-${Date.now()}`;
+  const shell = process.env.SHELL || '/bin/sh';
+  const logFile = path.join(os.tmpdir(), `screen-test-${sessionName}.log`);
+
+  const version = getScreenVersion();
+  const useNativeLogging = supportsLogfileOption(version);
+
+  console.log(`Screen version: ${version ? version.raw : 'unknown'}`);
+  console.log(`Supports -Logfile: ${useNativeLogging}`);
+
+  let screenArgs;
+  let effectiveCommand = command;
+
+  if (useNativeLogging) {
+    // Modern screen
+    screenArgs = [
+      '-dmS',
+      sessionName,
+      '-L',
+      '-Logfile',
+      logFile,
+      shell,
+      '-c',
+      command,
+    ];
+  } else {
+    // Older screen - use tee fallback
+    effectiveCommand = `(${command}) 2>&1 | tee "${logFile}"`;
+    screenArgs = ['-dmS', sessionName, shell, '-c', effectiveCommand];
+  }
+
+  console.log(`Command: screen ${screenArgs.join(' ')}`);
+
+  return new Promise((resolve) => {
+    try {
+      const result = spawnSync('screen', screenArgs, { stdio: 'inherit' });
+
+      if (result.error) {
+        console.error(`Error: ${result.error.message}`);
+        resolve({ success: false, output: '' });
+        return;
+      }
+
+      // Poll for session completion
+      const checkInterval = 100;
+      const maxWait = 10000;
+      let waited = 0;
+
+      const checkCompletion = () => {
+        try {
+          const sessions = execSync('screen -ls', {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+          });
+
+          if (!sessions.includes(sessionName)) {
+            // Session ended
+            let output = '';
+            try {
+              output = fs.readFileSync(logFile, 'utf8');
+              console.log(`Captured output: "${output.trim()}"`);
+              fs.unlinkSync(logFile);
+            } catch {
+              console.log('Log file not found or empty');
+            }
+            resolve({ success: true, output });
+            return;
+          }
+
+          waited += checkInterval;
+          if (waited >= maxWait) {
+            resolve({ success: false, output: 'timeout' });
+            return;
+          }
+
+          setTimeout(checkCompletion, checkInterval);
+        } catch {
+          let output = '';
+          try {
+            output = fs.readFileSync(logFile, 'utf8');
+            console.log(`Captured output: "${output.trim()}"`);
+            fs.unlinkSync(logFile);
+          } catch {
+            // Ignore
+          }
+          resolve({ success: true, output });
+        }
+      };
+
+      setTimeout(checkCompletion, checkInterval);
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      resolve({ success: false, output: '' });
+    }
+  });
+}
+
+// Test 3: Script command for output capture (alternative approach)
+async function testScriptCapture(command) {
+  console.log('\n=== Test 3: Using script command for output capture ===');
+  const logFile = path.join(os.tmpdir(), `script-test-${Date.now()}.log`);
+  const shell = process.env.SHELL || '/bin/sh';
+
+  // Use 'script' command which is available on both macOS and Linux
+  // script -q logfile command  (macOS/BSD)
+  // script -q -c command logfile (Linux)
+  const isMac = process.platform === 'darwin';
+
+  let scriptArgs;
+  if (isMac) {
+    scriptArgs = ['-q', logFile, shell, '-c', command];
+  } else {
+    scriptArgs = ['-q', '-c', `${shell} -c '${command}'`, logFile];
+  }
+
+  console.log(`Command: script ${scriptArgs.join(' ')}`);
+
+  return new Promise((resolve) => {
+    const child = spawn('script', scriptArgs, {
+      stdio: 'inherit',
+    });
+
+    child.on('exit', (code) => {
+      let output = '';
+      try {
+        output = fs.readFileSync(logFile, 'utf8');
+        console.log(`Captured output: "${output.trim()}"`);
+        fs.unlinkSync(logFile);
+      } catch {
+        console.log('Log file not found');
+      }
+      resolve({ success: code === 0, output });
+    });
+
+    child.on('error', (err) => {
+      console.error(`Error: ${err.message}`);
+      resolve({ success: false, output: '' });
+    });
+  });
+}
+
+// Main
+async function main() {
+  console.log('Screen Output Capture Experiment');
+  console.log('=================================');
+  console.log(`Platform: ${process.platform}`);
+  console.log(
+    `TTY: stdin=${process.stdin.isTTY}, stdout=${process.stdout.isTTY}`
+  );
+
+  if (!isScreenAvailable()) {
+    console.log('Screen is not installed. Exiting.');
+    return;
+  }
+
+  const version = getScreenVersion();
+  console.log(`Screen version: ${version ? version.raw : 'unknown'}`);
+
+  const testCommand = 'echo "hello from screen"';
+
+  // Test 2 is the recommended approach
+  const result = await testDetachedWithLog(testCommand);
+  console.log('\n=== Summary ===');
+  console.log(
+    `Test 2 (detached with log): Success=${result.success}, Output captured=${result.output.includes('hello')}`
+  );
+}
+
+main().catch(console.error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "start-command",
-  "version": "0.7.4",
+  "version": "0.7.5",
   "description": "Gamification of coding, execute any command with ability to auto-report issues on GitHub",
   "main": "index.js",
   "bin": {

package/src/lib/isolation.js

@@ -342,50 +342,22 @@ function runInScreen(command, options = {}) {
         message: `Command started in detached screen session: ${sessionName}\nReattach with: screen -r ${sessionName}`,
       });
     } else {
-      // Attached mode: need TTY for screen to work properly
-
-      // Check if we have a TTY
-      if (hasTTY()) {
-        // We have a TTY, use direct screen invocation
-        const screenArgs = ['-S', sessionName, shell, shellArg, command];
-
-        if (DEBUG) {
-          console.log(`[DEBUG] Running: screen ${screenArgs.join(' ')}`);
-        }
-
-        return new Promise((resolve) => {
-          const child = spawn('screen', screenArgs, {
-            stdio: 'inherit',
-          });
-
-          child.on('exit', (code) => {
-            resolve({
-              success: code === 0,
-              sessionName,
-              message: `Screen session "${sessionName}" exited with code ${code}`,
-              exitCode: code,
-            });
-          });
-
-          child.on('error', (err) => {
-            resolve({
-              success: false,
-              sessionName,
-              message: `Failed to start screen: ${err.message}`,
-            });
-          });
-        });
-      } else {
-        // No TTY available - use detached mode with log capture
-        // This allows screen to run without a terminal while still capturing output
-        if (DEBUG) {
-          console.log(
-            `[DEBUG] No TTY available, using detached mode with log capture`
-          );
-        }
-
-        return runScreenWithLogCapture(command, sessionName, shellInfo);
+      // Attached mode: always use detached mode with log capture
+      // This ensures output is captured and displayed correctly, even for quick commands
+      // that would otherwise have their output lost in a rapidly-terminating screen session.
+      // Direct screen invocation (screen -S session shell -c command) loses output because:
+      // 1. Screen creates a virtual terminal for the session
+      // 2. Command output goes to that virtual terminal
+      // 3. When the command exits quickly, screen shows "[screen is terminating]"
+      // 4. The virtual terminal is destroyed and output is lost
+      // See issue #25 for details: https://github.com/link-foundation/start/issues/25
+      if (DEBUG) {
+        console.log(
+          `[DEBUG] Using detached mode with log capture for reliable output`
+        );
       }
+
+      return runScreenWithLogCapture(command, sessionName, shellInfo);
     }
   } catch (err) {
     return Promise.resolve({

package/test/isolation.test.js

@@ -380,6 +380,33 @@ describe('Isolation Runner with Available Backends', () => {
         );
       }
     });
+
+    it('should always return output property in attached mode (issue #25 fix verification)', async () => {
+      if (!isCommandAvailable('screen')) {
+        console.log('  Skipping: screen not installed');
+        return;
+      }
+
+      // This test verifies that attached mode always uses log capture,
+      // ensuring output is never lost even for quick commands.
+      // This is the core fix for issue #25 where output was lost on macOS
+      // because screen's virtual terminal was destroyed before output could be seen.
+      const result = await runInScreen('echo "quick command output"', {
+        session: `test-output-guaranteed-${Date.now()}`,
+        detached: false,
+      });
+
+      assert.strictEqual(result.success, true);
+      assert.ok(
+        result.output !== undefined,
+        'Attached mode should always return output property'
+      );
+      assert.ok(
+        result.output.includes('quick command output'),
+        'Output should be captured (issue #25 fix verification)'
+      );
+      console.log(`  Verified output capture: "${result.output.trim()}"`);
+    });
   });
 
   describe('runInTmux (if available)', () => {