start-command 0.10.0 → 0.13.0

package/src/bin/cli.js

@@ -28,6 +28,7 @@ const {
   hasSudoAccess,
   getCurrentUserGroups,
 } = require('../lib/user-manager');
+const { handleFailure } = require('../lib/failure-handler');
 
 // Configuration from environment variables
 const config = {
@@ -50,6 +51,10 @@ const config = {
     process.env.START_DISABLE_SUBSTITUTIONS === 'true',
   // Custom substitutions file path
   substitutionsPath: process.env.START_SUBSTITUTIONS_PATH || null,
+  // Use command-stream library for command execution (experimental)
+  useCommandStream:
+    process.env.START_USE_COMMAND_STREAM === '1' ||
+    process.env.START_USE_COMMAND_STREAM === 'true',
 };
 
 // Get all arguments passed after the command
@@ -86,6 +91,66 @@ if (args.length === 0) {
   process.exit(0);
 }
 
+// Parse wrapper options and command
+let parsedArgs;
+try {
+  parsedArgs = parseArgs(args);
+} catch (err) {
+  console.error(`Error: ${err.message}`);
+  process.exit(1);
+}
+
+const { wrapperOptions, command: parsedCommand } = parsedArgs;
+
+// Check if no command was provided
+if (!parsedCommand || parsedCommand.trim() === '') {
+  console.error('Error: No command provided');
+  printUsage();
+  process.exit(1);
+}
+
+// Process through substitution engine (unless disabled)
+let command = parsedCommand;
+let substitutionResult = null;
+
+if (!config.disableSubstitutions) {
+  substitutionResult = processCommand(parsedCommand, {
+    customLinoPath: config.substitutionsPath,
+    verbose: config.verbose,
+  });
+
+  if (substitutionResult.matched) {
+    command = substitutionResult.command;
+    if (config.verbose) {
+      console.log(`[Substitution] "${parsedCommand}" -> "${command}"`);
+      console.log('');
+    }
+  }
+}
+
+// Determine if we should use command-stream
+// Can be enabled via --use-command-stream flag or START_USE_COMMAND_STREAM env var
+const useCommandStream =
+  wrapperOptions.useCommandStream || config.useCommandStream;
+
+// Main execution
+(async () => {
+  // Check if running in isolation mode or with user isolation
+  if (hasIsolation(wrapperOptions) || wrapperOptions.user) {
+    await runWithIsolation(wrapperOptions, command, useCommandStream);
+  } else {
+    if (useCommandStream) {
+      await runDirectWithCommandStream(
+        command,
+        parsedCommand,
+        substitutionResult
+      );
+    } else {
+      await runDirect(command);
+    }
+  }
+})();
+
 /**
  * Print version information
  * @param {boolean} verbose - Whether to show verbose debugging info
@@ -224,15 +289,17 @@ function printUsage() {
        $ <command> [args...]
 
 Options:
-  --isolated, -i <env>  Run in isolated environment (screen, tmux, docker)
+  --isolated, -i <env>  Run in isolated environment (screen, tmux, docker, ssh)
   --attached, -a        Run in attached mode (foreground)
   --detached, -d        Run in detached mode (background)
   --session, -s <name>  Session name for isolation
   --image <image>       Docker image (required for docker isolation)
+  --endpoint <endpoint> SSH endpoint (required for ssh isolation, e.g., user@host)
   --isolated-user, -u [name]  Create isolated user with same permissions
   --keep-user           Keep isolated user after command completes
   --keep-alive, -k      Keep isolation environment alive after command exits
   --auto-remove-docker-container  Auto-remove docker container after exit
+  --use-command-stream  Use command-stream library for execution (experimental)
   --version, -v         Show version information
 
 Examples:
@@ -241,10 +308,12 @@ Examples:
   $ --isolated tmux -- bun start
   $ -i screen -d bun start
   $ --isolated docker --image oven/bun:latest -- bun install
+  $ --isolated ssh --endpoint user@remote.server -- ls -la
   $ --isolated-user -- npm test            # Create isolated user
   $ -u myuser -- npm start                 # Custom username
   $ -i screen --isolated-user -- npm test  # Combine with process isolation
-  $ --isolated-user --keep-user -- npm start`);
+  $ --isolated-user --keep-user -- npm start
+  $ --use-command-stream echo "Hello"      # Use command-stream library`);
   console.log('');
   console.log('Piping with $:');
   console.log('  echo "hi" | $ agent       # Preferred - pipe TO $ command');
@@ -275,59 +344,13 @@ Examples:
   );
 }
 
-// Parse wrapper options and command
-let parsedArgs;
-try {
-  parsedArgs = parseArgs(args);
-} catch (err) {
-  console.error(`Error: ${err.message}`);
-  process.exit(1);
-}
-
-const { wrapperOptions, command: parsedCommand } = parsedArgs;
-
-// Check if no command was provided
-if (!parsedCommand || parsedCommand.trim() === '') {
-  console.error('Error: No command provided');
-  printUsage();
-  process.exit(1);
-}
-
-// Process through substitution engine (unless disabled)
-let command = parsedCommand;
-let substitutionResult = null;
-
-if (!config.disableSubstitutions) {
-  substitutionResult = processCommand(parsedCommand, {
-    customLinoPath: config.substitutionsPath,
-    verbose: config.verbose,
-  });
-
-  if (substitutionResult.matched) {
-    command = substitutionResult.command;
-    if (config.verbose) {
-      console.log(`[Substitution] "${parsedCommand}" -> "${command}"`);
-      console.log('');
-    }
-  }
-}
-
-// Main execution
-(async () => {
-  // Check if running in isolation mode or with user isolation
-  if (hasIsolation(wrapperOptions) || wrapperOptions.user) {
-    await runWithIsolation(wrapperOptions, command);
-  } else {
-    await runDirect(command);
-  }
-})();
-
 /**
  * Run command in isolation mode
  * @param {object} options - Wrapper options
  * @param {string} cmd - Command to execute
+ * @param {boolean} useCommandStream - Whether to use command-stream for isolation
  */
-async function runWithIsolation(options, cmd) {
+async function runWithIsolation(options, cmd, useCommandStream = false) {
   const environment = options.isolated;
   const mode = getEffectiveMode(options);
   const startTime = getTimestamp();
@@ -404,9 +427,15 @@ async function runWithIsolation(options, cmd) {
   if (options.image) {
     console.log(`[Isolation] Image: ${options.image}`);
   }
+  if (options.endpoint) {
+    console.log(`[Isolation] Endpoint: ${options.endpoint}`);
+  }
   if (createdUser) {
     console.log(`[Isolation] User: ${createdUser} (isolated)`);
   }
+  if (useCommandStream) {
+    console.log(`[Isolation] Using command-stream library`);
+  }
   console.log('');
 
   // Create log content
@@ -423,10 +452,13 @@ async function runWithIsolation(options, cmd) {
   let result;
 
   if (environment) {
-    // Run in isolation backend (screen, tmux, docker)
+    // Run in isolation backend (screen, tmux, docker, ssh)
+    // Note: Isolation backends currently use native spawn/execSync
+    // Future: Add command-stream support with raw() function for multiplexers
     result = await runIsolated(environment, cmd, {
       session: options.session,
       image: options.image,
+      endpoint: options.endpoint,
       detached: mode === 'detached',
       user: createdUser,
       keepAlive: options.keepAlive,
@@ -481,7 +513,7 @@ async function runWithIsolation(options, cmd) {
 }
 
 /**
- * Run command directly (without isolation)
+ * Run command directly (without isolation) - original synchronous version
  * @param {string} cmd - Command to execute
  */
 function runDirect(cmd) {
@@ -576,7 +608,7 @@ function runDirect(cmd) {
 
     // If command failed, try to auto-report
     if (exitCode !== 0) {
-      handleFailure(commandName, cmd, exitCode, logFilePath, logContent);
+      handleFailure(config, commandName, cmd, exitCode, logFilePath);
     }
 
     process.exit(exitCode);
@@ -605,379 +637,130 @@ function runDirect(cmd) {
     console.log(`Exit code: 1`);
     console.log(`Log saved: ${logFilePath}`);
 
-    handleFailure(commandName, cmd, 1, logFilePath, logContent);
+    handleFailure(config, commandName, cmd, 1, logFilePath);
 
     process.exit(1);
   });
 }
 
 /**
- * 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`;
-}
-
-/**
- * Handle command failure - detect repository, upload log, create issue
+ * Run command directly using command-stream library (experimental)
+ * @param {string} cmd - Command to execute
+ * @param {string} parsedCmd - Original parsed command
+ * @param {object} subResult - Result from substitution engine
  */
-function handleFailure(cmdName, fullCommand, exitCode, logPath) {
-  console.log('');
+async function runDirectWithCommandStream(cmd, parsedCmd, subResult) {
+  // Lazy load command-stream
+  const { getCommandStream } = require('../lib/command-stream');
+  const { $, raw } = await getCommandStream();
 
-  // Check if auto-issue is disabled
-  if (config.disableAutoIssue) {
-    if (config.verbose) {
-      console.log('Auto-issue creation disabled via START_DISABLE_AUTO_ISSUE');
-    }
-    return;
-  }
+  // Get the command name (first word of the actual command to execute)
+  const commandName = cmd.split(' ')[0];
 
-  // Try to detect repository for the command
-  const repoInfo = detectRepository(cmdName);
+  // Determine the shell based on the platform
+  const isWindows = process.platform === 'win32';
+  const shell = isWindows ? 'powershell.exe' : process.env.SHELL || '/bin/sh';
 
-  if (!repoInfo) {
-    console.log('Repository not detected - automatic issue creation skipped');
-    return;
-  }
+  // Setup logging
+  const logDir = config.logDir || os.tmpdir();
+  const logFilename = generateLogFilename();
+  const logFilePath = path.join(logDir, logFilename);
 
-  console.log(`Detected repository: ${repoInfo.url}`);
+  let logContent = '';
+  const startTime = getTimestamp();
 
-  // Check if gh CLI is available and authenticated
-  if (!isGhAuthenticated()) {
-    console.log(
-      'GitHub CLI not authenticated - automatic issue creation skipped'
-    );
-    console.log('Run "gh auth login" to enable automatic issue creation');
-    return;
-  }
+  // Get runtime information
+  const runtime = typeof Bun !== 'undefined' ? 'Bun' : 'Node.js';
+  const runtimeVersion =
+    typeof Bun !== 'undefined' ? Bun.version : process.version;
 
-  // Try to upload log
-  let logUrl = null;
-  if (config.disableLogUpload) {
-    if (config.verbose) {
-      console.log('Log upload disabled via START_DISABLE_LOG_UPLOAD');
-    }
-  } else if (isGhUploadLogAvailable()) {
-    logUrl = uploadLog(logPath);
-    if (logUrl) {
-      console.log(`Log uploaded: ${logUrl}`);
-    }
+  // Log header
+  logContent += `=== Start Command Log ===\n`;
+  logContent += `Timestamp: ${startTime}\n`;
+  logContent += `Execution Mode: command-stream\n`;
+  if (subResult && subResult.matched) {
+    logContent += `Original Input: ${parsedCmd}\n`;
+    logContent += `Substituted Command: ${cmd}\n`;
+    logContent += `Pattern Matched: ${subResult.rule.pattern}\n`;
   } else {
-    console.log('gh-upload-log not installed - log upload skipped');
-    console.log('Install with: bun install -g gh-upload-log');
-  }
-
-  // Check if we can create issues in this repository
-  if (!canCreateIssue(repoInfo.owner, repoInfo.repo)) {
-    console.log('Cannot create issue in repository - skipping issue creation');
-    return;
+    logContent += `Command: ${cmd}\n`;
   }
+  logContent += `Shell: ${shell}\n`;
+  logContent += `Platform: ${process.platform}\n`;
+  logContent += `${runtime} Version: ${runtimeVersion}\n`;
+  logContent += `Working Directory: ${process.cwd()}\n`;
+  logContent += `${'='.repeat(50)}\n\n`;
 
-  // Create issue
-  const issueUrl = createIssue(
-    repoInfo,
-    fullCommand,
-    exitCode,
-    logUrl,
-    logPath
-  );
-  if (issueUrl) {
-    console.log(`Issue created: ${issueUrl}`);
+  // Print start message to console
+  if (subResult && subResult.matched) {
+    console.log(`[${startTime}] Input: ${parsedCmd}`);
+    console.log(`[${startTime}] Executing: ${cmd}`);
+  } else {
+    console.log(`[${startTime}] Starting: ${cmd}`);
   }
-}
+  console.log('[command-stream] Using command-stream library');
+  console.log('');
 
-/**
- * Detect repository URL for a command (currently supports NPM global packages)
- */
-function detectRepository(cmdName) {
-  const isWindows = process.platform === 'win32';
+  // Execute the command using command-stream with real-time output
+  // Using mirror: true to show output in real-time, capture: true to collect it
+  // Using raw() to avoid auto-escaping that might interfere with complex shell commands
+  const $cmd = $({ mirror: true, capture: true });
 
+  let exitCode = 0;
   try {
-    // Find command location
-    const whichCmd = isWindows ? 'where' : 'which';
-    let cmdPath;
-
-    try {
-      cmdPath = execSync(`${whichCmd} ${cmdName}`, {
-        encoding: 'utf8',
-        stdio: ['pipe', 'pipe', 'pipe'],
-      }).trim();
-    } catch {
-      return null;
+    // 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)}`;
+    exitCode = result.code || 0;
+
+    // Collect output for log
+    if (result.stdout) {
+      logContent += result.stdout;
     }
-
-    if (!cmdPath) {
-      return null;
-    }
-
-    // Handle Windows where command that returns multiple lines
-    if (isWindows && cmdPath.includes('\n')) {
-      cmdPath = cmdPath.split('\n')[0].trim();
+    if (result.stderr) {
+      logContent += result.stderr;
     }
-
-    // Check if it's in npm global modules
-    let npmGlobalPath;
-    try {
-      npmGlobalPath = execSync('npm root -g', {
-        encoding: 'utf8',
-        stdio: ['pipe', 'pipe', 'pipe'],
-      }).trim();
-    } catch {
-      return null;
-    }
-
-    // Get the npm bin directory (parent of node_modules)
-    const npmBinPath = `${path.dirname(npmGlobalPath)}/bin`;
-
-    // Check if the command is located in the npm bin directory or node_modules
-    let packageName = null;
-    let isNpmPackage = false;
-
-    try {
-      // Try to resolve the symlink to find the actual path
-      const realPath = fs.realpathSync(cmdPath);
-
-      // Check if the real path is within node_modules
-      if (realPath.includes('node_modules')) {
-        isNpmPackage = true;
-        const npmPathMatch = realPath.match(/node_modules\/([^/]+)/);
-        if (npmPathMatch) {
-          packageName = npmPathMatch[1];
-        }
-      }
-
-      // Also check if the command path itself is in npm's bin directory
-      if (!isNpmPackage && cmdPath.includes(npmBinPath)) {
-        isNpmPackage = true;
-      }
-
-      // Try to read the bin script to extract package info
-      if (!packageName) {
-        const binContent = fs.readFileSync(cmdPath, 'utf8');
-
-        // Check if this is a Node.js script
-        if (
-          binContent.startsWith('#!/usr/bin/env node') ||
-          binContent.includes('node_modules')
-        ) {
-          isNpmPackage = true;
-
-          // Look for package path in the script
-          const packagePathMatch = binContent.match(/node_modules\/([^/'"]+)/);
-          if (packagePathMatch) {
-            packageName = packagePathMatch[1];
-          }
-        }
-      }
-    } catch {
-      // Could not read/resolve command - not an npm package
-      return null;
-    }
-
-    // If we couldn't confirm this is an npm package, don't proceed
-    if (!isNpmPackage) {
-      return null;
-    }
-
-    // If we couldn't find the package name from the path, use the command name
-    if (!packageName) {
-      packageName = cmdName;
-    }
-
-    // Try to get repository URL from npm
-    try {
-      const npmInfo = execSync(
-        `npm view ${packageName} repository.url 2>/dev/null`,
-        {
-          encoding: 'utf8',
-          stdio: ['pipe', 'pipe', 'pipe'],
-        }
-      ).trim();
-
-      if (npmInfo) {
-        // Parse git URL to extract owner and repo
-        const parsed = parseGitUrl(npmInfo);
-        if (parsed) {
-          return parsed;
-        }
-      }
-    } catch {
-      // npm view failed, package might not exist or have no repository
-    }
-
-    // Try to get homepage or bugs URL as fallback
-    try {
-      const bugsUrl = execSync(`npm view ${packageName} bugs.url 2>/dev/null`, {
-        encoding: 'utf8',
-        stdio: ['pipe', 'pipe', 'pipe'],
-      }).trim();
-
-      if (bugsUrl && bugsUrl.includes('github.com')) {
-        const parsed = parseGitUrl(bugsUrl);
-        if (parsed) {
-          return parsed;
-        }
-      }
-    } catch {
-      // Fallback also failed
-    }
-
-    return null;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Parse a git URL to extract owner, repo, and normalized URL
- */
-function parseGitUrl(url) {
-  if (!url) {
-    return null;
+  } catch (err) {
+    exitCode = err.code || 1;
+    const errorMessage = `Error executing command: ${err.message}`;
+    logContent += `\n${errorMessage}\n`;
+    console.error(`\n${errorMessage}`);
   }
 
-  // Handle various git URL formats
-  // git+https://github.com/owner/repo.git
-  // git://github.com/owner/repo.git
-  // https://github.com/owner/repo.git
-  // https://github.com/owner/repo
-  // git@github.com:owner/repo.git
-  // https://github.com/owner/repo/issues
-
-  const match = url.match(/github\.com[/:]([^/]+)\/([^/.]+)/);
-  if (match) {
-    const owner = match[1];
-    const repo = match[2].replace(/\.git$/, '');
-    return {
-      owner,
-      repo,
-      url: `https://github.com/${owner}/${repo}`,
-    };
-  }
+  const endTime = getTimestamp();
 
-  return null;
-}
+  // Log footer
+  logContent += `\n${'='.repeat(50)}\n`;
+  logContent += `Finished: ${endTime}\n`;
+  logContent += `Exit Code: ${exitCode}\n`;
 
-/**
- * Check if GitHub CLI is authenticated
- */
-function isGhAuthenticated() {
-  try {
-    execSync('gh auth status', { stdio: ['pipe', 'pipe', 'pipe'] });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Check if gh-upload-log is available
- */
-function isGhUploadLogAvailable() {
-  const isWindows = process.platform === 'win32';
+  // Write log file
   try {
-    const whichCmd = isWindows ? 'where' : 'which';
-    execSync(`${whichCmd} gh-upload-log`, { stdio: ['pipe', 'pipe', 'pipe'] });
-    return true;
-  } catch {
-    return false;
+    fs.writeFileSync(logFilePath, logContent, 'utf8');
+  } catch (err) {
+    console.error(`\nWarning: Could not save log file: ${err.message}`);
   }
-}
 
-/**
- * Upload log file using gh-upload-log
- */
-function uploadLog(logPath) {
-  try {
-    const result = execSync(`gh-upload-log "${logPath}" --public`, {
-      encoding: 'utf8',
-      stdio: ['pipe', 'pipe', 'pipe'],
-    });
-
-    // Extract URL from output
-    const urlMatch = result.match(/https:\/\/gist\.github\.com\/[^\s]+/);
-    if (urlMatch) {
-      return urlMatch[0];
-    }
-
-    // Try other URL patterns
-    const repoUrlMatch = result.match(/https:\/\/github\.com\/[^\s]+/);
-    if (repoUrlMatch) {
-      return repoUrlMatch[0];
-    }
+  // Print footer to console
+  console.log('');
+  console.log(`[${endTime}] Finished`);
+  console.log(`Exit code: ${exitCode}`);
+  console.log(`Log saved: ${logFilePath}`);
 
-    return null;
-  } catch (err) {
-    console.log(`Warning: Log upload failed - ${err.message}`);
-    return null;
+  // If command failed, try to auto-report
+  if (exitCode !== 0) {
+    handleFailure(config, commandName, cmd, exitCode, logFilePath);
   }
-}
 
-/**
- * Check if we can create an issue in a repository
- */
-function canCreateIssue(owner, repo) {
-  try {
-    // Check if the repository exists and we have access
-    execSync(`gh repo view ${owner}/${repo} --json name`, {
-      stdio: ['pipe', 'pipe', 'pipe'],
-    });
-    return true;
-  } catch {
-    return false;
-  }
+  process.exit(exitCode);
 }
 
 /**
- * Create an issue in the repository
+ * Generate unique log filename for direct execution
+ * @returns {string} Log filename
  */
-function createIssue(repoInfo, fullCommand, exitCode, logUrl) {
-  try {
-    const title = `Command failed with exit code ${exitCode}: ${fullCommand.substring(0, 50)}${fullCommand.length > 50 ? '...' : ''}`;
-
-    // Get runtime information
-    const runtime = typeof Bun !== 'undefined' ? 'Bun' : 'Node.js';
-    const runtimeVersion =
-      typeof Bun !== 'undefined' ? Bun.version : process.version;
-
-    let body = `## Command Execution Failure Report\n\n`;
-    body += `**Command:** \`${fullCommand}\`\n\n`;
-    body += `**Exit Code:** ${exitCode}\n\n`;
-    body += `**Timestamp:** ${getTimestamp()}\n\n`;
-    body += `### System Information\n\n`;
-    body += `- **Platform:** ${process.platform}\n`;
-    body += `- **OS Release:** ${os.release()}\n`;
-    body += `- **${runtime} Version:** ${runtimeVersion}\n`;
-    body += `- **Architecture:** ${process.arch}\n\n`;
-
-    if (logUrl) {
-      body += `### Log File\n\n`;
-      body += `Full log available at: ${logUrl}\n\n`;
-    }
-
-    body += `---\n`;
-    body += `*This issue was automatically created by [start-command](https://github.com/link-foundation/start)*\n`;
-
-    const result = execSync(
-      `gh issue create --repo ${repoInfo.owner}/${repoInfo.repo} --title "${title.replace(/"/g, '\\"')}" --body "${body.replace(/"/g, '\\"').replace(/\n/g, '\\n')}"`,
-      {
-        encoding: 'utf8',
-        stdio: ['pipe', 'pipe', 'pipe'],
-      }
-    );
-
-    // Extract issue URL from output
-    const urlMatch = result.match(/https:\/\/github\.com\/[^\s]+/);
-    if (urlMatch) {
-      return urlMatch[0];
-    }
-
-    return null;
-  } catch (err) {
-    console.log(`Warning: Issue creation failed - ${err.message}`);
-    return null;
-  }
+function generateLogFilename() {
+  const timestamp = Date.now();
+  const random = Math.random().toString(36).substring(2, 8);
+  return `start-command-${timestamp}-${random}.log`;
 }