@locusai/cli 0.20.2 → 0.20.3

package/bin/locus.js

@@ -890,7 +890,8 @@ __export(exports_sandbox, {
   getProviderSandboxName: () => getProviderSandboxName,
   getModelSandboxName: () => getModelSandboxName,
   displaySandboxWarning: () => displaySandboxWarning,
-  detectSandboxSupport: () => detectSandboxSupport
+  detectSandboxSupport: () => detectSandboxSupport,
+  checkProviderSandboxMismatch: () => checkProviderSandboxMismatch
 });
 import { execFile } from "node:child_process";
 import { createInterface } from "node:readline";
@@ -901,6 +902,19 @@ function getModelSandboxName(config, model, fallbackProvider) {
   const provider = inferProviderFromModel(model) ?? fallbackProvider;
   return getProviderSandboxName(config, provider);
 }
+function checkProviderSandboxMismatch(config, model, fallbackProvider) {
+  if (!config.enabled)
+    return null;
+  const targetProvider = inferProviderFromModel(model) ?? fallbackProvider;
+  const sandboxName = getProviderSandboxName(config, targetProvider);
+  if (sandboxName)
+    return null;
+  const configured = ["claude", "codex"].filter((p) => config.providers[p]);
+  if (configured.length > 0) {
+    return `Sandbox is configured for ${configured.join(", ")} but not for ${targetProvider}. ` + `Run "locus sandbox" and select ${targetProvider} to create its sandbox.`;
+  }
+  return `No sandbox is configured for ${targetProvider}. ` + `Run "locus sandbox" to create one.`;
+}
 async function detectSandboxSupport() {
   if (cachedStatus)
     return cachedStatus;
@@ -5337,7 +5351,7 @@ ${red("✗")} ${dim("Force exit.")}\r
         return {
           success: false,
           output: "",
-          error: `Sandbox for provider "${resolvedProvider}" is not configured. ` + `Run "locus sandbox" and authenticate via "locus sandbox ${resolvedProvider}".`,
+          error: `No sandbox configured for "${resolvedProvider}". ` + `Run "locus sandbox" and select "${resolvedProvider}" to create its sandbox, ` + `then authenticate via "locus sandbox ${resolvedProvider}".`,
           interrupted: false,
           exitCode: 1
         };
@@ -7983,7 +7997,8 @@ async function runInteractiveRepl(session, sessionManager, options) {
       process.stderr.write(`${dim("Using")} ${dim(provider)} ${dim("sandbox")} ${dim(sandboxName)}
 `);
     } else {
-      process.stderr.write(`${yellow("⚠")} ${dim(`No sandbox configured for ${provider}. Run locus sandbox.`)}
+      const mismatch = checkProviderSandboxMismatch(config.sandbox, config.ai.model, config.ai.provider);
+      process.stderr.write(`${yellow("⚠")} ${dim(mismatch ?? `No sandbox configured for ${provider}. Run locus sandbox.`)}
 `);
     }
   }
@@ -8027,7 +8042,8 @@ async function runInteractiveRepl(session, sessionManager, options) {
 `);
           } else {
             sandboxRunner = null;
-            process.stderr.write(`${yellow("⚠")} ${dim(`No sandbox configured for ${inferredProvider}. Run locus sandbox.`)}
+            const mismatch = checkProviderSandboxMismatch(config.sandbox, model, config.ai.provider);
+            process.stderr.write(`${yellow("⚠")} ${dim(mismatch ?? `No sandbox configured for ${inferredProvider}. Run locus sandbox.`)}
 `);
           }
         }
@@ -8332,7 +8348,8 @@ async function handleJsonStream(projectRoot, config, args, sessionId) {
     const sandboxName = getProviderSandboxName(config.sandbox, config.ai.provider);
     const runner = config.sandbox.enabled ? sandboxName ? createUserManagedSandboxRunner(config.ai.provider, sandboxName) : null : await createRunnerAsync(config.ai.provider, false);
     if (!runner) {
-      stream.emitError(`Sandbox for provider "${config.ai.provider}" is not configured. Run locus sandbox.`, false);
+      const mismatch = checkProviderSandboxMismatch(config.sandbox, config.ai.model, config.ai.provider);
+      stream.emitError(mismatch ?? `No sandbox configured for "${config.ai.provider}". Run "locus sandbox" to create one.`, false);
       return;
     }
     const available = await runner.isAvailable();
@@ -9335,6 +9352,15 @@ async function runCommand(projectRoot, args, flags = {}) {
       process.stderr.write(`${yellow("⚠")} Running without sandbox. The AI agent will have unrestricted access to your filesystem, network, and environment variables.
 `);
     }
+    if (sandboxed) {
+      const model = flags.model ?? config.ai.model;
+      const mismatch = checkProviderSandboxMismatch(config.sandbox, model, config.ai.provider);
+      if (mismatch) {
+        process.stderr.write(`${red("✗")} ${mismatch}
+`);
+        return;
+      }
+    }
     if (flags.resume) {
       return handleResume(projectRoot, config, sandboxed);
     }
@@ -10288,6 +10314,14 @@ ${bold("Planning:")} ${cyan(displayDirective)}
   }
   process.stderr.write(`
 `);
+  if (config.sandbox.enabled) {
+    const mismatch = checkProviderSandboxMismatch(config.sandbox, flags.model ?? config.ai.model, config.ai.provider);
+    if (mismatch) {
+      process.stderr.write(`${red("✗")} ${mismatch}
+`);
+      return;
+    }
+  }
   const prompt = buildPlanningPrompt(projectRoot, config, directive, sprintName, id, planPathRelative);
   const aiResult = await runAI({
     prompt,
@@ -10383,6 +10417,14 @@ ${bold("Organizing issues for:")} ${cyan(sprintName)}
 `);
     return;
   }
+  if (config.sandbox.enabled) {
+    const mismatch = checkProviderSandboxMismatch(config.sandbox, flags.model ?? config.ai.model, config.ai.provider);
+    if (mismatch) {
+      process.stderr.write(`${red("✗")} ${mismatch}
+`);
+      return;
+    }
+  }
   const issueDescriptions = issues.map((i) => `#${i.number}: ${i.title}
 ${i.body?.slice(0, 300) ?? ""}`).join(`
 
@@ -10712,6 +10754,14 @@ async function reviewCommand(projectRoot, args, flags = {}) {
       prNumber = Number.parseInt(args[i], 10);
     }
   }
+  if (config.sandbox.enabled) {
+    const mismatch = checkProviderSandboxMismatch(config.sandbox, flags.model ?? config.ai.model, config.ai.provider);
+    if (mismatch) {
+      process.stderr.write(`${red("✗")} ${mismatch}
+`);
+      return;
+    }
+  }
   if (prNumber) {
     return reviewSinglePR(projectRoot, config, prNumber, focus, flags);
   }
@@ -10939,6 +10989,14 @@ async function iterateCommand(projectRoot, args, flags = {}) {
       issueNumber = Number.parseInt(args[i], 10);
     }
   }
+  if (config.sandbox.enabled) {
+    const mismatch = checkProviderSandboxMismatch(config.sandbox, config.ai.model, config.ai.provider);
+    if (mismatch) {
+      process.stderr.write(`${red("✗")} ${mismatch}
+`);
+      return;
+    }
+  }
   if (prNumber) {
     return handleSinglePR(projectRoot, config, prNumber, flags);
   }
@@ -11135,6 +11193,7 @@ var init_iterate = __esm(() => {
   init_agent();
   init_config();
   init_github();
+  init_sandbox();
   init_progress();
   init_terminal();
 });
@@ -11339,6 +11398,14 @@ async function startDiscussion(projectRoot, topic, flags) {
   const config = loadConfig(projectRoot);
   const timer = createTimer();
   const id = generateId2();
+  if (config.sandbox.enabled) {
+    const mismatch = checkProviderSandboxMismatch(config.sandbox, flags.model ?? config.ai.model, config.ai.provider);
+    if (mismatch) {
+      process.stderr.write(`${red("✗")} ${mismatch}
+`);
+      return;
+    }
+  }
   process.stderr.write(`
 ${bold("Discussion:")} ${cyan(topic)}
 
@@ -11733,12 +11800,13 @@ import { execSync as execSync17, spawn as spawn6 } from "node:child_process";
 import { createHash } from "node:crypto";
 import { existsSync as existsSync24, readFileSync as readFileSync17 } from "node:fs";
 import { basename as basename4, join as join24 } from "node:path";
+import { createInterface as createInterface3 } from "node:readline";
 function printSandboxHelp() {
   process.stderr.write(`
 ${bold("locus sandbox")} — Manage Docker sandbox lifecycle
 
 ${bold("Usage:")}
-  locus sandbox                     ${dim("# Create claude/codex sandboxes and enable sandbox mode")}
+  locus sandbox                     ${dim("# Select a provider and create its sandbox")}
   locus sandbox claude              ${dim("# Run claude interactively (for login)")}
   locus sandbox codex               ${dim("# Run codex interactively (for login)")}
   locus sandbox setup               ${dim("# Re-run dependency install in sandbox(es)")}
@@ -11749,10 +11817,10 @@ ${bold("Usage:")}
   locus sandbox status              ${dim("# Show current sandbox state")}
 
 ${bold("Flow:")}
-  1. ${cyan("locus sandbox")}          Create sandboxes (auto-installs dependencies)
-  2. ${cyan("locus sandbox claude")}   Login Claude inside its sandbox
-  3. ${cyan("locus sandbox codex")}    Login Codex inside its sandbox
-  4. ${cyan("locus sandbox install bun")}  Install extra tools (optional)
+  1. ${cyan("locus sandbox")}              Select a provider and create its sandbox
+  2. ${cyan("locus sandbox <provider>")}   Login to the provider inside its sandbox
+  3. ${cyan("locus sandbox install bun")}  Install extra tools (optional)
+  4. Run ${cyan("locus sandbox")} again to add another provider (optional)
 
 `);
 }
@@ -11786,6 +11854,41 @@ async function sandboxCommand(projectRoot, args) {
 `);
   }
 }
+async function promptProviderSelection() {
+  process.stderr.write(`
+${bold("Select a provider to create a sandbox for:")}
+
+`);
+  for (let i = 0;i < PROVIDERS.length; i++) {
+    process.stderr.write(`  ${bold(String(i + 1))}. ${PROVIDERS[i]}
+`);
+  }
+  process.stderr.write(`
+`);
+  const rl = createInterface3({
+    input: process.stdin,
+    output: process.stderr
+  });
+  return new Promise((resolve2) => {
+    rl.question("Enter choice (1-2): ", (answer) => {
+      rl.close();
+      const trimmed = answer.trim().toLowerCase();
+      if (trimmed === "claude" || trimmed === "codex") {
+        resolve2(trimmed);
+        return;
+      }
+      const num = Number.parseInt(trimmed, 10);
+      if (num >= 1 && num <= PROVIDERS.length) {
+        resolve2(PROVIDERS[num - 1]);
+        return;
+      }
+      process.stderr.write(`${red("✗")} Invalid selection.
+`);
+      resolve2(null);
+    });
+    rl.on("close", () => resolve2(null));
+  });
+}
 async function handleCreate(projectRoot) {
   const config = loadConfig(projectRoot);
   const status = await detectSandboxSupport();
@@ -11796,54 +11899,44 @@ async function handleCreate(projectRoot) {
 `);
     return;
   }
+  const provider = await promptProviderSelection();
+  if (!provider)
+    return;
   const sandboxNames = buildProviderSandboxNames(projectRoot);
-  const readySandboxes = {};
-  const newlyCreated = new Set;
-  let failed = false;
-  const createResults = await Promise.all(PROVIDERS.map(async (provider) => {
-    const name = sandboxNames[provider];
-    if (isSandboxAlive(name)) {
-      process.stderr.write(`${green("✓")} ${provider} sandbox ready: ${bold(name)}
+  const name = sandboxNames[provider];
+  const readySandboxes = { ...config.sandbox.providers };
+  if (isSandboxAlive(name)) {
+    process.stderr.write(`${green("✓")} ${provider} sandbox already exists: ${bold(name)}
+`);
+    readySandboxes[provider] = name;
+    config.sandbox.enabled = true;
+    config.sandbox.providers = readySandboxes;
+    saveConfig(projectRoot, config);
+    process.stderr.write(`  Next: run ${cyan(`locus sandbox ${provider}`)} to authenticate.
 `);
-      return { provider, name, created: false, existed: true };
-    }
-    process.stderr.write(`Creating ${bold(provider)} sandbox ${dim(name)} with workspace ${dim(projectRoot)}...
+    return;
+  }
+  process.stderr.write(`Creating ${bold(provider)} sandbox ${dim(name)} with workspace ${dim(projectRoot)}...
 `);
-    const created = await createProviderSandbox(provider, name, projectRoot);
-    if (!created) {
-      process.stderr.write(`${red("✗")} Failed to create ${provider} sandbox (${name}).
+  const created = await createProviderSandbox(provider, name, projectRoot);
+  if (!created) {
+    process.stderr.write(`${red("✗")} Failed to create ${provider} sandbox (${name}).
 `);
-      return { provider, name, created: false, existed: false };
-    }
-    process.stderr.write(`${green("✓")} ${provider} sandbox created: ${bold(name)}
+    process.stderr.write(`  Re-run ${cyan("locus sandbox")} after resolving Docker issues.
 `);
-    return { provider, name, created: true, existed: false };
-  }));
-  for (const result of createResults) {
-    if (result.created || result.existed) {
-      readySandboxes[result.provider] = result.name;
-      if (result.created)
-        newlyCreated.add(result.name);
-    } else {
-      failed = true;
-    }
+    return;
   }
+  process.stderr.write(`${green("✓")} ${provider} sandbox created: ${bold(name)}
+`);
+  readySandboxes[provider] = name;
   config.sandbox.enabled = true;
   config.sandbox.providers = readySandboxes;
   saveConfig(projectRoot, config);
-  await Promise.all(PROVIDERS.filter((provider) => {
-    const sandboxName = readySandboxes[provider];
-    return sandboxName && newlyCreated.has(sandboxName);
-  }).map((provider) => runSandboxSetup(readySandboxes[provider], projectRoot)));
-  if (failed) {
-    process.stderr.write(`
-${yellow("⚠")} Some sandboxes failed to create. Re-run ${cyan("locus sandbox")} after resolving Docker issues.
-`);
-  }
+  await runSandboxSetup(name, projectRoot);
   process.stderr.write(`
-${green("✓")} Sandbox mode enabled with provider-specific sandboxes.
+${green("✓")} Sandbox mode enabled for ${bold(provider)}.
 `);
-  process.stderr.write(`  Next: run ${cyan("locus sandbox claude")} and ${cyan("locus sandbox codex")} to authenticate both providers.
+  process.stderr.write(`  Next: run ${cyan(`locus sandbox ${provider}`)} to authenticate.
 `);
 }
 async function handleAgentLogin(projectRoot, agent) {
@@ -11939,9 +12032,9 @@ ${bold("Sandbox Status")}
 `);
     }
   }
-  if (!config.sandbox.providers.claude || !config.sandbox.providers.codex) {
+  if (!config.sandbox.providers.claude && !config.sandbox.providers.codex) {
     process.stderr.write(`
-  ${yellow("⚠")} Provider sandboxes are incomplete. Run ${bold("locus sandbox")}.
+  ${yellow("⚠")} No provider sandboxes configured. Run ${bold("locus sandbox")} to create one.
 `);
   }
   process.stderr.write(`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@locusai/cli",
-  "version": "0.20.2",
+  "version": "0.20.3",
   "description": "GitHub-native AI engineering assistant",
   "type": "module",
   "bin": {