@aiden-ade/sandbox-agent 0.1.9 → 0.1.11

package/dist/index.cjs

@@ -11142,7 +11142,7 @@ var WSClient = class {
 };
 
 // src/version.ts
-var AGENT_VERSION = "0.1.9";
+var AGENT_VERSION = "0.1.11";
 
 // src/sandbox.ts
 async function runSandbox(config) {
@@ -11324,23 +11324,64 @@ 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 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_path.join)((0, import_node_os.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");
+}
 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_fs.existsSync)(configPath)) return {};
+  return JSON.parse((0, import_node_fs.readFileSync)(configPath, "utf8"));
+}
+function readEndpointDefaults() {
+  const endpointsPath = getEndpointDefaultsPath();
+  if (!(0, import_node_fs.existsSync)(endpointsPath)) return {};
+  try {
+    return JSON.parse((0, import_node_fs.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_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 });
 }
 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_fs.existsSync)(configPath)) (0, import_node_fs.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);
@@ -11449,15 +11490,20 @@ 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 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 --setup-token <token> or --team <team-id> and --token <aiden PAT>");
+    throw new Error(
+      "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" : ""}`, {
     method: "POST",
@@ -11475,8 +11521,8 @@ async function setupDaemon(args) {
       managementKind: "user_managed",
       hostKind: "daemon",
       lifecycle: "durable",
-      ownerType: "team",
-      visibility: "team",
+      ownerType: scope,
+      visibility: scope,
       capabilities: discoverCapabilities(),
       metadata: {
         platform: (0, import_node_os.platform)(),
@@ -11492,6 +11538,7 @@ async function setupDaemon(args) {
   writeConfig({
     apiUrl,
     wsUrl,
+    endpointProfile,
     teamId,
     runtimeId: body.runtime.id,
     runtimeToken: body.runtimeToken,
@@ -11499,11 +11546,10 @@ 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 { apiUrl, wsUrl, endpointProfile } = resolveEndpoints(args);
   const displayName = argValue(args, "--name") ?? (0, import_node_os.hostname)();
   const maxPolls = Number.parseInt(argValue(args, "--max-polls") ?? "300", 10);
   const start = await fetch(`${apiUrl}/public/runtimes/device-authorizations`, {
@@ -11542,6 +11588,7 @@ async function loginWithDeviceCode(args) {
     writeConfig({
       apiUrl,
       wsUrl,
+      endpointProfile,
       teamId: body.runtime.teamId ?? void 0,
       runtimeId: body.runtime.id,
       runtimeToken: body.runtimeToken,
@@ -11549,7 +11596,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");
@@ -11708,9 +11755,20 @@ async function startDaemon(args) {
     res.writeHead(404, { "content-type": "application/json" }).end(JSON.stringify({ error: "Not found" }));
   });
   await new Promise((resolve2, reject) => {
-    localServer.once("error", reject);
+    const onError = (error) => {
+      clearInterval(heartbeat);
+      socket.disconnect();
+      if (error.code === "EADDRINUSE") {
+        reject(new Error(
+          `local daemon API port ${localApiPort} is already in use. Another aiden-agent daemon may already be running; use \`aiden-agent status\` or stop the existing daemon before starting a new one.`
+        ));
+        return;
+      }
+      reject(error);
+    };
+    localServer.once("error", onError);
     localServer.listen(localApiPort, "127.0.0.1", () => {
-      localServer.off("error", reject);
+      localServer.off("error", onError);
       const address = localServer.address();
       if (address && typeof address === "object") localApiPort = address.port;
       pushLog(`local_api listening port=${localApiPort}`);
@@ -11783,17 +11841,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 = []) {
@@ -11821,16 +11889,61 @@ 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
   }, null, 2));
 }
 
+// src/cli-help.ts
+var HELP_TEXT = `Aiden agent CLI
+
+Usage:
+  aiden-agent <command> [options]
+
+Commands:
+  setup       Register this computer with a setup token from Aiden
+  login       Register this computer through browser authorization
+  daemon      Start the durable runtime daemon
+  status      Show local runtime configuration without secrets
+  doctor      Check local CLI capabilities
+  logout      Remove local runtime configuration
+  token       Rotate or revoke the configured runtime token
+  run-session Internal: run one ephemeral sandbox/session from AIDEN_* env vars
+
+Common flows:
+  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(
+    env.AIDEN_WS_URL && env.AIDEN_SESSION_ID && env.AIDEN_TASK_ID && env.AIDEN_SESSION_TOKEN && env.AIDEN_TASK !== void 0
+  );
+}
+function resolveCommand(args, env) {
+  const [command, ...commandArgs] = args;
+  if (!command) {
+    return { command: hasRunSessionEnv(env) ? "run-session" : "help", commandArgs: [] };
+  }
+  if (command === "help" || command === "--help" || command === "-h") {
+    return { command: "help", commandArgs };
+  }
+  return { command, commandArgs };
+}
+
 // src/index.ts
 async function runSessionFromEnv() {
   const wsUrl = process.env.AIDEN_WS_URL;
@@ -11849,7 +11962,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({
@@ -11877,7 +11992,11 @@ async function main() {
 `);
     return;
   }
-  const [command = "run-session", ...commandArgs] = process.argv.slice(2);
+  const { command, commandArgs } = resolveCommand(process.argv.slice(2), process.env);
+  if (command === "help") {
+    process.stdout.write(HELP_TEXT);
+    return;
+  }
   if (command === "setup") {
     await setupDaemon(commandArgs);
     return;
@@ -11914,7 +12033,9 @@ async function main() {
     await runSessionFromEnv();
     return;
   }
-  throw new Error(`Unknown command: ${command}`);
+  throw new Error(`Unknown command: ${command}
+
+${HELP_TEXT}`);
 }
 main().catch((error) => {
   console.error("[aiden-agent] Fatal error:", error instanceof Error ? error.message : error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiden-ade/sandbox-agent",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "type": "module",
   "bin": {
     "aiden-agent": "./dist/index.cjs"
@@ -11,21 +11,22 @@
   "publishConfig": {
     "access": "public"
   },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsx src/index.ts",
+    "prepack": "pnpm build",
+    "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",
-    "@aiden/shared": "0.1.0",
-    "@aiden/agent-core": "0.1.0"
-  },
-  "scripts": {
-    "build": "tsup",
-    "dev": "tsx src/index.ts",
-    "test": "vitest run",
-    "type-check": "tsc --noEmit"
+    "typescript": "~5.9.3"
   }
-}
+}