start-command 0.25.1 → 0.25.3

package/src/lib/screen-isolation.js

@@ -2,8 +2,12 @@
 
 const { execSync, spawnSync } = require('child_process');
 const fs = require('fs');
-const os = require('os');
 const path = require('path');
+const {
+  ensureParentDirectory,
+  getTempDir,
+  wrapCommandWithLogFooter,
+} = require('./isolation-log-utils');
 
 const setTimeout = globalThis.setTimeout;
 
@@ -131,14 +135,21 @@ function runScreenWithLogCapture(
   shellInfo,
   user = null,
   wrapCommandWithUser,
-  isInteractiveShellCommand
+  isInteractiveShellCommand,
+  logPath = null
 ) {
   const { shell, shellArg } = shellInfo;
-  const logFile = path.join(os.tmpdir(), `screen-output-${sessionName}.log`);
+  const screenTempDir = getTempDir('isolation', 'screen');
+  const logFile =
+    logPath || path.join(screenTempDir, `screen-output-${sessionName}.log`);
+  const shouldCleanupLogFile = !logPath;
   const exitCodeFile = path.join(
-    os.tmpdir(),
+    screenTempDir,
     `screen-exit-${sessionName}.code`
   );
+  ensureParentDirectory(logFile);
+  const logStartOffset =
+    logPath && fs.existsSync(logFile) ? fs.statSync(logFile).size : 0;
 
   return new Promise((resolve) => {
     try {
@@ -159,7 +170,7 @@ function runScreenWithLogCapture(
       // - `logfile <path>` sets the output log path (replaces -Logfile CLI option)
       // - `logfile flush 0` forces immediate buffer flush (prevents output loss)
       // - `deflog on` enables logging for any subsequently created windows
-      const screenrcFile = path.join(os.tmpdir(), `screenrc-${sessionName}`);
+      const screenrcFile = path.join(screenTempDir, `screenrc-${sessionName}`);
       const screenrcContent = [
         `logfile ${logFile}`,
         'logfile flush 0',
@@ -243,7 +254,7 @@ function runScreenWithLogCapture(
 
         let output = '';
         try {
-          output = fs.readFileSync(logFile, 'utf8');
+          output = fs.readFileSync(logFile, 'utf8').slice(logStartOffset);
         } catch {
           // Log file might not exist if command produced no output
         }
@@ -313,7 +324,10 @@ function runScreenWithLogCapture(
 
       // Clean up temp files
       const cleanupTempFiles = () => {
-        for (const f of [logFile, screenrcFile, exitCodeFile]) {
+        const filesToRemove = shouldCleanupLogFile
+          ? [logFile, screenrcFile, exitCodeFile]
+          : [screenrcFile, exitCodeFile];
+        for (const f of filesToRemove) {
           try {
             fs.unlinkSync(f);
           } catch {
@@ -392,6 +406,105 @@ function runScreenWithLogCapture(
   });
 }
 
+/**
+ * Start a detached GNU Screen session with live command output appended to logPath.
+ * The command itself prints the final footer through the terminal so screen writes it
+ * after the command output in the same log stream.
+ */
+function startDetachedScreenWithLogCapture(
+  command,
+  sessionName,
+  shellInfo,
+  options = {}
+) {
+  const { shell, shellArg } = shellInfo;
+  const {
+    user = null,
+    keepAlive = false,
+    logPath = null,
+    wrapCommandWithUser,
+  } = options;
+
+  const screenTempDir = getTempDir('isolation', 'screen');
+  const logFile =
+    logPath || path.join(screenTempDir, `screen-output-${sessionName}.log`);
+  ensureParentDirectory(logFile);
+
+  const screenrcFile = path.join(screenTempDir, `screenrc-${sessionName}`);
+  const screenrcContent = [
+    `logfile ${logFile}`,
+    'logfile flush 0',
+    'deflog on',
+    '',
+  ].join('\n');
+
+  try {
+    fs.writeFileSync(screenrcFile, screenrcContent);
+  } catch (err) {
+    return {
+      success: false,
+      sessionName,
+      message: `Failed to create screenrc for logging: ${err.message}`,
+    };
+  }
+
+  const effectiveCommand = wrapCommandWithLogFooter(
+    wrapCommandWithUser ? wrapCommandWithUser(command, user) : command,
+    { shell, keepAlive }
+  );
+  const screenArgs = [
+    '-dmS',
+    sessionName,
+    '-L',
+    '-c',
+    screenrcFile,
+    shell,
+    shellArg,
+    effectiveCommand,
+  ];
+
+  if (isDebug()) {
+    console.error(`[screen-isolation] Running: screen ${screenArgs.join(' ')}`);
+    console.error(`[screen-isolation] screenrc: ${screenrcContent.trim()}`);
+    console.error(`[screen-isolation] Log file: ${logFile}`);
+  }
+
+  try {
+    const result = spawnSync('screen', screenArgs, { stdio: 'inherit' });
+    if (result.error) {
+      throw result.error;
+    }
+    if (result.status !== 0) {
+      return {
+        success: false,
+        sessionName,
+        message: `Failed to start screen session (exit code ${result.status})`,
+      };
+    }
+  } catch (err) {
+    return {
+      success: false,
+      sessionName,
+      message: `Failed to run in screen: ${err.message}`,
+    };
+  }
+
+  let message = `Command started in detached screen session: ${sessionName}`;
+  if (keepAlive) {
+    message += `\nSession will stay alive after command completes.`;
+  } else {
+    message += `\nSession will exit automatically after command completes.`;
+  }
+  message += `\nReattach with: screen -r ${sessionName}`;
+  message += `\nLive log: ${logFile}`;
+
+  return {
+    success: true,
+    sessionName,
+    message,
+  };
+}
+
 /** Reset screen version cache (useful for testing) */
 function resetScreenVersionCache() {
   cachedScreenVersion = null;
@@ -402,5 +515,6 @@ module.exports = {
   getScreenVersion,
   supportsLogfileOption,
   runScreenWithLogCapture,
+  startDetachedScreenWithLogCapture,
   resetScreenVersionCache,
 };

package/src/lib/spawn-helpers.js

@@ -11,6 +11,20 @@
 
 const { spawn } = require('child_process');
 const fs = require('fs');
+const path = require('path');
+
+function ensureParentDirectory(filePath) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+}
+
+function writeInitialLog(logFilePath, logContent) {
+  ensureParentDirectory(logFilePath);
+  fs.writeFileSync(logFilePath, logContent || '', 'utf8');
+}
+
+function appendLog(logFilePath, content) {
+  fs.appendFileSync(logFilePath, content, 'utf8');
+}
 
 /**
  * Run command using Bun.spawn (for Bun runtime)
@@ -44,6 +58,8 @@ async function runWithBunSpawn(options) {
   let logContent = options.logContent || '';
 
   try {
+    writeInitialLog(logFilePath, logContent);
+
     // Spawn the process using Bun's native API
     const proc = Bun.spawn([shell, ...shellArgs], {
       stdout: 'pipe',
@@ -87,6 +103,7 @@ async function runWithBunSpawn(options) {
           }
           const text = decoder.decode(value);
           process.stdout.write(text);
+          appendLog(logFilePath, text);
           output += text;
         }
       } catch (err) {
@@ -109,6 +126,7 @@ async function runWithBunSpawn(options) {
           }
           const text = decoder.decode(value);
           process.stderr.write(text);
+          appendLog(logFilePath, text);
           output += text;
         }
       } catch (err) {
@@ -133,12 +151,11 @@ async function runWithBunSpawn(options) {
     const durationMs = Date.now() - startTimeMs;
     const endTime = new Date().toISOString().replace('T', ' ').substring(0, 23);
 
-    // Write log file
+    // Write log footer
     try {
-      logContent += `\n${'='.repeat(50)}\n`;
-      logContent += `Finished: ${endTime}\n`;
-      logContent += `Exit Code: ${exitCode}\n`;
-      fs.writeFileSync(logFilePath, logContent, 'utf8');
+      const footer = `\n${'='.repeat(50)}\nFinished: ${endTime}\nExit Code: ${exitCode}\n`;
+      logContent += footer;
+      appendLog(logFilePath, footer);
     } catch (err) {
       console.error(`\nWarning: Could not save log file: ${err.message}`);
     }
@@ -175,7 +192,7 @@ async function runWithBunSpawn(options) {
 
     // Write log file
     try {
-      fs.writeFileSync(logFilePath, logContent, 'utf8');
+      writeInitialLog(logFilePath, logContent);
     } catch (writeErr) {
       console.error(`\nWarning: Could not save log file: ${writeErr.message}`);
     }
@@ -223,6 +240,7 @@ function runWithNodeSpawn(options) {
   } = options;
 
   let logContent = options.logContent || '';
+  writeInitialLog(logFilePath, logContent);
 
   // Execute the command with captured output
   const child = spawn(shell, shellArgs, {
@@ -248,6 +266,7 @@ function runWithNodeSpawn(options) {
   child.stdout.on('data', (data) => {
     const text = data.toString();
     process.stdout.write(text);
+    appendLog(logFilePath, text);
     logContent += text;
   });
 
@@ -255,6 +274,7 @@ function runWithNodeSpawn(options) {
   child.stderr.on('data', (data) => {
     const text = data.toString();
     process.stderr.write(text);
+    appendLog(logFilePath, text);
     logContent += text;
   });
 
@@ -272,9 +292,12 @@ function runWithNodeSpawn(options) {
     logContent += `Finished: ${endTime}\n`;
     logContent += `Exit Code: ${exitCode}\n`;
 
-    // Write log file
+    // Write log footer
     try {
-      fs.writeFileSync(logFilePath, logContent, 'utf8');
+      appendLog(
+        logFilePath,
+        `\n${'='.repeat(50)}\nFinished: ${endTime}\nExit Code: ${exitCode}\n`
+      );
     } catch (err) {
       console.error(`\nWarning: Could not save log file: ${err.message}`);
     }
@@ -312,7 +335,7 @@ function runWithNodeSpawn(options) {
 
     // Write log file
     try {
-      fs.writeFileSync(logFilePath, logContent, 'utf8');
+      writeInitialLog(logFilePath, logContent);
     } catch (writeErr) {
       console.error(`\nWarning: Could not save log file: ${writeErr.message}`);
     }

package/src/lib/status-formatter.js

@@ -7,11 +7,125 @@
  * - Text: Human-readable text format
  */
 
+const { execSync } = require('child_process');
+const fs = require('fs');
 const {
   escapeForLinksNotation,
   formatAsNestedLinksNotation,
 } = require('./output-blocks');
 
+/**
+ * Check if a detached isolation session is still running
+ * @param {Object} record - Execution record
+ * @returns {boolean|null} true if running, false if not, null if unable to determine
+ */
+function isDetachedSessionAlive(record) {
+  const opts = record.options || {};
+  const sessionName = opts.sessionName;
+  const isolationMode = opts.isolationMode;
+  const isolated = opts.isolated;
+
+  if (!sessionName || isolationMode !== 'detached') {
+    return null;
+  }
+
+  try {
+    switch (isolated) {
+      case 'screen': {
+        const output = execSync('screen -ls', {
+          encoding: 'utf8',
+          stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        return output.includes(sessionName);
+      }
+      case 'tmux': {
+        execSync(`tmux has-session -t ${sessionName}`, {
+          stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        return true;
+      }
+      case 'docker': {
+        const output = execSync(
+          `docker inspect -f "{{.State.Running}}" ${sessionName}`,
+          { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }
+        );
+        return output.trim() === 'true';
+      }
+      case 'ssh': {
+        // For SSH, check if the PID is still running on remote would require
+        // re-connecting. Fall back to checking the local wrapper PID.
+        if (record.pid) {
+          try {
+            process.kill(record.pid, 0);
+            return true;
+          } catch {
+            return false;
+          }
+        }
+        return null;
+      }
+      default:
+        return null;
+    }
+  } catch {
+    // Command failed - session is likely not running
+    return false;
+  }
+}
+
+function readExitCodeFromLog(logPath) {
+  if (!logPath) {
+    return null;
+  }
+  try {
+    const content = fs.readFileSync(logPath, 'utf8');
+    const matches = [...content.matchAll(/Exit Code:\s*(-?\d+)/g)];
+    if (matches.length === 0) {
+      return null;
+    }
+    return parseInt(matches[matches.length - 1][1], 10);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Enrich execution record with live session status for detached executions.
+ * If a record shows "executing" but the detached session has actually ended,
+ * returns an updated copy with status "executed". If it shows "executed" but
+ * the session is still running, returns a copy with status "executing".
+ * @param {Object} record - Execution record
+ * @returns {Object} Possibly updated execution record
+ */
+function enrichDetachedStatus(record) {
+  const alive = isDetachedSessionAlive(record);
+  if (alive === null) {
+    return record;
+  }
+
+  // Create a shallow copy to avoid mutating the original
+  const enriched = Object.create(Object.getPrototypeOf(record));
+  Object.assign(enriched, record);
+
+  if (alive && enriched.status === 'executed') {
+    // Session still running but record says executed - correct it
+    enriched.status = 'executing';
+    enriched.exitCode = null;
+    enriched.endTime = null;
+  } else if (!alive && enriched.status === 'executing') {
+    // Session ended but record says executing - correct it
+    enriched.status = 'executed';
+    if (enriched.exitCode === null || enriched.exitCode === undefined) {
+      enriched.exitCode = readExitCodeFromLog(enriched.logPath) ?? -1;
+    }
+    if (!enriched.endTime) {
+      enriched.endTime = new Date().toISOString();
+    }
+  }
+
+  return enriched;
+}
+
 /**
  * Format execution record as Links Notation (indented style)
  * Uses nested Links notation for object values (like options) instead of JSON
@@ -122,18 +236,23 @@ function formatRecord(record, format) {
  * @param {string|null} outputFormat - Output format (links-notation, json, text)
  * @returns {{success: boolean, output?: string, error?: string}}
  */
-function queryStatus(store, uuid, outputFormat) {
+function queryStatus(store, identifier, outputFormat) {
   if (!store) {
     return { success: false, error: 'Execution tracking is disabled.' };
   }
-  const record = store.get(uuid);
+  const record = store.get(identifier);
   if (!record) {
-    return { success: false, error: `No execution found with UUID: ${uuid}` };
+    return {
+      success: false,
+      error: `No execution found with UUID or session name: ${identifier}`,
+    };
   }
   try {
+    // Enrich detached execution status with live session check
+    const enrichedRecord = enrichDetachedStatus(record);
     return {
       success: true,
-      output: formatRecord(record, outputFormat || 'links-notation'),
+      output: formatRecord(enrichedRecord, outputFormat || 'links-notation'),
     };
   } catch (err) {
     return { success: false, error: err.message };
@@ -145,4 +264,6 @@ module.exports = {
   formatRecordAsText,
   formatRecord,
   queryStatus,
+  isDetachedSessionAlive,
+  enrichDetachedStatus,
 };

package/test/isolation-log-utils.test.js

@@ -14,6 +14,7 @@ const {
   createLogFooter,
   getLogDir,
   createLogPath,
+  getTempRoot,
 } = require('../src/lib/isolation-log-utils');
 
 describe('isolation-log-utils', () => {
@@ -194,13 +195,12 @@ describe('isolation-log-utils', () => {
       }
     });
 
-    it('should fall back to os.tmpdir() when START_LOG_DIR is not set', () => {
-      const os = require('os');
+    it('should fall back to /tmp/start-command/logs when START_LOG_DIR is not set', () => {
       const original = process.env.START_LOG_DIR;
       delete process.env.START_LOG_DIR;
       try {
         const dir = getLogDir();
-        assert.strictEqual(dir, os.tmpdir());
+        assert.strictEqual(dir, path.join(getTempRoot(), 'logs'));
       } finally {
         if (original !== undefined) {
           process.env.START_LOG_DIR = original;
@@ -230,5 +230,19 @@ describe('isolation-log-utils', () => {
       const logPath = createLogPath('screen');
       assert.ok(logPath.startsWith(logDir));
     });
+
+    it('should create stable isolation log path when execution id is provided', () => {
+      const logPath = createLogPath('screen', 'uuid-123');
+      assert.ok(
+        logPath.endsWith(
+          path.join('logs', 'isolation', 'screen', 'uuid-123.log')
+        )
+      );
+    });
+
+    it('should create stable direct log path without duplicated environment segment', () => {
+      const logPath = createLogPath('direct', 'uuid-123');
+      assert.ok(logPath.endsWith(path.join('logs', 'direct', 'uuid-123.log')));
+    });
   });
 });

package/test/screen-integration.test.js

@@ -7,9 +7,27 @@
 
 const { describe, it } = require('node:test');
 const assert = require('assert');
-const { execSync } = require('child_process');
+const { execSync, spawnSync } = require('child_process');
+const crypto = require('crypto');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
 const { isCommandAvailable, runInScreen } = require('../src/lib/isolation');
 
+function waitForFileContent(filePath, predicate, timeoutMs = 5000) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    if (fs.existsSync(filePath)) {
+      const content = fs.readFileSync(filePath, 'utf8');
+      if (predicate(content)) {
+        return content;
+      }
+    }
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 100);
+  }
+  return fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf8') : '';
+}
+
 describe('Screen Integration Tests', () => {
   describe('runInScreen (if available)', () => {
     it('should run command in detached screen session', async () => {
@@ -38,6 +56,85 @@ describe('Screen Integration Tests', () => {
       }
     });
 
+    it('should stream detached screen output to the tracked CLI log path', () => {
+      if (!isCommandAvailable('screen')) {
+        console.log('  Skipping: screen not installed');
+        return;
+      }
+
+      const executionId = crypto.randomUUID();
+      const sessionName = `test-screen-log-${Date.now()}`;
+      const appFolder = fs.mkdtempSync(
+        path.join(os.tmpdir(), 'start-command-test-store-')
+      );
+      const cliPath = path.join(__dirname, '..', 'src', 'bin', 'cli.js');
+      const command =
+        'printf "detached-log-test-1\\n"; sleep 0.2; printf "detached-log-test-2\\n"';
+
+      const result = spawnSync(
+        process.execPath,
+        [
+          cliPath,
+          '--session-id',
+          executionId,
+          '-i',
+          'screen',
+          '-d',
+          '--session',
+          sessionName,
+          '--',
+          command,
+        ],
+        {
+          encoding: 'utf8',
+          env: {
+            ...process.env,
+            START_APP_FOLDER: appFolder,
+            START_DISABLE_AUTO_ISSUE: '1',
+          },
+        }
+      );
+
+      assert.strictEqual(
+        result.status,
+        0,
+        `CLI failed:\nstdout:\n${result.stdout}\nstderr:\n${result.stderr}`
+      );
+
+      const logPathMatch = result.stdout.match(/│ log\s+(.+)/);
+      assert.ok(result.stdout.includes(`│ screen    ${sessionName}`));
+      assert.ok(logPathMatch, `Expected log path in output:\n${result.stdout}`);
+
+      const logPath = logPathMatch[1].trim();
+      assert.ok(
+        logPath.endsWith(
+          path.join('logs', 'isolation', 'screen', `${executionId}.log`)
+        ),
+        `Unexpected log path: ${logPath}`
+      );
+
+      const logContent = waitForFileContent(
+        logPath,
+        (content) =>
+          content.includes('detached-log-test-1') &&
+          content.includes('detached-log-test-2') &&
+          content.includes('Exit Code: 0')
+      );
+
+      assert.ok(
+        logContent.includes('detached-log-test-1'),
+        `Missing first output line in log:\n${logContent}`
+      );
+      assert.ok(
+        logContent.includes('detached-log-test-2'),
+        `Missing second output line in log:\n${logContent}`
+      );
+      assert.ok(
+        logContent.includes('Command started in detached screen session'),
+        `Missing detached start message in log:\n${logContent}`
+      );
+    });
+
     it('should run command in attached mode and capture output (issue #15)', async () => {
       if (!isCommandAvailable('screen')) {
         console.log('  Skipping: screen not installed');