agentbox-sdk 0.1.319 → 0.1.322

package/dist/agents/index.js

@@ -2,7 +2,7 @@ import {
   Agent,
   agentboxRoot,
   getAgentLayout
-} from "../chunk-2IHQY3WC.js";
+} from "../chunk-ZK5PDWOI.js";
 import "../chunk-775FIGGL.js";
 import {
   AGENT_RESERVED_PORTS,

package/dist/{chunk-HYHLKO3L.js → chunk-T4AS2WEF.js}

@@ -254,6 +254,16 @@ function resolveSandboxResources(resources) {
 var DaytonaSandboxAdapter = class extends SandboxAdapter {
   client;
   sandbox;
+  /**
+   * Per-sandbox preview access token, captured from `getPreviewLink`.
+   * Daytona's preview proxy now requires this token to reach a sandbox's
+   * ports: unauthenticated requests get 307-redirected to an Auth0 login
+   * (which surfaces as a 307 on WebSocket upgrades and a 404 on plain GETs).
+   * The token is sandbox-level and stable across ports, so caching the most
+   * recent one is sufficient — every consumer calls `getPreviewLink` to build
+   * the URL right before reading `previewHeaders`. See {@link previewHeaders}.
+   */
+  previewToken;
   constructor(options) {
     super(options);
     this.client = new Daytona({
@@ -494,12 +504,26 @@ var DaytonaSandboxAdapter = class extends SandboxAdapter {
   }
   async openPort(port) {
     this.requireProvisioned();
-    await this.requireSandbox().getPreviewLink(port);
+    const preview = await this.requireSandbox().getPreviewLink(port);
+    this.previewToken = preview.token;
+  }
+  /**
+   * Headers callers must attach to HTTP/WebSocket requests against this
+   * sandbox's preview URLs. Daytona private sandboxes gate their preview
+   * proxy behind `x-daytona-preview-token`; without it the proxy 307-redirects
+   * to Auth0, which breaks every provider (claude-code `/start` 404, codex WS
+   * "307", opencode `/session` 404). The token is captured lazily from
+   * `getPreviewLink`/`openPort`, both of which every consumer calls to build
+   * the URL immediately before reading these headers.
+   */
+  get previewHeaders() {
+    return this.previewToken ? { "x-daytona-preview-token": this.previewToken } : {};
   }
   async getPreviewLink(port) {
     this.requireProvisioned();
     const sandbox = this.requireSandbox();
     const preview = await sandbox.getPreviewLink(port);
+    this.previewToken = preview.token;
     return preview.url;
   }
   async uploadFile(content, targetPath) {

package/dist/{chunk-2IHQY3WC.js → chunk-ZK5PDWOI.js}

@@ -1244,16 +1244,23 @@ async function preflightSetup(target, setupId, daemon) {
   );
 }
 async function markSetupComplete(target, setupId) {
-  await time(
-    debugSetup,
-    `markSetupComplete ${target.provider}`,
-    () => target.runCommand(
-      [
-        `mkdir -p ${shellQuote(target.layout.rootDir)}`,
-        `printf '%s' ${shellQuote(setupId)} > ${shellQuote(path5.posix.join(target.layout.rootDir, SETUP_ID_FILENAME))}`
-      ].join(" && ")
-    )
-  );
+  await time(debugSetup, `markSetupComplete ${target.provider}`, async () => {
+    const setupIdFile = path5.posix.join(
+      target.layout.rootDir,
+      SETUP_ID_FILENAME
+    );
+    const result = await target.uploadAndRun(
+      [{ path: setupIdFile, content: setupId }],
+      "true"
+    );
+    if (result.exitCode !== 0) {
+      const detail = result.combinedOutput?.trim();
+      throw new Error(
+        `markSetupComplete failed (${result.exitCode})${detail ? `
+${detail}` : ""}`
+      );
+    }
+  });
 }
 function buildInstallScript(rootDir, installCommandsByKey) {
   const commandsB64 = Buffer.from(
@@ -1641,6 +1648,8 @@ var DAEMON_PORT = 43180;
 var DAEMON_PATH = "/tmp/agentbox/claude-code/daemon.mjs";
 var DAEMON_LOG_PATH = "/tmp/agentbox/claude-code/daemon.log";
 var DAEMON_PID_PATH = "/tmp/agentbox/claude-code/daemon.pid";
+var DAEMON_READY_TIMEOUT_MS = 3e4;
+var DAEMON_READY_POLL_INTERVAL_MS = 250;
 function claudeConfigDir(options) {
   return path8.join(
     agentboxRoot(AgentProvider.ClaudeCode, Boolean(options.sandbox)),
@@ -2078,16 +2087,44 @@ async function ensureClaudeCodeDaemonUncached(options, env) {
         `Could not start claude-code daemon: ${launch.stderr || launch.combinedOutput || "(no output)"}`
       );
     }
+    const deadline = Date.now() + DAEMON_READY_TIMEOUT_MS;
+    let lastProbe = "";
+    while (Date.now() < deadline) {
+      const ready = await sandbox.run(
+        `curl -fsS --max-time 1 http://127.0.0.1:${DAEMON_PORT}/__version 2>/dev/null`,
+        { cwd: options.cwd, timeoutMs: 1e4 }
+      );
+      lastProbe = ready.combinedOutput.trim();
+      if (ready.exitCode === 0 && lastProbe === DAEMON_PROTOCOL_VERSION) {
+        return;
+      }
+      await sleep(DAEMON_READY_POLL_INTERVAL_MS);
+    }
+    const logTail = await sandbox.run(`tail -n 20 ${shellQuote(DAEMON_LOG_PATH)} 2>/dev/null`, {
+      cwd: options.cwd
+    }).catch(() => void 0);
+    throw new Error(
+      `claude-code daemon did not become ready within ${DAEMON_READY_TIMEOUT_MS}ms` + (lastProbe ? ` (last /__version response: ${lastProbe})` : "") + (logTail?.combinedOutput ? `
+${logTail.combinedOutput}` : "")
+    );
   });
 }
 var DAEMON_FIRST_REQUEST_RETRY_BUDGET_MS = 3e4;
 var DAEMON_FIRST_REQUEST_RETRY_INTERVAL_MS = 250;
+var TRANSIENT_PROXY_STATUSES = /* @__PURE__ */ new Set([404, 502, 503, 504]);
 async function fetchWithDaemonRetry(input, init) {
   const deadline = Date.now() + DAEMON_FIRST_REQUEST_RETRY_BUDGET_MS;
   let lastError;
+  let lastResponse;
   while (Date.now() < deadline) {
     try {
-      return await fetch(input, init);
+      const response = await fetch(input, init);
+      if (TRANSIENT_PROXY_STATUSES.has(response.status)) {
+        lastResponse = response;
+        await sleep(DAEMON_FIRST_REQUEST_RETRY_INTERVAL_MS);
+        continue;
+      }
+      return response;
     } catch (error) {
       lastError = error;
       const aborted = error?.name === "AbortError";
@@ -2097,6 +2134,9 @@ async function fetchWithDaemonRetry(input, init) {
       await sleep(DAEMON_FIRST_REQUEST_RETRY_INTERVAL_MS);
     }
   }
+  if (lastResponse) {
+    return lastResponse;
+  }
   throw lastError ?? new Error("claude-code daemon request timed out");
 }
 async function* parseNdjsonStream(body) {
@@ -4147,42 +4187,79 @@ async function ensureSandboxOpenCodeServer(request) {
         `disown 2>/dev/null || true`
       ].join(" ")})`
     ].join(" && ");
-    await killSandboxOpenCodeServer(sandbox, pidFilePath, options.cwd, port);
-    const launchResult = await time(
+    const OPENCODE_MAX_LAUNCH_ATTEMPTS = 4;
+    const OPENCODE_RELAUNCH_BACKOFF_MS = 1e3;
+    const readyDeadline = Date.now() + SANDBOX_OPENCODE_READY_TIMEOUT_MS;
+    const pidAlive = `kill -0 "$(cat ${shellQuote(pidFilePath)} 2>/dev/null)" 2>/dev/null`;
+    let lastLog = "";
+    const becameReady = await time(
       debugOpencode,
-      "spawn opencode serve",
-      () => sandbox.run(launchCommand, {
-        cwd: options.cwd,
-        env: serveEnv,
-        timeoutMs: 2e4
-      })
-    );
-    if (launchResult.exitCode !== 0) {
-      await target.cleanup().catch(() => void 0);
-      throw new Error(
-        `Could not start OpenCode server: ${launchResult.combinedOutput || launchResult.stderr}`
-      );
-    }
-    await time(debugOpencode, "poll opencode until ready", async () => {
-      const readyDeadline = Date.now() + SANDBOX_OPENCODE_READY_TIMEOUT_MS;
-      let attempt = 0;
-      while (Date.now() < readyDeadline) {
-        attempt++;
-        const probe = await sandbox.run(
-          `curl -fsS http://127.0.0.1:${port}/global/health >/dev/null 2>&1`,
-          { cwd: options.cwd, timeoutMs: 5e3 }
-        );
-        if (probe.exitCode === 0) {
-          debugOpencode("ready after %d probe attempt(s)", attempt);
-          return;
+      "launch + poll opencode until ready",
+      async () => {
+        for (let attempt = 1; attempt <= OPENCODE_MAX_LAUNCH_ATTEMPTS && Date.now() < readyDeadline; attempt++) {
+          await killSandboxOpenCodeServer(
+            sandbox,
+            pidFilePath,
+            options.cwd,
+            port
+          );
+          const launchResult = await sandbox.run(launchCommand, {
+            cwd: options.cwd,
+            env: serveEnv,
+            timeoutMs: 4e4
+          });
+          if (launchResult.exitCode !== 0) {
+            await target.cleanup().catch(() => void 0);
+            throw new Error(
+              `Could not start OpenCode server: ${launchResult.combinedOutput || launchResult.stderr}`
+            );
+          }
+          while (Date.now() < readyDeadline) {
+            const probe = await sandbox.run(
+              `curl -fsS http://127.0.0.1:${port}/global/health >/dev/null 2>&1`,
+              { cwd: options.cwd, timeoutMs: 5e3 }
+            );
+            if (probe.exitCode === 0) {
+              debugOpencode("ready on attempt %d", attempt);
+              return true;
+            }
+            const alive = await sandbox.run(pidAlive, {
+              cwd: options.cwd,
+              timeoutMs: 5e3
+            });
+            if (alive.exitCode !== 0) {
+              lastLog = (await sandbox.run(`tail -n 40 ${shellQuote(logFilePath)} 2>/dev/null`, {
+                cwd: options.cwd
+              }).catch(() => void 0))?.combinedOutput?.trim() ?? lastLog;
+              debugOpencode(
+                "opencode died on attempt %d/%d; relaunching. log:\n%s",
+                attempt,
+                OPENCODE_MAX_LAUNCH_ATTEMPTS,
+                lastLog
+              );
+              break;
+            }
+            await sleep(500);
+          }
+          if (Date.now() >= readyDeadline) break;
+          await sleep(OPENCODE_RELAUNCH_BACKOFF_MS);
         }
-        await sleep(500);
+        return false;
+      }
+    );
+    if (!becameReady) {
+      if (!lastLog) {
+        lastLog = (await sandbox.run(`tail -n 40 ${shellQuote(logFilePath)} 2>/dev/null`, {
+          cwd: options.cwd
+        }).catch(() => void 0))?.combinedOutput?.trim() ?? "";
       }
       await target.cleanup().catch(() => void 0);
       throw new Error(
-        `OpenCode server did not become ready within ${SANDBOX_OPENCODE_READY_TIMEOUT_MS}ms.`
+        `OpenCode server did not become ready within ${SANDBOX_OPENCODE_READY_TIMEOUT_MS}ms.` + (lastLog ? `
+opencode log:
+${lastLog}` : "")
       );
-    });
+    }
     await markSetupComplete(target, setupId);
   });
 }

package/dist/index.js

@@ -2,7 +2,7 @@ import {
   Agent,
   agentboxRoot,
   getAgentLayout
-} from "./chunk-2IHQY3WC.js";
+} from "./chunk-ZK5PDWOI.js";
 import {
   ProviderLogAssembler,
   createNormalizedEvent,
@@ -14,7 +14,7 @@ import {
   Sandbox,
   SandboxAdapter,
   buildGitCloneCommand
-} from "./chunk-HYHLKO3L.js";
+} from "./chunk-T4AS2WEF.js";
 import {
   AGENT_RESERVED_PORTS,
   collectAllAgentReservedPorts

package/dist/sandboxes/index.js

@@ -2,7 +2,7 @@ import {
   Sandbox,
   SandboxAdapter,
   buildGitCloneCommand
-} from "../chunk-HYHLKO3L.js";
+} from "../chunk-T4AS2WEF.js";
 import "../chunk-AVXJMCBC.js";
 import "../chunk-NSJM57Z4.js";
 import {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentbox-sdk",
-  "version": "0.1.319",
+  "version": "0.1.322",
   "description": "Swappable coding agents and sandbox providers for Bun and TypeScript.",
   "license": "MIT",
   "repository": {