@locusai/cli 0.19.0 → 0.19.1

package/bin/locus.js

@@ -7926,7 +7926,6 @@ __export(exports_exec, {
 });
 async function execCommand(projectRoot, args, flags = {}) {
   const config = loadConfig(projectRoot);
-  const _log = getLogger();
   if (args[0] === "sessions") {
     return handleSessionSubcommand(projectRoot, args.slice(1));
   }
@@ -8094,7 +8093,6 @@ function formatAge(isoDate) {
 var init_exec = __esm(() => {
   init_runner();
   init_config();
-  init_logger();
   init_prompt_builder();
   init_sandbox();
   init_terminal();
@@ -11263,7 +11261,10 @@ var init_artifacts = __esm(() => {
 // src/commands/sandbox.ts
 var exports_sandbox2 = {};
 __export(exports_sandbox2, {
-  sandboxCommand: () => sandboxCommand
+  sandboxCommand: () => sandboxCommand,
+  parseSandboxLogsArgs: () => parseSandboxLogsArgs,
+  parseSandboxInstallArgs: () => parseSandboxInstallArgs,
+  parseSandboxExecArgs: () => parseSandboxExecArgs
 });
 import { execSync as execSync17, spawn as spawn6 } from "node:child_process";
 import { createHash } from "node:crypto";
@@ -11276,6 +11277,10 @@ ${bold("Usage:")}
   locus sandbox                     ${dim("# Create claude/codex sandboxes and enable sandbox mode")}
   locus sandbox claude              ${dim("# Run claude interactively (for login)")}
   locus sandbox codex               ${dim("# Run codex interactively (for login)")}
+  locus sandbox install <pkg>       ${dim("# npm install -g package(s) in sandbox(es)")}
+  locus sandbox exec <provider> -- <cmd...> ${dim("# Run one command inside provider sandbox")}
+  locus sandbox shell <provider>    ${dim("# Open interactive shell in provider sandbox")}
+  locus sandbox logs <provider>     ${dim("# Show provider sandbox logs")}
   locus sandbox rm                  ${dim("# Destroy all provider sandboxes and disable sandbox mode")}
   locus sandbox status              ${dim("# Show current sandbox state")}
 
@@ -11283,7 +11288,7 @@ ${bold("Flow:")}
   1. ${cyan("locus sandbox")}          Create provider sandboxes
   2. ${cyan("locus sandbox claude")}   Login Claude inside its sandbox
   3. ${cyan("locus sandbox codex")}    Login Codex inside its sandbox
-  4. ${cyan("locus exec")}/${cyan("locus run")}      Commands resync + execute in provider sandbox
+  4. ${cyan("locus sandbox install bun")}  Install extra tools (optional)
 
 `);
 }
@@ -11296,6 +11301,14 @@ async function sandboxCommand(projectRoot, args) {
     case "claude":
     case "codex":
       return handleAgentLogin(projectRoot, subcommand);
+    case "install":
+      return handleInstall(projectRoot, args.slice(1));
+    case "exec":
+      return handleExec(projectRoot, args.slice(1));
+    case "shell":
+      return handleShell(projectRoot, args.slice(1));
+    case "logs":
+      return handleLogs(projectRoot, args.slice(1));
     case "rm":
       return handleRemove(projectRoot);
     case "status":
@@ -11305,7 +11318,7 @@ async function sandboxCommand(projectRoot, args) {
     default:
       process.stderr.write(`${red("✗")} Unknown sandbox subcommand: ${bold(subcommand)}
 `);
-      process.stderr.write(`  Available: ${cyan("claude")}, ${cyan("codex")}, ${cyan("rm")}, ${cyan("status")}
+      process.stderr.write(`  Available: ${cyan("claude")}, ${cyan("codex")}, ${cyan("install")}, ${cyan("exec")}, ${cyan("shell")}, ${cyan("logs")}, ${cyan("rm")}, ${cyan("status")}
 `);
   }
 }
@@ -11458,6 +11471,259 @@ ${bold("Sandbox Status")}
   process.stderr.write(`
 `);
 }
+function parseSandboxInstallArgs(args) {
+  const packages = [];
+  let provider = "all";
+  for (let i = 0;i < args.length; i++) {
+    const token = args[i];
+    if (token === "--provider") {
+      const value = args[i + 1];
+      if (!value) {
+        return {
+          provider,
+          packages,
+          error: "Missing value for --provider (expected claude, codex, or all)."
+        };
+      }
+      if (value !== "claude" && value !== "codex" && value !== "all") {
+        return {
+          provider,
+          packages,
+          error: `Invalid provider "${value}". Expected claude, codex, or all.`
+        };
+      }
+      provider = value;
+      i++;
+      continue;
+    }
+    if (token.startsWith("--provider=")) {
+      const value = token.slice("--provider=".length);
+      if (value !== "claude" && value !== "codex" && value !== "all") {
+        return {
+          provider,
+          packages,
+          error: `Invalid provider "${value}". Expected claude, codex, or all.`
+        };
+      }
+      provider = value;
+      continue;
+    }
+    if (token.startsWith("-")) {
+      return {
+        provider,
+        packages,
+        error: `Unknown option "${token}".`
+      };
+    }
+    packages.push(token);
+  }
+  if (packages.length === 0) {
+    return {
+      provider,
+      packages,
+      error: "Usage: locus sandbox install <package...> [--provider claude|codex|all]"
+    };
+  }
+  return { provider, packages };
+}
+async function handleInstall(projectRoot, args) {
+  const parsed = parseSandboxInstallArgs(args);
+  if (parsed.error) {
+    process.stderr.write(`${red("✗")} ${parsed.error}
+`);
+    return;
+  }
+  const config = loadConfig(projectRoot);
+  const targets = getTargetProviders(config.sandbox.providers, parsed.provider);
+  if (targets.length === 0) {
+    process.stderr.write(`${red("✗")} No provider sandboxes are configured. Run ${cyan("locus sandbox")} first.
+`);
+    return;
+  }
+  let anySucceeded = false;
+  let anyFailed = false;
+  for (const provider of targets) {
+    const sandboxName = config.sandbox.providers[provider];
+    if (!sandboxName) {
+      process.stderr.write(`${yellow("⚠")} ${provider} sandbox is not configured. Run ${cyan("locus sandbox")} first.
+`);
+      anyFailed = true;
+      continue;
+    }
+    if (!isSandboxAlive(sandboxName)) {
+      process.stderr.write(`${yellow("⚠")} ${provider} sandbox is not running: ${dim(sandboxName)}
+`);
+      anyFailed = true;
+      continue;
+    }
+    process.stderr.write(`Installing ${bold(parsed.packages.join(", "))} in ${provider} sandbox ${dim(sandboxName)}...
+`);
+    const ok = await runInteractiveCommand("docker", [
+      "sandbox",
+      "exec",
+      sandboxName,
+      "npm",
+      "install",
+      "-g",
+      ...parsed.packages
+    ]);
+    if (ok) {
+      anySucceeded = true;
+      process.stderr.write(`${green("✓")} Installed package(s) in ${provider} sandbox.
+`);
+    } else {
+      anyFailed = true;
+      process.stderr.write(`${red("✗")} Failed to install package(s) in ${provider} sandbox.
+`);
+    }
+  }
+  if (!anySucceeded && anyFailed) {
+    process.stderr.write(`${yellow("⚠")} No package installs completed successfully.
+`);
+  }
+}
+function parseSandboxExecArgs(args) {
+  if (args.length === 0) {
+    return {
+      command: [],
+      error: "Usage: locus sandbox exec <provider> -- <command...>"
+    };
+  }
+  const provider = args[0];
+  if (provider !== "claude" && provider !== "codex") {
+    return {
+      command: [],
+      error: `Invalid provider "${provider}". Expected claude or codex.`
+    };
+  }
+  const separatorIndex = args.indexOf("--");
+  const command = separatorIndex >= 0 ? args.slice(separatorIndex + 1) : args.slice(1);
+  if (command.length === 0) {
+    return {
+      provider,
+      command: [],
+      error: "Missing command. Example: locus sandbox exec codex -- bun --version"
+    };
+  }
+  return { provider, command };
+}
+async function handleExec(projectRoot, args) {
+  const parsed = parseSandboxExecArgs(args);
+  if (parsed.error || !parsed.provider) {
+    process.stderr.write(`${red("✗")} ${parsed.error}
+`);
+    return;
+  }
+  const sandboxName = getActiveProviderSandbox(projectRoot, parsed.provider);
+  if (!sandboxName) {
+    return;
+  }
+  await runInteractiveCommand("docker", [
+    "sandbox",
+    "exec",
+    "-w",
+    projectRoot,
+    sandboxName,
+    ...parsed.command
+  ]);
+}
+async function handleShell(projectRoot, args) {
+  const provider = args[0];
+  if (provider !== "claude" && provider !== "codex") {
+    process.stderr.write(`${red("✗")} Usage: locus sandbox shell <provider>  (provider: claude|codex)
+`);
+    return;
+  }
+  const sandboxName = getActiveProviderSandbox(projectRoot, provider);
+  if (!sandboxName) {
+    return;
+  }
+  process.stderr.write(`Opening shell in ${provider} sandbox ${dim(sandboxName)}...
+`);
+  await runInteractiveCommand("docker", [
+    "sandbox",
+    "exec",
+    "-it",
+    "-w",
+    projectRoot,
+    sandboxName,
+    "sh"
+  ]);
+}
+function parseSandboxLogsArgs(args) {
+  if (args.length === 0) {
+    return {
+      follow: false,
+      error: "Usage: locus sandbox logs <provider> [--follow] [--tail <lines>]"
+    };
+  }
+  const provider = args[0];
+  if (provider !== "claude" && provider !== "codex") {
+    return {
+      follow: false,
+      error: `Invalid provider "${provider}". Expected claude or codex.`
+    };
+  }
+  let follow = false;
+  let tail;
+  for (let i = 1;i < args.length; i++) {
+    const token = args[i];
+    if (token === "--follow" || token === "-f") {
+      follow = true;
+      continue;
+    }
+    if (token === "--tail") {
+      const value = args[i + 1];
+      if (!value) {
+        return { provider, follow, tail, error: "Missing value for --tail." };
+      }
+      const parsedTail = Number.parseInt(value, 10);
+      if (!Number.isFinite(parsedTail) || parsedTail < 0) {
+        return { provider, follow, tail, error: "Invalid --tail value." };
+      }
+      tail = parsedTail;
+      i++;
+      continue;
+    }
+    if (token.startsWith("--tail=")) {
+      const value = token.slice("--tail=".length);
+      const parsedTail = Number.parseInt(value, 10);
+      if (!Number.isFinite(parsedTail) || parsedTail < 0) {
+        return { provider, follow, tail, error: "Invalid --tail value." };
+      }
+      tail = parsedTail;
+      continue;
+    }
+    return {
+      provider,
+      follow,
+      tail,
+      error: `Unknown option "${token}".`
+    };
+  }
+  return { provider, follow, tail };
+}
+async function handleLogs(projectRoot, args) {
+  const parsed = parseSandboxLogsArgs(args);
+  if (parsed.error || !parsed.provider) {
+    process.stderr.write(`${red("✗")} ${parsed.error}
+`);
+    return;
+  }
+  const sandboxName = getActiveProviderSandbox(projectRoot, parsed.provider);
+  if (!sandboxName) {
+    return;
+  }
+  const dockerArgs = ["sandbox", "logs"];
+  if (parsed.follow) {
+    dockerArgs.push("--follow");
+  }
+  if (parsed.tail !== undefined) {
+    dockerArgs.push("--tail", String(parsed.tail));
+  }
+  dockerArgs.push(sandboxName);
+  await runInteractiveCommand("docker", dockerArgs);
+}
 function buildProviderSandboxNames(projectRoot) {
   const segment = sanitizeSegment(basename4(projectRoot));
   const hash = createHash("sha1").update(projectRoot).digest("hex").slice(0, 8);
@@ -11470,6 +11736,36 @@ function sanitizeSegment(input) {
   const cleaned = input.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
   return cleaned || "workspace";
 }
+function getTargetProviders(sandboxes, provider) {
+  if (provider === "claude" || provider === "codex") {
+    return [provider];
+  }
+  return PROVIDERS.filter((name) => Boolean(sandboxes[name]));
+}
+function getActiveProviderSandbox(projectRoot, provider) {
+  const config = loadConfig(projectRoot);
+  const sandboxName = config.sandbox.providers[provider];
+  if (!sandboxName) {
+    process.stderr.write(`${red("✗")} No ${provider} sandbox configured. Run ${cyan("locus sandbox")} first.
+`);
+    return null;
+  }
+  if (!isSandboxAlive(sandboxName)) {
+    process.stderr.write(`${red("✗")} ${provider} sandbox is not running: ${dim(sandboxName)}
+`);
+    process.stderr.write(`  Recreate it with ${cyan("locus sandbox")}.
+`);
+    return null;
+  }
+  return sandboxName;
+}
+function runInteractiveCommand(command, args) {
+  return new Promise((resolve2) => {
+    const child = spawn6(command, args, { stdio: "inherit" });
+    child.on("close", (code) => resolve2(code === 0));
+    child.on("error", () => resolve2(false));
+  });
+}
 async function createProviderSandbox(provider, sandboxName, projectRoot) {
   try {
     execSync17(`docker sandbox run --name ${sandboxName} claude ${projectRoot} -- --version`, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@locusai/cli",
-  "version": "0.19.0",
+  "version": "0.19.1",
   "description": "GitHub-native AI engineering assistant",
   "type": "module",
   "bin": {
@@ -10,8 +10,8 @@
     "build": "bun build src/cli.ts --outfile bin/locus.js --target node",
     "dev": "bun run src/cli.ts",
     "test": "bun test",
-    "test:unit": "bun test src/core/__tests__ src/repl/__tests__ src/display/__tests__ src/ai/__tests__",
-    "test:integration": "bun test src/commands/__tests__",
+    "test:unit": "bun test __tests__",
+    "test:integration": "bun test __tests__",
     "test:watch": "bun test --watch",
     "test:coverage": "bun test --coverage",
     "typecheck": "tsc --noEmit",