start-command 0.5.2 → 0.6.0

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,22 @@
 # start-command
 
+## 0.6.0
+
+### Minor Changes
+
+- 37eb93b: Drop zellij isolation backend support, focusing on screen, tmux, and docker. Remove zellij from VALID_BACKENDS, remove runInZellij function, and update all documentation accordingly.
+
+## 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

package/README.md

@@ -141,18 +141,17 @@ $ -i tmux -s my-session -d npm start
 | -------- | -------------------------------------- | ---------------------------------------------------------- |
 | `screen` | GNU Screen terminal multiplexer        | `apt install screen` / `brew install screen`               |
 | `tmux`   | Modern terminal multiplexer            | `apt install tmux` / `brew install tmux`                   |
-| `zellij` | Modern terminal workspace              | `cargo install zellij` / `brew install zellij`             |
 | `docker` | Container isolation (requires --image) | [Docker Installation](https://docs.docker.com/get-docker/) |
 
 #### Isolation Options
 
-| Option           | Description                                      |
-| ---------------- | ------------------------------------------------ |
-| `--isolated, -i` | Isolation backend (screen, tmux, docker, zellij) |
-| `--attached, -a` | Run in attached/foreground mode (default)        |
-| `--detached, -d` | Run in detached/background mode                  |
-| `--session, -s`  | Custom session/container name                    |
-| `--image`        | Docker image (required for docker isolation)     |
+| Option           | Description                                  |
+| ---------------- | -------------------------------------------- |
+| `--isolated, -i` | Isolation backend (screen, tmux, docker)     |
+| `--attached, -a` | Run in attached/foreground mode (default)    |
+| `--detached, -d` | Run in detached/background mode              |
+| `--session, -s`  | Custom session/container name                |
+| `--image`        | Docker image (required for docker isolation) |
 
 **Note:** Using both `--attached` and `--detached` together will result in an error - you must choose one mode.
 

package/REQUIREMENTS.md

@@ -147,7 +147,6 @@ Support two patterns for passing wrapper options:
 
 - `screen`: GNU Screen terminal multiplexer
 - `tmux`: tmux terminal multiplexer
-- `zellij`: Modern terminal workspace
 - `docker`: Docker containers (requires --image option)
 
 #### 6.4 Mode Behavior

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

@@ -15,7 +15,7 @@ The screen isolation environment does not display command output when running in
 
 - **Platform:** macOS (reported), Linux (reproduced)
 - **Package:** start-command@0.5.1
-- **Screen version:** Tested with GNU Screen
+- **Screen version:** macOS bundled 4.0.3, Linux 4.09.01
 
 ## Timeline of Events
 
@@ -57,7 +57,42 @@ Exit code: 0
 
 ## Root Cause Analysis
 
-### Investigation
+### 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.
 
@@ -76,8 +111,21 @@ Exit code: 0
 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
+- 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
 
@@ -87,70 +135,67 @@ Docker isolation works because:
 2. Docker spawns an isolated container that manages its own pseudo-terminal
 3. The command output flows through Docker's I/O handling
 
-## Solution Options
-
-### Option 1: Use Script Command for PTY Allocation (Recommended)
-
-Wrap the screen command with `script -q -c "command" /dev/null` to allocate a pseudo-terminal.
-
-**Pros:**
-
-- Provides a real PTY that screen requires
-- Works across Linux/macOS
-- Maintains attached behavior
-
-**Cons:**
-
-- Adds terminal escape codes to output
-- Requires `script` command to be available
-
-### Option 2: Switch to Detached Mode with Log Capture
-
-Run screen in detached mode (`-dmS`) with logging enabled (`-L -Logfile`), wait for completion, then display the log.
-
-**Pros:**
-
-- Clean output without escape codes
-- Reliable across platforms
-- Captures full command output
-
-**Cons:**
-
-- Not truly "attached" - user can't interact with the process
-- Requires polling or waiting for completion
-
-### Option 3: Hybrid Approach (Chosen Solution)
-
-For attached mode:
-
-1. Check if running in a TTY (`process.stdin.isTTY`)
-2. If TTY available: Use standard screen spawn with `stdio: 'inherit'`
-3. If no TTY: Use `script` command to allocate PTY
-
-For detached mode:
-
-- Use existing implementation with `-dmS` flags
-
-## Implementation
+## 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)
+  );
+}
+```
 
-The fix modifies `src/lib/isolation.js` to:
+For older versions, wrap command with tee:
 
-1. Check for TTY availability before spawning screen
-2. Use `script` command as PTY allocator when no TTY is available
-3. Clean terminal escape codes from output when using script wrapper
-4. Maintain compatibility with existing detached mode
+```javascript
+const wrappedCommand = `(${command}) 2>&1 | tee "${logFile}"`;
+const screenArgs = ['-dmS', sessionName, shell, shellArg, wrappedCommand];
+```
 
 ## Testing Strategy
 
-1. **Unit tests**: Test TTY detection logic
-2. **Integration tests**: Test screen isolation in detached mode
-3. **Environment tests**: Test behavior with and without TTY
+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)
-- [Stack Overflow: Must be connected to terminal](https://stackoverflow.com/questions/tagged/gnu-screen+tty)
-- [node-pty for PTY allocation](https://github.com/microsoft/node-pty)
 - [script command man page](https://man7.org/linux/man-pages/man1/script.1.html)
 
 ## Appendix: Test Logs
@@ -160,3 +205,4 @@ 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/experiments/isolation-design.md

@@ -10,11 +10,10 @@ This document outlines the design for adding process isolation support to start-
 
 1. **screen** - GNU Screen, classic session manager
 2. **tmux** - Modern terminal multiplexer
-3. **zellij** - Modern, user-friendly multiplexer
 
 ### Container Isolation
 
-4. **docker** - Docker containers
+3. **docker** - Docker containers
 
 ## Command Syntax
 
@@ -31,7 +30,7 @@ $ [wrapper-options] command [command-options]
 ### Wrapper Options
 
 - `--isolated <backend>` or `-i <backend>`: Run command in isolated environment
-  - Backends: `screen`, `tmux`, `docker`, `zellij`
+  - Backends: `screen`, `tmux`, `docker`
 - `--attached` or `-a`: Run in attached mode (foreground)
 - `--detached` or `-d`: Run in detached mode (background)
 - `--session <name>` or `-s <name>`: Name for the session (optional)
@@ -56,7 +55,7 @@ $ -i tmux -d npm start
 
 ### Attached Mode (--attached)
 
-- Default for terminal multiplexers (screen, tmux, zellij)
+- Default for terminal multiplexers (screen, tmux)
 - Command runs in foreground
 - User can interact with the terminal
 - For docker: runs with -it flags
@@ -103,16 +102,6 @@ tmux new-session -s <session> '<command>'
 tmux new-session -d -s <session> '<command>'
 ```
 
-#### Zellij
-
-```bash
-# Attached
-zellij run -- <command>
-
-# Detached (via layout file or action)
-zellij -s <session> action new-pane -- <command>
-```
-
 #### Docker
 
 ```bash

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/package.json

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

package/src/bin/cli.js

@@ -62,7 +62,7 @@ function printUsage() {
   console.log('');
   console.log('Options:');
   console.log(
-    '  --isolated, -i <environment>      Run in isolated environment (screen, tmux, docker, zellij)'
+    '  --isolated, -i <environment>      Run in isolated environment (screen, tmux, docker)'
   );
   console.log('  --attached, -a            Run in attached mode (foreground)');
   console.log('  --detached, -d            Run in detached mode (background)');
@@ -85,7 +85,7 @@ function printUsage() {
     '  - Auto-reports failures for NPM packages (when gh is available)'
   );
   console.log('  - Natural language command aliases (via substitutions.lino)');
-  console.log('  - Process isolation via screen, tmux, zellij, or docker');
+  console.log('  - Process isolation via screen, tmux, or docker');
   console.log('');
   console.log('Alias examples:');
   console.log('  $ install lodash npm package           -> npm install lodash');

package/src/lib/args-parser.js

@@ -6,7 +6,7 @@
  * 2. $ [wrapper-options] command [command-options]
  *
  * Wrapper Options:
- * --isolated, -i <backend>  Run in isolated environment (screen, tmux, docker, zellij)
+ * --isolated, -i <backend>  Run in isolated environment (screen, tmux, docker)
  * --attached, -a            Run in attached mode (foreground)
  * --detached, -d            Run in detached mode (background)
  * --session, -s <name>      Session name for isolation
@@ -20,7 +20,7 @@ const DEBUG =
 /**
  * Valid isolation backends
  */
-const VALID_BACKENDS = ['screen', 'tmux', 'docker', 'zellij'];
+const VALID_BACKENDS = ['screen', 'tmux', 'docker'];
 
 /**
  * Parse command line arguments into wrapper options and command
@@ -29,7 +29,7 @@ const VALID_BACKENDS = ['screen', 'tmux', 'docker', 'zellij'];
  */
 function parseArgs(args) {
   const wrapperOptions = {
-    isolated: null, // Isolation backend: screen, tmux, docker, zellij
+    isolated: null, // Isolation backend: screen, tmux, docker
     attached: false, // Run in attached mode
     detached: false, // Run in detached mode
     session: null, // Session name
@@ -116,7 +116,7 @@ function parseOption(args, index, options) {
       return 2;
     } else {
       throw new Error(
-        `Option ${arg} requires a backend argument (screen, tmux, docker, zellij)`
+        `Option ${arg} requires a backend argument (screen, tmux, docker)`
       );
     }
   }

package/src/lib/isolation.js

@@ -4,7 +4,6 @@
  * Provides execution of commands in various isolated environments:
  * - screen: GNU Screen terminal multiplexer
  * - tmux: tmux terminal multiplexer
- * - zellij: Modern terminal workspace
  * - docker: Docker containers
  */
 
@@ -20,6 +19,83 @@ const setTimeout = globalThis.setTimeout;
 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
@@ -58,6 +134,11 @@ function hasTTY() {
 /**
  * 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()
@@ -67,25 +148,45 @@ 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 {
-      // Use detached mode with logging to capture output
-      // screen -dmS <session> -L -Logfile <logfile> <shell> -c '<command>'
-      const screenArgs = [
-        '-dmS',
-        sessionName,
-        '-L',
-        '-Logfile',
-        logFile,
-        shell,
-        shellArg,
-        command,
-      ];
+      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 log capture: screen ${screenArgs.join(' ')}`
-        );
+        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(' ')}`, {
@@ -360,87 +461,6 @@ function runInTmux(command, options = {}) {
   }
 }
 
-/**
- * Run command in Zellij
- * @param {string} command - Command to execute
- * @param {object} options - Options (session, detached)
- * @returns {Promise<{success: boolean, sessionName: string, message: string}>}
- */
-function runInZellij(command, options = {}) {
-  if (!isCommandAvailable('zellij')) {
-    return Promise.resolve({
-      success: false,
-      sessionName: null,
-      message:
-        'zellij is not installed. Install it with: cargo install zellij or brew install zellij (macOS)',
-    });
-  }
-
-  const sessionName = options.session || generateSessionName('zellij');
-  const { shell, shellArg } = getShell();
-
-  try {
-    if (options.detached) {
-      // Detached mode for zellij
-      if (DEBUG) {
-        console.log(`[DEBUG] Creating detached zellij session: ${sessionName}`);
-      }
-
-      // Create the session in background
-      execSync(
-        `zellij -s "${sessionName}" action new-tab -- ${shell} ${shellArg} "${command}" &`,
-        { stdio: 'inherit', shell: true }
-      );
-
-      return Promise.resolve({
-        success: true,
-        sessionName,
-        message: `Command started in detached zellij session: ${sessionName}\nReattach with: zellij attach ${sessionName}`,
-      });
-    } else {
-      // Attached mode: zellij -s <session> -- <shell> -c <command>
-      if (DEBUG) {
-        console.log(
-          `[DEBUG] Running: zellij -s "${sessionName}" -- ${shell} ${shellArg} "${command}"`
-        );
-      }
-
-      return new Promise((resolve) => {
-        const child = spawn(
-          'zellij',
-          ['-s', sessionName, '--', shell, shellArg, command],
-          {
-            stdio: 'inherit',
-          }
-        );
-
-        child.on('exit', (code) => {
-          resolve({
-            success: code === 0,
-            sessionName,
-            message: `Zellij session "${sessionName}" exited with code ${code}`,
-            exitCode: code,
-          });
-        });
-
-        child.on('error', (err) => {
-          resolve({
-            success: false,
-            sessionName,
-            message: `Failed to start zellij: ${err.message}`,
-          });
-        });
-      });
-    }
-  } catch (err) {
-    return Promise.resolve({
-      success: false,
-      sessionName,
-      message: `Failed to run in zellij: ${err.message}`,
-    });
-  }
-}
-
 /**
  * Run command in Docker container
  * @param {string} command - Command to execute
@@ -547,7 +567,7 @@ function runInDocker(command, options = {}) {
 
 /**
  * Run command in the specified isolation backend
- * @param {string} backend - Isolation backend (screen, tmux, docker, zellij)
+ * @param {string} backend - Isolation backend (screen, tmux, docker)
  * @param {string} command - Command to execute
  * @param {object} options - Options
  * @returns {Promise<{success: boolean, message: string}>}
@@ -558,8 +578,6 @@ function runIsolated(backend, command, options = {}) {
       return runInScreen(command, options);
     case 'tmux':
       return runInTmux(command, options);
-    case 'zellij':
-      return runInZellij(command, options);
     case 'docker':
       return runInDocker(command, options);
     default:
@@ -665,12 +683,19 @@ 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,
   runInDocker,
   runIsolated,
   // Export logging utilities for unified experience
@@ -681,4 +706,8 @@ module.exports = {
   writeLogFile,
   getLogDir,
   createLogPath,
+  // Export screen version utilities for testing and debugging
+  getScreenVersion,
+  supportsLogfileOption,
+  resetScreenVersionCache,
 };

package/test/args-parser.test.js

@@ -382,8 +382,4 @@ describe('VALID_BACKENDS', () => {
   it('should include docker', () => {
     assert.ok(VALID_BACKENDS.includes('docker'));
   });
-
-  it('should include zellij', () => {
-    assert.ok(VALID_BACKENDS.includes('zellij'));
-  });
 });

package/test/isolation.test.js

@@ -7,7 +7,13 @@
 
 const { describe, it } = require('node:test');
 const assert = require('assert');
-const { isCommandAvailable, hasTTY } = require('../src/lib/isolation');
+const {
+  isCommandAvailable,
+  hasTTY,
+  getScreenVersion,
+  supportsLogfileOption,
+  resetScreenVersionCache,
+} = require('../src/lib/isolation');
 
 describe('Isolation Module', () => {
   describe('isCommandAvailable', () => {
@@ -70,11 +76,91 @@ describe('Isolation Module', () => {
       console.log(`  docker available: ${result}`);
       assert.ok(typeof result === 'boolean');
     });
+  });
 
-    it('should check if zellij is available', () => {
-      const result = isCommandAvailable('zellij');
-      console.log(`  zellij available: ${result}`);
-      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'
+        );
+      }
     });
   });
 });
@@ -86,7 +172,6 @@ describe('Isolation Runner Error Handling', () => {
     runInScreen,
     runInTmux,
     runInDocker,
-    runInZellij,
   } = require('../src/lib/isolation');
 
   describe('runInScreen', () => {
@@ -156,23 +241,6 @@ describe('Isolation Runner Error Handling', () => {
       );
     });
   });
-
-  describe('runInZellij', () => {
-    it('should return informative error if zellij is not installed', async () => {
-      // Skip if zellij is installed
-      if (isCommandAvailable('zellij')) {
-        console.log('  Skipping: zellij is installed');
-        return;
-      }
-
-      const result = await runInZellij('echo test', { detached: true });
-      assert.strictEqual(result.success, false);
-      assert.ok(result.message.includes('zellij is not installed'));
-      assert.ok(
-        result.message.includes('cargo') || result.message.includes('brew')
-      );
-    });
-  });
 });
 
 describe('Isolation Runner with Available Backends', () => {