sandboxbox 2.5.4 → 3.0.0

package/cli.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 /**
- * SandboxBox CLI - Portable Container Runner with Podman
- * Cross-platform container runner using Podman with Claude Code integration
+ * SandboxBox CLI - Process Containment Sandbox
+ * Lightweight process isolation for CLI tools
  */
 
 import { resolve } from 'path';
@@ -10,7 +10,7 @@ import { color } from './utils/colors.js';
 import { showBanner, showHelp } from './utils/ui.js';
 import { buildCommand, runCommand, shellCommand, claudeCommand, versionCommand } from './utils/commands/index.js';
 
-function main() {
+async function main() {
   const args = process.argv.slice(2);
   showBanner();
 
@@ -22,53 +22,57 @@ function main() {
   const command = args[0].toLowerCase();
   const commandArgs = args.slice(1);
 
-  switch (command) {
-    case 'build':
-      const dockerfilePath = commandArgs[0] || './Dockerfile';
-      if (!buildCommand(dockerfilePath)) process.exit(1);
-      break;
+  try {
+    switch (command) {
+      case 'build':
+        const dockerfilePath = commandArgs[0] || './Dockerfile';
+        if (!buildCommand(dockerfilePath)) process.exit(1);
+        break;
 
-    case 'run':
-      if (commandArgs.length === 0) {
-        console.log(color('red', '❌ Please specify a project directory'));
-        console.log(color('yellow', 'Usage: npx sandboxbox run <project-dir> [command]'));
-        process.exit(1);
-      }
-      // For NPX usage, resolve relative to current working directory, not script location
-      const projectDir = resolve(process.cwd(), commandArgs[0]);
-      const cmd = commandArgs[1] || 'bash';
-      if (!runCommand(projectDir, cmd)) process.exit(1);
-      break;
+      case 'run':
+        if (commandArgs.length === 0) {
+          console.log(color('red', '❌ Please specify a project directory'));
+          console.log(color('yellow', 'Usage: npx sandboxbox run <project-dir> [command]'));
+          process.exit(1);
+        }
+        const projectDir = resolve(process.cwd(), commandArgs[0]);
+        const cmd = commandArgs.slice(1).join(' ') || 'bash';
+        if (!(await runCommand(projectDir, cmd))) process.exit(1);
+        break;
 
-    case 'shell':
-      if (commandArgs.length === 0) {
-        console.log(color('red', '❌ Please specify a project directory'));
-        console.log(color('yellow', 'Usage: npx sandboxbox shell <project-dir>'));
-        process.exit(1);
-      }
-      const shellProjectDir = resolve(process.cwd(), commandArgs[0]);
-      if (!shellCommand(shellProjectDir)) process.exit(1);
-      break;
+      case 'shell':
+        if (commandArgs.length === 0) {
+          console.log(color('red', '❌ Please specify a project directory'));
+          console.log(color('yellow', 'Usage: npx sandboxbox shell <project-dir>'));
+          process.exit(1);
+        }
+        const shellProjectDir = resolve(process.cwd(), commandArgs[0]);
+        if (!(await shellCommand(shellProjectDir))) process.exit(1);
+        break;
 
-    case 'claude':
-      if (commandArgs.length === 0) {
-        console.log(color('red', '❌ Please specify a project directory'));
-        console.log(color('yellow', 'Usage: npx sandboxbox claude <project-dir>'));
-        process.exit(1);
-      }
-      const claudeProjectDir = resolve(process.cwd(), commandArgs[0]);
-      const claudeCmd = commandArgs.slice(1).join(' ') || 'claude';
-      if (!claudeCommand(claudeProjectDir, claudeCmd)) process.exit(1);
-      break;
+      case 'claude':
+        if (commandArgs.length === 0) {
+          console.log(color('red', '❌ Please specify a project directory'));
+          console.log(color('yellow', 'Usage: npx sandboxbox claude <project-dir>'));
+          process.exit(1);
+        }
+        const claudeProjectDir = resolve(process.cwd(), commandArgs[0]);
+        const claudeCmd = commandArgs.slice(1).join(' ') || 'claude';
+        if (!(await claudeCommand(claudeProjectDir, claudeCmd))) process.exit(1);
+        break;
 
-    case 'version':
-      if (!versionCommand()) process.exit(1);
-      break;
+      case 'version':
+        if (!versionCommand()) process.exit(1);
+        break;
 
-    default:
-      console.log(color('red', `❌ Unknown command: ${command}`));
-      console.log(color('yellow', 'Use --help for usage information'));
-      process.exit(1);
+      default:
+        console.log(color('red', `❌ Unknown command: ${command}`));
+        console.log(color('yellow', 'Use --help for usage information'));
+        process.exit(1);
+    }
+  } catch (error) {
+    console.log(color('red', `\n❌ Fatal error: ${error.message}`));
+    process.exit(1);
   }
 }
 

package/package.json

@@ -1,28 +1,29 @@
 {
   "name": "sandboxbox",
-  "version": "2.5.4",
-  "description": "Portable container runner with Podman - Claude Code & Playwright support. Works on Windows, macOS, and Linux.",
+  "version": "3.0.0",
+  "description": "Lightweight process containment sandbox for CLI tools - Playwright, Claude Code, and more. Pure Node.js, no dependencies.",
   "type": "module",
   "main": "cli.js",
   "bin": {
     "sandboxbox": "cli.js"
   },
   "scripts": {
-    "start": "node cli.js",
-    "postinstall": "node scripts/download-podman.js"
+    "start": "node cli.js"
   },
   "keywords": [
-    "containers",
-    "podman",
+    "sandbox",
+    "process-isolation",
     "playwright",
     "claude-code",
-    "sandbox",
-    "isolation",
+    "cli-tools",
+    "environment-isolation",
     "cross-platform",
     "windows",
     "macos",
     "linux",
-    "portable"
+    "portable",
+    "npm",
+    "npx"
   ],
   "author": "",
   "license": "MIT",

package/testproject/Dockerfile

@@ -0,0 +1,3 @@
+FROM node:20-alpine
+WORKDIR /app
+RUN echo "Test container"

package/utils/commands/claude.js

@@ -1,16 +1,10 @@
-import { existsSync, writeFileSync } from 'fs';
-import { execSync } from 'child_process';
-import { resolve, dirname } from 'path';
-import { fileURLToPath } from 'url';
+import { existsSync, cpSync, mkdirSync } from 'fs';
+import { resolve, join } from 'path';
+import { homedir } from 'os';
 import { color } from '../colors.js';
-import { checkPodman, setupBackendNonBlocking, getPodmanPath } from '../podman.js';
-import { buildClaudeContainerCommand, createClaudeDockerfile } from '../claude-workspace.js';
-import { createIsolatedEnvironment, setupCleanupHandlers, buildContainerMounts } from '../isolation.js';
+import { createSandbox, createSandboxEnv, runInSandbox } from '../sandbox.js';
 
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-export function claudeCommand(projectDir, command = 'claude') {
+export async function claudeCommand(projectDir, command = 'claude') {
   if (!existsSync(projectDir)) {
     console.log(color('red', `❌ Project directory not found: ${projectDir}`));
     return false;
@@ -22,90 +16,40 @@ export function claudeCommand(projectDir, command = 'claude') {
     return false;
   }
 
-  const podmanPath = getPodmanPath();
-  try {
-    execSync(`"${podmanPath}" image inspect sandboxbox-local:latest`, {
-      stdio: 'pipe',
-      shell: process.platform === 'win32',
-      windowsHide: process.platform === 'win32'
-    });
-  } catch {
-    console.log(color('yellow', '📦 Building Claude Code container...'));
-    if (!buildClaudeContainer()) {
-      return false;
-    }
-  }
-
-  console.log(color('blue', '🚀 Starting Claude Code in isolated environment...'));
+  console.log(color('blue', '🚀 Starting Claude Code in sandbox...'));
   console.log(color('yellow', `Project: ${projectDir}`));
-  console.log(color('yellow', `Command: ${command}`));
-  console.log(color('cyan', '📦 Note: Changes will be isolated and will NOT affect the original repository\n'));
-
-  const buildPodman = checkPodman();
-  if (!buildPodman) return false;
-  if (!setupBackendNonBlocking(buildPodman)) return false;
+  console.log(color('yellow', `Command: ${command}\n`));
 
-  // Create isolated environment once (outside retry loop)
-  const { tempProjectDir, cleanup } = createIsolatedEnvironment(projectDir);
-  setupCleanupHandlers(cleanup);
-  const mounts = buildContainerMounts(tempProjectDir, projectDir);
-  const containerCommand = buildClaudeContainerCommand(tempProjectDir, buildPodman, command, mounts);
+  const { sandboxDir, cleanup } = createSandbox(projectDir);
 
-  // Retry container operation with backend readiness check
-  let retries = 0;
-  const maxRetries = process.platform === 'linux' ? 3 : 12; // More retries for Windows/macOS
+  process.on('SIGINT', cleanup);
+  process.on('SIGTERM', cleanup);
 
-  while (retries < maxRetries) {
-    try {
-      execSync(containerCommand, {
-        stdio: 'inherit',
-        shell: process.platform === 'win32',
-        windowsHide: process.platform === 'win32'
-        // No timeout for interactive Claude sessions
-      });
+  try {
+    const claudeDir = join(sandboxDir, '.claude');
+    mkdirSync(claudeDir, { recursive: true });
 
-      cleanup();
-      console.log(color('green', '\n✅ Claude Code session completed! (Isolated - no host changes)'));
-      return true;
-    } catch (error) {
-      retries++;
-      if (retries < maxRetries && (error.message.includes('Cannot connect to Podman') || error.message.includes('connectex') || error.message.includes('No connection could be made') || error.message.includes('actively refused') || error.message.includes('Command failed'))) {
-        console.log(color('yellow', `   Backend not ready yet (${retries}/${maxRetries}), waiting 15 seconds...`));
-        const start = Date.now();
-        while (Date.now() - start < 15000) {
-          // Wait 15 seconds
-        }
-        continue;
-      }
-      cleanup(); // Cleanup on final failure
-      console.log(color('red', `\n❌ Claude Code failed: ${error.message}`));
-      return false;
+    const hostClaudeDir = join(homedir(), '.claude');
+    if (existsSync(hostClaudeDir)) {
+      cpSync(hostClaudeDir, claudeDir, { recursive: true });
     }
-  }
-}
 
-function buildClaudeContainer() {
-  const dockerfilePath = resolve(__dirname, '..', '..', 'Dockerfile.claude');
-  const dockerfileContent = createClaudeDockerfile();
+    const env = createSandboxEnv(sandboxDir, {
+      ANTHROPIC_AUTH_TOKEN: process.env.ANTHROPIC_AUTH_TOKEN,
+      CLAUDECODE: '1'
+    });
 
-  writeFileSync(dockerfilePath, dockerfileContent);
-  console.log(color('blue', '🏗️  Building Claude Code container...'));
+    console.log(color('green', `✅ Sandbox created: ${sandboxDir}`));
+    console.log(color('cyan', '📦 Claude Code running in isolated environment...\n'));
 
-  const podmanPath = checkPodman();
-  if (!podmanPath) return false;
-  if (!setupBackendNonBlocking(podmanPath)) return false;
+    await runInSandbox(`claude ${command}`, [], sandboxDir, env);
 
-  try {
-    execSync(`"${podmanPath}" build -f "${dockerfilePath}" -t sandboxbox-local:latest .`, {
-      stdio: 'inherit',
-      cwd: resolve(__dirname, '..', '..'),
-      shell: process.platform === 'win32',
-      windowsHide: process.platform === 'win32'
-    });
-    console.log(color('green', '\n✅ Claude Code container built successfully!'));
+    console.log(color('green', '\n✅ Claude Code session completed!'));
+    cleanup();
     return true;
   } catch (error) {
-    console.log(color('red', `\n❌ Build failed: ${error.message}`));
+    console.log(color('red', `\n❌ Claude Code failed: ${error.message}`));
+    cleanup();
     return false;
   }
 }

package/utils/commands/container.js

@@ -1,295 +1,60 @@
 import { existsSync } from 'fs';
-import { execSync } from 'child_process';
-import { dirname } from 'path';
+import { resolve, join } from 'path';
 import { color } from '../colors.js';
-import { checkPodman, setupBackendNonBlocking } from '../podman.js';
-import { createIsolatedEnvironment, setupCleanupHandlers, buildContainerMounts } from '../isolation.js';
+import { createSandbox, createSandboxEnv, runInSandbox } from '../sandbox.js';
 
 export function buildCommand(dockerfilePath) {
-  if (!existsSync(dockerfilePath)) {
-    console.log(color('red', `❌ Dockerfile not found: ${dockerfilePath}`));
-    return false;
-  }
-
-  console.log(color('blue', '🏗️  Building container...'));
-  console.log(color('yellow', `Dockerfile: ${dockerfilePath}\n`));
-
-  const podmanPath = checkPodman();
-  if (!podmanPath) return false;
-
-  // Start backend setup but don't block on Windows/macOS
-  const backendReady = setupBackendNonBlocking(podmanPath);
-  if (process.platform === 'linux' && !backendReady) {
-    return false; // Only block on Linux for rootless service
-  }
-
-  // Retry container operation with backend readiness check
-  let retries = 0;
-  const maxRetries = process.platform === 'linux' ? 3 : 12; // More retries for Windows/macOS
-
-  while (retries < maxRetries) {
-    try {
-      execSync(`"${podmanPath}" build -f "${dockerfilePath}" -t sandboxbox:latest .`, {
-        stdio: 'inherit',
-        cwd: dirname(dockerfilePath),
-        shell: process.platform === 'win32',
-        windowsHide: process.platform === 'win32',
-        timeout: 300000 // 5 minutes for container builds
-      });
-      console.log(color('green', '\n✅ Container built successfully!'));
-      return true;
-    } catch (error) {
-      retries++;
-      if (retries < maxRetries && (error.message.includes('Cannot connect to Podman') || error.message.includes('connectex') || error.message.includes('No connection could be made') || error.message.includes('actively refused') || error.message.includes('Command failed'))) {
-        console.log(color('yellow', `   Backend not ready yet (${retries}/${maxRetries}), waiting 15 seconds...`));
-        const start = Date.now();
-        while (Date.now() - start < 15000) {
-          // Wait 15 seconds
-        }
-        continue;
-      }
-      console.log(color('red', `\n❌ Build failed: ${error.message}`));
-      return false;
-    }
-  }
+  console.log(color('yellow', '⚠️  Build command not yet implemented'));
+  return false;
 }
 
-export function runCommand(projectDir, cmd = 'bash') {
+export async function runCommand(projectDir, cmd = 'bash') {
   if (!existsSync(projectDir)) {
     console.log(color('red', `❌ Project directory not found: ${projectDir}`));
     return false;
   }
 
-  console.log(color('blue', '🚀 Running project in isolated container...'));
+  console.log(color('blue', '🚀 Creating sandbox environment...'));
   console.log(color('yellow', `Project: ${projectDir}`));
   console.log(color('yellow', `Command: ${cmd}\n`));
-  console.log(color('cyan', '📦 Note: Changes will NOT affect host files (isolated environment)'));
-
-  const podmanPath = checkPodman();
-  if (!podmanPath) return false;
-
-  // Start backend setup but don't block on Windows/macOS
-  const backendReady = setupBackendNonBlocking(podmanPath);
-  if (process.platform === 'linux' && !backendReady) {
-    return false; // Only block on Linux for rootless service
-  }
-
-  // Create isolated environment once (outside retry loop)
-  const { tempProjectDir, cleanup } = createIsolatedEnvironment(projectDir);
-  setupCleanupHandlers(cleanup);
-  const mounts = buildContainerMounts(tempProjectDir, projectDir);
-
-  // Retry container operation with backend readiness check
-  let retries = 0;
-  const maxRetries = process.platform === 'linux' ? 3 : 12; // More retries for Windows/macOS
-
-  while (retries < maxRetries) {
-    try {
-      // Try container operation first
-      const containerOptions = {
-        stdio: process.platform === 'win32' ? ['pipe', 'pipe', 'pipe'] : 'inherit',
-        shell: process.platform === 'win32',
-        windowsHide: process.platform === 'win32',
-        timeout: 30000 // 30 second timeout
-      };
 
-      // For echo command, capture and display output
-      if (cmd === 'echo' || cmd.startsWith('echo ')) {
-        const echoCmd = cmd.replace('echo ', '');
-        const output = execSync(`"${podmanPath}" run --rm ${mounts.join(' ')} -w /workspace sandboxbox:latest echo ${echoCmd}`, {
-          ...containerOptions,
-          encoding: 'utf8'
-        }).trim();
-        console.log(output);
-      } else {
-        // For longer-running commands, use extended timeout
-        const longRunningOptions = {
-          ...containerOptions,
-          timeout: 600000 // 10 minutes for longer operations
-        };
-        execSync(`"${podmanPath}" run --rm -it ${mounts.join(' ')} -w /workspace sandboxbox:latest ${cmd}`, longRunningOptions);
-      }
+  const { sandboxDir, cleanup } = createSandbox(projectDir);
 
-      cleanup();
-      console.log(color('green', '\n✅ Container execution completed! (Isolated - no host changes)'));
-      return true;
-    } catch (error) {
-      retries++;
-      if (retries < maxRetries && (error.message.includes('Cannot connect to Podman') || error.message.includes('connectex') || error.message.includes('No connection could be made') || error.message.includes('actively refused') || error.message.includes('Command failed'))) {
-        console.log(color('yellow', `   Backend not ready yet (${retries}/${maxRetries}), initializing machine...`));
+  process.on('SIGINT', cleanup);
+  process.on('SIGTERM', cleanup);
 
-        // Actually initialize the machine instead of just waiting
-        if (process.platform === 'win32') {
-          try {
-            // First try to start existing machine
-            console.log(color('cyan', '   Starting Podman machine...'));
-            execSync(`"${podmanPath}" machine start`, {
-              stdio: 'pipe',
-              shell: true,
-              windowsHide: true,
-              timeout: 60000 // 1 minute for machine start
-            });
+  try {
+    const env = createSandboxEnv(sandboxDir, {
+      PLAYWRIGHT_BROWSERS_PATH: join(sandboxDir, 'browsers')
+    });
 
-            console.log(color('green', '   ✅ Podman machine started!'));
-            // Wait a bit more for machine to be fully ready
-            console.log(color('cyan', '   Waiting 5 seconds for machine to fully initialize...'));
-            const readyStart = Date.now();
-            while (Date.now() - readyStart < 5000) {
-              // Wait 5 seconds
-            }
-            continue; // Try container again
-          } catch (startError) {
-            // Machine doesn't exist or failed to start, try initializing it
-            if (startError.message.includes('does not exist') || startError.message.includes('not found')) {
-              try {
-                console.log(color('cyan', '   Initializing new Podman machine...'));
-                execSync(`"${podmanPath}" machine init --rootful=false`, {
-                  stdio: 'pipe',
-                  shell: true,
-                  windowsHide: true,
-                  timeout: 180000 // 3 minutes for machine init
-                });
+    console.log(color('green', `✅ Sandbox created: ${sandboxDir}`));
+    console.log(color('cyan', '📦 Running in isolated environment...\n'));
 
-                console.log(color('cyan', '   Starting new Podman machine...'));
-                execSync(`"${podmanPath}" machine start`, {
-                  stdio: 'pipe',
-                  shell: true,
-                  windowsHide: true,
-                  timeout: 60000 // 1 minute for machine start
-                });
+    await runInSandbox(cmd, [], sandboxDir, env);
 
-                console.log(color('green', '   ✅ Podman machine ready!'));
-                continue; // Try container again immediately
-              } catch (initError) {
-                console.log(color('red', `   Machine init failed: ${initError.message}`));
-              }
-            } else {
-              console.log(color('red', `   Machine start failed: ${startError.message}`));
-            }
-          }
-        }
-
-        // If machine setup failed or not Windows, wait and retry
-        console.log(color('yellow', `   Waiting 15 seconds before retry...`));
-        const start = Date.now();
-        while (Date.now() - start < 15000) {
-          // Wait 15 seconds
-        }
-        continue;
-      }
-      cleanup(); // Cleanup on final failure
-      console.log(color('red', `\n❌ Run failed: ${error.message}`));
-      return false;
-    }
+    console.log(color('green', '\n✅ Command completed!'));
+    cleanup();
+    return true;
+  } catch (error) {
+    console.log(color('red', `\n❌ Command failed: ${error.message}`));
+    cleanup();
+    return false;
   }
 }
 
-export function shellCommand(projectDir) {
+export async function shellCommand(projectDir) {
   if (!existsSync(projectDir)) {
     console.log(color('red', `❌ Project directory not found: ${projectDir}`));
     return false;
   }
 
-  console.log(color('blue', '🐚 Starting interactive shell in isolated container...'));
-  console.log(color('yellow', `Project: ${projectDir}\n`));
-  console.log(color('cyan', '📦 Note: Changes will NOT affect host files (isolated environment)'));
-
-  const podmanPath = checkPodman();
-  if (!podmanPath) return false;
-
-  // Start backend setup but don't block on Windows/macOS
-  const backendReady = setupBackendNonBlocking(podmanPath);
-  if (process.platform === 'linux' && !backendReady) {
-    return false; // Only block on Linux for rootless service
-  }
-
-  // Create isolated environment once (outside retry loop)
-  const { tempProjectDir, cleanup } = createIsolatedEnvironment(projectDir);
-  setupCleanupHandlers(cleanup);
-  const mounts = buildContainerMounts(tempProjectDir, projectDir);
-
-  // Retry container operation with backend readiness check
-  let retries = 0;
-  const maxRetries = process.platform === 'linux' ? 3 : 12; // More retries for Windows/macOS
-
-  while (retries < maxRetries) {
-    try {
-      execSync(`"${podmanPath}" run --rm -it ${mounts.join(' ')} -w /workspace sandboxbox:latest /bin/bash`, {
-        stdio: process.platform === 'win32' ? ['pipe', 'pipe', 'pipe'] : 'inherit',
-        shell: process.platform === 'win32',
-        windowsHide: process.platform === 'win32',
-        timeout: 600000 // 10 minutes for interactive shell sessions
-      });
-
-      cleanup();
-      return true;
-    } catch (error) {
-      retries++;
-      if (retries < maxRetries && (error.message.includes('Cannot connect to Podman') || error.message.includes('connectex') || error.message.includes('No connection could be made') || error.message.includes('actively refused') || error.message.includes('Command failed'))) {
-        console.log(color('yellow', `   Backend not ready yet (${retries}/${maxRetries}), initializing machine...`));
-
-        // Actually initialize the machine instead of just waiting
-        if (process.platform === 'win32') {
-          try {
-            // First try to start existing machine
-            console.log(color('cyan', '   Starting Podman machine...'));
-            execSync(`"${podmanPath}" machine start`, {
-              stdio: 'pipe',
-              shell: true,
-              windowsHide: true,
-              timeout: 60000 // 1 minute for machine start
-            });
-
-            console.log(color('green', '   ✅ Podman machine started!'));
-            // Wait a bit more for machine to be fully ready
-            console.log(color('cyan', '   Waiting 5 seconds for machine to fully initialize...'));
-            const readyStart = Date.now();
-            while (Date.now() - readyStart < 5000) {
-              // Wait 5 seconds
-            }
-            continue; // Try container again
-          } catch (startError) {
-            // Machine doesn't exist or failed to start, try initializing it
-            if (startError.message.includes('does not exist') || startError.message.includes('not found')) {
-              try {
-                console.log(color('cyan', '   Initializing new Podman machine...'));
-                execSync(`"${podmanPath}" machine init --rootful=false`, {
-                  stdio: 'pipe',
-                  shell: true,
-                  windowsHide: true,
-                  timeout: 180000 // 3 minutes for machine init
-                });
-
-                console.log(color('cyan', '   Starting new Podman machine...'));
-                execSync(`"${podmanPath}" machine start`, {
-                  stdio: 'pipe',
-                  shell: true,
-                  windowsHide: true,
-                  timeout: 60000 // 1 minute for machine start
-                });
-
-                console.log(color('green', '   ✅ Podman machine ready!'));
-                continue; // Try container again immediately
-              } catch (initError) {
-                console.log(color('red', `   Machine init failed: ${initError.message}`));
-              }
-            } else {
-              console.log(color('red', `   Machine start failed: ${startError.message}`));
-            }
-          }
-        }
+  console.log(color('blue', '🚀 Starting interactive shell...'));
+  return runCommand(projectDir, 'bash');
+}
 
-        // If machine setup failed or not Windows, wait and retry
-        console.log(color('yellow', `   Waiting 15 seconds before retry...`));
-        const start = Date.now();
-        while (Date.now() - start < 15000) {
-          // Wait 15 seconds
-        }
-        continue;
-      }
-      cleanup(); // Cleanup on final failure
-      console.log(color('red', `\n❌ Shell failed: ${error.message}`));
-      return false;
-    }
-  }
+export function versionCommand() {
+  console.log(color('green', 'SandboxBox - Process Containment Sandbox'));
+  console.log(color('cyan', 'Using Node.js process isolation'));
+  return true;
 }

package/utils/commands/index.js

@@ -2,7 +2,6 @@ import { readFileSync } from 'fs';
 import { resolve, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { color } from '../colors.js';
-import { checkPodman } from '../podman.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -14,10 +13,8 @@ export function versionCommand() {
   try {
     const packageJson = JSON.parse(readFileSync(resolve(__dirname, '..', '..', 'package.json'), 'utf-8'));
     console.log(color('green', `SandboxBox v${packageJson.version}`));
-    console.log(color('cyan', 'Portable containers with Claude Code integration'));
-    if (checkPodman()) {
-      console.log('');
-    }
+    console.log(color('cyan', 'Process containment sandbox for CLI tools'));
+    console.log(color('yellow', 'Supports: Playwright, Claude Code, and more'));
     return true;
   } catch (error) {
     console.log(color('red', '❌ Could not read version'));