start-command 0.16.0 → 0.17.1

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # start-command
 
+## 0.17.1
+
+### Patch Changes
+
+- 82a5297: fix: Improve output uniformity and ensure echo hi works in all modes
+  - Fixed truncation of log paths, session IDs, and result messages in output blocks
+  - Added consistent empty line formatting before/after command output
+  - Ensured proper output display in screen isolation mode
+  - Added integration tests for echo command across all isolation modes
+
+## 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "start-command",
-  "version": "0.16.0",
+  "version": "0.17.1",
   "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,
@@ -286,6 +287,12 @@ async function runWithIsolation(
   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');
 
@@ -298,38 +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 start block with session ID
-  console.log(
-    createStartBlock({
-      sessionId,
-      timestamp: startTime,
-      command: cmd,
-    })
-  );
-  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;
@@ -352,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(', ')}`
       );
     }
@@ -369,37 +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('');
   }
 
-  // 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
@@ -421,7 +430,7 @@ async function runWithIsolation(
     environment: environment || 'direct',
     mode,
     sessionName,
-    image: options.image,
+    image: effectiveImage,
     user: createdUser,
     startTime,
   });
@@ -442,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,
@@ -483,30 +492,28 @@ async function runWithIsolation(
     }
   }
 
-  // Print result
-  console.log('');
-  console.log(result.message);
-
   // 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 finish block
-  const durationMs = Date.now() - startTimeMs;
+  // Print finish block with result message inside
+  // Add empty line before finish block for visual separation
   console.log('');
+  const durationMs = Date.now() - startTimeMs;
   console.log(
     createFinishBlock({
       sessionId,
@@ -514,6 +521,7 @@ async function runWithIsolation(
       exitCode,
       logPath: logFilePath,
       durationMs,
+      resultMessage: result.message,
     })
   );
 

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

@@ -1,11 +1,4 @@
-/**
- * Isolation Runners for start-command
- *
- * Provides execution of commands in various isolated environments:
- * - screen: GNU Screen terminal multiplexer
- * - tmux: tmux terminal multiplexer
- * - docker: Docker containers
- */
+/** Isolation Runners for start-command (screen, tmux, docker, ssh) */
 
 const { execSync, spawn, spawnSync } = require('child_process');
 const fs = require('fs');
@@ -237,9 +230,13 @@ function runScreenWithLogCapture(command, sessionName, shellInfo, user = null) {
             let output = '';
             try {
               output = fs.readFileSync(logFile, 'utf8');
-              // Display the output
+              // Display the output with surrounding empty lines for consistency
               if (output.trim()) {
                 process.stdout.write(output);
+                // Add trailing newline if output doesn't end with one
+                if (!output.endsWith('\n')) {
+                  process.stdout.write('\n');
+                }
               }
             } catch {
               // Log file might not exist if command was very quick
@@ -281,6 +278,10 @@ function runScreenWithLogCapture(command, sessionName, shellInfo, user = null) {
             output = fs.readFileSync(logFile, 'utf8');
             if (output.trim()) {
               process.stdout.write(output);
+              // Add trailing newline if output doesn't end with one
+              if (!output.endsWith('\n')) {
+                process.stdout.write('\n');
+              }
             }
           } catch {
             // Ignore
@@ -964,6 +965,9 @@ function canRunLinuxDockerImages() {
   }
 }
 
+// Re-export getDefaultDockerImage from docker-utils for backwards compatibility
+const { getDefaultDockerImage } = require('./docker-utils');
+
 module.exports = {
   isCommandAvailable,
   hasTTY,
@@ -985,4 +989,5 @@ module.exports = {
   supportsLogfileOption,
   resetScreenVersionCache,
   canRunLinuxDockerImages,
+  getDefaultDockerImage,
 };

package/src/lib/output-blocks.js

@@ -85,10 +85,15 @@ function createHorizontalLine(width, style) {
  * Pad or truncate text to fit a specific width
  * @param {string} text - Text to pad
  * @param {number} width - Target width
+ * @param {boolean} [allowOverflow=false] - If true, don't truncate long text
  * @returns {string} Padded text
  */
-function padText(text, width) {
+function padText(text, width, allowOverflow = false) {
   if (text.length >= width) {
+    // If overflow is allowed, return text as-is (for copyable content like paths)
+    if (allowOverflow) {
+      return text;
+    }
     return text.substring(0, width);
   }
   return text + ' '.repeat(width - text.length);
@@ -99,12 +104,17 @@ function padText(text, width) {
  * @param {string} text - Text content
  * @param {number} width - Total width (including borders)
  * @param {object} style - Box style
+ * @param {boolean} [allowOverflow=false] - If true, allow text to overflow (for copyable content)
  * @returns {string} Bordered line
  */
-function createBorderedLine(text, width, style) {
+function createBorderedLine(text, width, style, allowOverflow = false) {
   if (style.vertical) {
     const innerWidth = width - 4; // 2 for borders, 2 for padding
-    const paddedText = padText(text, innerWidth);
+    const paddedText = padText(text, innerWidth, allowOverflow);
+    // If text overflows, extend the right border position
+    if (allowOverflow && text.length > innerWidth) {
+      return `${style.vertical} ${paddedText} ${style.vertical}`;
+    }
     return `${style.vertical} ${paddedText} ${style.vertical}`;
   }
   return text;
@@ -144,6 +154,7 @@ function createBottomBorder(width, style) {
  * @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
@@ -153,6 +164,7 @@ function createStartBlock(options) {
     sessionId,
     timestamp,
     command,
+    extraLines = [],
     style: styleName = DEFAULT_STYLE,
     width = DEFAULT_WIDTH,
   } = options;
@@ -165,6 +177,12 @@ function createStartBlock(options) {
   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');
@@ -197,6 +215,7 @@ function formatDuration(durationMs) {
  * @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
@@ -208,6 +227,7 @@ function createFinishBlock(options) {
     exitCode,
     logPath,
     durationMs,
+    resultMessage,
     style: styleName = DEFAULT_STYLE,
     width = DEFAULT_WIDTH,
   } = options;
@@ -222,10 +242,20 @@ function createFinishBlock(options) {
   }
 
   lines.push(createTopBorder(width, style));
+
+  // Add result message first if provided (e.g., "Docker container exited...")
+  // Allow overflow so the full message is visible and copyable
+  if (resultMessage) {
+    lines.push(createBorderedLine(resultMessage, width, style, true));
+  }
+
   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));
+  // Allow overflow for log path and session ID so they can be copied completely
+  lines.push(createBorderedLine(`Log: ${logPath}`, width, style, true));
+  lines.push(
+    createBorderedLine(`Session ID: ${sessionId}`, width, style, true)
+  );
   lines.push(createBottomBorder(width, style));
 
   return lines.join('\n');

package/test/echo-integration.test.js

@@ -0,0 +1,767 @@
+#!/usr/bin/env bun
+/**
+ * Integration tests for echo command across all isolation modes
+ *
+ * Issue #55: Ensure `echo "hi"` works reliably in all modes with proper output
+ *
+ * These tests verify for ALL isolation modes (attached + detached):
+ * 1. Command output is captured and displayed
+ * 2. Start and finish blocks are properly formatted
+ * 3. Empty lines exist before and after command output
+ * 4. Log paths and session IDs are not truncated (fully copyable)
+ *
+ * Test coverage:
+ * - No isolation mode (direct execution)
+ * - Screen isolation: attached + detached
+ * - Tmux isolation: attached + detached
+ * - Docker isolation: attached + detached
+ */
+
+const { describe, it } = require('node:test');
+const assert = require('assert');
+const { execSync } = require('child_process');
+const path = require('path');
+const {
+  isCommandAvailable,
+  canRunLinuxDockerImages,
+} = require('../src/lib/isolation');
+
+// Path to the CLI
+const CLI_PATH = path.join(__dirname, '..', 'src', 'bin', 'cli.js');
+
+// Helper function to run the CLI and capture output
+function runCli(args, options = {}) {
+  const timeout = options.timeout || 30000;
+  try {
+    const result = execSync(`bun run ${CLI_PATH} ${args}`, {
+      encoding: 'utf8',
+      timeout,
+      env: {
+        ...process.env,
+        START_DISABLE_AUTO_ISSUE: '1',
+        START_DISABLE_TRACKING: '1',
+      },
+      maxBuffer: 1024 * 1024, // 1MB
+    });
+    return { success: true, output: result };
+  } catch (err) {
+    return {
+      success: false,
+      output: err.stdout || '',
+      stderr: err.stderr || '',
+      exitCode: err.status,
+    };
+  }
+}
+
+// Verify output contains expected structure for attached modes (shows finish block)
+function verifyAttachedModeOutput(output, expectedOutputText = 'hi') {
+  // Should contain start block
+  assert.ok(
+    output.includes('╭'),
+    'Output should contain start block top border'
+  );
+  assert.ok(output.includes('╰'), 'Output should contain block bottom border');
+  assert.ok(output.includes('Session ID:'), 'Output should contain Session ID');
+  assert.ok(
+    output.includes('Starting at'),
+    'Output should contain Starting at timestamp'
+  );
+
+  // Should contain command output
+  assert.ok(
+    output.includes(expectedOutputText),
+    `Output should contain the "${expectedOutputText}" command output`
+  );
+
+  // Should contain finish block (for attached modes)
+  assert.ok(
+    output.includes('Finished at'),
+    'Output should contain Finished at timestamp'
+  );
+  assert.ok(output.includes('Exit code:'), 'Output should contain Exit code');
+  assert.ok(output.includes('Log:'), 'Output should contain Log path');
+
+  // Verify there are empty lines around output (structure check)
+  const lines = output.split('\n');
+  const outputIndex = lines.findIndex((l) => l.trim() === expectedOutputText);
+
+  if (outputIndex > 0) {
+    // Check for empty line before output
+    const lineBefore = lines[outputIndex - 1];
+    // Line before should be empty or end of start block
+    assert.ok(
+      lineBefore.trim() === '' || lineBefore.includes('╰'),
+      `Expected empty line or block end before output, got: "${lineBefore}"`
+    );
+  }
+
+  if (outputIndex >= 0 && outputIndex < lines.length - 1) {
+    // Check for empty line after output
+    const lineAfter = lines[outputIndex + 1];
+    // Line after should be empty or start of finish block
+    assert.ok(
+      lineAfter.trim() === '' || lineAfter.includes('╭'),
+      `Expected empty line or block start after output, got: "${lineAfter}"`
+    );
+  }
+}
+
+// Verify output for detached modes (only start block, no finish block)
+function verifyDetachedModeOutput(output) {
+  // Should contain start block
+  assert.ok(
+    output.includes('╭'),
+    'Output should contain start block top border'
+  );
+  assert.ok(output.includes('╰'), 'Output should contain block bottom border');
+  assert.ok(output.includes('Session ID:'), 'Output should contain Session ID');
+  assert.ok(
+    output.includes('Starting at'),
+    'Output should contain Starting at timestamp'
+  );
+
+  // Should show detached mode info
+  assert.ok(
+    output.includes('Mode: detached') || output.includes('Reattach with'),
+    'Output should indicate detached mode or show reattach instructions'
+  );
+}
+
+// Verify log path is not truncated
+function verifyLogPathNotTruncated(output) {
+  const logMatch = output.match(/Log: (.+)/);
+  assert.ok(logMatch, 'Should have Log line');
+  const logPath = logMatch[1].trim();
+  // Remove trailing box border character if present
+  const cleanPath = logPath.replace(/\s*│\s*$/, '').trim();
+
+  // Log path should end with .log extension
+  assert.ok(
+    cleanPath.endsWith('.log'),
+    `Log path should end with .log extension, got: "${cleanPath}"`
+  );
+}
+
+// Verify session ID is a valid UUID
+function verifySessionId(output) {
+  const sessionMatches = output.match(/Session ID: ([a-f0-9-]+)/g);
+  assert.ok(
+    sessionMatches && sessionMatches.length >= 1,
+    'Should have Session ID'
+  );
+
+  // Extract UUID from first match
+  const uuidMatch = sessionMatches[0].match(
+    /([a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12})/
+  );
+  assert.ok(uuidMatch, 'Session ID should be a valid UUID format');
+}
+
+describe('Echo Integration Tests - Issue #55', () => {
+  // ============================================
+  // NO ISOLATION MODE (Direct Execution)
+  // ============================================
+  describe('No Isolation Mode (Direct Execution)', () => {
+    it('should execute echo hi and show output with proper formatting', () => {
+      const result = runCli('echo hi');
+
+      assert.ok(result.success, 'Command should succeed');
+      verifyAttachedModeOutput(result.output);
+      verifyLogPathNotTruncated(result.output);
+      verifySessionId(result.output);
+
+      console.log('  ✓ No isolation mode: echo hi works correctly');
+    });
+
+    it('should execute echo with single quotes', () => {
+      const result = runCli("'echo hi'");
+
+      assert.ok(result.success, 'Command should succeed');
+      assert.ok(result.output.includes('hi'), 'Output should contain "hi"');
+
+      console.log('  ✓ No isolation mode: echo with single quotes works');
+    });
+
+    it('should execute echo with double quotes', () => {
+      const result = runCli('\'echo "hi"\'');
+
+      assert.ok(result.success, 'Command should succeed');
+      assert.ok(result.output.includes('hi'), 'Output should contain "hi"');
+
+      console.log('  ✓ No isolation mode: echo with double quotes works');
+    });
+
+    it('should have consistent empty line formatting', () => {
+      const result = runCli('echo hi');
+
+      assert.ok(result.success, 'Command should succeed');
+
+      // The pattern should be:
+      // [start block]
+      // [empty line]
+      // hi
+      // [empty line]
+      // [finish block]
+
+      const lines = result.output.split('\n');
+      let foundHi = false;
+      let hiIndex = -1;
+
+      for (let i = 0; i < lines.length; i++) {
+        if (lines[i].trim() === 'hi') {
+          foundHi = true;
+          hiIndex = i;
+          break;
+        }
+      }
+
+      assert.ok(foundHi, 'Should find "hi" output on its own line');
+
+      // Check line before hi
+      if (hiIndex > 0) {
+        const prevLine = lines[hiIndex - 1].trim();
+        assert.ok(
+          prevLine === '' || prevLine.startsWith('╰'),
+          `Line before "hi" should be empty or end of start block`
+        );
+      }
+
+      // Check line after hi
+      if (hiIndex < lines.length - 1) {
+        const nextLine = lines[hiIndex + 1].trim();
+        assert.ok(
+          nextLine === '' || nextLine.startsWith('╭'),
+          `Line after "hi" should be empty or start of finish block`
+        );
+      }
+
+      console.log('  ✓ Empty line formatting is consistent');
+    });
+  });
+
+  // ============================================
+  // SCREEN ISOLATION MODE (Attached + Detached)
+  // ============================================
+  describe('Screen Isolation Mode', () => {
+    const screenAvailable = isCommandAvailable('screen');
+
+    if (!screenAvailable) {
+      it('should skip screen tests when screen is not installed', () => {
+        console.log('  ⚠ screen not installed, skipping screen tests');
+        assert.ok(true);
+      });
+      return;
+    }
+
+    describe('Attached Mode', () => {
+      it('should execute echo hi in attached screen mode with proper formatting', () => {
+        const result = runCli('--isolated screen -- echo hi', {
+          timeout: 30000,
+        });
+
+        assert.ok(
+          result.success,
+          `Command should succeed. Output: ${result.output || result.stderr}`
+        );
+        verifyAttachedModeOutput(result.output);
+        verifyLogPathNotTruncated(result.output);
+        verifySessionId(result.output);
+
+        // Should show isolation info
+        assert.ok(
+          result.output.includes('[Isolation] Environment: screen'),
+          'Should show screen isolation info'
+        );
+        assert.ok(
+          result.output.includes('Mode: attached'),
+          'Should show attached mode'
+        );
+
+        console.log('  ✓ Screen isolation (attached): echo hi works correctly');
+      });
+
+      it('should execute echo with quotes in attached screen mode', () => {
+        const result = runCli('--isolated screen -- echo "hello world"', {
+          timeout: 30000,
+        });
+
+        assert.ok(
+          result.success,
+          `Command should succeed. Output: ${result.output || result.stderr}`
+        );
+        assert.ok(
+          result.output.includes('hello world'),
+          'Output should contain "hello world"'
+        );
+
+        console.log('  ✓ Screen isolation (attached): echo with quotes works');
+      });
+
+      it('should show exit code and finish block in attached screen mode', () => {
+        const result = runCli('--isolated screen -- echo hi', {
+          timeout: 30000,
+        });
+
+        assert.ok(result.success, 'Command should succeed');
+        assert.ok(
+          result.output.includes('Exit code: 0'),
+          'Should show exit code 0'
+        );
+        assert.ok(
+          result.output.includes('exited with code 0') ||
+            result.output.includes('Finished at'),
+          'Should show completion info'
+        );
+
+        console.log(
+          '  ✓ Screen isolation (attached): finish block displays correctly'
+        );
+      });
+    });
+
+    describe('Detached Mode', () => {
+      it('should execute echo hi in detached screen mode', () => {
+        const sessionName = `test-screen-detached-${Date.now()}`;
+        const result = runCli(
+          `--isolated screen -d --session ${sessionName} -- echo hi`,
+          { timeout: 10000 }
+        );
+
+        // Detached mode should succeed (command starts in background)
+        assert.ok(
+          result.success,
+          `Command should succeed. Output: ${result.output || result.stderr}`
+        );
+        verifyDetachedModeOutput(result.output);
+        verifySessionId(result.output);
+
+        // Should show screen isolation info with detached mode
+        assert.ok(
+          result.output.includes('[Isolation] Environment: screen'),
+          'Should show screen isolation info'
+        );
+        assert.ok(
+          result.output.includes('Mode: detached'),
+          'Should show detached mode'
+        );
+
+        // Cleanup: kill the screen session
+        try {
+          execSync(`screen -S ${sessionName} -X quit`, { stdio: 'ignore' });
+        } catch {
+          // Session may have already exited
+        }
+
+        console.log(
+          '  ✓ Screen isolation (detached): echo hi starts correctly'
+        );
+      });
+
+      it('should provide reattach instructions in detached screen mode', () => {
+        const sessionName = `test-screen-reattach-${Date.now()}`;
+        const result = runCli(
+          `--isolated screen -d --session ${sessionName} -- echo hi`,
+          { timeout: 10000 }
+        );
+
+        assert.ok(result.success, 'Command should succeed');
+        assert.ok(
+          result.output.includes('Reattach with') ||
+            result.output.includes('screen -r'),
+          'Should show reattach instructions'
+        );
+
+        // Cleanup
+        try {
+          execSync(`screen -S ${sessionName} -X quit`, { stdio: 'ignore' });
+        } catch {
+          // Ignore
+        }
+
+        console.log(
+          '  ✓ Screen isolation (detached): reattach instructions displayed'
+        );
+      });
+    });
+  });
+
+  // ============================================
+  // TMUX ISOLATION MODE (Attached + Detached)
+  // ============================================
+  describe('Tmux Isolation Mode', () => {
+    const tmuxAvailable = isCommandAvailable('tmux');
+
+    if (!tmuxAvailable) {
+      it('should skip tmux tests when tmux is not installed', () => {
+        console.log('  ⚠ tmux not installed, skipping tmux tests');
+        assert.ok(true);
+      });
+      return;
+    }
+
+    describe('Attached Mode', () => {
+      // Note: Attached tmux mode requires a TTY, which is not available in CI
+      // We test that it properly handles no-TTY scenario
+      it('should handle attached tmux mode (may require TTY)', () => {
+        const result = runCli('--isolated tmux -- echo hi', { timeout: 30000 });
+
+        // Either succeeds or fails due to no TTY - both are valid
+        if (result.success) {
+          assert.ok(result.output.includes('hi'), 'Output should contain "hi"');
+          assert.ok(
+            result.output.includes('[Isolation] Environment: tmux'),
+            'Should show tmux isolation info'
+          );
+          console.log('  ✓ Tmux isolation (attached): echo hi works correctly');
+        } else {
+          // May fail due to no TTY in CI
+          console.log(
+            '  ⚠ Tmux isolation (attached): skipped (no TTY available)'
+          );
+          assert.ok(true);
+        }
+      });
+    });
+
+    describe('Detached Mode', () => {
+      it('should execute echo hi in detached tmux mode', () => {
+        const sessionName = `test-tmux-detached-${Date.now()}`;
+        const result = runCli(
+          `--isolated tmux -d --session ${sessionName} -- echo hi`,
+          { timeout: 10000 }
+        );
+
+        // Detached mode should succeed
+        assert.ok(
+          result.success,
+          `Command should succeed. Output: ${result.output || result.stderr}`
+        );
+        verifyDetachedModeOutput(result.output);
+        verifySessionId(result.output);
+
+        // Should show tmux isolation info
+        assert.ok(
+          result.output.includes('[Isolation] Environment: tmux'),
+          'Should show tmux isolation info'
+        );
+        assert.ok(
+          result.output.includes('Mode: detached'),
+          'Should show detached mode'
+        );
+
+        // Cleanup: kill the tmux session
+        try {
+          execSync(`tmux kill-session -t ${sessionName}`, { stdio: 'ignore' });
+        } catch {
+          // Session may have already exited
+        }
+
+        console.log('  ✓ Tmux isolation (detached): echo hi starts correctly');
+      });
+
+      it('should provide reattach instructions in detached tmux mode', () => {
+        const sessionName = `test-tmux-reattach-${Date.now()}`;
+        const result = runCli(
+          `--isolated tmux -d --session ${sessionName} -- echo hi`,
+          { timeout: 10000 }
+        );
+
+        assert.ok(result.success, 'Command should succeed');
+        assert.ok(
+          result.output.includes('Reattach with') ||
+            result.output.includes('tmux attach'),
+          'Should show reattach instructions'
+        );
+
+        // Cleanup
+        try {
+          execSync(`tmux kill-session -t ${sessionName}`, { stdio: 'ignore' });
+        } catch {
+          // Ignore
+        }
+
+        console.log(
+          '  ✓ Tmux isolation (detached): reattach instructions displayed'
+        );
+      });
+
+      it('should execute echo with quotes in detached tmux mode', () => {
+        const sessionName = `test-tmux-quotes-${Date.now()}`;
+        const result = runCli(
+          `--isolated tmux -d --session ${sessionName} -- echo "hello world"`,
+          { timeout: 10000 }
+        );
+
+        assert.ok(
+          result.success,
+          `Command should succeed. Output: ${result.output || result.stderr}`
+        );
+
+        // Cleanup
+        try {
+          execSync(`tmux kill-session -t ${sessionName}`, { stdio: 'ignore' });
+        } catch {
+          // Ignore
+        }
+
+        console.log('  ✓ Tmux isolation (detached): echo with quotes works');
+      });
+    });
+  });
+
+  // ============================================
+  // DOCKER ISOLATION MODE (Attached + Detached)
+  // ============================================
+  describe('Docker Isolation Mode', () => {
+    const dockerAvailable = canRunLinuxDockerImages();
+
+    if (!dockerAvailable) {
+      it('should skip docker tests when docker is not available or cannot run Linux containers', () => {
+        console.log(
+          '  ⚠ docker not available or cannot run Linux containers, skipping docker tests'
+        );
+        assert.ok(true);
+      });
+      return;
+    }
+
+    describe('Attached Mode', () => {
+      it('should execute echo hi in attached docker mode with proper formatting', () => {
+        const containerName = `test-docker-attached-${Date.now()}`;
+        const result = runCli(
+          `--isolated docker --image alpine:latest --session ${containerName} -- echo hi`,
+          { timeout: 60000 }
+        );
+
+        assert.ok(
+          result.success,
+          `Command should succeed. Output: ${result.output || result.stderr}`
+        );
+        verifyAttachedModeOutput(result.output);
+        verifyLogPathNotTruncated(result.output);
+        verifySessionId(result.output);
+
+        // Should show docker isolation info
+        assert.ok(
+          result.output.includes('[Isolation] Environment: docker'),
+          'Should show docker isolation info'
+        );
+        assert.ok(
+          result.output.includes('[Isolation] Image: alpine:latest'),
+          'Should show docker image info'
+        );
+
+        console.log('  ✓ Docker isolation (attached): echo hi works correctly');
+      });
+
+      it('should execute echo with quotes in attached docker mode', () => {
+        const containerName = `test-docker-quotes-${Date.now()}`;
+        const result = runCli(
+          `--isolated docker --image alpine:latest --session ${containerName} -- echo "hello world"`,
+          { timeout: 60000 }
+        );
+
+        assert.ok(
+          result.success,
+          `Command should succeed. Output: ${result.output || result.stderr}`
+        );
+        assert.ok(
+          result.output.includes('hello world'),
+          'Output should contain "hello world"'
+        );
+
+        console.log('  ✓ Docker isolation (attached): echo with quotes works');
+      });
+
+      it('should show exit code and finish block in attached docker mode', () => {
+        const containerName = `test-docker-finish-${Date.now()}`;
+        const result = runCli(
+          `--isolated docker --image alpine:latest --session ${containerName} -- echo hi`,
+          { timeout: 60000 }
+        );
+
+        assert.ok(result.success, 'Command should succeed');
+        assert.ok(
+          result.output.includes('Exit code: 0'),
+          'Should show exit code 0'
+        );
+        assert.ok(
+          result.output.includes('exited with code 0') ||
+            result.output.includes('Finished at'),
+          'Should show completion info'
+        );
+
+        console.log(
+          '  ✓ Docker isolation (attached): finish block displays correctly'
+        );
+      });
+    });
+
+    describe('Detached Mode', () => {
+      it('should execute echo hi in detached docker mode', () => {
+        const containerName = `test-docker-detached-${Date.now()}`;
+        const result = runCli(
+          `--isolated docker -d --image alpine:latest --session ${containerName} -- echo hi`,
+          { timeout: 60000 }
+        );
+
+        // Detached mode should succeed
+        assert.ok(
+          result.success,
+          `Command should succeed. Output: ${result.output || result.stderr}`
+        );
+        verifyDetachedModeOutput(result.output);
+        verifySessionId(result.output);
+
+        // Should show docker isolation info with detached mode
+        assert.ok(
+          result.output.includes('[Isolation] Environment: docker'),
+          'Should show docker isolation info'
+        );
+        assert.ok(
+          result.output.includes('Mode: detached'),
+          'Should show detached mode'
+        );
+
+        // Cleanup: remove the docker container
+        try {
+          execSync(`docker rm -f ${containerName}`, { stdio: 'ignore' });
+        } catch {
+          // Container may have already exited
+        }
+
+        console.log(
+          '  ✓ Docker isolation (detached): echo hi starts correctly'
+        );
+      });
+
+      it('should provide reattach instructions in detached docker mode', () => {
+        const containerName = `test-docker-reattach-${Date.now()}`;
+        const result = runCli(
+          `--isolated docker -d --image alpine:latest --session ${containerName} -- echo hi`,
+          { timeout: 60000 }
+        );
+
+        assert.ok(result.success, 'Command should succeed');
+        assert.ok(
+          result.output.includes('Reattach with') ||
+            result.output.includes('docker attach') ||
+            result.output.includes('docker logs'),
+          'Should show reattach instructions'
+        );
+
+        // Cleanup
+        try {
+          execSync(`docker rm -f ${containerName}`, { stdio: 'ignore' });
+        } catch {
+          // Ignore
+        }
+
+        console.log(
+          '  ✓ Docker isolation (detached): reattach instructions displayed'
+        );
+      });
+
+      it('should execute echo with quotes in detached docker mode', () => {
+        const containerName = `test-docker-quotes-detached-${Date.now()}`;
+        const result = runCli(
+          `--isolated docker -d --image alpine:latest --session ${containerName} -- echo "hello world"`,
+          { timeout: 60000 }
+        );
+
+        assert.ok(
+          result.success,
+          `Command should succeed. Output: ${result.output || result.stderr}`
+        );
+
+        // Cleanup
+        try {
+          execSync(`docker rm -f ${containerName}`, { stdio: 'ignore' });
+        } catch {
+          // Ignore
+        }
+
+        console.log('  ✓ Docker isolation (detached): echo with quotes works');
+      });
+    });
+  });
+
+  // ============================================
+  // OUTPUT BLOCK FORMATTING (Cross-mode tests)
+  // ============================================
+  describe('Output Block Formatting', () => {
+    it('should not truncate long log paths', () => {
+      const result = runCli('echo hi');
+
+      assert.ok(result.success, 'Command should succeed');
+
+      // Get the log path line
+      const logMatch = result.output.match(/Log: (.+)/);
+      assert.ok(logMatch, 'Should have Log line');
+
+      const logLine = logMatch[0];
+      // Log line should contain full path ending in .log
+      assert.ok(
+        logLine.includes('.log'),
+        'Log path should be complete and not truncated'
+      );
+
+      console.log('  ✓ Log paths are not truncated');
+    });
+
+    it('should show full session ID in both start and finish blocks', () => {
+      const result = runCli('echo hi');
+
+      assert.ok(result.success, 'Command should succeed');
+
+      // Get session IDs from output (should appear twice: start and finish block)
+      const sessionMatches = result.output.match(/Session ID: ([a-f0-9-]+)/g);
+      assert.ok(
+        sessionMatches && sessionMatches.length >= 2,
+        'Should have Session ID in both blocks'
+      );
+
+      // Extract UUID from first match
+      const uuidMatch = sessionMatches[0].match(
+        /([a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12})/
+      );
+      assert.ok(uuidMatch, 'Session ID should be a valid UUID format');
+
+      console.log('  ✓ Session IDs are complete UUIDs in both blocks');
+    });
+
+    it('should have consistent exit code formatting', () => {
+      const result = runCli('echo hi');
+
+      assert.ok(result.success, 'Command should succeed');
+      assert.ok(
+        result.output.includes('Exit code: 0'),
+        'Should show "Exit code: 0" for successful command'
+      );
+
+      console.log('  ✓ Exit code formatting is consistent');
+    });
+
+    it('should include timing information in finish block', () => {
+      const result = runCli('echo hi');
+
+      assert.ok(result.success, 'Command should succeed');
+      assert.ok(
+        result.output.includes('seconds') || result.output.includes('in 0.'),
+        'Should include timing information'
+      );
+
+      console.log('  ✓ Timing information is present in finish block');
+    });
+  });
+});
+
+console.log('=== Echo Integration Tests - Issue #55 ===');
+console.log(
+  'Testing that "echo hi" works correctly across all isolation modes'
+);
+console.log(
+  'Coverage: No isolation, Screen (attached/detached), Tmux (attached/detached), Docker (attached/detached)'
+);
+console.log('');

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

@@ -77,6 +77,26 @@ describe('output-blocks module', () => {
       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', () => {
@@ -110,6 +130,26 @@ describe('output-blocks module', () => {
       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', () => {