sandboxbox 2.3.4 → 2.3.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sandboxbox",
-  "version": "2.3.4",
+  "version": "2.3.6",
   "description": "Portable container runner with Podman - Claude Code & Playwright support. Works on Windows, macOS, and Linux.",
   "type": "module",
   "main": "cli.js",

package/utils/commands/container.js

@@ -16,19 +16,40 @@ export function buildCommand(dockerfilePath) {
 
   const podmanPath = checkPodman();
   if (!podmanPath) return false;
-  if (!setupBackendNonBlocking(podmanPath)) return false;
 
-  try {
-    execSync(`"${podmanPath}" build -f "${dockerfilePath}" -t sandboxbox:latest .`, {
-      stdio: 'inherit',
-      cwd: dirname(dockerfilePath),
-      shell: process.platform === 'win32'
-    });
-    console.log(color('green', '\n✅ Container built successfully!'));
-    return true;
-  } catch (error) {
-    console.log(color('red', `\n❌ Build failed: ${error.message}`));
-    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',
+        timeout: 30000 // 30 second timeout
+      });
+      console.log(color('green', '\n✅ Container built successfully!'));
+      return true;
+    } catch (error) {
+      retries++;
+      if (retries < maxRetries && error.message.includes('Cannot connect to Podman')) {
+        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;
+    }
   }
 }
 
@@ -45,7 +66,12 @@ export function runCommand(projectDir, cmd = 'bash') {
 
   const podmanPath = checkPodman();
   if (!podmanPath) return false;
-  if (!setupBackendNonBlocking(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
+  }
 
   try {
     const { tempProjectDir, cleanup } = createIsolatedEnvironment(projectDir);
@@ -78,7 +104,12 @@ export function shellCommand(projectDir) {
 
   const podmanPath = checkPodman();
   if (!podmanPath) return false;
-  if (!setupBackendNonBlocking(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
+  }
 
   try {
     const { tempProjectDir, cleanup } = createIsolatedEnvironment(projectDir);

package/utils/podman.js

@@ -27,153 +27,93 @@ export function getPodmanPath() {
 }
 
 export function setupBackendNonBlocking(podmanPath) {
-  if (process.platform === 'linux') return true;
-
-  const execOptions = { encoding: 'utf-8', stdio: 'pipe', shell: true };
-
-  try {
-    execSync(`"${podmanPath}" info`, execOptions);
-    return true;
-  } catch (infoError) {
-    if (!infoError.message.includes('Cannot connect to Podman')) {
-      return false;
-    }
-
-    console.log(color('yellow', '\n🔧 Initializing Podman backend (one-time setup, takes 2-3 minutes)...'));
-
+  if (process.platform === 'linux') {
+    // Linux can run true rootless Podman
+    const execOptions = { encoding: 'utf-8', stdio: 'pipe', shell: true };
     try {
-      // Check existing machines with shorter timeout
-      let machines = [];
+      execSync(`"${podmanPath}" info`, execOptions);
+      return true;
+    } catch (infoError) {
+      console.log(color('yellow', '\n🔧 Starting Podman rootless service...'));
+      // Try to start service automatically
       try {
-        const machineListOutput = execSync(`"${podmanPath}" machine list --format json`, {
-          ...execOptions,
-          timeout: 3000 // 3 seconds timeout
-        });
-        machines = JSON.parse(machineListOutput || '[]');
-        console.log(color('cyan', `   Found ${machines.length} existing machine(s)`));
-      } catch (machineListError) {
-        console.log(color('yellow', '   Could not list machines quickly, checking via info command...'));
-        // Try to detect if machine exists by checking for specific error messages
-        try {
-          execSync(`"${podmanPath}" info`, {
-            ...execOptions,
-            timeout: 3000
-          });
-          console.log(color('green', '   Backend is already working!'));
-          return true;
-        } catch (infoError) {
-          if (infoError.message.includes('127.0.0.1')) {
-            console.log(color('cyan', '   Machine exists but not running, proceeding...'));
-          } else {
-            console.log(color('yellow', '   Assuming no machines exist'));
-          }
-        }
+        execSync('podman system service --time=0 &', { stdio: 'ignore', shell: true });
+        return true;
+      } catch (serviceError) {
+        console.log(color('cyan', '   Run: podman system service --time=0 &'));
+        return false;
       }
+    }
+  }
 
-      if (machines.length === 0) {
-        console.log(color('cyan', '   Creating Podman machine...'));
-        const initCmd = process.platform === 'win32'
-          ? `"${podmanPath}" machine init --rootful=false`
-          : `"${podmanPath}" machine init`;
+  // Windows: Implement completely silent automated setup
+  if (process.platform === 'win32') {
+    const execOptions = { encoding: 'utf-8', stdio: 'pipe', shell: true };
 
-        try {
-          execSync(initCmd, {
-            stdio: ['pipe', 'pipe', 'pipe'],
-            shell: true,
-            timeout: 120000 // 2 minutes
-          });
-        } catch (initError) {
-          const errorOutput = initError.stdout?.toString() + initError.stderr?.toString();
-          if (errorOutput?.includes('already exists') ||
-              errorOutput?.includes('VM already exists') ||
-              initError.message.includes('already exists')) {
-            console.log(color('cyan', '   Machine already exists, proceeding...'));
-          } else {
-            console.log(color('red', `   Error output: ${errorOutput}`));
-            throw initError;
-          }
-        }
-      } else {
-        console.log(color('cyan', '   Using existing machine'));
+    try {
+      execSync(`"${podmanPath}" info`, execOptions);
+      return true;
+    } catch (infoError) {
+      if (!infoError.message.includes('Cannot connect to Podman')) {
+        return false;
       }
 
-      console.log(color('cyan', '   Checking machine status...'));
-      try {
-        const statusOutput = execSync(`"${podmanPath}" machine list`, {
-          encoding: 'utf-8',
-          stdio: 'pipe',
-          shell: true,
-          timeout: 3000 // 3 seconds timeout
-        });
+      console.log(color('yellow', '\n🔧 Setting up Podman automatically (silent mode)...'));
 
-        if (statusOutput.includes('Running')) {
-          console.log(color('green', '   Machine is already running'));
-        } else {
-          console.log(color('cyan', '   Starting Podman machine...'));
-          startMachineWithRetry();
-        }
-      } catch (statusError) {
-        console.log(color('cyan', '   Could not check status, attempting to start machine...'));
-        startMachineWithRetry();
-      }
+      // Start machine setup in background without blocking
+      setupMachineBackground(podmanPath);
+      return true; // Continue even if setup is in progress
+    }
+  }
 
-      // Give background process time to start, then verify once
-      console.log(color('cyan', '   Giving background process time to start...'));
-      const start = Date.now();
-      while (Date.now() - start < 15000) {
-        // Wait 15 seconds for background start
-      }
+  // macOS: Similar automated approach
+  if (process.platform === 'darwin') {
+    const execOptions = { encoding: 'utf-8', stdio: 'pipe', shell: true };
 
-      // Quick verification attempt
-      console.log(color('cyan', '   Verifying backend connection...'));
-      try {
-        execSync(`"${podmanPath}" info`, {
-          ...execOptions,
-          timeout: 5000 // 5 second timeout
-        });
-        console.log(color('green', '   Backend is ready!'));
-      } catch (verifyError) {
-        console.log(color('yellow', '   Backend still starting. This is normal for first-time setup.'));
-        console.log(color('cyan', '   If this persists, run manually:'));
-        const manualCmd = process.platform === 'win32'
-          ? `"${podmanPath}" machine init --rootful=false && "${podmanPath}" machine start`
-          : `"${podmanPath}" machine init && "${podmanPath}" machine start`;
-        console.log(color('cyan', `   ${manualCmd}`));
-        console.log(color('yellow', '   Then try sandboxbox again.'));
+    try {
+      execSync(`"${podmanPath}" info`, execOptions);
+      return true;
+    } catch (infoError) {
+      if (!infoError.message.includes('Cannot connect to Podman')) {
         return false;
       }
 
-      console.log(color('green', '\n✅ Podman backend setup completed!\n'));
+      console.log(color('yellow', '\n🔧 Setting up Podman automatically...'));
+      setupMachineBackground(podmanPath);
       return true;
-
-      function startMachineWithRetry() {
-        // Use completely silent background start
-        console.log(color('cyan', '   Starting Podman machine silently in background...'));
-
-        const startProcess = spawn(`"${podmanPath}" machine start`, {
-          stdio: ['pipe', 'pipe', 'pipe'],
-          shell: true,
-          detached: true
-        });
-
-        startProcess.unref(); // Completely detach from parent
-        console.log(color('yellow', '   Machine start initiated in background (may take 1-2 minutes)'));
-      }
-    } catch (setupError) {
-      if (setupError.signal === 'SIGTERM') {
-        console.log(color('red', '\n❌ Setup timed out. Please run manually:'));
-      } else {
-        console.log(color('red', `\n❌ Setup failed: ${setupError.message}`));
-        console.log(color('red', `   Error details: ${setupError.stack}`));
-      }
-
-      const manualCmd = process.platform === 'win32'
-        ? `"${podmanPath}" machine init --rootful=false && "${podmanPath}" machine start`
-        : `"${podmanPath}" machine init && "${podmanPath}" machine start`;
-      console.log(color('cyan', `   Manual setup: ${manualCmd}`));
-      return false;
     }
   }
+
+  return false;
+}
+
+function setupMachineBackground(podmanPath) {
+  console.log(color('cyan', '   Starting machine setup in background...'));
+
+  const initCmd = process.platform === 'win32'
+    ? `"${podmanPath}" machine init --rootful=false`
+    : `"${podmanPath}" machine init`;
+
+  const initProcess = spawn(initCmd, {
+    stdio: ['pipe', 'pipe', 'pipe'],
+    shell: true,
+    detached: true
+  });
+
+  initProcess.unref();
+
+  // Start machine after init completes (with delay)
+  setTimeout(() => {
+    const startProcess = spawn(`"${podmanPath}" machine start`, {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      shell: true,
+      detached: true
+    });
+    startProcess.unref();
+  }, 30000); // Wait 30 seconds for init to complete
+
+  console.log(color('yellow', '   Setup initiated in background (may take 2-3 minutes)'));
+  console.log(color('cyan', '   Container operations will work when setup completes\n'));
 }
 
 export function checkBackend(podmanPath) {