start-command 0.16.0 → 0.17.0

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "start-command",
-  "version": "0.16.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,
@@ -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,26 @@ 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
+  // Print finish block with result message inside
   const durationMs = Date.now() - startTimeMs;
-  console.log('');
   console.log(
     createFinishBlock({
       sessionId,
@@ -514,6 +519,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

@@ -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

@@ -144,6 +144,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 +154,7 @@ function createStartBlock(options) {
     sessionId,
     timestamp,
     command,
+    extraLines = [],
     style: styleName = DEFAULT_STYLE,
     width = DEFAULT_WIDTH,
   } = options;
@@ -165,6 +167,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 +205,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 +217,7 @@ function createFinishBlock(options) {
     exitCode,
     logPath,
     durationMs,
+    resultMessage,
     style: styleName = DEFAULT_STYLE,
     width = DEFAULT_WIDTH,
   } = options;
@@ -222,6 +232,12 @@ function createFinishBlock(options) {
   }
 
   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));

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', () => {