agentbox-sdk 0.0.0 → 0.1.0

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,401 @@
+#!/usr/bin/env node
+import {
+  toShellCommand
+} from "./chunk-JFDP556Q.js";
+
+// src/sandbox-images/build.ts
+import { existsSync } from "fs";
+import path from "path";
+import { pathToFileURL } from "url";
+import { Daytona, Image as DaytonaImage } from "@daytonaio/sdk";
+import Docker from "dockerode";
+import { ModalClient } from "modal";
+import tar from "tar-stream";
+
+// src/sandbox-images/utils.ts
+import { createHash } from "crypto";
+function sandboxImageDefinitionToDockerfileCommands(image) {
+  const commands = [];
+  for (const [name, value] of Object.entries(image.env ?? {})) {
+    commands.push(`ENV ${name}=${JSON.stringify(value)}`);
+  }
+  for (const command of image.run ?? []) {
+    commands.push(`RUN ${command}`);
+  }
+  if (image.workdir) {
+    commands.push(`WORKDIR ${image.workdir}`);
+  }
+  if (image.cmd) {
+    commands.push(`CMD ${JSON.stringify(image.cmd)}`);
+  }
+  return commands;
+}
+function sandboxImageDefinitionToDockerfile(image) {
+  return [
+    `FROM ${image.base}`,
+    ...sandboxImageDefinitionToDockerfileCommands(image)
+  ].join("\n").concat("\n");
+}
+function buildSandboxImageReference(image, prefix = "agentbox") {
+  const hash = createHash("sha256").update(JSON.stringify(image)).digest("hex").slice(0, 12);
+  const name = sanitizeName(image.name ?? "sandbox-image");
+  return `${prefix}/${name}:${hash}`;
+}
+function buildDaytonaSnapshotName(image) {
+  const hash = createHash("sha256").update(JSON.stringify(image)).digest("hex").slice(0, 12);
+  const name = sanitizeName(image.name ?? "sandbox-image").replace(/\//g, "-");
+  return `${name}-${hash}`;
+}
+function buildE2bTemplateReference(image, prefix = "agentbox") {
+  const hash = createHash("sha256").update(JSON.stringify(image)).digest("hex").slice(0, 12);
+  const safePrefix = sanitizeName(prefix).replace(/\//g, "-");
+  const safeName = sanitizeName(image.name ?? "sandbox-image").replace(
+    /\//g,
+    "-"
+  );
+  return `${safePrefix}-${safeName}:${hash}`;
+}
+function sanitizeName(value) {
+  return value.toLowerCase().replace(/[^a-z0-9._/-]+/g, "-").replace(/^-+|-+$/g, "");
+}
+
+// src/sandbox-images/build.ts
+var e2bModulePromise;
+async function loadE2bModule() {
+  if (!e2bModulePromise) {
+    e2bModulePromise = import("e2b");
+  }
+  return e2bModulePromise;
+}
+function getBuildEnv(options, key) {
+  return options.env?.[key] ?? process.env[key];
+}
+async function buildSandboxImage(options) {
+  const definition = await loadSandboxImageDefinition(
+    options.preset,
+    options.file,
+    options.cwd
+  );
+  switch (options.provider) {
+    case "local-docker":
+      return buildLocalDockerImage(definition, options);
+    case "modal":
+      return buildModalImage(definition, options);
+    case "daytona":
+      return buildDaytonaSnapshot(definition, options);
+    case "e2b":
+      return buildE2bTemplate(definition, options);
+  }
+}
+async function loadSandboxImageDefinition(preset, file, cwd = process.cwd()) {
+  if (!preset && !file) {
+    throw new Error("Provide either --preset or --file.");
+  }
+  if (preset && file) {
+    throw new Error("Use either --preset or --file, not both.");
+  }
+  const target = preset ? resolveBuiltInImageUrl(preset) : pathToFileURL(path.resolve(cwd, file));
+  const module = await import(target.href);
+  const definition = module.default;
+  if (!definition?.base) {
+    throw new Error(
+      "Sandbox image definitions must export a default object with a base image."
+    );
+  }
+  return definition;
+}
+function resolveBuiltInImageUrl(preset) {
+  const candidates = [
+    new URL(`../../images/${preset}.mjs`, import.meta.url),
+    new URL(`../images/${preset}.mjs`, import.meta.url)
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return new URL(`../../images/${preset}.mjs`, import.meta.url);
+}
+async function buildLocalDockerImage(definition, options) {
+  const client = new Docker();
+  const tag = options.imageName ?? buildSandboxImageReference(definition, "agentbox");
+  const pack = tar.pack();
+  pack.entry(
+    { name: "Dockerfile" },
+    sandboxImageDefinitionToDockerfile(definition)
+  );
+  pack.finalize();
+  const stream = await client.buildImage(pack, {
+    t: tag,
+    dockerfile: "Dockerfile",
+    pull: true
+  });
+  await new Promise((resolve, reject) => {
+    client.modem.followProgress(
+      stream,
+      (error, output) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        const messages = Array.isArray(output) ? output : [];
+        for (const message of messages) {
+          if (typeof message.stream === "string") {
+            options.log?.(message.stream.trimEnd());
+          }
+          if (typeof message.error === "string") {
+            reject(new Error(message.error));
+            return;
+          }
+        }
+        resolve();
+      },
+      (event) => {
+        if (typeof event.stream === "string") {
+          options.log?.(event.stream.trimEnd());
+        }
+      }
+    );
+  });
+  options.log?.(`Built local-docker image ${tag}`);
+  return tag;
+}
+async function buildModalImage(definition, options) {
+  const tokenId = getBuildEnv(options, "MODAL_TOKEN_ID");
+  const tokenSecret = getBuildEnv(options, "MODAL_TOKEN_SECRET");
+  if (!tokenId || !tokenSecret) {
+    throw new Error("MODAL_TOKEN_ID and MODAL_TOKEN_SECRET are required.");
+  }
+  const client = new ModalClient({
+    tokenId,
+    tokenSecret,
+    environment: getBuildEnv(options, "MODAL_ENVIRONMENT"),
+    endpoint: getBuildEnv(options, "MODAL_ENDPOINT")
+  });
+  try {
+    const appName = options.modalAppName ?? getBuildEnv(options, "AGENTBOX_MODAL_APP_NAME") ?? "agentbox-images";
+    const app = await client.apps.fromName(appName, {
+      createIfMissing: true,
+      environment: getBuildEnv(options, "MODAL_ENVIRONMENT")
+    });
+    let image = client.images.fromRegistry(definition.base);
+    const commands = sandboxImageDefinitionToDockerfileCommands(definition);
+    if (commands.length > 0) {
+      image = image.dockerfileCommands(commands);
+    }
+    const builtImage = await image.build(app);
+    options.log?.(`Built Modal image ${builtImage.imageId}`);
+    return builtImage.imageId;
+  } finally {
+    try {
+      client.close();
+    } catch {
+    }
+  }
+}
+async function buildDaytonaSnapshot(definition, options) {
+  if (!definition.resources?.cpu || !definition.resources?.memoryMiB) {
+    throw new Error(
+      "Daytona image definitions must include resources.cpu and resources.memoryMiB."
+    );
+  }
+  if (!getBuildEnv(options, "DAYTONA_API_KEY") && !getBuildEnv(options, "DAYTONA_JWT_TOKEN")) {
+    throw new Error("DAYTONA_API_KEY or DAYTONA_JWT_TOKEN is required.");
+  }
+  const client = new Daytona({
+    apiKey: getBuildEnv(options, "DAYTONA_API_KEY"),
+    jwtToken: getBuildEnv(options, "DAYTONA_JWT_TOKEN"),
+    organizationId: getBuildEnv(options, "DAYTONA_ORGANIZATION_ID"),
+    apiUrl: getBuildEnv(options, "DAYTONA_API_URL"),
+    target: getBuildEnv(options, "DAYTONA_TARGET")
+  });
+  let image = DaytonaImage.base(definition.base);
+  if (definition.env) {
+    image = image.env(definition.env);
+  }
+  for (const command of definition.run ?? []) {
+    image = image.runCommands(command);
+  }
+  if (definition.workdir) {
+    image = image.workdir(definition.workdir);
+  }
+  if (definition.cmd) {
+    image = image.cmd(definition.cmd);
+  }
+  const snapshotName = options.imageName ?? buildDaytonaSnapshotName(definition);
+  try {
+    const existing = await client.snapshot.get(snapshotName);
+    if (existing.state === "active") {
+      options.log?.(`Reusing existing Daytona snapshot ${existing.name}`);
+      return existing.name;
+    }
+  } catch {
+  }
+  const snapshot = await client.snapshot.create(
+    {
+      name: snapshotName,
+      image,
+      resources: {
+        cpu: definition.resources.cpu,
+        memory: definition.resources.memoryMiB / 1024
+      }
+    },
+    {
+      onLogs: (chunk) => options.log?.(chunk),
+      timeout: 0
+    }
+  );
+  try {
+    const activated = await client.snapshot.activate(snapshot);
+    options.log?.(`Built Daytona snapshot ${activated.name}`);
+    return activated.name;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes("already active")) {
+      options.log?.(`Built Daytona snapshot ${snapshot.name}`);
+      return snapshot.name;
+    }
+    throw error;
+  }
+}
+async function buildE2bTemplate(definition, options) {
+  if (!getBuildEnv(options, "E2B_API_KEY") && !getBuildEnv(options, "E2B_ACCESS_TOKEN")) {
+    throw new Error("E2B_API_KEY or E2B_ACCESS_TOKEN is required.");
+  }
+  const { Template, waitForTimeout } = await loadE2bModule();
+  let template = Template().fromImage(definition.base).setUser("root");
+  if (definition.env) {
+    template = template.setEnvs(definition.env);
+  }
+  if (definition.run?.length) {
+    template = template.runCmd(definition.run);
+  }
+  if (definition.workdir) {
+    template = template.setWorkdir(definition.workdir);
+  }
+  const finalTemplate = definition.cmd?.length ? template.setStartCmd(toShellCommand(definition.cmd), waitForTimeout(1e3)) : template;
+  const builtTemplate = await Template.build(
+    finalTemplate,
+    options.imageName ?? buildE2bTemplateReference(definition),
+    {
+      apiKey: getBuildEnv(options, "E2B_API_KEY"),
+      accessToken: getBuildEnv(options, "E2B_ACCESS_TOKEN"),
+      domain: getBuildEnv(options, "E2B_DOMAIN"),
+      cpuCount: definition.resources?.cpu,
+      memoryMB: definition.resources?.memoryMiB,
+      onBuildLogs: (entry) => {
+        options.log?.(`[${entry.level}] ${entry.message}`);
+      }
+    }
+  );
+  const reference = builtTemplate.name;
+  options.log?.(`Built E2B template ${reference}`);
+  return reference;
+}
+
+// src/cli.ts
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.length === 0 || args.includes("--help") || args.includes("-h")) {
+    printHelp();
+    return;
+  }
+  const [command, subcommand, ...rest] = args;
+  if (!((command === "image" || command === "sandbox-image") && subcommand === "build")) {
+    printHelp();
+    process.exitCode = 1;
+    return;
+  }
+  const options = parseOptions(rest);
+  if (!options.provider || !options.preset && !options.file) {
+    printHelp();
+    process.exitCode = 1;
+    return;
+  }
+  const reference = await buildSandboxImage({
+    provider: options.provider,
+    preset: options.preset,
+    file: options.file,
+    imageName: options.imageName,
+    modalAppName: options.modalAppName,
+    log: (chunk) => {
+      process.stderr.write(chunk.endsWith("\n") ? chunk : `${chunk}
+`);
+    }
+  });
+  process.stdout.write(`${reference}
+`);
+}
+function parseOptions(args) {
+  const options = {};
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    const next = args[i + 1];
+    if (!arg || !arg.startsWith("--")) {
+      throw new Error(`Unexpected argument: ${arg}`);
+    }
+    if (!next) {
+      throw new Error(`Missing value for ${arg}`);
+    }
+    switch (arg) {
+      case "--provider":
+        if (!isSandboxProviderName(next)) {
+          throw new Error(`Unsupported sandbox provider: ${next}`);
+        }
+        options.provider = next;
+        i += 1;
+        break;
+      case "--preset":
+        if (!isBuiltInImageName(next)) {
+          throw new Error(`Unknown built-in image preset: ${next}`);
+        }
+        options.preset = next;
+        i += 1;
+        break;
+      case "--file":
+        options.file = next;
+        i += 1;
+        break;
+      case "--image-name":
+        options.imageName = next;
+        i += 1;
+        break;
+      case "--modal-app-name":
+        options.modalAppName = next;
+        i += 1;
+        break;
+      default:
+        throw new Error(`Unknown option: ${arg}`);
+    }
+  }
+  return options;
+}
+function isSandboxProviderName(value) {
+  return value === "local-docker" || value === "modal" || value === "daytona" || value === "e2b";
+}
+function isBuiltInImageName(value) {
+  return value === "browser-agent" || value === "computer-use";
+}
+function printHelp() {
+  process.stdout.write(`agentbox
+
+Usage:
+  agentbox image build --provider <local-docker|modal|daytona|e2b> --preset <browser-agent|computer-use>
+  agentbox image build --provider <local-docker|modal|daytona|e2b> --file <path>
+
+Options:
+  --image-name <name>        Override the built artifact name
+  --modal-app-name <name>    Modal app used for image builds
+
+Environment:
+  Modal: MODAL_TOKEN_ID, MODAL_TOKEN_SECRET, MODAL_ENVIRONMENT?, MODAL_ENDPOINT?
+  Daytona: DAYTONA_API_KEY or DAYTONA_JWT_TOKEN, DAYTONA_ORGANIZATION_ID?, DAYTONA_API_URL?, DAYTONA_TARGET?
+  E2B: E2B_API_KEY, E2B_DOMAIN?, E2B_ACCESS_TOKEN?
+`);
+}
+void main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  process.stderr.write(`${message}
+`);
+  process.exitCode = 1;
+});

package/dist/events/index.d.ts

@@ -0,0 +1,6 @@
+export { A as AISDKEvent, M as MessageCompletedEvent, N as MessageInjectedEvent, O as MessageStartedEvent, P as NormalizedAgentEvent, Q as NormalizedAgentEventBase, R as NormalizedAgentEventType, X as PermissionRequestedEvent, Y as PermissionResolvedEvent, Z as RawAgentEvent, _ as ReasoningDeltaEvent, a0 as RunCompletedEvent, a1 as RunErrorEvent, a2 as RunStartedEvent, a3 as TextDeltaEvent, a5 as ToolCallCompletedEvent, a6 as ToolCallDeltaEvent, a7 as ToolCallStartedEvent, aa as createNormalizedEvent, ab as normalizeRawAgentEvent, ac as toAISDKEvent, ad as toAISDKStream } from '../types-BwcoN0n-.js';
+import '../Sandbox-DTprxRZf.js';
+import 'e2b';
+import '@daytonaio/sdk';
+import 'modal';
+import 'dockerode';

package/dist/events/index.js

@@ -0,0 +1,12 @@
+import {
+  createNormalizedEvent,
+  normalizeRawAgentEvent,
+  toAISDKEvent,
+  toAISDKStream
+} from "../chunk-7FLLQJ6J.js";
+export {
+  createNormalizedEvent,
+  normalizeRawAgentEvent,
+  toAISDKEvent,
+  toAISDKStream
+};

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { A as AISDKEvent, a as AgentApprovalMode, b as AgentCommandConfig, c as AgentExecutionRequest, d as AgentLocalMcpConfig, e as AgentMcpConfig, f as AgentOptions, g as AgentOptionsBase, h as AgentOptionsMap, i as AgentPermissionDecision, j as AgentPermissionKind, k as AgentPermissionResponse, l as AgentProviderAdapter, m as AgentProviderName, n as AgentRemoteMcpConfig, o as AgentResult, p as AgentRun, q as AgentRunConfig, r as AgentRunSink, s as AgentSkillConfig, t as AgentSubAgentConfig, C as ClaudeCodeAgentOptions, u as ClaudeCodeHookConfig, v as ClaudeCodeHookEvent, w as ClaudeCodeHookHandler, x as ClaudeCodeHookMatcherGroup, y as ClaudeCodeHooksConfig, z as ClaudeCodeProviderOptions, B as CodexAgentOptions, D as CodexCommandHook, E as CodexHookEvent, F as CodexHookMatcherGroup, G as CodexHooksConfig, H as CodexProviderOptions, I as DataContent, J as EmbeddedSkillConfig, K as FilePart, L as ImagePart, M as MessageCompletedEvent, N as MessageInjectedEvent, O as MessageStartedEvent, P as NormalizedAgentEvent, Q as NormalizedAgentEventBase, R as NormalizedAgentEventType, S as OpenCodeAgentOptions, T as OpenCodePluginConfig, U as OpenCodePluginEvent, V as OpenCodePluginHookConfig, W as OpenCodeProviderOptions, X as PermissionRequestedEvent, Y as PermissionResolvedEvent, Z as RawAgentEvent, _ as ReasoningDeltaEvent, $ as RepoSkillConfig, a0 as RunCompletedEvent, a1 as RunErrorEvent, a2 as RunStartedEvent, a3 as TextDeltaEvent, a4 as TextPart, a5 as ToolCallCompletedEvent, a6 as ToolCallDeltaEvent, a7 as ToolCallStartedEvent, a8 as UserContent, a9 as UserContentPart, aa as createNormalizedEvent, ab as normalizeRawAgentEvent, ac as toAISDKEvent, ad as toAISDKStream } from './types-BwcoN0n-.js';
+export { Agent } from './agents/index.js';
+export { A as AsyncCommandHandle, C as CommandEvent, a as CommandOptions, b as CommandResult, D as DaytonaProviderOptions, c as DaytonaSandboxOptions, E as E2bProviderOptions, d as E2bSandboxOptions, G as GitCloneOptions, L as LocalDockerProviderOptions, e as LocalDockerSandboxOptions, M as ModalProviderOptions, f as ModalSandboxOptions, S as Sandbox, g as SandboxDescriptor, h as SandboxListOptions, i as SandboxOptions, j as SandboxOptionsBase, k as SandboxOptionsMap, l as SandboxProviderName, m as SandboxRaw, n as SandboxRawMap, o as SandboxResourceSpec } from './Sandbox-DTprxRZf.js';
+export { SandboxAdapter, buildGitCloneCommand } from './sandboxes/index.js';
+import 'e2b';
+import '@daytonaio/sdk';
+import 'modal';
+import 'dockerode';

package/dist/index.js

@@ -0,0 +1,26 @@
+import {
+  Agent
+} from "./chunk-BW43ESRM.js";
+import {
+  createNormalizedEvent,
+  normalizeRawAgentEvent,
+  toAISDKEvent,
+  toAISDKStream
+} from "./chunk-7FLLQJ6J.js";
+import {
+  Sandbox,
+  SandboxAdapter,
+  buildGitCloneCommand
+} from "./chunk-QRQFQTGH.js";
+import "./chunk-HMBWQSVN.js";
+import "./chunk-JFDP556Q.js";
+export {
+  Agent,
+  Sandbox,
+  SandboxAdapter,
+  buildGitCloneCommand,
+  createNormalizedEvent,
+  normalizeRawAgentEvent,
+  toAISDKEvent,
+  toAISDKStream
+};

package/dist/sandboxes/index.d.ts

@@ -0,0 +1,38 @@
+import { l as SandboxProviderName, i as SandboxOptions, a as CommandOptions, b as CommandResult, A as AsyncCommandHandle, h as SandboxListOptions, g as SandboxDescriptor, G as GitCloneOptions } from '../Sandbox-DTprxRZf.js';
+export { C as CommandEvent, D as DaytonaProviderOptions, c as DaytonaSandboxOptions, E as E2bProviderOptions, d as E2bSandboxOptions, L as LocalDockerProviderOptions, e as LocalDockerSandboxOptions, M as ModalProviderOptions, f as ModalSandboxOptions, S as Sandbox, j as SandboxOptionsBase, k as SandboxOptionsMap, m as SandboxRaw, n as SandboxRawMap, o as SandboxResourceSpec } from '../Sandbox-DTprxRZf.js';
+import 'e2b';
+import '@daytonaio/sdk';
+import 'modal';
+import 'dockerode';
+
+declare abstract class SandboxAdapter<TProvider extends SandboxProviderName = SandboxProviderName, TOptions extends SandboxOptions<TProvider> = SandboxOptions<TProvider>, TRaw = unknown> {
+    protected readonly options: TOptions;
+    protected readonly secrets: Record<string, string>;
+    protected readonly baseEnv: Record<string, string>;
+    private provisioned;
+    private provisioning?;
+    constructor(options: TOptions);
+    abstract get provider(): TProvider;
+    abstract get raw(): TRaw | undefined;
+    abstract get id(): string | undefined;
+    protected abstract provision(): Promise<void>;
+    abstract run(command: string | string[], options?: CommandOptions): Promise<CommandResult>;
+    abstract runAsync(command: string | string[], options?: CommandOptions): Promise<AsyncCommandHandle>;
+    abstract list(options?: SandboxListOptions): Promise<SandboxDescriptor[]>;
+    abstract snapshot(): Promise<string | null>;
+    abstract stop(): Promise<void>;
+    abstract delete(): Promise<void>;
+    abstract openPort(port: number): Promise<void>;
+    abstract getPreviewLink(port: number): Promise<string>;
+    protected ensureProvisioned(): Promise<void>;
+    get tags(): Record<string, string>;
+    get workingDir(): string;
+    getMergedEnv(extra?: Record<string, string>): Record<string, string>;
+    setSecret(name: string, value: string): void;
+    setSecrets(values: Record<string, string>): void;
+    gitClone(options: GitCloneOptions): Promise<CommandResult>;
+}
+
+declare function buildGitCloneCommand(options: GitCloneOptions): string;
+
+export { AsyncCommandHandle, CommandOptions, CommandResult, GitCloneOptions, SandboxAdapter, SandboxDescriptor, SandboxListOptions, SandboxOptions, SandboxProviderName, buildGitCloneCommand };

package/dist/sandboxes/index.js

@@ -0,0 +1,12 @@
+import {
+  Sandbox,
+  SandboxAdapter,
+  buildGitCloneCommand
+} from "../chunk-QRQFQTGH.js";
+import "../chunk-HMBWQSVN.js";
+import "../chunk-JFDP556Q.js";
+export {
+  Sandbox,
+  SandboxAdapter,
+  buildGitCloneCommand
+};