@aiden-ade/sandbox-agent 0.1.25 → 0.1.26

package/dist/index.cjs

@@ -10225,10 +10225,7 @@ function createClaudeCliBackend(command = "claude", defaultArgs = []) {
           stdin.write(`${message}
 `);
         },
-        keepStdinOpen: true,
-        allowContinuation: true,
-        continuationIdleMs: 10 * 60 * 1e3
-        // 10 minutes
+        keepStdinOpen: true
       }).run(context);
     }
   };
@@ -12673,7 +12670,7 @@ function extractGeneratedImagesFromToolResult(toolId, content, cwd, toolName) {
 }
 
 // src/version.ts
-var AGENT_VERSION = "0.1.25";
+var AGENT_VERSION = "0.1.26";
 
 // src/daemon.ts
 var OPENCODE_FREE_MODEL_IDS = [
@@ -12687,6 +12684,23 @@ 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 correlationLogFields(input) {
+  return Object.fromEntries(
+    Object.entries({
+      taskId: input.taskId,
+      conversationId: input.conversationId,
+      runId: input.runId,
+      messageId: input.messageId,
+      cloudEnvironmentId: input.cloudEnvironmentId,
+      provider: input.backendKind,
+      backendKind: input.backendKind,
+      agentVersion: input.agentVersion
+    }).filter((entry) => {
+      const value2 = entry[1];
+      return typeof value2 === "string" && value2.trim().length > 0;
+    }).map(([key, value2]) => [key, value2.trim()])
+  );
+}
 async function probeLocalDaemonEndpoint(port, token, timeoutMs = 750) {
   try {
     const headers = {};
@@ -12923,12 +12937,13 @@ async function collectRuntimeMetadataWithProviderLimits() {
   return metadata;
 }
 var RuntimePresenter = class {
-  constructor(socket, conversationId, runId, cwd, touchRunnerActivity) {
+  constructor(socket, conversationId, runId, cwd, touchRunnerActivity, onRunComplete) {
     this.socket = socket;
     this.conversationId = conversationId;
     this.runId = runId;
     this.cwd = cwd;
     this.touchRunnerActivity = touchRunnerActivity;
+    this.onRunComplete = onRunComplete;
   }
   emittedGeneratedImageKeys = /* @__PURE__ */ new Set();
   toolNamesById = /* @__PURE__ */ new Map();
@@ -13015,6 +13030,7 @@ var RuntimePresenter = class {
   }
   onComplete(result) {
     this.emitEvent({ type: "query_complete", result, ts: Date.now() });
+    this.onRunComplete?.();
   }
 };
 async function setupDaemon(args) {
@@ -13213,19 +13229,34 @@ async function startDaemon(args) {
       return;
     }
     socket.emit("agent.accepted", { runId: payload.runId });
+    const correlation = correlationLogFields({
+      taskId: payload.taskId ?? payload.taskMeta?.id,
+      conversationId: payload.conversationId,
+      runId: payload.runId,
+      messageId: payload.messageId,
+      cloudEnvironmentId: payload.cloudEnvironmentId,
+      backendKind,
+      agentVersion: AGENT_VERSION
+    });
     pushLog(`accepted run=${payload.runId}`);
+    console.info("[aiden-agent] Agent run accepted", correlation);
     const cwd = payload.projectPath ?? process.cwd();
     const nowMs = Date.now();
     const touchActivity = () => {
       const entry = activeAgents.get(payload.runId);
       if (entry) entry.lastActivityAtMs = Date.now();
     };
+    const releaseActiveRun = () => {
+      if (!activeAgents.delete(payload.runId)) return;
+      console.info("[aiden-agent] Agent run finished", correlation);
+    };
     const presenter = new RuntimePresenter(
       socket,
       payload.conversationId,
       payload.runId,
       cwd,
-      touchActivity
+      touchActivity,
+      releaseActiveRun
     );
     const agent = new CoreAgent(presenter, {
       backendKind,
@@ -13254,7 +13285,7 @@ async function startDaemon(args) {
       taskMeta: payload.taskMeta,
       prMeta: payload.prMeta,
       conversationId: payload.conversationId,
-      taskId: payload.taskMeta?.id,
+      taskId: payload.taskId ?? payload.taskMeta?.id,
       teamId: payload.teamId,
       currentUser: payload.currentUser,
       workflowTools: payload.workflowTools,
@@ -13263,13 +13294,17 @@ async function startDaemon(args) {
     }).catch((error) => {
       const message = error instanceof Error ? error.message : String(error);
       pushLog(`failed run=${payload.runId} ${message}`);
+      console.error("[aiden-agent] Agent run failed", {
+        ...correlation,
+        error: message
+      });
       socket.emit("agent.event", {
         conversationId: payload.conversationId,
         runId: payload.runId,
         event: { type: "session_error", error: message }
       });
     }).finally(() => {
-      activeAgents.delete(payload.runId);
+      releaseActiveRun();
     });
   });
   socket.on("agent.abort", (payload) => {
@@ -13279,6 +13314,10 @@ async function startDaemon(args) {
     abortActiveAgent(entry);
     activeAgents.delete(payload.runId);
     pushLog(`aborted run=${payload.runId}`);
+    console.info("[aiden-agent] Agent run aborted", {
+      runId: payload.runId,
+      agentVersion: AGENT_VERSION
+    });
   });
   socket.on(
     "agent.tool_response",
@@ -13607,6 +13646,78 @@ async function printDoctor(args = []) {
   );
 }
 
+// src/lifecycle-logger.ts
+var AgentLifecycleLogger = class _AgentLifecycleLogger {
+  context;
+  constructor(context = {}) {
+    this.context = normalizeContext(context);
+  }
+  setContext(context) {
+    this.context = normalizeContext({ ...this.context, ...context });
+  }
+  child(context) {
+    return new _AgentLifecycleLogger({ ...this.context, ...context });
+  }
+  debug(event, fields = {}) {
+    this.log("debug", event, fields);
+  }
+  info(event, fields = {}) {
+    this.log("info", event, fields);
+  }
+  warn(event, fields = {}) {
+    this.log("warn", event, fields);
+  }
+  error(event, fields = {}) {
+    this.log("error", event, fields);
+  }
+  log(level, event, fields) {
+    const record = omitUndefined({
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      level,
+      component: "sandbox-agent",
+      event,
+      ...this.context,
+      ...normalizeFields(fields)
+    });
+    console[level](JSON.stringify(record));
+  }
+};
+function lifecycleContextFromEnv(env) {
+  return normalizeContext({
+    taskId: env.AIDEN_TASK_ID,
+    conversationId: env.AIDEN_SESSION_ID,
+    runId: env.AIDEN_RUN_ID,
+    sandboxId: env.AIDEN_SANDBOX_ID,
+    provider: env.AIDEN_SANDBOX_PROVIDER,
+    backendKind: env.AIDEN_BACKEND_KIND,
+    agentVersion: AGENT_VERSION
+  });
+}
+function normalizeContext(context) {
+  return omitUndefined({
+    ...context,
+    agentVersion: context.agentVersion ?? AGENT_VERSION
+  });
+}
+function normalizeFields(fields) {
+  const normalized = {};
+  for (const [key, value2] of Object.entries(fields)) {
+    if (value2 instanceof Error) {
+      normalized[key] = {
+        name: value2.name,
+        message: value2.message,
+        stack: value2.stack
+      };
+    } else {
+      normalized[key] = value2;
+    }
+  }
+  return normalized;
+}
+function omitUndefined(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value2]) => value2 !== void 0));
+}
+
 // src/web-presenter.ts
 var WebPresenter = class {
   constructor(wsClient, _conversationId, cwd) {
@@ -13725,8 +13836,9 @@ var WebPresenter = class {
 
 // src/ws-client.ts
 var WSClient = class {
-  socket;
-  constructor(wsUrl, sessionId, taskId, token, callbacks, agentVersion) {
+  constructor(wsUrl, sessionId, taskId, token, callbacks, agentVersion, lifecycle) {
+    this.lifecycle = lifecycle;
+    this.lifecycle?.info("sandbox_agent_ws_socket_create", { wsUrl });
     this.socket = lookup(wsUrl, {
       query: { type: "agent", sessionId, taskId, agentVersion: agentVersion ?? "" },
       auth: { token },
@@ -13741,6 +13853,7 @@ var WSClient = class {
     });
     this.setupListeners(callbacks);
   }
+  socket;
   emitEvent(event) {
     this.socket.emit("agent_event", event);
   }
@@ -13767,20 +13880,26 @@ var WSClient = class {
   get connected() {
     return this.socket.connected;
   }
+  setLifecycleContext(context) {
+    this.lifecycle?.setContext(context);
+  }
   close() {
+    this.lifecycle?.info("sandbox_agent_ws_close_requested");
     this.socket.disconnect();
   }
   setupListeners(callbacks) {
     this.socket.on("connect", () => {
-      console.debug("[WSClient] Connected to WS server");
+      this.lifecycle?.info("sandbox_agent_ws_socket_connected", { socketId: this.socket.id });
       callbacks.onConnect?.();
     });
     this.socket.on("disconnect", (reason) => {
-      console.debug(`[WSClient] Disconnected: ${reason}`);
+      this.lifecycle?.info("sandbox_agent_ws_socket_disconnected", { reason });
       callbacks.onDisconnect?.(reason);
     });
     this.socket.on("connect_error", (error) => {
-      console.warn(`[WSClient] Connection error: ${error.message}`);
+      this.lifecycle?.warn("sandbox_agent_ws_socket_connect_error", {
+        error: error instanceof Error ? error : new Error(String(error))
+      });
     });
     this.socket.on(
       "user_message",
@@ -13805,6 +13924,7 @@ var WSClient = class {
           messageId: data.messageId,
           maxIterations: data.maxIterations,
           taskId: data.taskId,
+          cloudEnvironmentId: data.cloudEnvironmentId,
           conversationId: data.conversationId,
           teamId: data.teamId,
           currentUser: data.currentUser
@@ -13820,12 +13940,32 @@ var WSClient = class {
       }
     });
     this.socket.on("error", (data) => {
-      console.error(`[WSClient] Server error: ${data.message} (${data.code})`);
+      this.lifecycle?.error("sandbox_agent_ws_server_error", {
+        message: data.message,
+        code: data.code
+      });
     });
   }
 };
 
 // src/sandbox.ts
+function correlationLogFields2(input) {
+  return Object.fromEntries(
+    Object.entries({
+      taskId: input.taskId,
+      conversationId: input.conversationId,
+      runId: input.runId,
+      messageId: input.messageId,
+      cloudEnvironmentId: input.cloudEnvironmentId,
+      provider: input.backendKind,
+      backendKind: input.backendKind,
+      agentVersion: input.agentVersion
+    }).filter((entry) => {
+      const value2 = entry[1];
+      return typeof value2 === "string" && value2.trim().length > 0;
+    }).map(([key, value2]) => [key, value2.trim()])
+  );
+}
 async function runSandbox(config) {
   let currentTask = config.task;
   let currentImages = [];
@@ -13840,15 +13980,26 @@ async function runSandbox(config) {
   let currentMaxIterations = config.maxIterations ?? 50;
   let currentTaskId = config.taskId;
   let currentConversationId = config.sessionId;
+  let currentRunId;
+  let currentMessageId;
+  let currentCloudEnvironmentId;
   let currentTeamId = config.teamId;
   const workflowId = config.workflowId;
   const workflowExecutionId = config.workflowExecutionId;
   let currentUser = config.currentUser;
   let currentTerminalContextRefs;
   let currentTerminalSnapshots;
-  console.info("[sandbox] Connecting to WS server", {
-    wsUrl: config.wsUrl,
-    sessionId: config.sessionId
+  const lifecycle = config.lifecycle ?? new AgentLifecycleLogger({
+    taskId: config.taskId,
+    conversationId: config.sessionId,
+    runId: config.runId,
+    sandboxId: config.sandboxId,
+    provider: config.provider,
+    backendKind: config.backendKind,
+    agentVersion: AGENT_VERSION
+  });
+  lifecycle.info("sandbox_agent_ws_connect_attempt", {
+    wsUrl: config.wsUrl
   });
   const wsClient = new WSClient(
     config.wsUrl,
@@ -13857,6 +14008,31 @@ async function runSandbox(config) {
     config.sessionToken,
     {
       onUserMessage: (payload) => {
+        if (payload === null) {
+          if (pendingMessageResolve) {
+            const resolve2 = pendingMessageResolve;
+            pendingMessageResolve = null;
+            resolve2(null);
+          }
+          return;
+        }
+        lifecycle.setContext({
+          runId: payload.runId,
+          taskId: payload.taskId,
+          conversationId: payload.conversationId,
+          backendKind: payload.backendKind
+        });
+        wsClient.setLifecycleContext({
+          runId: payload.runId,
+          taskId: payload.taskId,
+          conversationId: payload.conversationId,
+          backendKind: payload.backendKind
+        });
+        lifecycle.info("sandbox_agent_user_message_received", {
+          messageId: payload.messageId,
+          hasImages: Boolean(payload.images?.length),
+          fileCount: payload.files?.length ?? 0
+        });
         if (pendingMessageResolve) {
           const resolve2 = pendingMessageResolve;
           pendingMessageResolve = null;
@@ -13866,7 +14042,7 @@ async function runSandbox(config) {
         }
       },
       onStop: () => {
-        console.info("[sandbox] Stop signal received");
+        lifecycle.info("sandbox_agent_stop_received");
         if (currentAgent) {
           const killed = currentAgent.kill();
           if (!killed) currentAgent.abort();
@@ -13876,21 +14052,24 @@ async function runSandbox(config) {
         if (currentAgent) {
           const sent = currentAgent.sendToolResponse(toolId, response);
           if (!sent) {
-            console.warn("[sandbox] Failed to deliver tool_response to agent stdin", { toolId });
+            lifecycle.warn("sandbox_agent_tool_response_delivery_failed", { toolId });
           }
         } else {
-          console.warn("[sandbox] No active agent for tool_response", { toolId });
+          lifecycle.warn("sandbox_agent_tool_response_without_active_agent", { toolId });
         }
       },
-      onConnect: () => console.info("[sandbox] WS connected"),
-      onDisconnect: (reason) => console.info(`[sandbox] WS disconnected: ${reason}`)
+      onConnect: () => lifecycle.info("sandbox_agent_ws_connected"),
+      onDisconnect: (reason) => lifecycle.info("sandbox_agent_ws_disconnected", { reason })
     },
-    AGENT_VERSION
+    AGENT_VERSION,
+    lifecycle
   );
   try {
     await wsClient.waitForConnection();
   } catch (error) {
-    console.error("[sandbox] Failed to connect to WS server:", error.message);
+    lifecycle.error("sandbox_agent_ws_connect_failed", {
+      error: error instanceof Error ? error : new Error(String(error))
+    });
     process.exit(1);
   }
   const presenter = new WebPresenter(wsClient, config.sessionId, config.projectPath);
@@ -13909,8 +14088,33 @@ async function runSandbox(config) {
         backendKind: activeBackendKind
       });
       currentAgent = agent;
+      const correlation = correlationLogFields2({
+        taskId: currentTaskId,
+        conversationId: currentConversationId,
+        runId: currentRunId,
+        messageId: currentMessageId,
+        cloudEnvironmentId: currentCloudEnvironmentId,
+        backendKind: activeBackendKind,
+        agentVersion: AGENT_VERSION
+      });
+      console.info("[sandbox] Agent run started", correlation);
       let result;
       try {
+        lifecycle.setContext({
+          taskId: currentTaskId,
+          conversationId: currentConversationId,
+          backendKind: activeBackendKind
+        });
+        wsClient.setLifecycleContext({
+          taskId: currentTaskId,
+          conversationId: currentConversationId,
+          backendKind: activeBackendKind
+        });
+        lifecycle.info("sandbox_agent_run_start", {
+          mode: activeMode,
+          model: activeModel,
+          maxIterations: currentMaxIterations
+        });
         result = await agent.run({
           task: currentTask,
           maxIterations: currentMaxIterations,
@@ -13954,7 +14158,13 @@ async function runSandbox(config) {
         });
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
-        console.error("[sandbox] Agent run failed:", errorMessage);
+        console.error("[sandbox] Agent run failed", {
+          ...correlation,
+          error: errorMessage
+        });
+        lifecycle.error("sandbox_agent_run_failed", {
+          error: error instanceof Error ? error : new Error(errorMessage)
+        });
         result = {
           success: false,
           summary: "Agent run failed",
@@ -13965,9 +14175,19 @@ async function runSandbox(config) {
         };
       }
       currentAgent = null;
+      lifecycle.info("sandbox_agent_run_complete", {
+        success: result.success,
+        iterations: result.iterations,
+        error: result.error
+      });
       if (result?.providerSessionId) {
         lastProviderSessionId = result.providerSessionId;
       }
+      console.info("[sandbox] Agent run finished", {
+        ...correlation,
+        success: String(result.success),
+        iterations: String(result.iterations)
+      });
       if (stopped) break;
     }
     const nextPayload = queuedMessages.shift() ?? await new Promise((resolve2) => {
@@ -14018,6 +14238,15 @@ async function runSandbox(config) {
     if (nextPayload.taskId !== void 0) {
       currentTaskId = nextPayload.taskId;
     }
+    if (nextPayload.runId !== void 0) {
+      currentRunId = nextPayload.runId;
+    }
+    if (nextPayload.messageId !== void 0) {
+      currentMessageId = nextPayload.messageId;
+    }
+    if (nextPayload.cloudEnvironmentId !== void 0) {
+      currentCloudEnvironmentId = nextPayload.cloudEnvironmentId;
+    }
     if (nextPayload.conversationId !== void 0) {
       currentConversationId = nextPayload.conversationId;
     }
@@ -14035,6 +14264,7 @@ async function runSandbox(config) {
     }
   }
   presenter.setSuppressSessionLifecycle(false);
+  lifecycle.info("sandbox_agent_process_exit");
   wsClient.close();
 }
 
@@ -14057,20 +14287,28 @@ async function runSessionFromEnv() {
   const providerSessionId = process.env.AIDEN_PROVIDER_SESSION_ID || void 0;
   const workflowId = process.env.AIDEN_WORKFLOW_ID || void 0;
   const workflowExecutionId = process.env.AIDEN_WORKFLOW_EXECUTION_ID || void 0;
+  const sandboxId = process.env.AIDEN_SANDBOX_ID || void 0;
+  const provider = process.env.AIDEN_SANDBOX_PROVIDER || void 0;
+  const runId = process.env.AIDEN_RUN_ID || void 0;
+  const lifecycle = new AgentLifecycleLogger(lifecycleContextFromEnv(process.env));
   if (!wsUrl || !sessionId || !taskId || !sessionToken || task == null) {
+    lifecycle.error("sandbox_agent_bootstrap_missing_env", {
+      hasWsUrl: Boolean(wsUrl),
+      hasConversationId: Boolean(sessionId),
+      hasTaskId: Boolean(taskId),
+      hasSessionToken: Boolean(sessionToken),
+      hasTask: task != null
+    });
     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", {
+  lifecycle.info("sandbox_agent_process_start", {
     sessionId,
-    taskId,
     projectPath,
-    backendKind,
     agentId,
     mode,
-    model,
-    version: AGENT_VERSION
+    model
   });
   await runSandbox({
     wsUrl,
@@ -14090,6 +14328,10 @@ async function runSessionFromEnv() {
     providerSessionId,
     workflowId,
     workflowExecutionId,
+    sandboxId,
+    provider,
+    runId,
+    lifecycle,
     maxIterations: 50
   });
 }
@@ -14149,7 +14391,9 @@ async function main() {
 ${HELP_TEXT}`);
 }
 main().catch((error) => {
-  console.error("[aiden-agent] Fatal error:", error instanceof Error ? error.message : error);
+  new AgentLifecycleLogger(lifecycleContextFromEnv(process.env)).error("sandbox_agent_fatal", {
+    error: error instanceof Error ? error : new Error(String(error))
+  });
   process.exit(1);
 });
 /*! Bundled license information:

package/dist/index.d.ts

@@ -1,2 +1,6 @@
+/**
+ * Aiden Sandbox Agent
+ * Runs inside E2B sandbox, connects to WS server, executes CoreAgent.
+ */
 export {};
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG"}