start-command 0.5.2 → 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,16 @@
 # 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

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

@@ -20,6 +20,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 +135,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 +149,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(' ')}`, {
@@ -665,6 +767,14 @@ 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,
@@ -681,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, hasTTY } = require('../src/lib/isolation');
+const {
+  isCommandAvailable,
+  hasTTY,
+  getScreenVersion,
+  supportsLogfileOption,
+  resetScreenVersionCache,
+} = require('../src/lib/isolation');
 
 describe('Isolation Module', () => {
   describe('isCommandAvailable', () => {
@@ -77,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', () => {