@aiden-ade/sandbox-agent 0.1.11 → 0.1.13

package/dist/index.cjs

@@ -5304,17 +5304,39 @@ function buildPlanModePrefix(promptText) {
     promptText
   ].join("\n");
 }
-function spawnCli(command, args, context) {
+function planCliSpawn(command, args, env = process.env) {
   const isWindows = process.platform === "win32";
-  return (0, import_child_process.spawn)(command, args, {
+  const comSpec = env.ComSpec ?? process.env.ComSpec ?? "cmd.exe";
+  if (isWindows && /\.(cmd|bat)$/i.test(command)) {
+    return {
+      file: comSpec,
+      args: ["/d", "/s", "/c", command, ...args],
+      shell: false,
+      windowsHide: true
+    };
+  }
+  if (isWindows && /[\\/]/.test(command) && /\.exe$/i.test(command)) {
+    return { file: command, args, shell: false, windowsHide: true };
+  }
+  return {
+    file: command,
+    args,
+    shell: isWindows,
+    windowsHide: isWindows ? true : void 0
+  };
+}
+function spawnCli(command, args, context) {
+  const plan = planCliSpawn(command, args, context.env);
+  return (0, import_child_process.spawn)(plan.file, plan.args, {
     cwd: context.cwd,
     env: context.env,
     stdio: ["pipe", "pipe", "pipe"],
-    shell: isWindows,
+    shell: plan.shell,
+    windowsHide: plan.windowsHide,
     // Detached on Unix creates a new process group so we can kill the entire tree
     // (CLI tools spawn child processes for tool execution that would otherwise be orphaned).
     // On Windows, detached opens a new console — shell mode handles grouping instead.
-    detached: !isWindows
+    detached: process.platform !== "win32"
   });
 }
 function createGenericCliBackend(options) {
@@ -7181,6 +7203,198 @@ Prefer relative paths and keep your work scoped to this project.`
   }
 };
 
+// src/core-agent.ts
+var import_node_os2 = require("os");
+
+// src/cli-executable.ts
+var import_node_fs = require("fs");
+var import_node_child_process = require("child_process");
+var import_node_os = require("os");
+var import_node_path = require("path");
+var PROVIDER_CLI_COMMANDS = {
+  claude_cli: { provider: "claude_cli", command: "claude", envVar: "AIDEN_CLAUDE_PATH" },
+  codex: { provider: "codex", command: "codex", envVar: "AIDEN_CODEX_PATH" },
+  gemini: { provider: "gemini", command: "gemini", envVar: "AIDEN_GEMINI_PATH" }
+};
+var BACKEND_CLI_COMMANDS = {
+  claude_cli: "claude",
+  codex: "codex",
+  codex_app_server: "codex",
+  gemini_cli: "gemini",
+  gemini: "gemini"
+};
+var resolvedCliCache = /* @__PURE__ */ new Map();
+function getDaemonCliEnvironment() {
+  return augmentCliPath(process.env);
+}
+function cacheResolvedCli(command, resolvedPath) {
+  resolvedCliCache.set(command, resolvedPath);
+}
+function getCachedResolvedCli(command) {
+  return resolvedCliCache.get(command);
+}
+function resolveViaWhere(command, env) {
+  if ((0, import_node_os.platform)() !== "win32") return null;
+  const whereExe = (0, import_node_path.join)(env.SystemRoot ?? process.env.SystemRoot ?? "C:\\Windows", "System32", "where.exe");
+  if (!(0, import_node_fs.existsSync)(whereExe)) return null;
+  const result = (0, import_node_child_process.spawnSync)(whereExe, [command], {
+    encoding: "utf8",
+    env,
+    windowsHide: true,
+    timeout: 3e3
+  });
+  if (result.error || result.status !== 0) return null;
+  for (const line of result.stdout.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    if (isRunnableFile(trimmed)) return trimmed;
+  }
+  return null;
+}
+function runCliVersionProbe(executable, env, args = ["--version"]) {
+  const isWin = (0, import_node_os.platform)() === "win32";
+  if (isWin && /\.(cmd|bat)$/i.test(executable)) {
+    const comSpec = env.ComSpec ?? process.env.ComSpec ?? "cmd.exe";
+    return (0, import_node_child_process.spawnSync)(comSpec, ["/d", "/s", "/c", executable, ...args], {
+      encoding: "utf8",
+      timeout: 3e3,
+      env,
+      windowsHide: true
+    });
+  }
+  const useShell = isWin && !/[\\/]/.test(executable);
+  return (0, import_node_child_process.spawnSync)(executable, args, {
+    encoding: "utf8",
+    timeout: 3e3,
+    env,
+    shell: useShell,
+    windowsHide: isWin ? true : void 0
+  });
+}
+function pathSeparator() {
+  return (0, import_node_os.platform)() === "win32" ? ";" : ":";
+}
+function splitPath(pathValue) {
+  if (!pathValue) return [];
+  return pathValue.split(pathSeparator()).filter(Boolean);
+}
+function isRunnableFile(path) {
+  if (!(0, import_node_fs.existsSync)(path)) return false;
+  if ((0, import_node_os.platform)() === "win32") return true;
+  try {
+    (0, import_node_fs.accessSync)(path, import_node_fs.constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function windowsCommandCandidates(command, pathExt) {
+  const trimmed = command.trim();
+  if (!trimmed) return [];
+  const hasExtension = /\.[a-z0-9]+$/i.test(trimmed);
+  if (hasExtension) return [trimmed];
+  const extensions = pathExt.split(";").map((ext) => ext.trim()).filter(Boolean);
+  return [trimmed, ...extensions.map((ext) => `${trimmed}${ext}`)];
+}
+function augmentCliPath(env) {
+  const home = env.HOME || env.USERPROFILE || (0, import_node_os.homedir)();
+  const isWin = (0, import_node_os.platform)() === "win32";
+  const extraPaths = isWin ? [
+    (0, import_node_path.join)(home, "AppData", "Roaming", "npm"),
+    (0, import_node_path.join)(home, "AppData", "Local", "Programs", "Microsoft", "WindowsApps"),
+    (0, import_node_path.join)(home, ".local", "bin"),
+    "C:\\Program Files\\nodejs",
+    "C:\\Program Files\\Git\\cmd"
+  ] : [
+    (0, import_node_path.join)(home, ".local", "bin"),
+    (0, import_node_path.join)(home, ".local", "node", "bin"),
+    (0, import_node_path.join)(home, ".bun", "bin"),
+    (0, import_node_path.join)(home, ".cargo", "bin"),
+    "/opt/homebrew/bin",
+    "/usr/local/bin"
+  ];
+  const basePath = env.PATH ?? "";
+  const existing = new Set(splitPath(basePath));
+  const missing = extraPaths.filter((dir) => !existing.has(dir));
+  if (missing.length === 0) return env;
+  return {
+    ...env,
+    PATH: missing.length > 0 ? `${missing.join(pathSeparator())}${pathSeparator()}${basePath}` : basePath
+  };
+}
+function resolveCliExecutable(command, env = getDaemonCliEnvironment()) {
+  const trimmed = command.trim();
+  if (!trimmed) return null;
+  const cached = resolvedCliCache.get(trimmed);
+  if (cached && isRunnableFile(cached)) return cached;
+  if ((trimmed.includes("/") || trimmed.includes("\\")) && isRunnableFile(trimmed)) {
+    resolvedCliCache.set(trimmed, trimmed);
+    return trimmed;
+  }
+  const enriched = augmentCliPath(env);
+  const home = enriched.HOME || enriched.USERPROFILE || (0, import_node_os.homedir)();
+  const isWin = (0, import_node_os.platform)() === "win32";
+  const pathExt = enriched.PATHEXT ?? (isWin ? ".EXE;.CMD;.BAT;.COM" : "");
+  const names = isWin ? windowsCommandCandidates(trimmed, pathExt) : [trimmed];
+  const candidates = [];
+  for (const name of names) {
+    if (name.includes("/") || name.includes("\\")) {
+      candidates.push(name);
+      continue;
+    }
+    for (const dir of splitPath(enriched.PATH)) {
+      candidates.push((0, import_node_path.join)(dir, name));
+    }
+    candidates.push(
+      (0, import_node_path.join)(home, ".local", "bin", name),
+      (0, import_node_path.join)(home, ".local", "node", "bin", name)
+    );
+    if (!isWin) {
+      candidates.push((0, import_node_path.join)("/opt/homebrew/bin", name), (0, import_node_path.join)("/usr/local/bin", name));
+    } else {
+      candidates.push((0, import_node_path.join)(home, "AppData", "Roaming", "npm", name));
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const candidate of candidates) {
+    if (seen.has(candidate)) continue;
+    seen.add(candidate);
+    if (isRunnableFile(candidate)) {
+      resolvedCliCache.set(trimmed, candidate);
+      return candidate;
+    }
+  }
+  const viaWhere = resolveViaWhere(trimmed, enriched);
+  if (viaWhere) {
+    resolvedCliCache.set(trimmed, viaWhere);
+    return viaWhere;
+  }
+  return null;
+}
+function resolveProviderCliCommand(provider, env = getDaemonCliEnvironment()) {
+  const spec = PROVIDER_CLI_COMMANDS[provider];
+  const override = process.env[spec.envVar]?.trim();
+  if (override) {
+    const resolved2 = resolveCliExecutable(override, env) ?? (isRunnableFile(override) ? override : null);
+    if (resolved2) cacheResolvedCli(spec.command, resolved2);
+    return resolved2;
+  }
+  const resolved = resolveCliExecutable(spec.command, env);
+  if (resolved) cacheResolvedCli(spec.command, resolved);
+  return resolved;
+}
+function resolveBackendRuntimeCommand(backendKind, env = getDaemonCliEnvironment()) {
+  if (!backendKind) return void 0;
+  const command = BACKEND_CLI_COMMANDS[backendKind];
+  if (!command) return void 0;
+  const cached = getCachedResolvedCli(command);
+  if (cached && isRunnableFile(cached)) return cached;
+  const envOverride = command === "codex" ? env.AIDEN_CODEX_PATH : command === "claude" ? env.AIDEN_CLAUDE_PATH : command === "gemini" ? env.AIDEN_GEMINI_PATH : void 0;
+  const resolved = resolveCliExecutable(envOverride?.trim() || command, env);
+  if (resolved) cacheResolvedCli(command, resolved);
+  return resolved ?? void 0;
+}
+
 // src/core-agent.ts
 var CoreAgent = class _CoreAgent extends BaseMachineAgent {
   childProcess = null;
@@ -7308,18 +7522,23 @@ var CoreAgent = class _CoreAgent extends BaseMachineAgent {
     };
   }
   async buildCliEnvironment() {
-    const loginEnv = process.env;
     const env = {};
-    for (const [key, value2] of Object.entries(loginEnv)) {
+    for (const [key, value2] of Object.entries(process.env)) {
       if (value2 !== void 0) env[key] = value2;
     }
-    const home = env.HOME ?? "/home/user";
-    const extraPaths = [`${home}/.local/node/bin`, `${home}/.local/bin`];
-    const basePath = env.PATH ?? "";
-    const existingSegments = new Set(basePath.split(":").filter(Boolean));
-    const missing = extraPaths.filter((p) => !existingSegments.has(p));
-    env.PATH = missing.length > 0 ? `${missing.join(":")}:${basePath}` : basePath;
-    return env;
+    const augmented = getDaemonCliEnvironment();
+    if ((0, import_node_os2.platform)() !== "win32") {
+      const home = augmented.HOME ?? "/home/user";
+      const extraPaths = [`${home}/.local/node/bin`, `${home}/.local/bin`];
+      const separator = ":";
+      const basePath = augmented.PATH ?? "";
+      const existingSegments = new Set(basePath.split(separator).filter(Boolean));
+      const missing = extraPaths.filter((p) => !existingSegments.has(p));
+      if (missing.length > 0) {
+        augmented.PATH = `${missing.join(separator)}${separator}${basePath}`;
+      }
+    }
+    return augmented;
   }
   buildExtraSystemPromptParts(config) {
     const parts2 = [];
@@ -11142,7 +11361,7 @@ var WSClient = class {
 };
 
 // src/version.ts
-var AGENT_VERSION = "0.1.11";
+var AGENT_VERSION = "0.1.13";
 
 // src/sandbox.ts
 async function runSandbox(config) {
@@ -11318,44 +11537,43 @@ async function runSandbox(config) {
 }
 
 // src/daemon.ts
-var import_node_fs = require("fs");
+var import_node_fs2 = require("fs");
 var import_node_http = __toESM(require("http"), 1);
 var import_node_crypto = require("crypto");
-var import_node_os = require("os");
-var import_node_path = require("path");
-var import_node_child_process = require("child_process");
+var import_node_os3 = require("os");
+var import_node_path2 = require("path");
 var PRODUCTION_API_URL = "https://api.aiden-platform.com";
 var PRODUCTION_WS_URL = "wss://ws.aiden-platform.com";
 var LOCAL_API_URL = "http://localhost:8400";
 var LOCAL_WS_URL = "ws://localhost:8401";
 function getConfigPath() {
-  return process.env.AIDEN_AGENT_CONFIG_PATH ?? (0, import_node_path.join)((0, import_node_os.homedir)(), ".aiden", "agent", "config.json");
+  return process.env.AIDEN_AGENT_CONFIG_PATH ?? (0, import_node_path2.join)((0, import_node_os3.homedir)(), ".aiden", "agent", "config.json");
 }
 function getEndpointDefaultsPath() {
-  return process.env.AIDEN_AGENT_ENDPOINTS_PATH ?? (0, import_node_path.join)((0, import_node_path.dirname)(getConfigPath()), "endpoints.json");
+  return process.env.AIDEN_AGENT_ENDPOINTS_PATH ?? (0, import_node_path2.join)((0, import_node_path2.dirname)(getConfigPath()), "endpoints.json");
 }
 function readConfig() {
   const configPath = getConfigPath();
-  if (!(0, import_node_fs.existsSync)(configPath)) return {};
-  return JSON.parse((0, import_node_fs.readFileSync)(configPath, "utf8"));
+  if (!(0, import_node_fs2.existsSync)(configPath)) return {};
+  return JSON.parse((0, import_node_fs2.readFileSync)(configPath, "utf8"));
 }
 function readEndpointDefaults() {
   const endpointsPath = getEndpointDefaultsPath();
-  if (!(0, import_node_fs.existsSync)(endpointsPath)) return {};
+  if (!(0, import_node_fs2.existsSync)(endpointsPath)) return {};
   try {
-    return JSON.parse((0, import_node_fs.readFileSync)(endpointsPath, "utf8"));
+    return JSON.parse((0, import_node_fs2.readFileSync)(endpointsPath, "utf8"));
   } catch {
     return {};
   }
 }
 function writeConfig(config) {
   const configPath = getConfigPath();
-  (0, import_node_fs.mkdirSync)((0, import_node_path.dirname)(configPath), { recursive: true, mode: 448 });
-  (0, import_node_fs.writeFileSync)(configPath, JSON.stringify(config, null, 2), { mode: 384 });
+  (0, import_node_fs2.mkdirSync)((0, import_node_path2.dirname)(configPath), { recursive: true, mode: 448 });
+  (0, import_node_fs2.writeFileSync)(configPath, JSON.stringify(config, null, 2), { mode: 384 });
 }
 function removeConfig() {
   const configPath = getConfigPath();
-  if ((0, import_node_fs.existsSync)(configPath)) (0, import_node_fs.rmSync)(configPath, { force: true });
+  if ((0, import_node_fs2.existsSync)(configPath)) (0, import_node_fs2.rmSync)(configPath, { force: true });
 }
 function argValue(args, name) {
   const index = args.indexOf(name);
@@ -11392,20 +11610,24 @@ function sleep(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 function commandVersion(command, args = ["--version"]) {
-  const result = (0, import_node_child_process.spawnSync)(command, args, { encoding: "utf8", timeout: 3e3 });
+  const env = getDaemonCliEnvironment();
+  const executable = command === "claude" ? resolveProviderCliCommand("claude_cli", env) : command === "codex" ? resolveProviderCliCommand("codex", env) : command === "gemini" ? resolveProviderCliCommand("gemini", env) : resolveCliExecutable(command, env);
+  if (!executable) return void 0;
+  const result = runCliVersionProbe(executable, env, args);
   if (result.error || result.status !== 0) return void 0;
   return (result.stdout || result.stderr).split("\n")[0]?.trim() || void 0;
 }
+function normalizeBackendKind(backendKind) {
+  if (backendKind === "codex") return "codex_app_server";
+  return backendKind;
+}
 function discoverCapabilities() {
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  const providers = [
-    { provider: "claude_cli", command: process.env.AIDEN_CLAUDE_PATH ?? "claude" },
-    { provider: "codex", command: process.env.AIDEN_CODEX_PATH ?? "codex" },
-    { provider: "gemini", command: process.env.AIDEN_GEMINI_PATH ?? "gemini" }
-  ];
+  const providers = ["claude_cli", "codex", "gemini"];
   return {
-    agents: providers.map(({ provider, command }) => {
-      const version = commandVersion(command);
+    agents: providers.map((provider) => {
+      const executable = resolveProviderCliCommand(provider);
+      const version = executable ? commandVersion(executable) : void 0;
       return {
         provider,
         available: Boolean(version),
@@ -11494,7 +11716,7 @@ async function setupDaemon(args) {
   const teamId = argValue(args, "--team") ?? process.env.AIDEN_TEAM_ID;
   const setupToken = argValue(args, "--setup-token") ?? process.env.AIDEN_RUNTIME_SETUP_TOKEN;
   const token = argValue(args, "--token") ?? process.env.AIDEN_SETUP_TOKEN;
-  const displayName = argValue(args, "--name") ?? (0, import_node_os.hostname)();
+  const displayName = argValue(args, "--name") ?? (0, import_node_os3.hostname)();
   const legacyLocalMachineId = argValue(args, "--legacy-local-machine-id") ?? process.env.AIDEN_LEGACY_LOCAL_MACHINE_ID;
   const scope = argValue(args, "--scope") ?? process.env.AIDEN_RUNTIME_SCOPE ?? "team";
   if (scope !== "team" && scope !== "user") {
@@ -11515,7 +11737,7 @@ async function setupDaemon(args) {
       ...teamId ? { teamId } : {},
       ...setupToken ? { setupToken } : {},
       displayName,
-      hostname: (0, import_node_os.hostname)(),
+      hostname: (0, import_node_os3.hostname)(),
       ...legacyLocalMachineId ? { legacyLocalMachineId } : {},
       runtimeKind: "machine",
       managementKind: "user_managed",
@@ -11525,8 +11747,8 @@ async function setupDaemon(args) {
       visibility: scope,
       capabilities: discoverCapabilities(),
       metadata: {
-        platform: (0, import_node_os.platform)(),
-        arch: (0, import_node_os.arch)(),
+        platform: (0, import_node_os3.platform)(),
+        arch: (0, import_node_os3.arch)(),
         agentVersion: AGENT_VERSION
       }
     })
@@ -11550,18 +11772,18 @@ async function setupDaemon(args) {
 }
 async function loginWithDeviceCode(args) {
   const { apiUrl, wsUrl, endpointProfile } = resolveEndpoints(args);
-  const displayName = argValue(args, "--name") ?? (0, import_node_os.hostname)();
+  const displayName = argValue(args, "--name") ?? (0, import_node_os3.hostname)();
   const maxPolls = Number.parseInt(argValue(args, "--max-polls") ?? "300", 10);
   const start = await fetch(`${apiUrl}/public/runtimes/device-authorizations`, {
     method: "POST",
     headers: { "content-type": "application/json" },
     body: JSON.stringify({
       displayName,
-      hostname: (0, import_node_os.hostname)(),
+      hostname: (0, import_node_os3.hostname)(),
       capabilities: discoverCapabilities(),
       metadata: {
-        platform: (0, import_node_os.platform)(),
-        arch: (0, import_node_os.arch)(),
+        platform: (0, import_node_os3.platform)(),
+        arch: (0, import_node_os3.arch)(),
         agentVersion: AGENT_VERSION
       }
     })
@@ -11657,11 +11879,21 @@ async function startDaemon(args) {
       socket.emit("agent.rejected", { runId: payload.runId, message: "Run is already active" });
       return;
     }
+    const backendKind = normalizeBackendKind(payload.backendKind);
+    const runtimeCommand = resolveBackendRuntimeCommand(backendKind ?? payload.backendKind);
+    if (!runtimeCommand && backendKind) {
+      socket.emit("agent.rejected", {
+        runId: payload.runId,
+        message: `CLI command not found for ${backendKind}. Install the provider CLI and restart the daemon.`
+      });
+      return;
+    }
     socket.emit("agent.accepted", { runId: payload.runId });
     pushLog(`accepted run=${payload.runId}`);
     const presenter = new RuntimePresenter(socket, payload.conversationId, payload.runId);
     const agent = new CoreAgent(presenter, {
-      backendKind: payload.backendKind
+      backendKind,
+      runtimeCommand
     });
     activeAgents.set(payload.runId, agent);
     const cwd = payload.projectPath ?? process.cwd();
@@ -11670,7 +11902,8 @@ async function startDaemon(args) {
       maxIterations: payload.maxIterations ?? 50,
       teamPath: cwd,
       cwd,
-      backendKind: payload.backendKind,
+      backendKind,
+      runtimeCommand,
       agentId: payload.agentId,
       agentPrompt: payload.agentPrompt,
       mode: payload.mode ?? "agent",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiden-ade/sandbox-agent",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "type": "module",
   "bin": {
     "aiden-agent": "./dist/index.cjs"