start-command 0.25.1 → 0.25.3

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # start-command
 
+## 0.25.3
+
+### Patch Changes
+
+- 873781e: Record detached isolation output in the tracked log path in real time.
+
+## 0.25.2
+
+### Patch Changes
+
+- 8f58d2b: fix: support --session name lookups in --status and track detached session lifecycle
+
+  `--status` now accepts session names in addition to UUIDs. Detached mode no longer incorrectly reports immediate completion — status is determined at query time by checking if the actual session is still running.
+
 ## 0.25.1
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "start-command",
-  "version": "0.25.1",
+  "version": "0.25.3",
   "description": "Gamification of coding, execute any command with ability to auto-report issues on GitHub",
   "main": "src/bin/cli.js",
   "exports": {

package/src/bin/cli.js

@@ -2,7 +2,6 @@
 
 const process = require('process');
 const os = require('os');
-const fs = require('fs');
 const path = require('path');
 
 // Import modules
@@ -20,6 +19,7 @@ const {
   createLogHeader,
   createLogFooter,
   writeLogFile,
+  appendLogFile,
   createLogPath,
   getDefaultDockerImage,
 } = require('../lib/isolation');
@@ -333,7 +333,7 @@ Options:
   --auto-remove-docker-container  Auto-remove docker container after exit
   --shell <shell>       Shell to use in isolation environments: auto, bash, zsh, sh (default: auto)
   --use-command-stream  Use command-stream library for execution (experimental)
-  --status <uuid>       Show status of execution by UUID (--output-format: links-notation|json|text)
+  --status <id>         Show status of execution by UUID or session name (--output-format: links-notation|json|text)
   --cleanup             Clean up stale "executing" records (crashed/killed processes)
   --cleanup-dry-run     Show stale records that would be cleaned up (without cleaning)
   --version, -v         Show version information
@@ -405,7 +405,7 @@ async function runWithIsolation(
   }
 
   // Create log file path
-  const logFilePath = createLogPath(environment || 'direct');
+  const logFilePath = createLogPath(environment || 'direct', sessionId);
 
   // Get session name (will be generated by runIsolated if not provided)
   const sessionName =
@@ -468,12 +468,9 @@ async function runWithIsolation(
     }
   }
 
-  // Add isolation info to extra lines
+  // Add isolation info to extra lines (session name for reconnecting, see issue #67)
   if (environment) {
     extraLines.push(`[Isolation] Environment: ${environment}, Mode: ${mode}`);
-    // Always add the session name so users can reconnect to detached sessions
-    // This is important for screen, tmux, docker where the session/container name
-    // is different from the session UUID used for tracking (see issue #67)
     extraLines.push(`[Isolation] Session: ${sessionName}`);
   }
   if (effectiveImage) {
@@ -562,6 +559,8 @@ async function runWithIsolation(
     );
   }
 
+  writeLogFile(logFilePath, logContent);
+
   let result;
 
   if (environment) {
@@ -569,7 +568,7 @@ async function runWithIsolation(
     // Note: Isolation environments currently use native spawn/execSync
     // Future: Add command-stream support with raw() function for multiplexers
     result = await runIsolated(environment, cmd, {
-      session: options.session,
+      session: sessionName,
       image: effectiveImage,
       endpoint: options.endpoint,
       detached: mode === 'detached',
@@ -577,6 +576,7 @@ async function runWithIsolation(
       keepAlive: options.keepAlive,
       autoRemoveDockerContainer: options.autoRemoveDockerContainer,
       shell: options.shell,
+      logPath: logFilePath,
     });
   } else if (createdUser) {
     // Run directly as the created user (no isolation environment)
@@ -595,16 +595,19 @@ async function runWithIsolation(
   if (!result.success && result.message) {
     console.error(`Error: ${result.message}`);
   }
-  // Add result to log content
-  logContent += `${result.message}\n`;
-  logContent += createLogFooter(endTime, exitCode);
-
-  // Write log file
-  writeLogFile(logFilePath, logContent);
+  if (mode === 'detached' && result.success) {
+    appendLogFile(logFilePath, `${result.message}\n`);
+  } else {
+    // Add result to log content
+    appendLogFile(logFilePath, `${result.message}\n`);
+    appendLogFile(logFilePath, createLogFooter(endTime, exitCode));
+  }
 
-  // Update execution record as completed and clear global reference
+  // Update execution record: detached keeps "executing" (resolved at query time)
   if (executionRecord && store) {
-    executionRecord.complete(exitCode);
+    if (mode !== 'detached') {
+      executionRecord.complete(exitCode);
+    }
     try {
       store.save(executionRecord);
     } catch (err) {
@@ -614,7 +617,6 @@ async function runWithIsolation(
         );
       }
     }
-    // Clear global reference since we've completed normally
     currentExecutionRecord = null;
   }
 
@@ -676,9 +678,7 @@ async function runDirect(cmd, sessionId) {
   const shellArgs = isWindows ? ['-Command', cmd] : ['-c', cmd];
 
   // Setup logging
-  const logDir = config.logDir || os.tmpdir();
-  const logFilename = generateLogFilename();
-  const logFilePath = path.join(logDir, logFilename);
+  const logFilePath = createLogPath('direct', sessionId);
 
   let logContent = '';
   const startTime = getTimestamp();
@@ -827,9 +827,7 @@ async function runDirectWithCommandStream(
   const shell = isWindows ? 'powershell.exe' : process.env.SHELL || '/bin/sh';
 
   // Setup logging
-  const logDir = config.logDir || os.tmpdir();
-  const logFilename = generateLogFilename();
-  const logFilePath = path.join(logDir, logFilename);
+  const logFilePath = createLogPath('direct', sessionId);
 
   let logContent = '';
   const startTime = getTimestamp();
@@ -913,6 +911,7 @@ async function runDirectWithCommandStream(
 
   let exitCode = 0;
   try {
+    writeLogFile(logFilePath, logContent);
     // Use raw() to pass the command without auto-escaping
     // This is important for complex commands with pipes, redirects, etc.
     const result = await $cmd`${raw(cmd)}`;
@@ -926,14 +925,17 @@ async function runDirectWithCommandStream(
     // Collect output for log
     if (result.stdout) {
       logContent += result.stdout;
+      appendLogFile(logFilePath, result.stdout);
     }
     if (result.stderr) {
       logContent += result.stderr;
+      appendLogFile(logFilePath, result.stderr);
     }
   } catch (err) {
     exitCode = err.code || 1;
     const errorMessage = `Error executing command: ${err.message}`;
     logContent += `\n${errorMessage}\n`;
+    appendLogFile(logFilePath, `\n${errorMessage}\n`);
     console.error(`\n${errorMessage}`);
   }
 
@@ -946,7 +948,10 @@ async function runDirectWithCommandStream(
 
   // Write log file
   try {
-    fs.writeFileSync(logFilePath, logContent, 'utf8');
+    appendLogFile(
+      logFilePath,
+      `\n${'='.repeat(50)}\nFinished: ${endTime}\nExit Code: ${exitCode}\n`
+    );
   } catch (err) {
     console.error(`\nWarning: Could not save log file: ${err.message}`);
   }
@@ -987,13 +992,3 @@ async function runDirectWithCommandStream(
 
   process.exit(exitCode);
 }
-
-/**
- * Generate unique log filename for direct execution
- * @returns {string} Log filename
- */
-function generateLogFilename() {
-  const timestamp = Date.now();
-  const random = Math.random().toString(36).substring(2, 8);
-  return `start-command-${timestamp}-${random}.log`;
-}

package/src/lib/args-parser.js

@@ -418,13 +418,13 @@ function parseOption(args, index, options) {
     return 1;
   }
 
-  // --status <uuid>
+  // --status <uuid-or-session-name>
   if (arg === '--status') {
     if (index + 1 < args.length && !args[index + 1].startsWith('-')) {
       options.status = args[index + 1];
       return 2;
     } else {
-      throw new Error(`Option ${arg} requires a UUID argument`);
+      throw new Error(`Option ${arg} requires a UUID or session name argument`);
     }
   }
 

package/src/lib/execution-store.js

@@ -470,14 +470,23 @@ class ExecutionStore {
   }
 
   /**
-   * Get an execution record by UUID
-   * @param {string} uuid
+   * Get an execution record by UUID or session name
+   * First tries exact UUID match, then falls back to session name lookup
+   * @param {string} identifier - UUID or session name
    * @returns {ExecutionRecord|null}
    */
-  get(uuid) {
+  get(identifier) {
     const records = this.readLinoRecords();
-    const found = records.find((r) => r.uuid === uuid);
-    return found || null;
+    // First try exact UUID match
+    const byUuid = records.find((r) => r.uuid === identifier);
+    if (byUuid) {
+      return byUuid;
+    }
+    // Fall back to session name lookup (stored in options.sessionName)
+    const bySessionName = records.find(
+      (r) => r.options && r.options.sessionName === identifier
+    );
+    return bySessionName || null;
   }
 
   /**

package/src/lib/isolation-log-utils.js

@@ -5,6 +5,18 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 
+function getTempRoot() {
+  return process.env.START_TEMP_ROOT || path.join(os.tmpdir(), 'start-command');
+}
+
+function ensureDirectory(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+
+function ensureParentDirectory(filePath) {
+  ensureDirectory(path.dirname(filePath));
+}
+
 /**
  * Generate timestamp for logging
  * @returns {string} ISO timestamp without 'T' and 'Z'
@@ -77,6 +89,7 @@ function createLogFooter(endTime, exitCode) {
  */
 function writeLogFile(logPath, content) {
   try {
+    ensureParentDirectory(logPath);
     fs.writeFileSync(logPath, content, 'utf8');
     return true;
   } catch (err) {
@@ -85,23 +98,79 @@ function writeLogFile(logPath, content) {
   }
 }
 
+/**
+ * Append to a log file, creating its parent directory when needed.
+ * @param {string} logPath - Path to log file
+ * @param {string} content - Log content to append
+ * @returns {boolean} Success status
+ */
+function appendLogFile(logPath, content) {
+  try {
+    ensureParentDirectory(logPath);
+    fs.appendFileSync(logPath, content, 'utf8');
+    return true;
+  } catch (err) {
+    console.error(`\nWarning: Could not append log file: ${err.message}`);
+    return false;
+  }
+}
+
 /**
  * Get log directory from environment or use system temp
  * @returns {string} Log directory path
  */
 function getLogDir() {
-  return process.env.START_LOG_DIR || os.tmpdir();
+  return process.env.START_LOG_DIR || path.join(getTempRoot(), 'logs');
+}
+
+/**
+ * Get a start-command temporary directory for sidecar files.
+ * @param {...string} segments - Optional path segments below the temp directory
+ * @returns {string} Directory path
+ */
+function getTempDir(...segments) {
+  const dir = path.join(getTempRoot(), 'tmp', ...segments);
+  ensureDirectory(dir);
+  return dir;
 }
 
 /**
  * Create log file path
  * @param {string} environment - The isolation environment
+ * @param {string|null} executionId - Optional execution UUID/session ID
  * @returns {string} Full path to log file
  */
-function createLogPath(environment) {
+function createLogPath(environment, executionId = null) {
   const logDir = getLogDir();
+  if (executionId) {
+    return environment === 'direct'
+      ? path.join(logDir, 'direct', `${executionId}.log`)
+      : path.join(logDir, 'isolation', environment, `${executionId}.log`);
+  }
   const logFilename = generateLogFilename(environment);
-  return path.join(logDir, logFilename);
+  return environment === 'direct'
+    ? path.join(logDir, 'direct', logFilename)
+    : path.join(logDir, 'isolation', environment, logFilename);
+}
+
+function shellQuote(value) {
+  return `'${String(value).replace(/'/g, "'\\''")}'`;
+}
+
+function createShellLogFooterSnippet() {
+  const dateCommand =
+    "date '+%Y-%m-%d %H:%M:%S.%3N' 2>/dev/null || date '+%Y-%m-%d %H:%M:%S'";
+  return `printf '\\n==================================================\\nFinished: %s\\nExit Code: %s\\n' "$(${dateCommand})" "$__start_command_exit"`;
+}
+
+function wrapCommandWithLogFooter(command, options = {}) {
+  const shell = options.shell || 'sh';
+  const keepAlive = Boolean(options.keepAlive);
+  const footer = createShellLogFooterSnippet();
+  const afterFooter = keepAlive
+    ? `exec ${shellQuote(shell)}`
+    : 'exit "$__start_command_exit"';
+  return `(${command}); __start_command_exit=$?; ${footer}; ${afterFooter}`;
 }
 
 /**
@@ -136,12 +205,20 @@ function runAsIsolatedUser(cmd, username) {
 }
 
 module.exports = {
+  getTempRoot,
+  ensureDirectory,
+  ensureParentDirectory,
   getTimestamp,
   generateLogFilename,
   createLogHeader,
   createLogFooter,
   writeLogFile,
+  appendLogFile,
   getLogDir,
+  getTempDir,
   createLogPath,
+  shellQuote,
+  createShellLogFooterSnippet,
+  wrapCommandWithLogFooter,
   runAsIsolatedUser,
 };

package/src/lib/isolation.js

@@ -13,8 +13,15 @@ const {
   getScreenVersion,
   supportsLogfileOption,
   runScreenWithLogCapture: _runScreenWithLogCapture,
+  startDetachedScreenWithLogCapture,
   resetScreenVersionCache,
 } = require('./screen-isolation');
+const {
+  appendLogFile,
+  createShellLogFooterSnippet,
+  shellQuote,
+  wrapCommandWithLogFooter,
+} = require('./isolation-log-utils');
 
 /**
  * Check if a command is available on the system
@@ -170,14 +177,21 @@ function wrapCommandWithUser(command, user) {
  * @param {string|null} user - Username to run command as (optional)
  * @returns {Promise<{success: boolean, sessionName: string, message: string, output: string}>}
  */
-function runScreenWithLogCapture(command, sessionName, shellInfo, user = null) {
+function runScreenWithLogCapture(
+  command,
+  sessionName,
+  shellInfo,
+  user = null,
+  logPath = null
+) {
   return _runScreenWithLogCapture(
     command,
     sessionName,
     shellInfo,
     user,
     wrapCommandWithUser,
-    isInteractiveShellCommand
+    isInteractiveShellCommand,
+    logPath
   );
 }
 
@@ -199,54 +213,24 @@ function runInScreen(command, options = {}) {
 
   const sessionName = options.session || generateSessionName('screen');
   const shellInfo = getShell();
-  const { shell, shellArg } = shellInfo;
 
   try {
-    // Wrap command with user switch if specified
-    let effectiveCommand = wrapCommandWithUser(command, options.user);
-
     if (options.detached) {
-      if (options.keepAlive) {
-        effectiveCommand = `${effectiveCommand}; exec ${shell}`;
-      }
-
-      const screenArgs = isInteractiveShellCommand(command)
-        ? ['-dmS', sessionName, ...command.trim().split(/\s+/)]
-        : ['-dmS', sessionName, shell, shellArg, effectiveCommand];
-
-      if (DEBUG) {
-        console.log(`[DEBUG] Running: screen ${screenArgs.join(' ')}`);
-        console.log(`[DEBUG] keepAlive: ${options.keepAlive || false}`);
-      }
-
-      // Use spawnSync with array args (not execSync string) to avoid quoting issues (issue #25)
-      const result = spawnSync('screen', screenArgs, {
-        stdio: 'inherit',
-      });
-
-      if (result.error) {
-        throw result.error;
-      }
-
-      let message = `Command started in detached screen session: ${sessionName}`;
-      if (options.keepAlive) {
-        message += `\nSession will stay alive after command completes.`;
-      } else {
-        message += `\nSession will exit automatically after command completes.`;
-      }
-      message += `\nReattach with: screen -r ${sessionName}`;
-
-      return Promise.resolve({
-        success: true,
-        sessionName,
-        message,
-      });
+      return Promise.resolve(
+        startDetachedScreenWithLogCapture(command, sessionName, shellInfo, {
+          user: options.user,
+          keepAlive: options.keepAlive,
+          logPath: options.logPath,
+          wrapCommandWithUser,
+        })
+      );
     } else {
       return runScreenWithLogCapture(
         command,
         sessionName,
         shellInfo,
-        options.user
+        options.user,
+        options.logPath
       );
     }
   } catch (err) {
@@ -294,12 +278,40 @@ function runInTmux(command, options = {}) {
         console.log(`[DEBUG] keepAlive: ${options.keepAlive || false}`);
       }
 
-      execSync(
-        `tmux new-session -d -s "${sessionName}" "${effectiveCommand}"`,
-        {
+      if (options.logPath) {
+        const loggedCommand = wrapCommandWithLogFooter(effectiveCommand, {
+          shell,
+          keepAlive: options.keepAlive,
+        });
+        spawnSync('tmux', ['new-session', '-d', '-s', sessionName, shell], {
           stdio: 'inherit',
-        }
-      );
+        });
+        spawnSync(
+          'tmux',
+          [
+            'pipe-pane',
+            '-t',
+            sessionName,
+            '-o',
+            `cat >> ${shellQuote(options.logPath)}`,
+          ],
+          { stdio: 'inherit' }
+        );
+        spawnSync(
+          'tmux',
+          ['send-keys', '-t', sessionName, loggedCommand, 'C-m'],
+          {
+            stdio: 'inherit',
+          }
+        );
+      } else {
+        execSync(
+          `tmux new-session -d -s "${sessionName}" "${effectiveCommand}"`,
+          {
+            stdio: 'inherit',
+          }
+        );
+      }
 
       let message = `Command started in detached tmux session: ${sessionName}`;
       if (options.keepAlive) {
@@ -401,8 +413,8 @@ function runInSsh(command, options = {}) {
         ? `${remoteShell} ${shellInteractiveFlag}`
         : remoteShell;
       const remoteCommand = isInteractiveShellCommand(command)
-        ? `nohup ${command} > /tmp/${sessionName}.log 2>&1 &`
-        : `nohup ${shellInvocation} -c ${JSON.stringify(command)} > /tmp/${sessionName}.log 2>&1 &`;
+        ? `mkdir -p /tmp/start-command/logs/isolation/ssh && nohup ${command} > /tmp/start-command/logs/isolation/ssh/${sessionName}.log 2>&1 &`
+        : `mkdir -p /tmp/start-command/logs/isolation/ssh && nohup ${shellInvocation} -c ${JSON.stringify(command)} > /tmp/start-command/logs/isolation/ssh/${sessionName}.log 2>&1 &`;
       const sshArgs = [sshTarget, remoteCommand];
 
       if (DEBUG) {
@@ -419,7 +431,7 @@ function runInSsh(command, options = {}) {
       return Promise.resolve({
         success: true,
         sessionName,
-        message: `Command started in detached SSH session on ${sshTarget}\nSession: ${sessionName}\nView logs: ssh ${sshTarget} "tail -f /tmp/${sessionName}.log"`,
+        message: `Command started in detached SSH session on ${sshTarget}\nSession: ${sessionName}\nView logs: ssh ${sshTarget} "tail -f /tmp/start-command/logs/isolation/ssh/${sessionName}.log"`,
       });
     } else {
       const extraFlags = shellInteractiveFlag ? [shellInteractiveFlag] : [];
@@ -568,6 +580,19 @@ function runInDocker(command, options = {}) {
         encoding: 'utf8',
       }).trim();
 
+      if (options.logPath) {
+        const loggerScript = [
+          `docker logs -f ${shellQuote(containerName)} >> ${shellQuote(options.logPath)} 2>&1`,
+          `__start_command_exit=$(docker inspect -f '{{.State.ExitCode}}' ${shellQuote(containerName)} 2>/dev/null || printf '%s' '-1')`,
+          `${createShellLogFooterSnippet()} >> ${shellQuote(options.logPath)}`,
+        ].join('; ');
+        const logger = spawn('sh', ['-c', loggerScript], {
+          detached: true,
+          stdio: 'ignore',
+        });
+        logger.unref();
+      }
+
       let message = `Command started in detached docker container: ${containerName}`;
       message += `\nContainer ID: ${containerId.substring(0, 12)}`;
       if (options.keepAlive) {
@@ -582,6 +607,9 @@ function runInDocker(command, options = {}) {
       }
       message += `\nAttach with: docker attach ${containerName}`;
       message += `\nView logs: docker logs ${containerName}`;
+      if (options.logPath) {
+        message += `\nLive log: ${options.logPath}`;
+      }
 
       return Promise.resolve({
         success: true,
@@ -696,6 +724,7 @@ function runIsolated(backend, command, options = {}) {
       ? options.endpointStack[0]
       : options.endpoint,
     session: options.sessionStack ? options.sessionStack[0] : options.session,
+    logPath: options.logPath,
   };
 
   switch (backend) {
@@ -746,6 +775,7 @@ module.exports = {
   createLogHeader,
   createLogFooter,
   writeLogFile,
+  appendLogFile,
   getLogDir,
   createLogPath,
   getScreenVersion,