@aiden-ade/sandbox-agent 0.1.10 → 0.1.12

package/dist/index.cjs

@@ -7181,6 +7181,128 @@ 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_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"
+};
+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 = process.env) {
+  const trimmed = command.trim();
+  if (!trimmed) return null;
+  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)) return candidate;
+  }
+  return null;
+}
+function resolveProviderCliCommand(provider) {
+  const spec = PROVIDER_CLI_COMMANDS[provider];
+  const override = process.env[spec.envVar]?.trim();
+  if (override) {
+    return resolveCliExecutable(override) ?? (isRunnableFile(override) ? override : null);
+  }
+  return resolveCliExecutable(spec.command);
+}
+function resolveBackendRuntimeCommand(backendKind, env = process.env) {
+  if (!backendKind) return void 0;
+  const command = BACKEND_CLI_COMMANDS[backendKind];
+  if (!command) return void 0;
+  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);
+  return resolved ?? void 0;
+}
+
 // src/core-agent.ts
 var CoreAgent = class _CoreAgent extends BaseMachineAgent {
   childProcess = null;
@@ -7308,18 +7430,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 = augmentCliPath(env);
+    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 +11269,7 @@ var WSClient = class {
 };
 
 // src/version.ts
-var AGENT_VERSION = "0.1.9";
+var AGENT_VERSION = "0.1.12";
 
 // src/sandbox.ts
 async function runSandbox(config) {
@@ -11318,29 +11445,70 @@ 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_os3 = require("os");
+var import_node_path2 = require("path");
 var import_node_child_process = require("child_process");
-var CONFIG_PATH = process.env.AIDEN_AGENT_CONFIG_PATH ?? (0, import_node_path.join)((0, import_node_os.homedir)(), ".aiden", "agent", "config.json");
+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_path2.join)((0, import_node_os3.homedir)(), ".aiden", "agent", "config.json");
+}
+function getEndpointDefaultsPath() {
+  return process.env.AIDEN_AGENT_ENDPOINTS_PATH ?? (0, import_node_path2.join)((0, import_node_path2.dirname)(getConfigPath()), "endpoints.json");
+}
 function readConfig() {
-  if (!(0, import_node_fs.existsSync)(CONFIG_PATH)) return {};
-  return JSON.parse((0, import_node_fs.readFileSync)(CONFIG_PATH, "utf8"));
+  const configPath = getConfigPath();
+  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_fs2.existsSync)(endpointsPath)) return {};
+  try {
+    return JSON.parse((0, import_node_fs2.readFileSync)(endpointsPath, "utf8"));
+  } catch {
+    return {};
+  }
 }
 function writeConfig(config) {
-  (0, import_node_fs.mkdirSync)((0, import_node_path.dirname)(CONFIG_PATH), { recursive: true, mode: 448 });
-  (0, import_node_fs.writeFileSync)(CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 384 });
+  const configPath = getConfigPath();
+  (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() {
-  if ((0, import_node_fs.existsSync)(CONFIG_PATH)) (0, import_node_fs.rmSync)(CONFIG_PATH, { force: true });
+  const configPath = getConfigPath();
+  if ((0, import_node_fs2.existsSync)(configPath)) (0, import_node_fs2.rmSync)(configPath, { force: true });
 }
 function argValue(args, name) {
   const index = args.indexOf(name);
   if (index === -1) return void 0;
   return args[index + 1];
 }
+function resolveEndpointProfile(args) {
+  const profile = argValue(args, "--profile") ?? process.env.AIDEN_AGENT_PROFILE;
+  if (!profile) return "production";
+  if (profile === "production" || profile === "prod") return "production";
+  if (profile === "local" || profile === "dev") return "local";
+  throw new Error("Unsupported endpoint profile. Use --profile production or --profile local.");
+}
+function resolveEndpoints(args, stored = {}) {
+  const requestedProfile = resolveEndpointProfile(args);
+  const profileApiUrl = requestedProfile === "local" ? LOCAL_API_URL : PRODUCTION_API_URL;
+  const profileWsUrl = requestedProfile === "local" ? LOCAL_WS_URL : PRODUCTION_WS_URL;
+  const endpointDefaults = readEndpointDefaults();
+  const apiUrl = argValue(args, "--api-url") ?? process.env.AIDEN_API_URL ?? stored.apiUrl ?? endpointDefaults.apiUrl ?? profileApiUrl;
+  const wsUrl = argValue(args, "--ws-url") ?? process.env.AIDEN_WS_URL ?? stored.wsUrl ?? endpointDefaults.wsUrl ?? profileWsUrl;
+  const endpointProfile = apiUrl === profileApiUrl && wsUrl === profileWsUrl ? requestedProfile : apiUrl === endpointDefaults.apiUrl && wsUrl === endpointDefaults.wsUrl && endpointDefaults.endpointProfile ? endpointDefaults.endpointProfile : "custom";
+  return { apiUrl, wsUrl, endpointProfile };
+}
+function isLocalEndpoint(url2) {
+  return Boolean(url2 && /^(https?|wss?):\/\/(localhost|127\.0\.0\.1)(:\d+)?(\/|$)/.test(url2));
+}
 function getLocalApiPort(args, stored) {
   const raw = argValue(args, "--local-api-port") ?? process.env.AIDEN_AGENT_LOCAL_API_PORT;
   if (raw) return Number.parseInt(raw, 10);
@@ -11351,20 +11519,26 @@ 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 executable = resolveCliExecutable(command) ?? command;
+  const result = (0, import_node_child_process.spawnSync)(executable, args, {
+    encoding: "utf8",
+    timeout: 3e3,
+    env: augmentCliPath(process.env)
+  });
   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),
@@ -11449,16 +11623,19 @@ var RuntimePresenter = class {
   }
 };
 async function setupDaemon(args) {
-  const apiUrl = argValue(args, "--api-url") ?? process.env.AIDEN_API_URL ?? "http://localhost:8400";
-  const wsUrl = argValue(args, "--ws-url") ?? process.env.AIDEN_WS_URL ?? "ws://localhost:8401";
+  const { apiUrl, wsUrl, endpointProfile } = resolveEndpoints(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") {
+    throw new Error("setup --scope must be either 'team' or 'user'");
+  }
   if (!setupToken && (!teamId || !token)) {
     throw new Error(
-      "setup requires the full command generated by Aiden: aiden-agent setup --api-url <api-url> --ws-url <ws-url> --setup-token <token>\nAlternatively, use browser authorization with: aiden-agent login --api-url <api-url> --ws-url <ws-url>"
+      "setup requires --setup-token <token> or --team <team-id> and --token <aiden PAT>.\nFor normal setup, copy the setup token from Aiden and run: aiden-agent setup --setup-token <token>\nFor browser authorization, run: aiden-agent login"
     );
   }
   const response = await fetch(`${apiUrl}/public/runtimes${setupToken ? "/register-with-setup-token" : ""}`, {
@@ -11471,18 +11648,18 @@ 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",
       hostKind: "daemon",
       lifecycle: "durable",
-      ownerType: "team",
-      visibility: "team",
+      ownerType: scope,
+      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
       }
     })
@@ -11494,6 +11671,7 @@ async function setupDaemon(args) {
   writeConfig({
     apiUrl,
     wsUrl,
+    endpointProfile,
     teamId,
     runtimeId: body.runtime.id,
     runtimeToken: body.runtimeToken,
@@ -11501,23 +11679,22 @@ async function setupDaemon(args) {
     localApiToken: (0, import_node_crypto.randomBytes)(24).toString("hex"),
     displayName: body.runtime.displayName ?? displayName
   });
-  console.info("[aiden-agent] Runtime registered", { runtimeId: body.runtime.id, configPath: CONFIG_PATH });
+  console.info("[aiden-agent] Runtime registered", { runtimeId: body.runtime.id, configPath: getConfigPath() });
 }
 async function loginWithDeviceCode(args) {
-  const apiUrl = argValue(args, "--api-url") ?? process.env.AIDEN_API_URL ?? "http://localhost:8400";
-  const wsUrl = argValue(args, "--ws-url") ?? process.env.AIDEN_WS_URL ?? "ws://localhost:8401";
-  const displayName = argValue(args, "--name") ?? (0, import_node_os.hostname)();
+  const { apiUrl, wsUrl, endpointProfile } = resolveEndpoints(args);
+  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
       }
     })
@@ -11544,6 +11721,7 @@ async function loginWithDeviceCode(args) {
     writeConfig({
       apiUrl,
       wsUrl,
+      endpointProfile,
       teamId: body.runtime.teamId ?? void 0,
       runtimeId: body.runtime.id,
       runtimeToken: body.runtimeToken,
@@ -11551,7 +11729,7 @@ async function loginWithDeviceCode(args) {
       localApiToken: (0, import_node_crypto.randomBytes)(24).toString("hex"),
       displayName: body.runtime.displayName ?? displayName
     });
-    console.info("[aiden-agent] Runtime registered", { runtimeId: body.runtime.id, configPath: CONFIG_PATH });
+    console.info("[aiden-agent] Runtime registered", { runtimeId: body.runtime.id, configPath: getConfigPath() });
     return;
   }
   throw new Error("device authorization timed out before approval");
@@ -11612,11 +11790,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 it or set the full path via AIDEN_CODEX_PATH / AIDEN_CLAUDE_PATH / AIDEN_GEMINI_PATH.`
+      });
+      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();
@@ -11625,7 +11813,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",
@@ -11796,17 +11985,27 @@ async function revokeRuntimeToken(args) {
 }
 function logoutDaemon() {
   removeConfig();
-  console.info("[aiden-agent] Runtime config removed", { configPath: CONFIG_PATH });
+  console.info("[aiden-agent] Runtime config removed", { configPath: getConfigPath() });
 }
 function printStatus() {
   const config = readConfig();
+  const configured = Boolean(config.runtimeId && config.runtimeToken && config.wsUrl);
+  const warnings = [];
+  if ((isLocalEndpoint(config.apiUrl) || isLocalEndpoint(config.wsUrl)) && config.endpointProfile !== "local") {
+    warnings.push("Configured endpoint points at localhost. Use --profile local only for local development.");
+  }
   console.info(JSON.stringify({
-    configured: Boolean(config.runtimeId && config.runtimeToken && config.wsUrl),
+    mode: "runtime",
+    configured,
     runtimeId: config.runtimeId ?? null,
+    apiUrl: config.apiUrl ?? null,
     wsUrl: config.wsUrl ?? null,
+    endpointProfile: config.endpointProfile ?? null,
     localApiPort: config.localApiPort ?? null,
     hasLocalApiToken: Boolean(config.localApiToken),
-    configPath: CONFIG_PATH
+    configPath: getConfigPath(),
+    note: configured ? "Durable runtime config is present. Start it with: aiden-agent daemon" : "No durable runtime configured. Cloud sandbox sessions are launched by Aiden with session env vars and do not appear in this local config.",
+    warnings
   }, null, 2));
 }
 async function printDoctor(args = []) {
@@ -11834,10 +12033,13 @@ async function printDoctor(args = []) {
   }
   console.info(JSON.stringify({
     version: AGENT_VERSION,
-    configPath: CONFIG_PATH,
+    configPath: getConfigPath(),
     configured: Boolean(config.runtimeId && config.runtimeToken && config.wsUrl),
     runtimeId: config.runtimeId ?? null,
+    apiUrl: config.apiUrl ?? null,
     wsUrl: config.wsUrl ?? null,
+    endpointProfile: config.endpointProfile ?? null,
+    warnings: (isLocalEndpoint(config.apiUrl) || isLocalEndpoint(config.wsUrl)) && config.endpointProfile !== "local" ? ["Configured endpoint points at localhost. Use --profile local only for local development."] : [],
     synced,
     syncError,
     capabilities
@@ -11858,12 +12060,17 @@ Commands:
   doctor      Check local CLI capabilities
   logout      Remove local runtime configuration
   token       Rotate or revoke the configured runtime token
-  run-session Run a sandbox session from AIDEN_* environment variables
+  run-session Internal: run one ephemeral sandbox/session from AIDEN_* env vars
 
 Common flows:
-  aiden-agent setup --api-url <api-url> --ws-url <ws-url> --setup-token <token>
-  aiden-agent login --api-url <api-url> --ws-url <ws-url>
+  aiden-agent login
+  aiden-agent setup --setup-token <token>
+  aiden-agent setup --setup-token <token> --scope user
   aiden-agent daemon
+
+Local development:
+  aiden-agent login --profile local
+  aiden-agent setup --profile local --setup-token <token>
 `;
 function hasRunSessionEnv(env) {
   return Boolean(
@@ -11899,7 +12106,9 @@ async function runSessionFromEnv() {
   const effortLevel = process.env.AIDEN_EFFORT_LEVEL || void 0;
   const providerSessionId = process.env.AIDEN_PROVIDER_SESSION_ID || void 0;
   if (!wsUrl || !sessionId || !taskId || !sessionToken || task == null) {
-    throw new Error("Missing required env vars: AIDEN_WS_URL, AIDEN_SESSION_ID, AIDEN_TASK_ID, AIDEN_SESSION_TOKEN, AIDEN_TASK");
+    throw new Error(
+      "run-session is an internal Aiden sandbox/session command and must be launched by Aiden with session env vars. Missing required env vars: AIDEN_WS_URL, AIDEN_SESSION_ID, AIDEN_TASK_ID, AIDEN_SESSION_TOKEN, AIDEN_TASK"
+    );
   }
   console.info("[aiden-agent] Starting", { sessionId, taskId, projectPath, backendKind, agentId, mode, model, version: AGENT_VERSION });
   await runSandbox({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiden-ade/sandbox-agent",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "type": "module",
   "bin": {
     "aiden-agent": "./dist/index.cjs"
@@ -11,21 +11,21 @@
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "build": "tsup",
-    "dev": "tsx src/index.ts",
-    "test": "vitest run",
-    "type-check": "tsc --noEmit"
-  },
   "dependencies": {},
   "devDependencies": {
-    "@aiden/agent-core": "workspace:*",
-    "@aiden/shared": "workspace:*",
     "socket.io-client": "^4.8.0",
     "socket.io": "^4.8.0",
     "@types/node": "^22.0.0",
     "tsup": "^8.5.1",
     "tsx": "^4.19.0",
-    "typescript": "~5.9.3"
+    "typescript": "~5.9.3",
+    "@aiden/agent-core": "0.1.0",
+    "@aiden/shared": "0.1.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsx src/index.ts",
+    "test": "vitest run",
+    "type-check": "tsc --noEmit"
   }
-}
+}