start-command 0.5.1 → 0.5.3

package/.github/workflows/release.yml

@@ -108,6 +108,14 @@ jobs:
         with:
           bun-version: latest
 
+      - name: Install screen (Linux)
+        if: runner.os == 'Linux'
+        run: sudo apt-get update && sudo apt-get install -y screen
+
+      - name: Install screen (macOS)
+        if: runner.os == 'macOS'
+        run: brew install screen
+
       - name: Install dependencies
         run: bun install
 

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # start-command
 
+## 0.5.3
+
+### Patch Changes
+
+- 20d0c1c: Fix screen isolation not capturing output on macOS (issue #15)
+  - Added version detection for GNU Screen to handle differences between versions
+  - Screen >= 4.5.1 uses native `-L -Logfile` for log capture
+  - Screen < 4.5.1 (like macOS bundled 4.0.3) uses `tee` command fallback
+  - Added tests for version detection and -Logfile support checking
+  - Updated case study documentation with root cause analysis
+
+## 0.5.2
+
+### Patch Changes
+
+- bdf77c7: Fix screen isolation environment not capturing command output in attached mode
+
+  When running commands with `--isolated screen` in attached mode, the command output was not being displayed (only "screen is terminating" was shown). This was because GNU Screen requires a TTY to run in attached mode, which is not available when spawning from Node.js without a terminal.
+
+  The fix implements a fallback mechanism that:
+  - Checks if a TTY is available before spawning screen
+  - If no TTY is available, uses detached mode with log capture to run the command and display its output
+  - Polls for session completion and reads the captured log file
+  - Displays the output to the user just as if it was running in attached mode
+
+  This ensures that `$ --isolated screen -- echo "hello"` now correctly displays "hello" even when running from environments without a TTY (like CI/CD pipelines, scripts, or when piping output).
+
 ## 0.5.1
 
 ### Patch Changes

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

@@ -0,0 +1,208 @@
+# Case Study: Issue #15 - Screen Isolation Not Working As Expected
+
+## Issue Summary
+
+**Issue URL:** https://github.com/link-foundation/start/issues/15
+**Date Reported:** 2025-12-22
+**Reporter:** @konard
+**Status:** Investigating
+
+### Problem Statement
+
+The screen isolation environment does not display command output when running in attached mode. When using `$ --isolated screen -- echo "hello"`, the expected output "hello" is not shown - instead, only `[screen is terminating]` appears.
+
+### Environment
+
+- **Platform:** macOS (reported), Linux (reproduced)
+- **Package:** start-command@0.5.1
+- **Screen version:** macOS bundled 4.0.3, Linux 4.09.01
+
+## Timeline of Events
+
+1. User installs start-command: `bun install -g start-command`
+2. Direct command execution works: `$ echo "hello"` shows "hello"
+3. Docker isolation works: `$ --isolated docker --image alpine -- echo "hello"` shows "hello"
+4. Screen isolation fails: `$ --isolated screen -- echo "hello"` shows only `[screen is terminating]`
+
+## Reproduction
+
+### Observed Behavior
+
+```
+$ echo "hello"
+[2025-12-22 13:45:05.245] Starting: echo hello
+hello
+[2025-12-22 13:45:05.254] Finished
+Exit code: 0
+
+$ --isolated docker --image alpine -- echo "hello"
+[2025-12-22 13:45:07.847] Starting: echo hello
+[Isolation] Environment: docker, Mode: attached
+[Isolation] Image: alpine
+hello
+Docker container "docker-..." exited with code 0
+[2025-12-22 13:45:08.066] Finished
+Exit code: 0
+
+$ --isolated screen -- echo "hello"
+[2025-12-22 13:45:11.134] Starting: echo hello
+[Isolation] Environment: screen, Mode: attached
+[screen is terminating]
+Screen session "screen-..." exited with code 0
+[2025-12-22 13:45:11.199] Finished
+Exit code: 0
+```
+
+**Notice:** No "hello" output in the screen isolation case, though exit code is 0.
+
+## Root Cause Analysis
+
+### PRIMARY ROOT CAUSE: macOS Screen Version Incompatibility
+
+**macOS ships with GNU Screen version 4.0.3, which does NOT support the `-Logfile` option.**
+
+The `-Logfile` option was introduced in **GNU Screen 4.5.1** (released February 2017).
+
+| Platform        | Screen Version | `-Logfile` Support |
+| --------------- | -------------- | ------------------ |
+| macOS (bundled) | 4.0.3          | **NO**             |
+| Linux (CI/Test) | 4.09.01        | YES                |
+
+The current implementation uses:
+
+```javascript
+const screenArgs = [
+  '-dmS',
+  sessionName,
+  '-L',
+  '-Logfile',
+  logFile, // <-- NOT SUPPORTED on macOS bundled screen
+  shell,
+  shellArg,
+  command,
+];
+```
+
+On macOS with screen 4.0.3:
+
+1. The `-Logfile` option is silently ignored or treated as a command argument
+2. The `-L` flag alone creates a log file named `screenlog.0` in the current directory
+3. The code tries to read from the wrong file path (`/tmp/screen-output-*.log`)
+4. Result: No output is captured or displayed
+
+### Secondary Root Cause: TTY Requirement
+
+When TTY is available, the code attempts attached mode which fails:
+
+1. **TTY Requirement**: The GNU Screen command requires a connected terminal (TTY/PTY) to run in attached mode.
+
+2. **Node.js spawn behavior**: When spawning processes with `child_process.spawn()`, even with `stdio: 'inherit'`, Node.js does not always provide a proper pseudo-terminal (PTY) that screen requires.
+
+3. **Error in non-TTY environments**: Running `screen -S session shell -c command` without a TTY results in:
+
+   ```
+   Must be connected to a terminal.
+   ```
+
+4. **Detached mode works**: Running `screen -dmS session shell -c command` works because it doesn't require an attached terminal.
+
+### Experimental Evidence
+
+Testing revealed:
+
+- `process.stdin.isTTY` and `process.stdout.isTTY` are `undefined` when running from Node.js
+- Detached mode with logging (`screen -dmS ... -L -Logfile ...`) captures output correctly **on Linux only**
+- Using `script -q -c "screen ..." /dev/null` can provide a PTY but includes terminal escape codes
+- On macOS with screen 4.0.3, the `-Logfile` option is unknown
+
+### Version Check Evidence
+
+```bash
+# Linux (works)
+$ screen --version
+Screen version 4.09.01 (GNU) 20-Aug-23
+
+# macOS bundled (broken)
+$ screen --version
+Screen version 4.00.03 (FAU) 23-Oct-06
+```
+
+### Comparison with Docker
+
+Docker isolation works because:
+
+1. Docker run with `-it` flags handles terminal attachment
+2. Docker spawns an isolated container that manages its own pseudo-terminal
+3. The command output flows through Docker's I/O handling
+
+## Solution: Version Detection with Fallback
+
+### Approach
+
+1. **Detect screen version** at runtime
+2. **Version >= 4.5.1**: Use `-L -Logfile` approach
+3. **Version < 4.5.1**: Use output redirection (`tee`) approach within the command
+
+### Implementation
+
+```javascript
+function getScreenVersion() {
+  try {
+    const output = execSync('screen --version', { encoding: 'utf8' });
+    const match = output.match(/(\d+)\.(\d+)\.(\d+)/);
+    if (match) {
+      return {
+        major: parseInt(match[1]),
+        minor: parseInt(match[2]),
+        patch: parseInt(match[3]),
+      };
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+
+function supportsLogfileOption() {
+  const version = getScreenVersion();
+  if (!version) return false;
+  // -Logfile was added in 4.5.1
+  return (
+    version.major > 4 ||
+    (version.major === 4 && version.minor > 5) ||
+    (version.major === 4 && version.minor === 5 && version.patch >= 1)
+  );
+}
+```
+
+For older versions, wrap command with tee:
+
+```javascript
+const wrappedCommand = `(${command}) 2>&1 | tee "${logFile}"`;
+const screenArgs = ['-dmS', sessionName, shell, shellArg, wrappedCommand];
+```
+
+## Testing Strategy
+
+1. **Unit tests**: Test version detection logic
+2. **Unit tests**: Test screen version comparison
+3. **Integration tests**: Test output capture for both code paths
+4. **Regression tests**: Verify existing tests still pass
+5. **CI tests**: Ensure output is verified in assertions (not just exit code)
+
+## References
+
+- [GNU Screen v.4.5.1 changelog](https://lists.gnu.org/archive/html/info-gnu/2017-02/msg00000.html) - Introduction of `-Logfile` option
+- [GitHub Issue: RHEL7 screen does not know the Logfile option](https://github.com/distributed-system-analysis/pbench/issues/1558)
+- [How to install GNU Screen on OS X using Homebrew](https://gist.github.com/bigeasy/2327150)
+- [GNU Screen Manual](https://www.gnu.org/software/screen/manual/screen.html)
+- [script command man page](https://man7.org/linux/man-pages/man1/script.1.html)
+
+## Appendix: Test Logs
+
+See accompanying log files:
+
+- `test-output-1.log` - Initial reproduction
+- `screen-modes-test.log` - Screen modes investigation
+- `screen-attached-approaches.log` - Solution approaches testing
+- `test-screen-logfile.js` - Version compatibility testing

package/eslint.config.mjs

@@ -105,9 +105,18 @@ export default [
       '**/*.test.js',
       'experiments/**/*.js',
     ],
+    languageOptions: {
+      globals: {
+        setTimeout: 'readonly',
+        setInterval: 'readonly',
+        clearTimeout: 'readonly',
+        clearInterval: 'readonly',
+      },
+    },
     rules: {
       'require-await': 'off', // Async functions without await are common in tests
       'no-unused-vars': 'warn', // Relax for experiments
+      'no-empty': 'off', // Empty catch blocks are common in experiments
     },
   },
   {

package/experiments/test-screen-attached.js

@@ -0,0 +1,126 @@
+#!/usr/bin/env node
+/**
+ * Experiment to test different approaches for running screen in attached mode
+ * from Node.js without a TTY
+ */
+
+const { spawn, spawnSync, execSync } = require('child_process');
+
+async function testApproaches() {
+  console.log('=== Testing Attached Mode Approaches ===\n');
+
+  // Approach 1: Using script command as wrapper
+  console.log('Approach 1: script -q -c "screen ..." /dev/null');
+  try {
+    const sessionName = `approach1-${Date.now()}`;
+    const result = spawnSync(
+      'script',
+      [
+        '-q',
+        '-c',
+        `screen -S ${sessionName} /bin/sh -c "echo hello; exit 0"`,
+        '/dev/null',
+      ],
+      {
+        stdio: ['inherit', 'pipe', 'pipe'],
+        timeout: 5000,
+      }
+    );
+    console.log(
+      `   stdout: "${result.stdout.toString().trim().replace(/\n/g, '\\n')}"`
+    );
+    console.log(
+      `   stderr: "${result.stderr.toString().trim().replace(/\n/g, '\\n')}"`
+    );
+    console.log(`   exit: ${result.status}`);
+    // Cleanup
+    try {
+      execSync(`screen -S ${sessionName} -X quit 2>/dev/null`);
+    } catch {}
+  } catch (e) {
+    console.log(`   Error: ${e.message}`);
+  }
+  console.log('');
+
+  // Approach 2: Using detached mode + wait for completion + capture output via log
+  console.log('Approach 2: detached + log capture');
+  try {
+    const sessionName = `approach2-${Date.now()}`;
+    const logFile = `/tmp/screen-${sessionName}.log`;
+
+    // Start with logging
+    execSync(
+      `screen -dmS ${sessionName} -L -Logfile ${logFile} /bin/sh -c "echo 'hello from approach2'"`,
+      {
+        stdio: 'inherit',
+      }
+    );
+
+    // Wait for completion
+    await new Promise((r) => setTimeout(r, 500));
+
+    // Read log
+    const output = execSync(`cat ${logFile}`, { encoding: 'utf8' });
+    console.log(`   Output: "${output.trim()}"`);
+    console.log(`   Status: SUCCESS`);
+
+    // Cleanup
+    try {
+      execSync(`rm ${logFile} 2>/dev/null`);
+    } catch {}
+    try {
+      execSync(`screen -S ${sessionName} -X quit 2>/dev/null`);
+    } catch {}
+  } catch (e) {
+    console.log(`   Error: ${e.message}`);
+  }
+  console.log('');
+
+  // Approach 3: Using stdio: 'inherit' with proper terminal allocation via script
+  console.log('Approach 3: Run through script, inherit all stdio');
+  try {
+    const sessionName = `approach3-${Date.now()}`;
+    const result = spawnSync(
+      'script',
+      [
+        '-q',
+        '-e',
+        '-c',
+        `screen -S ${sessionName} /bin/sh -c "echo hello_approach3"`,
+        '/dev/null',
+      ],
+      {
+        stdio: 'inherit',
+        timeout: 5000,
+      }
+    );
+    console.log(`   exit: ${result.status}`);
+    // Cleanup
+    try {
+      execSync(`screen -S ${sessionName} -X quit 2>/dev/null`);
+    } catch {}
+  } catch (e) {
+    console.log(`   Error: ${e.message}`);
+  }
+  console.log('');
+
+  // Approach 4: Direct run without screen for attached mode (fallback)
+  console.log(
+    'Approach 4: Just spawn the shell command directly (fallback, no screen)'
+  );
+  try {
+    const result = spawnSync('/bin/sh', ['-c', 'echo hello_direct'], {
+      stdio: ['inherit', 'pipe', 'pipe'],
+      timeout: 5000,
+    });
+    console.log(`   stdout: "${result.stdout.toString().trim()}"`);
+    console.log(`   exit: ${result.status}`);
+  } catch (e) {
+    console.log(`   Error: ${e.message}`);
+  }
+  console.log('');
+
+  console.log('=== Approaches Tested ===');
+}
+
+testApproaches();

package/experiments/test-screen-logfile.js

@@ -0,0 +1,286 @@
+#!/usr/bin/env node
+/**
+ * Experiment to test screen's logfile capture functionality
+ * to understand the root cause of issue #15
+ */
+
+const { execSync, spawnSync } = 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 testScreenLogfile() {
+  console.log('=== Testing Screen Logfile Capture ===\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: Basic logfile capture with -L -Logfile
+  console.log('Test 1: Basic -L -Logfile capture');
+  const sessionName1 = `logtest-${Date.now()}`;
+  const logFile1 = path.join(os.tmpdir(), `screen-log-${sessionName1}.log`);
+
+  try {
+    // Run screen with logging
+    const screenArgs = [
+      '-dmS',
+      sessionName1,
+      '-L',
+      '-Logfile',
+      logFile1,
+      '/bin/sh',
+      '-c',
+      'echo "TESTOUTPUT123"',
+    ];
+
+    console.log(`  Command: screen ${screenArgs.join(' ')}`);
+
+    execSync(`screen ${screenArgs.map((a) => `"${a}"`).join(' ')}`, {
+      stdio: 'inherit',
+    });
+
+    // Wait for completion (screen runs command and exits)
+    await sleep(500);
+
+    // Check if session still exists
+    let sessionExists = false;
+    try {
+      const sessions = execSync('screen -ls', {
+        encoding: 'utf8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+      sessionExists = sessions.includes(sessionName1);
+    } catch {
+      // screen -ls returns non-zero if no sessions
+    }
+    console.log(`  Session exists after 500ms: ${sessionExists}`);
+
+    // 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().replace(/\n/g, '\\n').slice(0, 200)}"`
+      );
+      console.log(
+        `  Contains expected output: ${content.includes('TESTOUTPUT123') ? '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 with sleep to ensure buffer flush
+  console.log('Test 2: With sleep for buffer flush');
+  const sessionName2 = `logtest2-${Date.now()}`;
+  const logFile2 = path.join(os.tmpdir(), `screen-log-${sessionName2}.log`);
+
+  try {
+    const screenArgs = [
+      '-dmS',
+      sessionName2,
+      '-L',
+      '-Logfile',
+      logFile2,
+      '/bin/sh',
+      '-c',
+      'echo "FLUSHED_OUTPUT" && sleep 0.5',
+    ];
+
+    console.log(`  Command: screen ${screenArgs.join(' ')}`);
+
+    execSync(`screen ${screenArgs.map((a) => `"${a}"`).join(' ')}`, {
+      stdio: 'inherit',
+    });
+
+    // Wait longer for flush (default is 10 seconds)
+    await sleep(1500);
+
+    // Check log file
+    if (fs.existsSync(logFile2)) {
+      const content = fs.readFileSync(logFile2, 'utf8');
+      console.log(`  Log file exists: YES`);
+      console.log(`  Log file size: ${content.length} bytes`);
+      console.log(
+        `  Contains expected output: ${content.includes('FLUSHED_OUTPUT') ? 'YES ✓' : 'NO ✗'}`
+      );
+      fs.unlinkSync(logFile2);
+    } else {
+      console.log(`  Log file exists: NO ✗`);
+    }
+
+    // Cleanup
+    try {
+      execSync(`screen -S ${sessionName2} -X quit 2>/dev/null`);
+    } catch {}
+  } catch (e) {
+    console.log(`  Error: ${e.message}`);
+  }
+  console.log('');
+
+  // Test 3: Alternative - using hardstatus/output redirection
+  console.log('Test 3: Direct command output capture (no screen logging)');
+  const sessionName3 = `logtest3-${Date.now()}`;
+  const logFile3 = path.join(os.tmpdir(), `screen-log-${sessionName3}.log`);
+
+  try {
+    // Run command through screen but capture output to file within the command
+    const command = `echo "DIRECT_CAPTURE" | tee ${logFile3}`;
+    const screenArgs = ['-dmS', sessionName3, '/bin/sh', '-c', command];
+
+    console.log(`  Command: screen ${screenArgs.join(' ')}`);
+
+    execSync(`screen ${screenArgs.map((a) => `"${a}"`).join(' ')}`, {
+      stdio: 'inherit',
+    });
+
+    await sleep(500);
+
+    // Check log file
+    if (fs.existsSync(logFile3)) {
+      const content = fs.readFileSync(logFile3, 'utf8');
+      console.log(`  Log file exists: YES`);
+      console.log(
+        `  Contains expected output: ${content.includes('DIRECT_CAPTURE') ? 'YES ✓' : 'NO ✗'}`
+      );
+      fs.unlinkSync(logFile3);
+    } else {
+      console.log(`  Log file exists: NO ✗`);
+    }
+
+    // Cleanup
+    try {
+      execSync(`screen -S ${sessionName3} -X quit 2>/dev/null`);
+    } catch {}
+  } catch (e) {
+    console.log(`  Error: ${e.message}`);
+  }
+  console.log('');
+
+  // Test 4: Script command approach
+  console.log('Test 4: Using script command to capture output');
+  const sessionName4 = `logtest4-${Date.now()}`;
+  const logFile4 = path.join(os.tmpdir(), `script-log-${sessionName4}.log`);
+
+  try {
+    // Use script to capture output
+    const result = spawnSync(
+      'script',
+      [
+        '-q',
+        logFile4,
+        '-c',
+        `screen -dmS ${sessionName4} /bin/sh -c "echo SCRIPT_CAPTURE"`,
+      ],
+      {
+        stdio: ['inherit', 'pipe', 'pipe'],
+        timeout: 5000,
+      }
+    );
+
+    await sleep(500);
+
+    console.log(`  Exit code: ${result.status}`);
+
+    // Check log file
+    if (fs.existsSync(logFile4)) {
+      const content = fs.readFileSync(logFile4, 'utf8');
+      console.log(`  Log file exists: YES`);
+      console.log(`  Log file size: ${content.length} bytes`);
+      fs.unlinkSync(logFile4);
+    } else {
+      console.log(`  Log file exists: NO`);
+    }
+
+    // Cleanup
+    try {
+      execSync(`screen -S ${sessionName4} -X quit 2>/dev/null`);
+    } catch {}
+  } catch (e) {
+    console.log(`  Error: ${e.message}`);
+  }
+  console.log('');
+
+  // Test 5: Test with -T option (terminal type)
+  console.log('Test 5: With explicit terminal type -T xterm');
+  const sessionName5 = `logtest5-${Date.now()}`;
+  const logFile5 = path.join(os.tmpdir(), `screen-log-${sessionName5}.log`);
+
+  try {
+    const screenArgs = [
+      '-T',
+      'xterm',
+      '-dmS',
+      sessionName5,
+      '-L',
+      '-Logfile',
+      logFile5,
+      '/bin/sh',
+      '-c',
+      'echo "TERMINAL_OUTPUT" && sleep 0.3',
+    ];
+
+    console.log(`  Command: screen ${screenArgs.join(' ')}`);
+
+    execSync(`screen ${screenArgs.map((a) => `"${a}"`).join(' ')}`, {
+      stdio: 'inherit',
+    });
+
+    await sleep(1000);
+
+    // Check log file
+    if (fs.existsSync(logFile5)) {
+      const content = fs.readFileSync(logFile5, 'utf8');
+      console.log(`  Log file exists: YES`);
+      console.log(`  Log file size: ${content.length} bytes`);
+      console.log(
+        `  Contains expected output: ${content.includes('TERMINAL_OUTPUT') ? 'YES ✓' : 'NO ✗'}`
+      );
+      fs.unlinkSync(logFile5);
+    } else {
+      console.log(`  Log file exists: NO ✗`);
+    }
+
+    // Cleanup
+    try {
+      execSync(`screen -S ${sessionName5} -X quit 2>/dev/null`);
+    } catch {}
+  } catch (e) {
+    console.log(`  Error: ${e.message}`);
+  }
+  console.log('');
+
+  console.log('=== Tests Complete ===');
+}
+
+testScreenLogfile();

package/experiments/test-screen-modes.js

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+/**
+ * Experiment to test different screen invocation modes
+ * This helps understand how screen behaves in different contexts
+ */
+
+const { spawn, execSync, spawnSync } = require('child_process');
+
+async function testScreenModes() {
+  console.log('=== Testing Screen Modes ===\n');
+
+  // Test 1: Check if running in a terminal
+  console.log('1. Terminal check:');
+  console.log(`   process.stdin.isTTY: ${process.stdin.isTTY}`);
+  console.log(`   process.stdout.isTTY: ${process.stdout.isTTY}`);
+  console.log(`   TERM: ${process.env.TERM || 'not set'}`);
+  console.log('');
+
+  // Test 2: Detached mode should work
+  console.log('2. Testing detached mode (screen -dmS):');
+  try {
+    const sessionName = `test-${Date.now()}`;
+    execSync(
+      `screen -dmS ${sessionName} /bin/sh -c "echo hello > /tmp/screen-test-${sessionName}.txt"`,
+      {
+        stdio: 'inherit',
+      }
+    );
+    // Wait a bit for the command to complete
+    await new Promise((r) => setTimeout(r, 200));
+
+    const output = execSync(
+      `cat /tmp/screen-test-${sessionName}.txt 2>/dev/null || echo "file not found"`,
+      { encoding: 'utf8' }
+    );
+    console.log(`   Output: ${output.trim()}`);
+
+    // Cleanup
+    try {
+      execSync(`screen -S ${sessionName} -X quit 2>/dev/null`);
+    } catch {}
+    try {
+      execSync(`rm /tmp/screen-test-${sessionName}.txt 2>/dev/null`);
+    } catch {}
+
+    console.log('   Status: SUCCESS');
+  } catch (e) {
+    console.log(`   Status: FAILED - ${e.message}`);
+  }
+  console.log('');
+
+  // Test 3: Attached mode with spawn (current implementation)
+  console.log('3. Testing attached mode with spawn (current implementation):');
+  try {
+    const sessionName = `test-${Date.now()}`;
+    const result = spawnSync(
+      'screen',
+      ['-S', sessionName, '/bin/sh', '-c', 'echo hello'],
+      {
+        stdio: 'inherit',
+      }
+    );
+    console.log(`   Exit code: ${result.status}`);
+    console.log(`   Status: ${result.status === 0 ? 'SUCCESS' : 'FAILED'}`);
+  } catch (e) {
+    console.log(`   Status: FAILED - ${e.message}`);
+  }
+  console.log('');
+
+  // Test 4: Try to use script command to allocate PTY
+  console.log('4. Testing with script command to allocate PTY:');
+  try {
+    const result = spawnSync(
+      'script',
+      ['-q', '-c', 'echo hello', '/dev/null'],
+      {
+        stdio: ['inherit', 'pipe', 'pipe'],
+      }
+    );
+    console.log(`   Output: ${result.stdout.toString().trim()}`);
+    console.log(`   Exit code: ${result.status}`);
+    console.log(`   Status: SUCCESS`);
+  } catch (e) {
+    console.log(`   Status: FAILED - ${e.message}`);
+  }
+  console.log('');
+
+  // Test 5: Detached mode with log capture
+  console.log('5. Testing detached mode with log capture:');
+  try {
+    const sessionName = `test-${Date.now()}`;
+    const logFile = `/tmp/screen-log-${sessionName}.txt`;
+
+    // Create detached session with logging
+    execSync(
+      `screen -dmS ${sessionName} -L -Logfile ${logFile} /bin/sh -c "echo 'hello from screen'; sleep 0.2"`,
+      {
+        stdio: 'inherit',
+      }
+    );
+
+    // Wait for command to complete
+    await new Promise((r) => setTimeout(r, 500));
+
+    const output = execSync(
+      `cat ${logFile} 2>/dev/null || echo "log not found"`,
+      { encoding: 'utf8' }
+    );
+    console.log(`   Log content: ${output.trim().replace(/\n/g, '\\n')}`);
+
+    // Cleanup
+    try {
+      execSync(`screen -S ${sessionName} -X quit 2>/dev/null`);
+    } catch {}
+    try {
+      execSync(`rm ${logFile} 2>/dev/null`);
+    } catch {}
+
+    console.log('   Status: SUCCESS');
+  } catch (e) {
+    console.log(`   Status: FAILED - ${e.message}`);
+  }
+  console.log('');
+
+  console.log('=== Tests Complete ===');
+}
+
+testScreenModes();

package/package.json

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

package/src/lib/isolation.js

@@ -14,10 +14,89 @@ const os = require('os');
 const path = require('path');
 const { generateSessionName } = require('./args-parser');
 
+const setTimeout = globalThis.setTimeout;
+
 // Debug mode from environment
 const DEBUG =
   process.env.START_DEBUG === '1' || process.env.START_DEBUG === 'true';
 
+// Cache for screen version detection
+let cachedScreenVersion = null;
+let screenVersionChecked = false;
+
+/**
+ * Get the installed screen version
+ * @returns {{major: number, minor: number, patch: number}|null} Version object or null if detection fails
+ */
+function getScreenVersion() {
+  if (screenVersionChecked) {
+    return cachedScreenVersion;
+  }
+
+  screenVersionChecked = true;
+
+  try {
+    const output = execSync('screen --version', {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    // Match patterns like "4.09.01", "4.00.03", "4.5.1"
+    const match = output.match(/(\d+)\.(\d+)\.(\d+)/);
+    if (match) {
+      cachedScreenVersion = {
+        major: parseInt(match[1], 10),
+        minor: parseInt(match[2], 10),
+        patch: parseInt(match[3], 10),
+      };
+
+      if (DEBUG) {
+        console.log(
+          `[DEBUG] Detected screen version: ${cachedScreenVersion.major}.${cachedScreenVersion.minor}.${cachedScreenVersion.patch}`
+        );
+      }
+
+      return cachedScreenVersion;
+    }
+  } catch {
+    if (DEBUG) {
+      console.log('[DEBUG] Could not detect screen version');
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Check if screen supports the -Logfile option
+ * The -Logfile option was introduced in GNU Screen 4.5.1
+ * @returns {boolean} True if -Logfile is supported
+ */
+function supportsLogfileOption() {
+  const version = getScreenVersion();
+  if (!version) {
+    // If we can't detect version, assume older version and use fallback
+    return false;
+  }
+
+  // -Logfile was added in 4.5.1
+  // Compare: version >= 4.5.1
+  if (version.major > 4) {
+    return true;
+  }
+  if (version.major < 4) {
+    return false;
+  }
+  // major === 4
+  if (version.minor > 5) {
+    return true;
+  }
+  if (version.minor < 5) {
+    return false;
+  }
+  // minor === 5
+  return version.patch >= 1;
+}
+
 /**
  * Check if a command is available on the system
  * @param {string} command - Command to check
@@ -45,6 +124,171 @@ function getShell() {
   return { shell, shellArg };
 }
 
+/**
+ * Check if the current process has a TTY attached
+ * @returns {boolean} True if TTY is available
+ */
+function hasTTY() {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+
+/**
+ * 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
+ *
+ * @param {string} command - Command to execute
+ * @param {string} sessionName - Session name
+ * @param {object} shellInfo - Shell info from getShell()
+ * @returns {Promise<{success: boolean, sessionName: string, message: string, output: string}>}
+ */
+function runScreenWithLogCapture(command, sessionName, shellInfo) {
+  const { shell, shellArg } = shellInfo;
+  const logFile = path.join(os.tmpdir(), `screen-output-${sessionName}.log`);
+
+  // Check if screen supports -Logfile option (added in 4.5.1)
+  const useNativeLogging = supportsLogfileOption();
+
+  return new Promise((resolve) => {
+    try {
+      let screenArgs;
+      let effectiveCommand = command;
+
+      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,
+          command,
+        ];
+
+        if (DEBUG) {
+          console.log(
+            `[DEBUG] Running screen with native log capture (-Logfile): screen ${screenArgs.join(' ')}`
+          );
+        }
+      } 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 = `(${command}) 2>&1 | tee "${logFile}"`;
+        screenArgs = ['-dmS', sessionName, shell, shellArg, effectiveCommand];
+
+        if (DEBUG) {
+          console.log(
+            `[DEBUG] Running screen with tee fallback (older screen version): screen ${screenArgs.join(' ')}`
+          );
+        }
+      }
+
+      execSync(`screen ${screenArgs.map((a) => `"${a}"`).join(' ')}`, {
+        stdio: 'inherit',
+      });
+
+      // Poll for session completion
+      const checkInterval = 100; // ms
+      const maxWait = 300000; // 5 minutes max
+      let waited = 0;
+
+      const checkCompletion = () => {
+        try {
+          // Check if session still exists
+          const sessions = execSync('screen -ls', {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+          });
+
+          if (!sessions.includes(sessionName)) {
+            // Session ended, read output
+            let output = '';
+            try {
+              output = fs.readFileSync(logFile, 'utf8');
+              // Display the output
+              if (output.trim()) {
+                process.stdout.write(output);
+              }
+            } catch {
+              // Log file might not exist if command was very quick
+            }
+
+            // Clean up log file
+            try {
+              fs.unlinkSync(logFile);
+            } catch {
+              // Ignore cleanup errors
+            }
+
+            resolve({
+              success: true,
+              sessionName,
+              message: `Screen session "${sessionName}" exited with code 0`,
+              exitCode: 0,
+              output,
+            });
+            return;
+          }
+
+          waited += checkInterval;
+          if (waited >= maxWait) {
+            resolve({
+              success: false,
+              sessionName,
+              message: `Screen session "${sessionName}" timed out after ${maxWait / 1000} seconds`,
+              exitCode: 1,
+            });
+            return;
+          }
+
+          setTimeout(checkCompletion, checkInterval);
+        } catch {
+          // screen -ls failed, session probably ended
+          let output = '';
+          try {
+            output = fs.readFileSync(logFile, 'utf8');
+            if (output.trim()) {
+              process.stdout.write(output);
+            }
+          } catch {
+            // Ignore
+          }
+
+          try {
+            fs.unlinkSync(logFile);
+          } catch {
+            // Ignore
+          }
+
+          resolve({
+            success: true,
+            sessionName,
+            message: `Screen session "${sessionName}" exited with code 0`,
+            exitCode: 0,
+            output,
+          });
+        }
+      };
+
+      // Start checking after a brief delay
+      setTimeout(checkCompletion, checkInterval);
+    } catch (err) {
+      resolve({
+        success: false,
+        sessionName,
+        message: `Failed to run in screen: ${err.message}`,
+      });
+    }
+  });
+}
+
 /**
  * Run command in GNU Screen
  * @param {string} command - Command to execute
@@ -62,7 +306,8 @@ function runInScreen(command, options = {}) {
   }
 
   const sessionName = options.session || generateSessionName('screen');
-  const { shell, shellArg } = getShell();
+  const shellInfo = getShell();
+  const { shell, shellArg } = shellInfo;
 
   try {
     if (options.detached) {
@@ -83,35 +328,50 @@ function runInScreen(command, options = {}) {
         message: `Command started in detached screen session: ${sessionName}\nReattach with: screen -r ${sessionName}`,
       });
     } else {
-      // Attached mode: screen -S <session> <shell> -c '<command>'
-      const screenArgs = ['-S', sessionName, shell, shellArg, command];
+      // Attached mode: need TTY for screen to work properly
 
-      if (DEBUG) {
-        console.log(`[DEBUG] Running: screen ${screenArgs.join(' ')}`);
-      }
+      // Check if we have a TTY
+      if (hasTTY()) {
+        // We have a TTY, use direct screen invocation
+        const screenArgs = ['-S', sessionName, shell, shellArg, command];
 
-      return new Promise((resolve) => {
-        const child = spawn('screen', screenArgs, {
-          stdio: 'inherit',
-        });
+        if (DEBUG) {
+          console.log(`[DEBUG] Running: screen ${screenArgs.join(' ')}`);
+        }
 
-        child.on('exit', (code) => {
-          resolve({
-            success: code === 0,
-            sessionName,
-            message: `Screen session "${sessionName}" exited with code ${code}`,
-            exitCode: code,
+        return new Promise((resolve) => {
+          const child = spawn('screen', screenArgs, {
+            stdio: 'inherit',
           });
-        });
 
-        child.on('error', (err) => {
-          resolve({
-            success: false,
-            sessionName,
-            message: `Failed to start screen: ${err.message}`,
+          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);
+      }
     }
   } catch (err) {
     return Promise.resolve({
@@ -507,8 +767,17 @@ function createLogPath(environment) {
   return path.join(logDir, logFilename);
 }
 
+/**
+ * Reset screen version cache (useful for testing)
+ */
+function resetScreenVersionCache() {
+  cachedScreenVersion = null;
+  screenVersionChecked = false;
+}
+
 module.exports = {
   isCommandAvailable,
+  hasTTY,
   runInScreen,
   runInTmux,
   runInZellij,
@@ -522,4 +791,8 @@ module.exports = {
   writeLogFile,
   getLogDir,
   createLogPath,
+  // Export screen version utilities for testing and debugging
+  getScreenVersion,
+  supportsLogfileOption,
+  resetScreenVersionCache,
 };

package/test/isolation.test.js

@@ -7,7 +7,13 @@
 
 const { describe, it } = require('node:test');
 const assert = require('assert');
-const { isCommandAvailable } = require('../src/lib/isolation');
+const {
+  isCommandAvailable,
+  hasTTY,
+  getScreenVersion,
+  supportsLogfileOption,
+  resetScreenVersionCache,
+} = require('../src/lib/isolation');
 
 describe('Isolation Module', () => {
   describe('isCommandAvailable', () => {
@@ -34,6 +40,21 @@ describe('Isolation Module', () => {
     });
   });
 
+  describe('hasTTY', () => {
+    it('should return a boolean', () => {
+      const result = hasTTY();
+      assert.strictEqual(typeof result, 'boolean');
+    });
+
+    it('should return false when running in test environment (no TTY)', () => {
+      // When running tests, we typically don't have a TTY
+      const result = hasTTY();
+      // This should be false in CI/test environments
+      console.log(`  hasTTY: ${result}`);
+      assert.ok(typeof result === 'boolean');
+    });
+  });
+
   describe('isolation backend checks', () => {
     // These tests check if specific backends are available
     // They don't fail if not installed, just report status
@@ -62,6 +83,92 @@ describe('Isolation Module', () => {
       assert.ok(typeof result === 'boolean');
     });
   });
+
+  describe('getScreenVersion', () => {
+    it('should return version object or null', () => {
+      // Reset cache before testing
+      resetScreenVersionCache();
+      const version = getScreenVersion();
+
+      if (isCommandAvailable('screen')) {
+        // If screen is installed, we should get a version object
+        assert.ok(
+          version !== null,
+          'Should return version object when screen is installed'
+        );
+        assert.ok(typeof version.major === 'number', 'major should be number');
+        assert.ok(typeof version.minor === 'number', 'minor should be number');
+        assert.ok(typeof version.patch === 'number', 'patch should be number');
+        console.log(
+          `  Detected screen version: ${version.major}.${version.minor}.${version.patch}`
+        );
+      } else {
+        // If screen is not installed, we should get null
+        assert.strictEqual(
+          version,
+          null,
+          'Should return null when screen is not installed'
+        );
+        console.log('  screen not installed, version is null');
+      }
+    });
+
+    it('should cache the version result', () => {
+      // Reset cache first
+      resetScreenVersionCache();
+
+      // Call twice
+      const version1 = getScreenVersion();
+      const version2 = getScreenVersion();
+
+      // Results should be identical (same object reference if cached)
+      assert.strictEqual(
+        version1,
+        version2,
+        'Cached version should return same object'
+      );
+    });
+  });
+
+  describe('supportsLogfileOption', () => {
+    it('should return boolean', () => {
+      // Reset cache before testing
+      resetScreenVersionCache();
+      const result = supportsLogfileOption();
+      assert.ok(typeof result === 'boolean', 'Should return a boolean');
+      console.log(`  supportsLogfileOption: ${result}`);
+    });
+
+    it('should return true for screen >= 4.5.1', () => {
+      // This tests the logic by checking the current system
+      resetScreenVersionCache();
+      const version = getScreenVersion();
+
+      if (version) {
+        const expected =
+          version.major > 4 ||
+          (version.major === 4 && version.minor > 5) ||
+          (version.major === 4 && version.minor === 5 && version.patch >= 1);
+        const result = supportsLogfileOption();
+        assert.strictEqual(
+          result,
+          expected,
+          `Version ${version.major}.${version.minor}.${version.patch} should ${expected ? 'support' : 'not support'} -Logfile`
+        );
+        console.log(
+          `  Version ${version.major}.${version.minor}.${version.patch}: -Logfile supported = ${result}`
+        );
+      } else {
+        // If no version detected, should return false (fallback to safe method)
+        const result = supportsLogfileOption();
+        assert.strictEqual(
+          result,
+          false,
+          'Should return false when version cannot be detected'
+        );
+      }
+    });
+  });
 });
 
 describe('Isolation Runner Error Handling', () => {
@@ -197,6 +304,56 @@ describe('Isolation Runner with Available Backends', () => {
         // Session may have already exited
       }
     });
+
+    it('should run command in attached mode and capture output (issue #15)', async () => {
+      if (!isCommandAvailable('screen')) {
+        console.log('  Skipping: screen not installed');
+        return;
+      }
+
+      // Test attached mode - this should work without TTY using log capture fallback
+      const result = await runInScreen('echo hello', {
+        session: `test-attached-${Date.now()}`,
+        detached: false,
+      });
+
+      assert.strictEqual(result.success, true);
+      assert.ok(result.sessionName);
+      assert.ok(result.message.includes('exited with code 0'));
+      // The output property should exist when using log capture
+      if (result.output !== undefined) {
+        console.log(`  Captured output: "${result.output.trim()}"`);
+        assert.ok(
+          result.output.includes('hello'),
+          'Output should contain the expected message'
+        );
+      }
+    });
+
+    it('should handle multi-line output in attached mode', async () => {
+      if (!isCommandAvailable('screen')) {
+        console.log('  Skipping: screen not installed');
+        return;
+      }
+
+      const result = await runInScreen(
+        "echo 'line1'; echo 'line2'; echo 'line3'",
+        {
+          session: `test-multiline-${Date.now()}`,
+          detached: false,
+        }
+      );
+
+      assert.strictEqual(result.success, true);
+      if (result.output !== undefined) {
+        console.log(
+          `  Captured multi-line output: "${result.output.trim().replace(/\n/g, '\\n')}"`
+        );
+        assert.ok(result.output.includes('line1'));
+        assert.ok(result.output.includes('line2'));
+        assert.ok(result.output.includes('line3'));
+      }
+    });
   });
 
   describe('runInTmux (if available)', () => {