start-command 0.15.0 → 0.17.0

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # start-command
 
+## 0.17.0
+
+### Minor Changes
+
+- 1da275c: feat: Improve output block uniformity and add OS-based Docker image detection
+  - Move isolation info lines into start block instead of printing them separately
+  - Move exit/result messages into finish block instead of printing them separately
+  - Add getDefaultDockerImage() to detect host OS and select matching Docker image
+  - Default Docker images: ubuntu, debian, archlinux, fedora, centos based on host OS
+
+## 0.16.0
+
+### Minor Changes
+
+- 35f3505: feat: Improve command output formatting with human-readable timestamps and duration
+  - Changed timestamp format from `[timestamp] Starting:` to `Starting at timestamp:`
+  - Changed finish message from `[timestamp] Finished` to `Finished at timestamp in X.XXX seconds`
+  - Added performance metric showing command execution duration
+  - Added `formatDuration` helper function for consistent duration formatting
+
 ## 0.15.0
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "start-command",
-  "version": "0.15.0",
+  "version": "0.17.0",
   "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

@@ -22,6 +22,7 @@ const {
   createLogFooter,
   writeLogFile,
   createLogPath,
+  getDefaultDockerImage,
 } = require('../lib/isolation');
 const {
   createIsolatedUser,
@@ -33,6 +34,7 @@ const { handleFailure } = require('../lib/failure-handler');
 const { ExecutionStore, ExecutionRecord } = require('../lib/execution-store');
 const { queryStatus } = require('../lib/status-formatter');
 const { printVersion } = require('../lib/version');
+const { createStartBlock, createFinishBlock } = require('../lib/output-blocks');
 
 // Configuration from environment variables
 const config = {
@@ -283,6 +285,13 @@ async function runWithIsolation(
   const environment = options.isolated;
   const mode = getEffectiveMode(options);
   const startTime = getTimestamp();
+  const startTimeMs = Date.now();
+
+  // Use default Docker image if docker isolation is selected but no image specified
+  let effectiveImage = options.image;
+  if (environment === 'docker' && !effectiveImage) {
+    effectiveImage = getDefaultDockerImage();
+  }
 
   // Create log file path
   const logFilePath = createLogPath(environment || 'direct');
@@ -296,32 +305,8 @@ async function runWithIsolation(
   const isWindows = process.platform === 'win32';
   const shell = isWindows ? 'powershell.exe' : process.env.SHELL || '/bin/sh';
 
-  // Create execution record for tracking with provided session ID
-  let executionRecord = null;
-  const store = getExecutionStore();
-  if (store) {
-    executionRecord = new ExecutionRecord({
-      uuid: sessionId, // Use the provided session ID
-      command: cmd,
-      logPath: logFilePath,
-      shell,
-      workingDirectory: process.cwd(),
-      options: {
-        isolated: environment,
-        isolationMode: mode,
-        sessionName,
-        image: options.image,
-        endpoint: options.endpoint,
-        user: options.user,
-        keepAlive: options.keepAlive,
-        useCommandStream,
-      },
-    });
-  }
-
-  // Print session UUID at start
-  console.log(sessionId);
-  console.log('');
+  // Collect isolation info lines for start block
+  const extraLines = [];
 
   // Handle --isolated-user option: create a new user with same permissions
   let createdUser = null;
@@ -344,9 +329,9 @@ async function runWithIsolation(
       currentGroups.includes(g)
     );
 
-    console.log(`[User Isolation] Creating new user with same permissions...`);
+    extraLines.push('[User Isolation] Creating new user...');
     if (importantGroups.length > 0) {
-      console.log(
+      extraLines.push(
         `[User Isolation] Inheriting groups: ${importantGroups.join(', ')}`
       );
     }
@@ -361,41 +346,69 @@ async function runWithIsolation(
     }
 
     createdUser = userResult.username;
-    console.log(`[User Isolation] Created user: ${createdUser}`);
+    extraLines.push(`[User Isolation] Created user: ${createdUser}`);
     if (userResult.groups && userResult.groups.length > 0) {
-      console.log(
+      extraLines.push(
         `[User Isolation] User groups: ${userResult.groups.join(', ')}`
       );
     }
     if (options.keepUser) {
-      console.log(`[User Isolation] User will be kept after command completes`);
+      extraLines.push('[User Isolation] User will be kept after completion');
     }
-    console.log('');
   }
 
-  // Print start message (unified format)
-  console.log(`[${startTime}] Starting: ${cmd}`);
-  console.log('');
-
-  // Log isolation info
+  // Add isolation info to extra lines
   if (environment) {
-    console.log(`[Isolation] Environment: ${environment}, Mode: ${mode}`);
+    extraLines.push(`[Isolation] Environment: ${environment}, Mode: ${mode}`);
   }
   if (options.session) {
-    console.log(`[Isolation] Session: ${options.session}`);
+    extraLines.push(`[Isolation] Session: ${options.session}`);
   }
-  if (options.image) {
-    console.log(`[Isolation] Image: ${options.image}`);
+  if (effectiveImage) {
+    extraLines.push(`[Isolation] Image: ${effectiveImage}`);
   }
   if (options.endpoint) {
-    console.log(`[Isolation] Endpoint: ${options.endpoint}`);
+    extraLines.push(`[Isolation] Endpoint: ${options.endpoint}`);
   }
   if (createdUser) {
-    console.log(`[Isolation] User: ${createdUser} (isolated)`);
+    extraLines.push(`[Isolation] User: ${createdUser} (isolated)`);
   }
   if (useCommandStream) {
-    console.log(`[Isolation] Using command-stream library`);
+    extraLines.push('[Isolation] Using command-stream library');
   }
+
+  // Create execution record for tracking with provided session ID
+  let executionRecord = null;
+  const store = getExecutionStore();
+  if (store) {
+    executionRecord = new ExecutionRecord({
+      uuid: sessionId, // Use the provided session ID
+      command: cmd,
+      logPath: logFilePath,
+      shell,
+      workingDirectory: process.cwd(),
+      options: {
+        isolated: environment,
+        isolationMode: mode,
+        sessionName,
+        image: effectiveImage,
+        endpoint: options.endpoint,
+        user: options.user,
+        keepAlive: options.keepAlive,
+        useCommandStream,
+      },
+    });
+  }
+
+  // Print start block with session ID and isolation info
+  console.log(
+    createStartBlock({
+      sessionId,
+      timestamp: startTime,
+      command: cmd,
+      extraLines,
+    })
+  );
   console.log('');
 
   // Save initial execution record
@@ -417,7 +430,7 @@ async function runWithIsolation(
     environment: environment || 'direct',
     mode,
     sessionName,
-    image: options.image,
+    image: effectiveImage,
     user: createdUser,
     startTime,
   });
@@ -438,7 +451,7 @@ async function runWithIsolation(
     // Future: Add command-stream support with raw() function for multiplexers
     result = await runIsolated(environment, cmd, {
       session: options.session,
-      image: options.image,
+      image: effectiveImage,
       endpoint: options.endpoint,
       detached: mode === 'detached',
       user: createdUser,
@@ -479,34 +492,36 @@ async function runWithIsolation(
     }
   }
 
-  // Print result and footer (unified format)
-  console.log('');
-  console.log(result.message);
-  console.log('');
-  console.log(`[${endTime}] Finished`);
-  console.log(`Exit code: ${exitCode}`);
-  console.log(`Log saved: ${logFilePath}`);
-
   // Cleanup: delete the created user if we created one (unless --keep-user)
+  // This output goes to stdout but NOT inside the boxes - it's operational info
   if (createdUser && !options.keepUser) {
-    console.log('');
     console.log(`[User Isolation] Cleaning up user: ${createdUser}`);
     const deleteResult = deleteUser(createdUser, { removeHome: true });
     if (deleteResult.success) {
-      console.log(`[User Isolation] User deleted successfully`);
+      console.log('[User Isolation] User deleted successfully');
     } else {
       console.log(`[User Isolation] Warning: ${deleteResult.message}`);
     }
-  } else if (createdUser && options.keepUser) {
     console.log('');
+  } else if (createdUser && options.keepUser) {
     console.log(
       `[User Isolation] Keeping user: ${createdUser} (use 'sudo userdel -r ${createdUser}' to delete)`
     );
+    console.log('');
   }
 
-  // Print session UUID at end
-  console.log('');
-  console.log(sessionId);
+  // Print finish block with result message inside
+  const durationMs = Date.now() - startTimeMs;
+  console.log(
+    createFinishBlock({
+      sessionId,
+      timestamp: endTime,
+      exitCode,
+      logPath: logFilePath,
+      durationMs,
+      resultMessage: result.message,
+    })
+  );
 
   process.exit(exitCode);
 }
@@ -532,6 +547,7 @@ function runDirect(cmd, sessionId) {
 
   let logContent = '';
   const startTime = getTimestamp();
+  const startTimeMs = Date.now();
 
   // Get runtime information
   const runtime = typeof Bun !== 'undefined' ? 'Bun' : 'Node.js';
@@ -574,17 +590,18 @@ function runDirect(cmd, sessionId) {
   logContent += `Working Directory: ${process.cwd()}\n`;
   logContent += `${'='.repeat(50)}\n\n`;
 
-  // Print session UUID at start
-  console.log(sessionId);
-  console.log('');
-
-  // Print start message to console
-  if (substitutionResult && substitutionResult.matched) {
-    console.log(`[${startTime}] Input: ${parsedCommand}`);
-    console.log(`[${startTime}] Executing: ${cmd}`);
-  } else {
-    console.log(`[${startTime}] Starting: ${cmd}`);
-  }
+  // Print start block with session ID
+  const displayCommand =
+    substitutionResult && substitutionResult.matched
+      ? `${parsedCommand} -> ${cmd}`
+      : cmd;
+  console.log(
+    createStartBlock({
+      sessionId,
+      timestamp: startTime,
+      command: displayCommand,
+    })
+  );
   console.log('');
 
   // Execute the command with captured output
@@ -652,14 +669,18 @@ function runDirect(cmd, sessionId) {
       }
     }
 
-    // Print footer to console
-    console.log('');
-    console.log(`[${endTime}] Finished`);
-    console.log(`Exit code: ${exitCode}`);
-    console.log(`Log saved: ${logFilePath}`);
+    // Print finish block
+    const durationMs = Date.now() - startTimeMs;
     console.log('');
-    // Print session UUID at end
-    console.log(sessionId);
+    console.log(
+      createFinishBlock({
+        sessionId,
+        timestamp: endTime,
+        exitCode,
+        logPath: logFilePath,
+        durationMs,
+      })
+    );
 
     // If command failed, try to auto-report
     if (exitCode !== 0) {
@@ -672,6 +693,7 @@ function runDirect(cmd, sessionId) {
   // Handle spawn errors
   child.on('error', (err) => {
     const endTime = getTimestamp();
+    const durationMs = Date.now() - startTimeMs;
     const errorMessage = `Error executing command: ${err.message}`;
 
     logContent += `\n${errorMessage}\n`;
@@ -702,12 +724,15 @@ function runDirect(cmd, sessionId) {
 
     console.error(`\n${errorMessage}`);
     console.log('');
-    console.log(`[${endTime}] Finished`);
-    console.log(`Exit code: 1`);
-    console.log(`Log saved: ${logFilePath}`);
-    console.log('');
-    // Print session UUID at end
-    console.log(sessionId);
+    console.log(
+      createFinishBlock({
+        sessionId,
+        timestamp: endTime,
+        exitCode: 1,
+        logPath: logFilePath,
+        durationMs,
+      })
+    );
 
     handleFailure(config, commandName, cmd, 1, logFilePath);
 
@@ -746,6 +771,7 @@ async function runDirectWithCommandStream(
 
   let logContent = '';
   const startTime = getTimestamp();
+  const startTimeMs = Date.now();
 
   // Get runtime information
   const runtime = typeof Bun !== 'undefined' ? 'Bun' : 'Node.js';
@@ -790,17 +816,16 @@ async function runDirectWithCommandStream(
   logContent += `Working Directory: ${process.cwd()}\n`;
   logContent += `${'='.repeat(50)}\n\n`;
 
-  // Print session UUID at start
-  console.log(sessionId);
-  console.log('');
-
-  // 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}`);
-  }
+  // Print start block with session ID
+  const displayCmd =
+    subResult && subResult.matched ? `${parsedCmd} -> ${cmd}` : cmd;
+  console.log(
+    createStartBlock({
+      sessionId,
+      timestamp: startTime,
+      command: displayCmd,
+    })
+  );
   console.log('[command-stream] Using command-stream library');
   console.log('');
 
@@ -876,14 +901,18 @@ async function runDirectWithCommandStream(
     }
   }
 
-  // Print footer to console
-  console.log('');
-  console.log(`[${endTime}] Finished`);
-  console.log(`Exit code: ${exitCode}`);
-  console.log(`Log saved: ${logFilePath}`);
+  // Print finish block
+  const durationMs = Date.now() - startTimeMs;
   console.log('');
-  // Print session UUID at end
-  console.log(sessionId);
+  console.log(
+    createFinishBlock({
+      sessionId,
+      timestamp: endTime,
+      exitCode,
+      logPath: logFilePath,
+      durationMs,
+    })
+  );
 
   // If command failed, try to auto-report
   if (exitCode !== 0) {

package/src/lib/docker-utils.js

@@ -0,0 +1,89 @@
+/**
+ * Docker utilities for the start-command CLI
+ *
+ * Provides Docker-related helper functions like detecting the default
+ * Docker image based on the host operating system.
+ */
+
+const fs = require('fs');
+
+/**
+ * Get the default Docker image based on the host operating system
+ * Returns an image that matches the current OS as closely as possible:
+ * - macOS: Uses alpine (since macOS cannot run in Docker)
+ * - Ubuntu/Debian: Uses ubuntu:latest
+ * - Arch Linux: Uses archlinux:latest
+ * - Other Linux: Uses the detected distro or alpine as fallback
+ * - Windows: Uses alpine (Windows containers have limited support)
+ * @returns {string} Docker image name
+ */
+function getDefaultDockerImage() {
+  const platform = process.platform;
+
+  if (platform === 'darwin') {
+    // macOS cannot run in Docker containers, use alpine as lightweight alternative
+    return 'alpine:latest';
+  }
+
+  if (platform === 'win32') {
+    // Windows containers have limited support, use alpine for Linux containers
+    return 'alpine:latest';
+  }
+
+  if (platform === 'linux') {
+    // Try to detect the Linux distribution
+    try {
+      const osRelease = fs.readFileSync('/etc/os-release', 'utf8');
+
+      // Check for Ubuntu
+      if (
+        osRelease.includes('ID=ubuntu') ||
+        osRelease.includes('ID_LIKE=ubuntu') ||
+        osRelease.includes('ID_LIKE=debian ubuntu')
+      ) {
+        return 'ubuntu:latest';
+      }
+
+      // Check for Debian
+      if (
+        osRelease.includes('ID=debian') ||
+        osRelease.includes('ID_LIKE=debian')
+      ) {
+        return 'debian:latest';
+      }
+
+      // Check for Arch Linux
+      if (osRelease.includes('ID=arch') || osRelease.includes('ID_LIKE=arch')) {
+        return 'archlinux:latest';
+      }
+
+      // Check for Fedora
+      if (osRelease.includes('ID=fedora')) {
+        return 'fedora:latest';
+      }
+
+      // Check for CentOS/RHEL
+      if (
+        osRelease.includes('ID=centos') ||
+        osRelease.includes('ID=rhel') ||
+        osRelease.includes('ID_LIKE=rhel')
+      ) {
+        return 'centos:latest';
+      }
+
+      // Check for Alpine
+      if (osRelease.includes('ID=alpine')) {
+        return 'alpine:latest';
+      }
+    } catch {
+      // Cannot read /etc/os-release, fall through to default
+    }
+  }
+
+  // Default fallback: use alpine as a lightweight, universal option
+  return 'alpine:latest';
+}
+
+module.exports = {
+  getDefaultDockerImage,
+};

package/src/lib/isolation.js

@@ -964,6 +964,9 @@ function canRunLinuxDockerImages() {
   }
 }
 
+// Re-export getDefaultDockerImage from docker-utils for backwards compatibility
+const { getDefaultDockerImage } = require('./docker-utils');
+
 module.exports = {
   isCommandAvailable,
   hasTTY,
@@ -985,4 +988,5 @@ module.exports = {
   supportsLogfileOption,
   resetScreenVersionCache,
   canRunLinuxDockerImages,
+  getDefaultDockerImage,
 };

package/src/lib/output-blocks.js

@@ -0,0 +1,373 @@
+/**
+ * Output formatting utilities for nicely rendered command blocks
+ *
+ * Provides various styles for start/finish blocks to distinguish
+ * command output from the $ wrapper output.
+ *
+ * Available styles:
+ * 1. 'rounded' (default): Rounded unicode box borders (╭─╮ ╰─╯)
+ * 2. 'heavy': Heavy unicode box borders (┏━┓ ┗━┛)
+ * 3. 'double': Double line box borders (╔═╗ ╚═╝)
+ * 4. 'simple': Simple dash lines (────────)
+ * 5. 'ascii': Pure ASCII compatible (-------- +------+)
+ */
+
+// Box drawing characters for different styles
+const BOX_STYLES = {
+  rounded: {
+    topLeft: '╭',
+    topRight: '╮',
+    bottomLeft: '╰',
+    bottomRight: '╯',
+    horizontal: '─',
+    vertical: '│',
+  },
+  heavy: {
+    topLeft: '┏',
+    topRight: '┓',
+    bottomLeft: '┗',
+    bottomRight: '┛',
+    horizontal: '━',
+    vertical: '┃',
+  },
+  double: {
+    topLeft: '╔',
+    topRight: '╗',
+    bottomLeft: '╚',
+    bottomRight: '╝',
+    horizontal: '═',
+    vertical: '║',
+  },
+  simple: {
+    topLeft: '',
+    topRight: '',
+    bottomLeft: '',
+    bottomRight: '',
+    horizontal: '─',
+    vertical: '',
+  },
+  ascii: {
+    topLeft: '+',
+    topRight: '+',
+    bottomLeft: '+',
+    bottomRight: '+',
+    horizontal: '-',
+    vertical: '|',
+  },
+};
+
+// Default style (can be overridden via environment variable)
+const DEFAULT_STYLE = process.env.START_OUTPUT_STYLE || 'rounded';
+
+// Default block width
+const DEFAULT_WIDTH = 60;
+
+/**
+ * Get the box style configuration
+ * @param {string} [styleName] - Style name (rounded, heavy, double, simple, ascii)
+ * @returns {object} Box style configuration
+ */
+function getBoxStyle(styleName = DEFAULT_STYLE) {
+  return BOX_STYLES[styleName] || BOX_STYLES.rounded;
+}
+
+/**
+ * Create a horizontal line
+ * @param {number} width - Line width
+ * @param {object} style - Box style
+ * @returns {string} Horizontal line
+ */
+function createHorizontalLine(width, style) {
+  return style.horizontal.repeat(width);
+}
+
+/**
+ * Pad or truncate text to fit a specific width
+ * @param {string} text - Text to pad
+ * @param {number} width - Target width
+ * @returns {string} Padded text
+ */
+function padText(text, width) {
+  if (text.length >= width) {
+    return text.substring(0, width);
+  }
+  return text + ' '.repeat(width - text.length);
+}
+
+/**
+ * Create a bordered line with text
+ * @param {string} text - Text content
+ * @param {number} width - Total width (including borders)
+ * @param {object} style - Box style
+ * @returns {string} Bordered line
+ */
+function createBorderedLine(text, width, style) {
+  if (style.vertical) {
+    const innerWidth = width - 4; // 2 for borders, 2 for padding
+    const paddedText = padText(text, innerWidth);
+    return `${style.vertical} ${paddedText} ${style.vertical}`;
+  }
+  return text;
+}
+
+/**
+ * Create the top border of a box
+ * @param {number} width - Box width
+ * @param {object} style - Box style
+ * @returns {string} Top border
+ */
+function createTopBorder(width, style) {
+  if (style.topLeft) {
+    const lineWidth = width - 2; // Subtract corners
+    return `${style.topLeft}${createHorizontalLine(lineWidth, style)}${style.topRight}`;
+  }
+  return createHorizontalLine(width, style);
+}
+
+/**
+ * Create the bottom border of a box
+ * @param {number} width - Box width
+ * @param {object} style - Box style
+ * @returns {string} Bottom border
+ */
+function createBottomBorder(width, style) {
+  if (style.bottomLeft) {
+    const lineWidth = width - 2; // Subtract corners
+    return `${style.bottomLeft}${createHorizontalLine(lineWidth, style)}${style.bottomRight}`;
+  }
+  return createHorizontalLine(width, style);
+}
+
+/**
+ * Create a start block for command execution
+ * @param {object} options - Options for the block
+ * @param {string} options.sessionId - Session UUID
+ * @param {string} options.timestamp - Timestamp string
+ * @param {string} options.command - Command being executed
+ * @param {string[]} [options.extraLines] - Additional lines to show after the command line
+ * @param {string} [options.style] - Box style name
+ * @param {number} [options.width] - Box width
+ * @returns {string} Formatted start block
+ */
+function createStartBlock(options) {
+  const {
+    sessionId,
+    timestamp,
+    command,
+    extraLines = [],
+    style: styleName = DEFAULT_STYLE,
+    width = DEFAULT_WIDTH,
+  } = options;
+
+  const style = getBoxStyle(styleName);
+  const lines = [];
+
+  lines.push(createTopBorder(width, style));
+  lines.push(createBorderedLine(`Session ID: ${sessionId}`, width, style));
+  lines.push(
+    createBorderedLine(`Starting at ${timestamp}: ${command}`, width, style)
+  );
+
+  // Add extra lines (e.g., isolation info, docker image, etc.)
+  for (const line of extraLines) {
+    lines.push(createBorderedLine(line, width, style));
+  }
+
+  lines.push(createBottomBorder(width, style));
+
+  return lines.join('\n');
+}
+
+/**
+ * Format duration in seconds with appropriate precision
+ * @param {number} durationMs - Duration in milliseconds
+ * @returns {string} Formatted duration string
+ */
+function formatDuration(durationMs) {
+  const seconds = durationMs / 1000;
+  if (seconds < 0.001) {
+    return '0.001';
+  } else if (seconds < 10) {
+    // For durations under 10 seconds, show 3 decimal places
+    return seconds.toFixed(3);
+  } else if (seconds < 100) {
+    return seconds.toFixed(2);
+  } else {
+    return seconds.toFixed(1);
+  }
+}
+
+/**
+ * Create a finish block for command execution
+ * @param {object} options - Options for the block
+ * @param {string} options.sessionId - Session UUID
+ * @param {string} options.timestamp - Timestamp string
+ * @param {number} options.exitCode - Exit code
+ * @param {string} options.logPath - Path to log file
+ * @param {number} [options.durationMs] - Duration in milliseconds
+ * @param {string} [options.resultMessage] - Result message (e.g., "Screen session exited...")
+ * @param {string} [options.style] - Box style name
+ * @param {number} [options.width] - Box width
+ * @returns {string} Formatted finish block
+ */
+function createFinishBlock(options) {
+  const {
+    sessionId,
+    timestamp,
+    exitCode,
+    logPath,
+    durationMs,
+    resultMessage,
+    style: styleName = DEFAULT_STYLE,
+    width = DEFAULT_WIDTH,
+  } = options;
+
+  const style = getBoxStyle(styleName);
+  const lines = [];
+
+  // Format the finished message with optional duration
+  let finishedMsg = `Finished at ${timestamp}`;
+  if (durationMs !== undefined && durationMs !== null) {
+    finishedMsg += ` in ${formatDuration(durationMs)} seconds`;
+  }
+
+  lines.push(createTopBorder(width, style));
+
+  // Add result message first if provided (e.g., "Docker container exited...")
+  if (resultMessage) {
+    lines.push(createBorderedLine(resultMessage, width, style));
+  }
+
+  lines.push(createBorderedLine(finishedMsg, width, style));
+  lines.push(createBorderedLine(`Exit code: ${exitCode}`, width, style));
+  lines.push(createBorderedLine(`Log: ${logPath}`, width, style));
+  lines.push(createBorderedLine(`Session ID: ${sessionId}`, width, style));
+  lines.push(createBottomBorder(width, style));
+
+  return lines.join('\n');
+}
+
+/**
+ * Escape a value for Links notation
+ * Smart quoting: uses single or double quotes based on content
+ * @param {string} str - String to escape
+ * @returns {string} Escaped string
+ */
+function escapeForLinksNotation(str) {
+  if (str === null || str === undefined) {
+    return 'null';
+  }
+
+  const value = String(str);
+
+  // Check for characters that need quoting
+  const hasColon = value.includes(':');
+  const hasDoubleQuotes = value.includes('"');
+  const hasSingleQuotes = value.includes("'");
+  const hasParens = value.includes('(') || value.includes(')');
+  const hasNewline = value.includes('\n');
+  const hasSpace = value.includes(' ');
+
+  const needsQuoting =
+    hasColon ||
+    hasDoubleQuotes ||
+    hasSingleQuotes ||
+    hasParens ||
+    hasNewline ||
+    hasSpace;
+
+  if (!needsQuoting) {
+    return value;
+  }
+
+  if (hasDoubleQuotes && !hasSingleQuotes) {
+    // Has " but not ' → use single quotes
+    return `'${value}'`;
+  } else if (hasSingleQuotes && !hasDoubleQuotes) {
+    // Has ' but not " → use double quotes
+    return `"${value}"`;
+  } else if (hasDoubleQuotes && hasSingleQuotes) {
+    // Has both " and ' → choose wrapper with fewer escapes
+    const doubleQuoteCount = (value.match(/"/g) || []).length;
+    const singleQuoteCount = (value.match(/'/g) || []).length;
+
+    if (singleQuoteCount <= doubleQuoteCount) {
+      // Escape single quotes by doubling them
+      const escaped = value.replace(/'/g, "''");
+      return `'${escaped}'`;
+    } else {
+      // Escape double quotes by doubling them
+      const escaped = value.replace(/"/g, '""');
+      return `"${escaped}"`;
+    }
+  } else {
+    // Has colon, parentheses, newlines, or spaces but no quotes
+    return `"${value}"`;
+  }
+}
+
+/**
+ * Format an object as nested Links notation
+ * @param {object} obj - Object to format
+ * @param {number} [indent=2] - Indentation level (spaces)
+ * @param {number} [depth=0] - Current depth
+ * @returns {string} Links notation formatted string
+ */
+function formatAsNestedLinksNotation(obj, indent = 2, depth = 0) {
+  if (obj === null || obj === undefined) {
+    return 'null';
+  }
+
+  if (typeof obj !== 'object') {
+    return escapeForLinksNotation(obj);
+  }
+
+  if (Array.isArray(obj)) {
+    // Format arrays
+    if (obj.length === 0) {
+      return '()';
+    }
+    const indentStr = ' '.repeat(indent * (depth + 1));
+    const items = obj.map((item) => {
+      const formatted = formatAsNestedLinksNotation(item, indent, depth + 1);
+      return `${indentStr}${formatted}`;
+    });
+    return `(\n${items.join('\n')}\n${' '.repeat(indent * depth)})`;
+  }
+
+  // Format objects
+  const entries = Object.entries(obj);
+  if (entries.length === 0) {
+    return '()';
+  }
+
+  const indentStr = ' '.repeat(indent * (depth + 1));
+  const lines = entries
+    .filter(([, value]) => value !== null && value !== undefined)
+    .map(([key, value]) => {
+      if (typeof value === 'object') {
+        const nested = formatAsNestedLinksNotation(value, indent, depth + 1);
+        return `${indentStr}${key}\n${nested}`;
+      }
+      const formattedValue = escapeForLinksNotation(value);
+      return `${indentStr}${key} ${formattedValue}`;
+    });
+
+  return lines.join('\n');
+}
+
+module.exports = {
+  BOX_STYLES,
+  DEFAULT_STYLE,
+  DEFAULT_WIDTH,
+  getBoxStyle,
+  createHorizontalLine,
+  createBorderedLine,
+  createTopBorder,
+  createBottomBorder,
+  createStartBlock,
+  createFinishBlock,
+  formatDuration,
+  escapeForLinksNotation,
+  formatAsNestedLinksNotation,
+};

package/src/lib/status-formatter.js

@@ -7,14 +7,23 @@
  * - Text: Human-readable text format
  */
 
+const {
+  escapeForLinksNotation,
+  formatAsNestedLinksNotation,
+} = require('./output-blocks');
+
 /**
  * Format execution record as Links Notation (indented style)
+ * Uses nested Links notation for object values (like options) instead of JSON
+ *
  * @param {Object} record - The execution record with toObject() method
  * @returns {string} Links Notation formatted string in indented style
  *
  * Output format:
  * <uuid>
  *   <key> "<value>"
+ *   options
+ *     <nested_key> <nested_value>
  *   ...
  */
 function formatRecordAsLinksNotation(record) {
@@ -23,16 +32,27 @@ function formatRecordAsLinksNotation(record) {
 
   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);
+      if (key === 'options' && typeof value === 'object') {
+        // Format options as nested Links notation
+        const optionEntries = Object.entries(value).filter(
+          ([, v]) => v !== null && v !== undefined
+        );
+        if (optionEntries.length > 0) {
+          lines.push('  options');
+          for (const [optKey, optValue] of optionEntries) {
+            const formattedOptValue = escapeForLinksNotation(optValue);
+            lines.push(`    ${optKey} ${formattedOptValue}`);
+          }
+        }
+      } else if (typeof value === 'object') {
+        // For other objects, still format as nested Links notation
+        lines.push(`  ${key}`);
+        const nested = formatAsNestedLinksNotation(value, 2, 2);
+        lines.push(nested);
       } else {
-        formattedValue = String(value);
+        const formattedValue = escapeForLinksNotation(value);
+        lines.push(`  ${key} ${formattedValue}`);
       }
-      // Escape quotes in the value
-      const escapedValue = formattedValue.replace(/"/g, '\\"');
-      lines.push(`  ${key} "${escapedValue}"`);
     }
   }
 
@@ -62,8 +82,15 @@ function formatRecordAsText(record) {
     `Log Path:          ${obj.logPath}`,
   ];
 
-  if (Object.keys(obj.options).length > 0) {
-    lines.push(`Options:           ${JSON.stringify(obj.options)}`);
+  // Format options as nested list instead of JSON
+  const optionEntries = Object.entries(obj.options || {}).filter(
+    ([, v]) => v !== null && v !== undefined
+  );
+  if (optionEntries.length > 0) {
+    lines.push(`Options:`);
+    for (const [key, value] of optionEntries) {
+      lines.push(`  ${key}: ${value}`);
+    }
   }
 
   return lines.join('\n');

package/test/isolation.test.js

@@ -13,6 +13,7 @@ const {
   getScreenVersion,
   supportsLogfileOption,
   resetScreenVersionCache,
+  getDefaultDockerImage,
 } = require('../src/lib/isolation');
 
 describe('Isolation Module', () => {
@@ -723,3 +724,34 @@ describe('Isolation Runner with Available Backends', () => {
     });
   });
 });
+
+describe('Default Docker Image Detection', () => {
+  describe('getDefaultDockerImage', () => {
+    it('should return a valid Docker image string', () => {
+      const image = getDefaultDockerImage();
+      assert.ok(image, 'Should return a non-empty string');
+      assert.ok(typeof image === 'string', 'Should return a string');
+    });
+
+    it('should return an image with a tag', () => {
+      const image = getDefaultDockerImage();
+      assert.ok(image.includes(':'), 'Image should have a tag (e.g., :latest)');
+    });
+
+    it('should return a known base image', () => {
+      const image = getDefaultDockerImage();
+      const knownImages = [
+        'alpine:latest',
+        'ubuntu:latest',
+        'debian:latest',
+        'archlinux:latest',
+        'fedora:latest',
+        'centos:latest',
+      ];
+      assert.ok(
+        knownImages.includes(image),
+        `Image '${image}' should be one of the known base images: ${knownImages.join(', ')}`
+      );
+    });
+  });
+});

package/test/output-blocks.test.js

@@ -0,0 +1,237 @@
+/**
+ * Tests for output-blocks module
+ */
+
+const { describe, it, expect } = require('bun:test');
+
+const {
+  BOX_STYLES,
+  DEFAULT_STYLE,
+  DEFAULT_WIDTH,
+  getBoxStyle,
+  createStartBlock,
+  createFinishBlock,
+  formatDuration,
+  escapeForLinksNotation,
+  formatAsNestedLinksNotation,
+} = require('../src/lib/output-blocks');
+
+describe('output-blocks module', () => {
+  describe('BOX_STYLES', () => {
+    it('should have all expected styles', () => {
+      expect(BOX_STYLES).toHaveProperty('rounded');
+      expect(BOX_STYLES).toHaveProperty('heavy');
+      expect(BOX_STYLES).toHaveProperty('double');
+      expect(BOX_STYLES).toHaveProperty('simple');
+      expect(BOX_STYLES).toHaveProperty('ascii');
+    });
+
+    it('should have correct rounded style characters', () => {
+      expect(BOX_STYLES.rounded.topLeft).toBe('╭');
+      expect(BOX_STYLES.rounded.topRight).toBe('╮');
+      expect(BOX_STYLES.rounded.bottomLeft).toBe('╰');
+      expect(BOX_STYLES.rounded.bottomRight).toBe('╯');
+    });
+  });
+
+  describe('getBoxStyle', () => {
+    it('should return rounded style by default', () => {
+      const style = getBoxStyle();
+      expect(style).toEqual(BOX_STYLES.rounded);
+    });
+
+    it('should return requested style', () => {
+      expect(getBoxStyle('heavy')).toEqual(BOX_STYLES.heavy);
+      expect(getBoxStyle('double')).toEqual(BOX_STYLES.double);
+      expect(getBoxStyle('ascii')).toEqual(BOX_STYLES.ascii);
+    });
+
+    it('should return rounded for unknown style', () => {
+      const style = getBoxStyle('unknown');
+      expect(style).toEqual(BOX_STYLES.rounded);
+    });
+  });
+
+  describe('createStartBlock', () => {
+    it('should create a start block with session ID', () => {
+      const block = createStartBlock({
+        sessionId: 'test-uuid-1234',
+        timestamp: '2025-01-01 00:00:00',
+        command: 'echo hello',
+      });
+
+      expect(block).toContain('╭');
+      expect(block).toContain('╰');
+      expect(block).toContain('Session ID: test-uuid-1234');
+      expect(block).toContain('Starting at 2025-01-01 00:00:00: echo hello');
+    });
+
+    it('should use specified style', () => {
+      const block = createStartBlock({
+        sessionId: 'test-uuid',
+        timestamp: '2025-01-01 00:00:00',
+        command: 'echo hello',
+        style: 'ascii',
+      });
+
+      expect(block).toContain('+');
+      expect(block).toContain('-');
+    });
+
+    it('should include extra lines when provided', () => {
+      const block = createStartBlock({
+        sessionId: 'test-uuid',
+        timestamp: '2025-01-01 00:00:00',
+        command: 'echo hello',
+        extraLines: [
+          '[Isolation] Environment: screen, Mode: attached',
+          '[Isolation] Session: my-session',
+        ],
+      });
+
+      expect(block).toContain('╭');
+      expect(block).toContain('╰');
+      expect(block).toContain('Session ID: test-uuid');
+      expect(block).toContain(
+        '[Isolation] Environment: screen, Mode: attached'
+      );
+      expect(block).toContain('[Isolation] Session: my-session');
+    });
+  });
+
+  describe('createFinishBlock', () => {
+    it('should create a finish block with session ID and exit code', () => {
+      const block = createFinishBlock({
+        sessionId: 'test-uuid-1234',
+        timestamp: '2025-01-01 00:00:01',
+        exitCode: 0,
+        logPath: '/tmp/test.log',
+        durationMs: 17,
+      });
+
+      expect(block).toContain('╭');
+      expect(block).toContain('╰');
+      expect(block).toContain('Session ID: test-uuid-1234');
+      expect(block).toContain(
+        'Finished at 2025-01-01 00:00:01 in 0.017 seconds'
+      );
+      expect(block).toContain('Exit code: 0');
+      expect(block).toContain('Log: /tmp/test.log');
+    });
+
+    it('should create a finish block without duration when not provided', () => {
+      const block = createFinishBlock({
+        sessionId: 'test-uuid-1234',
+        timestamp: '2025-01-01 00:00:01',
+        exitCode: 0,
+        logPath: '/tmp/test.log',
+      });
+
+      expect(block).toContain('Finished at 2025-01-01 00:00:01');
+      expect(block).not.toContain('seconds');
+    });
+
+    it('should include result message when provided', () => {
+      const block = createFinishBlock({
+        sessionId: 'test-uuid-1234',
+        timestamp: '2025-01-01 00:00:01',
+        exitCode: 0,
+        logPath: '/tmp/test.log',
+        durationMs: 17,
+        resultMessage: 'Screen session "my-session" exited with code 0',
+      });
+
+      expect(block).toContain('╭');
+      expect(block).toContain('╰');
+      expect(block).toContain('Screen session');
+      expect(block).toContain('exited with code 0');
+      expect(block).toContain('Session ID: test-uuid-1234');
+      expect(block).toContain(
+        'Finished at 2025-01-01 00:00:01 in 0.017 seconds'
+      );
+    });
+  });
+
+  describe('formatDuration', () => {
+    it('should format very small durations', () => {
+      expect(formatDuration(0.5)).toBe('0.001');
+    });
+
+    it('should format millisecond durations', () => {
+      expect(formatDuration(17)).toBe('0.017');
+      expect(formatDuration(500)).toBe('0.500');
+    });
+
+    it('should format second durations', () => {
+      expect(formatDuration(1000)).toBe('1.000');
+      expect(formatDuration(5678)).toBe('5.678');
+    });
+
+    it('should format longer durations with less precision', () => {
+      expect(formatDuration(12345)).toBe('12.35');
+      expect(formatDuration(123456)).toBe('123.5');
+    });
+  });
+
+  describe('escapeForLinksNotation', () => {
+    it('should not quote simple values', () => {
+      expect(escapeForLinksNotation('simple')).toBe('simple');
+      expect(escapeForLinksNotation('123')).toBe('123');
+      expect(escapeForLinksNotation('true')).toBe('true');
+    });
+
+    it('should quote values with spaces', () => {
+      expect(escapeForLinksNotation('hello world')).toBe('"hello world"');
+    });
+
+    it('should quote values with colons', () => {
+      expect(escapeForLinksNotation('key:value')).toBe('"key:value"');
+    });
+
+    it('should use single quotes for values with double quotes', () => {
+      expect(escapeForLinksNotation('say "hello"')).toBe('\'say "hello"\'');
+    });
+
+    it('should use double quotes for values with single quotes', () => {
+      expect(escapeForLinksNotation("it's cool")).toBe('"it\'s cool"');
+    });
+
+    it('should escape quotes when both types are present', () => {
+      const result = escapeForLinksNotation('say "hello" it\'s');
+      // Should wrap in one quote type and escape the other
+      expect(result).toMatch(/^["'].*["']$/);
+    });
+
+    it('should handle null values', () => {
+      expect(escapeForLinksNotation(null)).toBe('null');
+      expect(escapeForLinksNotation(undefined)).toBe('null');
+    });
+  });
+
+  describe('formatAsNestedLinksNotation', () => {
+    it('should format simple objects', () => {
+      const obj = { key: 'value', number: 123 };
+      const result = formatAsNestedLinksNotation(obj);
+
+      expect(result).toContain('key value');
+      expect(result).toContain('number 123');
+    });
+
+    it('should quote values with spaces', () => {
+      const obj = { message: 'hello world' };
+      const result = formatAsNestedLinksNotation(obj);
+
+      expect(result).toContain('message "hello world"');
+    });
+
+    it('should handle empty objects', () => {
+      expect(formatAsNestedLinksNotation({})).toBe('()');
+    });
+
+    it('should handle null', () => {
+      expect(formatAsNestedLinksNotation(null)).toBe('null');
+    });
+  });
+});
+
+console.log('=== Output Blocks Unit Tests ===');

package/test/status-query.test.js

@@ -82,9 +82,10 @@ describe('--status query functionality', () => {
       expect(result.exitCode).toBe(0);
       // Should start with UUID on its own line
       expect(result.stdout).toMatch(new RegExp(`^${testRecord.uuid}\\n`));
-      // Should have indented properties
-      expect(result.stdout).toContain(`  uuid "${testRecord.uuid}"`);
-      expect(result.stdout).toContain('  status "executed"');
+      // Should have indented properties (values without special chars are not quoted)
+      expect(result.stdout).toContain(`  uuid ${testRecord.uuid}`);
+      expect(result.stdout).toContain('  status executed');
+      // Command with space should be quoted
       expect(result.stdout).toContain('  command "echo hello world"');
     });
 
@@ -99,7 +100,8 @@ describe('--status query functionality', () => {
       expect(result.exitCode).toBe(0);
       // Should start with UUID on its own line
       expect(result.stdout).toMatch(new RegExp(`^${testRecord.uuid}\\n`));
-      expect(result.stdout).toContain(`  uuid "${testRecord.uuid}"`);
+      // UUID without special chars is not quoted
+      expect(result.stdout).toContain(`  uuid ${testRecord.uuid}`);
     });
   });