agentbox-sdk 0.1.0 → 0.1.3

package/dist/chunk-GOFJNFAD.js

@@ -0,0 +1,18 @@
+// src/enums.ts
+var AgentProvider = {
+  ClaudeCode: "claude-code",
+  OpenCode: "open-code",
+  Codex: "codex"
+};
+var SandboxProvider = {
+  LocalDocker: "local-docker",
+  Modal: "modal",
+  Daytona: "daytona",
+  Vercel: "vercel",
+  E2B: "e2b"
+};
+
+export {
+  AgentProvider,
+  SandboxProvider
+};

package/dist/{chunk-HMBWQSVN.js → chunk-INMA52FV.js}

@@ -1,3 +1,23 @@
+import {
+  AgentProvider
+} from "./chunk-GOFJNFAD.js";
+
+// src/agents/ports.ts
+var AGENT_RESERVED_PORTS = {
+  [AgentProvider.ClaudeCode]: [43180],
+  [AgentProvider.Codex]: [43181],
+  [AgentProvider.OpenCode]: [4096]
+};
+function collectAllAgentReservedPorts() {
+  const seen = /* @__PURE__ */ new Set();
+  for (const ports of Object.values(AGENT_RESERVED_PORTS)) {
+    for (const port of ports) {
+      seen.add(port);
+    }
+  }
+  return Array.from(seen);
+}
+
 // src/shared/errors.ts
 var AgentBoxError = class extends Error {
   code;
@@ -24,6 +44,10 @@ function asError(error) {
   }
   return new Error(typeof error === "string" ? error : JSON.stringify(error));
 }
+function suppressUnhandledRejection(promise) {
+  promise.catch(() => void 0);
+  return promise;
+}
 
 // src/shared/async-queue.ts
 var AsyncQueue = class {
@@ -80,33 +104,58 @@ var AsyncQueue = class {
   }
 };
 
+// src/shared/debug.ts
+import createDebug from "debug";
+var ROOT = "agentbox";
+var namespaces = {};
+function debug(namespace) {
+  let d = namespaces[namespace];
+  if (!d) {
+    d = createDebug(`${ROOT}:${namespace}`);
+    namespaces[namespace] = d;
+  }
+  return d;
+}
+var debugAgent = debug("agent");
+var debugClaude = debug("claude");
+var debugCodex = debug("codex");
+var debugOpencode = debug("opencode");
+var debugSetup = debug("setup");
+var debugRuntime = debug("runtime");
+var debugSandbox = debug("sandbox");
+var debugRelay = debug("relay");
+async function time(log, label, fn, extra) {
+  if (!log.enabled) {
+    return fn();
+  }
+  const start = Date.now();
+  log("\u2192 %s", label);
+  try {
+    const result = await fn();
+    const meta = extra?.(result);
+    if (meta) {
+      log("\u2190 %s (%dms) %o", label, Date.now() - start, meta);
+    } else {
+      log("\u2190 %s (%dms)", label, Date.now() - start);
+    }
+    return result;
+  } catch (error) {
+    log(
+      "\u2717 %s (%dms): %s",
+      label,
+      Date.now() - start,
+      error instanceof Error ? error.message : String(error)
+    );
+    throw error;
+  }
+}
+
 // src/shared/network.ts
 import net from "net";
 import { setTimeout as sleepTimeout } from "timers/promises";
 async function sleep(ms) {
   await sleepTimeout(ms);
 }
-async function getAvailablePort(host = "127.0.0.1") {
-  return new Promise((resolve, reject) => {
-    const server = net.createServer();
-    server.once("error", reject);
-    server.listen(0, host, () => {
-      const address = server.address();
-      if (!address || typeof address === "string") {
-        reject(new Error("Could not determine an available port."));
-        return;
-      }
-      const { port } = address;
-      server.close((error) => {
-        if (error) {
-          reject(error);
-          return;
-        }
-        resolve(port);
-      });
-    });
-  });
-}
 async function waitFor(predicate, options) {
   const timeoutMs = options?.timeoutMs ?? 15e3;
   const intervalMs = options?.intervalMs ?? 250;
@@ -193,12 +242,23 @@ export {
   AgentBoxError,
   UnsupportedProviderError,
   asError,
+  suppressUnhandledRejection,
   AsyncQueue,
+  debugAgent,
+  debugClaude,
+  debugCodex,
+  debugOpencode,
+  debugSetup,
+  debugRuntime,
+  debugSandbox,
+  debugRelay,
+  time,
   sleep,
-  getAvailablePort,
   waitFor,
   readStreamAsText,
   pipeReadableStream,
   readNodeStream,
-  linesFromTextChunks
+  linesFromTextChunks,
+  AGENT_RESERVED_PORTS,
+  collectAllAgentReservedPorts
 };