start-command 0.13.0 → 0.15.0

package/src/lib/isolation.js

@@ -914,6 +914,56 @@ function runAsIsolatedUser(cmd, username) {
   });
 }
 
+/**
+ * Check if the Docker daemon can run Linux container images
+ * On Windows with Docker Desktop in Windows containers mode,
+ * Linux images like alpine:latest cannot be pulled or run.
+ * @returns {boolean} True if Linux Docker images can be run
+ */
+function canRunLinuxDockerImages() {
+  if (!isCommandAvailable('docker')) {
+    return false;
+  }
+
+  try {
+    // First check if Docker daemon is running
+    execSync('docker info', { stdio: ['pipe', 'pipe', 'pipe'], timeout: 5000 });
+
+    // On Windows, check if Docker is configured for Linux containers
+    if (process.platform === 'win32') {
+      try {
+        const osType = execSync('docker info --format "{{.OSType}}"', {
+          encoding: 'utf8',
+          stdio: ['pipe', 'pipe', 'pipe'],
+          timeout: 5000,
+        }).trim();
+
+        // Docker must be using Linux containers to run Linux images
+        if (osType !== 'linux') {
+          if (DEBUG) {
+            console.log(
+              `[DEBUG] Docker is running in ${osType} containers mode, cannot run Linux images`
+            );
+          }
+          return false;
+        }
+      } catch {
+        // If we can't determine the OS type, assume Linux images won't work on Windows
+        if (DEBUG) {
+          console.log(
+            '[DEBUG] Could not determine Docker OS type, assuming Linux images unavailable'
+          );
+        }
+        return false;
+      }
+    }
+
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 module.exports = {
   isCommandAvailable,
   hasTTY,
@@ -934,4 +984,5 @@ module.exports = {
   getScreenVersion,
   supportsLogfileOption,
   resetScreenVersionCache,
+  canRunLinuxDockerImages,
 };

package/src/lib/status-formatter.js

@@ -0,0 +1,121 @@
+/**
+ * Status formatter module for execution records
+ *
+ * Provides formatting functions for execution status output in various formats:
+ * - Links Notation (links-notation): Structured link doublet format
+ * - JSON: Standard JSON output
+ * - Text: Human-readable text format
+ */
+
+/**
+ * Format execution record as Links Notation (indented style)
+ * @param {Object} record - The execution record with toObject() method
+ * @returns {string} Links Notation formatted string in indented style
+ *
+ * Output format:
+ * <uuid>
+ *   <key> "<value>"
+ *   ...
+ */
+function formatRecordAsLinksNotation(record) {
+  const obj = record.toObject();
+  const lines = [record.uuid];
+
+  for (const [key, value] of Object.entries(obj)) {
+    if (value !== null && value !== undefined) {
+      // Format value based on type
+      let formattedValue;
+      if (typeof value === 'object') {
+        formattedValue = JSON.stringify(value);
+      } else {
+        formattedValue = String(value);
+      }
+      // Escape quotes in the value
+      const escapedValue = formattedValue.replace(/"/g, '\\"');
+      lines.push(`  ${key} "${escapedValue}"`);
+    }
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Format execution record as human-readable text
+ * @param {Object} record - The execution record with toObject() method
+ * @returns {string} Human-readable text
+ */
+function formatRecordAsText(record) {
+  const obj = record.toObject();
+  const lines = [
+    `Execution Status`,
+    `${'='.repeat(50)}`,
+    `UUID:              ${obj.uuid}`,
+    `Status:            ${obj.status}`,
+    `Command:           ${obj.command}`,
+    `Exit Code:         ${obj.exitCode !== null ? obj.exitCode : 'N/A'}`,
+    `PID:               ${obj.pid !== null ? obj.pid : 'N/A'}`,
+    `Working Directory: ${obj.workingDirectory}`,
+    `Shell:             ${obj.shell}`,
+    `Platform:          ${obj.platform}`,
+    `Start Time:        ${obj.startTime}`,
+    `End Time:          ${obj.endTime || 'N/A'}`,
+    `Log Path:          ${obj.logPath}`,
+  ];
+
+  if (Object.keys(obj.options).length > 0) {
+    lines.push(`Options:           ${JSON.stringify(obj.options)}`);
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Format execution record based on format type
+ * @param {Object} record - The execution record
+ * @param {string} format - Output format (links-notation, json, text)
+ * @returns {string} Formatted output string
+ */
+function formatRecord(record, format) {
+  switch (format) {
+    case 'links-notation':
+      return formatRecordAsLinksNotation(record);
+    case 'json':
+      return JSON.stringify(record.toObject(), null, 2);
+    case 'text':
+      return formatRecordAsText(record);
+    default:
+      throw new Error(`Unknown output format: ${format}`);
+  }
+}
+
+/**
+ * Handle status query and output the result
+ * @param {Object} store - ExecutionStore instance
+ * @param {string} uuid - UUID of the execution to query
+ * @param {string|null} outputFormat - Output format (links-notation, json, text)
+ * @returns {{success: boolean, output?: string, error?: string}}
+ */
+function queryStatus(store, uuid, outputFormat) {
+  if (!store) {
+    return { success: false, error: 'Execution tracking is disabled.' };
+  }
+  const record = store.get(uuid);
+  if (!record) {
+    return { success: false, error: `No execution found with UUID: ${uuid}` };
+  }
+  try {
+    return {
+      success: true,
+      output: formatRecord(record, outputFormat || 'links-notation'),
+    };
+  } catch (err) {
+    return { success: false, error: err.message };
+  }
+}
+
+module.exports = {
+  formatRecordAsLinksNotation,
+  formatRecordAsText,
+  formatRecord,
+  queryStatus,
+};

package/src/lib/version.js

@@ -0,0 +1,143 @@
+/**
+ * Version and tool information utilities
+ */
+
+const os = require('os');
+const { execSync, spawnSync } = require('child_process');
+
+/**
+ * Print version information
+ * @param {boolean} verbose - Whether to show verbose debugging info
+ */
+function printVersion(verbose = false) {
+  // Get package version
+  const packageJson = require('../../package.json');
+  const startCommandVersion = packageJson.version;
+
+  console.log(`start-command version: ${startCommandVersion}`);
+  console.log('');
+
+  // Get runtime information (Bun or Node.js)
+  const runtime = typeof Bun !== 'undefined' ? 'Bun' : 'Node.js';
+  const runtimeVersion =
+    typeof Bun !== 'undefined' ? Bun.version : process.version;
+
+  // Get OS information
+  console.log(`OS: ${process.platform}`);
+
+  // Get OS version (use sw_vers on macOS for user-friendly version)
+  let osVersion = os.release();
+  if (process.platform === 'darwin') {
+    try {
+      osVersion = execSync('sw_vers -productVersion', {
+        encoding: 'utf8',
+        timeout: 5000,
+      }).trim();
+      if (verbose) {
+        console.log(`[verbose] macOS version from sw_vers: ${osVersion}`);
+      }
+    } catch {
+      // Fallback to kernel version if sw_vers fails
+      osVersion = os.release();
+      if (verbose) {
+        console.log(
+          `[verbose] sw_vers failed, using kernel version: ${osVersion}`
+        );
+      }
+    }
+  }
+
+  console.log(`OS Version: ${osVersion}`);
+  console.log(`${runtime} Version: ${runtimeVersion}`);
+  console.log(`Architecture: ${process.arch}`);
+  console.log('');
+
+  // Check for installed isolation tools
+  console.log('Isolation tools:');
+
+  if (verbose) {
+    console.log('[verbose] Checking isolation tools...');
+  }
+
+  // Check screen (use -v flag for compatibility with older versions)
+  const screenVersion = getToolVersion('screen', '-v', verbose);
+  if (screenVersion) {
+    console.log(`  screen: ${screenVersion}`);
+  } else {
+    console.log('  screen: not installed');
+  }
+
+  // Check tmux
+  const tmuxVersion = getToolVersion('tmux', '-V', verbose);
+  if (tmuxVersion) {
+    console.log(`  tmux: ${tmuxVersion}`);
+  } else {
+    console.log('  tmux: not installed');
+  }
+
+  // Check docker
+  const dockerVersion = getToolVersion('docker', '--version', verbose);
+  if (dockerVersion) {
+    console.log(`  docker: ${dockerVersion}`);
+  } else {
+    console.log('  docker: not installed');
+  }
+}
+
+/**
+ * Get version of an installed tool
+ * @param {string} toolName - Name of the tool
+ * @param {string} versionFlag - Flag to get version (e.g., '--version', '-V')
+ * @param {boolean} verbose - Whether to log verbose information
+ * @returns {string|null} Version string or null if not installed
+ */
+function getToolVersion(toolName, versionFlag, verbose = false) {
+  const isWindows = process.platform === 'win32';
+  const whichCmd = isWindows ? 'where' : 'which';
+
+  // First, check if the tool exists in PATH
+  try {
+    execSync(`${whichCmd} ${toolName}`, {
+      encoding: 'utf8',
+      timeout: 5000,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+  } catch {
+    // Tool not found in PATH
+    if (verbose) {
+      console.log(`[verbose] ${toolName}: not found in PATH`);
+    }
+    return null;
+  }
+
+  // Tool exists, try to get version using spawnSync
+  // This captures output regardless of exit code (some tools like older screen
+  // versions return non-zero exit code even when showing version successfully)
+  const result = spawnSync(toolName, [versionFlag], {
+    encoding: 'utf8',
+    timeout: 5000,
+    shell: false,
+  });
+
+  // Combine stdout and stderr (some tools output version to stderr)
+  const output = ((result.stdout || '') + (result.stderr || '')).trim();
+
+  if (verbose) {
+    console.log(
+      `[verbose] ${toolName} ${versionFlag}: exit=${result.status}, output="${output.substring(0, 100)}"`
+    );
+  }
+
+  if (!output) {
+    return null;
+  }
+
+  // Return the first line of output
+  const firstLine = output.split('\n')[0];
+  return firstLine || null;
+}
+
+module.exports = {
+  printVersion,
+  getToolVersion,
+};

package/test/args-parser.test.js

@@ -13,6 +13,7 @@ const {
   hasIsolation,
   getEffectiveMode,
   VALID_BACKENDS,
+  VALID_OUTPUT_FORMATS,
 } = require('../src/lib/args-parser');
 
 describe('parseArgs', () => {
@@ -782,3 +783,109 @@ describe('keep-user option', () => {
     assert.strictEqual(result.wrapperOptions.keepUser, true);
   });
 });
+
+describe('status option', () => {
+  it('should parse --status with UUID', () => {
+    const uuid = '12345678-1234-1234-1234-123456789abc';
+    const result = parseArgs(['--status', uuid]);
+    assert.strictEqual(result.wrapperOptions.status, uuid);
+    assert.strictEqual(result.command, '');
+  });
+
+  it('should parse --status=value format', () => {
+    const uuid = '12345678-1234-1234-1234-123456789abc';
+    const result = parseArgs([`--status=${uuid}`]);
+    assert.strictEqual(result.wrapperOptions.status, uuid);
+  });
+
+  it('should throw error for missing UUID argument', () => {
+    assert.throws(() => {
+      parseArgs(['--status']);
+    }, /requires a UUID argument/);
+  });
+
+  it('should throw error for --status with -flag as next argument', () => {
+    assert.throws(() => {
+      parseArgs(['--status', '--output-format']);
+    }, /requires a UUID argument/);
+  });
+
+  it('should default status to null', () => {
+    const result = parseArgs(['echo', 'hello']);
+    assert.strictEqual(result.wrapperOptions.status, null);
+  });
+});
+
+describe('output-format option', () => {
+  it('should parse --output-format with --status', () => {
+    const uuid = '12345678-1234-1234-1234-123456789abc';
+    const result = parseArgs([
+      '--status',
+      uuid,
+      '--output-format',
+      'links-notation',
+    ]);
+    assert.strictEqual(result.wrapperOptions.status, uuid);
+    assert.strictEqual(result.wrapperOptions.outputFormat, 'links-notation');
+  });
+
+  it('should parse --output-format=value format', () => {
+    const uuid = '12345678-1234-1234-1234-123456789abc';
+    const result = parseArgs(['--status', uuid, '--output-format=json']);
+    assert.strictEqual(result.wrapperOptions.outputFormat, 'json');
+  });
+
+  it('should normalize format to lowercase', () => {
+    const uuid = '12345678-1234-1234-1234-123456789abc';
+    const result = parseArgs(['--status', uuid, '--output-format', 'JSON']);
+    assert.strictEqual(result.wrapperOptions.outputFormat, 'json');
+  });
+
+  it('should throw error for missing format argument', () => {
+    const uuid = '12345678-1234-1234-1234-123456789abc';
+    assert.throws(() => {
+      parseArgs(['--status', uuid, '--output-format']);
+    }, /requires a format argument/);
+  });
+
+  it('should throw error for invalid format', () => {
+    const uuid = '12345678-1234-1234-1234-123456789abc';
+    assert.throws(() => {
+      parseArgs(['--status', uuid, '--output-format', 'invalid']);
+    }, /Invalid output format/);
+  });
+
+  it('should throw error for output-format without status', () => {
+    assert.throws(() => {
+      parseArgs(['--output-format', 'json', '--', 'npm', 'test']);
+    }, /--output-format option is only valid with --status/);
+  });
+
+  it('should accept all valid output formats', () => {
+    const uuid = '12345678-1234-1234-1234-123456789abc';
+    for (const format of VALID_OUTPUT_FORMATS) {
+      assert.doesNotThrow(() => {
+        parseArgs(['--status', uuid, '--output-format', format]);
+      });
+    }
+  });
+
+  it('should default outputFormat to null', () => {
+    const result = parseArgs(['echo', 'hello']);
+    assert.strictEqual(result.wrapperOptions.outputFormat, null);
+  });
+});
+
+describe('VALID_OUTPUT_FORMATS', () => {
+  it('should include links-notation', () => {
+    assert.ok(VALID_OUTPUT_FORMATS.includes('links-notation'));
+  });
+
+  it('should include json', () => {
+    assert.ok(VALID_OUTPUT_FORMATS.includes('json'));
+  });
+
+  it('should include text', () => {
+    assert.ok(VALID_OUTPUT_FORMATS.includes('text'));
+  });
+});

package/test/cli.test.js

@@ -13,10 +13,14 @@ const fs = require('fs');
 // Path to the CLI script
 const CLI_PATH = path.join(__dirname, '../src/bin/cli.js');
 
-// Helper to run CLI
+// Timeout for CLI operations - longer on Windows due to cold-start latency
+const CLI_TIMEOUT = process.platform === 'win32' ? 30000 : 10000;
+
+// Helper to run CLI with timeout
 function runCLI(args = []) {
   return spawnSync('bun', [CLI_PATH, ...args], {
     encoding: 'utf8',
+    timeout: CLI_TIMEOUT,
     env: {
       ...process.env,
       START_DISABLE_AUTO_ISSUE: '1',
@@ -29,6 +33,12 @@ describe('CLI version flag', () => {
   it('should display version with --version', () => {
     const result = runCLI(['--version']);
 
+    // Check if process was killed (e.g., due to timeout)
+    assert.notStrictEqual(
+      result.status,
+      null,
+      `Process should complete (was killed with signal: ${result.signal})`
+    );
     assert.strictEqual(result.status, 0, 'Exit code should be 0');
 
     // Check for key elements in version output

package/test/docker-autoremove.test.js

@@ -21,18 +21,9 @@ async function waitFor(conditionFn, timeout = 5000, interval = 100) {
   return false;
 }
 
-// Helper function to check if docker daemon is running
-function isDockerRunning() {
-  if (!isCommandAvailable('docker')) {
-    return false;
-  }
-  try {
-    execSync('docker info', { stdio: 'ignore', timeout: 5000 });
-    return true;
-  } catch {
-    return false;
-  }
-}
+// Use the canRunLinuxDockerImages function from isolation module
+// to properly detect if Linux containers can run (handles Windows containers mode)
+const { canRunLinuxDockerImages } = require('../src/lib/isolation');
 
 describe('Docker Auto-Remove Container Feature', () => {
   // These tests verify the --auto-remove-docker-container option
@@ -40,8 +31,10 @@ describe('Docker Auto-Remove Container Feature', () => {
 
   describe('auto-remove enabled', () => {
     it('should automatically remove container when autoRemoveDockerContainer is true', async () => {
-      if (!isDockerRunning()) {
-        console.log('  Skipping: docker not available or daemon not running');
+      if (!canRunLinuxDockerImages()) {
+        console.log(
+          '  Skipping: docker not available, daemon not running, or Linux containers not supported'
+        );
         return;
       }
 
@@ -103,8 +96,10 @@ describe('Docker Auto-Remove Container Feature', () => {
 
   describe('auto-remove disabled (default)', () => {
     it('should preserve container filesystem by default (without autoRemoveDockerContainer)', async () => {
-      if (!isDockerRunning()) {
-        console.log('  Skipping: docker not available or daemon not running');
+      if (!canRunLinuxDockerImages()) {
+        console.log(
+          '  Skipping: docker not available, daemon not running, or Linux containers not supported'
+        );
         return;
       }