@desplega.ai/agent-swarm 1.85.0 → 1.87.0

package/src/e2b/dispatch.ts

@@ -0,0 +1,429 @@
+import { DEFAULT_E2B_API_BASE, type EnvMap, redactWithEnv } from "./env";
+
+export type E2BRole = "api" | "worker";
+
+export type E2BSandboxInfo = {
+  templateID: string;
+  sandboxID: string;
+  clientID?: string;
+  envdVersion?: string;
+  alias?: string;
+  envdAccessToken?: string;
+  trafficAccessToken?: string;
+  domain?: string | null;
+  startedAt?: string;
+  endAt?: string;
+  metadata?: Record<string, string>;
+};
+
+export type E2BCommandResult = {
+  exitCode: number;
+  stdout: string;
+  stderr: string;
+};
+
+export type BuildTemplateOptions = {
+  role: E2BRole;
+  name: string;
+  dockerfile: string;
+  cwd: string;
+  cpuCount: number;
+  memoryMb: number;
+  noCache: boolean;
+  e2bEnv: EnvMap;
+  dryRun?: boolean;
+};
+
+export type DeleteTemplateOptions = {
+  name: string;
+  e2bEnv: EnvMap;
+  dryRun?: boolean;
+};
+
+export type TemplateVisibilityOptions = {
+  name: string;
+  e2bEnv: EnvMap;
+  public: boolean;
+  dryRun?: boolean;
+};
+
+export type BuildImageTemplateOptions = {
+  role: E2BRole;
+  name: string;
+  image: string;
+  cpuCount: number;
+  memoryMb: number;
+  noCache: boolean;
+  e2bEnv: EnvMap;
+  dryRun?: boolean;
+};
+
+export type CreateSandboxOptions = {
+  apiKey: string;
+  apiBase?: string;
+  template: string;
+  timeoutSec: number;
+  envVars: EnvMap;
+  metadata: Record<string, string>;
+  allowInternetAccess?: boolean;
+};
+
+export type StartDetachedOptions = {
+  sandbox: E2BSandboxInfo;
+  apiKey: string;
+  apiBase?: string;
+  e2bEnv?: EnvMap;
+  env: EnvMap;
+  command: string;
+  role: E2BRole;
+  user?: string;
+  cwd?: string;
+};
+
+type E2BSdkConnectionOptions = {
+  apiKey: string;
+  apiUrl?: string;
+  domain?: string;
+  sandboxUrl?: string;
+};
+
+type E2BTemplateVisibilityResponse = {
+  names: string[];
+};
+
+function e2bHeaders(apiKey: string): Record<string, string> {
+  return {
+    "Content-Type": "application/json",
+    "X-API-Key": apiKey,
+  };
+}
+
+export function buildDetachedShell(command: string, logPath: string, pidPath: string): string {
+  return [
+    "set -e",
+    `nohup ${command} >${logPath} 2>&1 </dev/null & pid=$!`,
+    "sleep 2",
+    `if ! kill -0 "$pid" 2>/dev/null; then cat ${logPath} >&2; exit 1; fi`,
+    `echo "$pid" > ${pidPath}`,
+    'echo "$pid"',
+  ].join("; ");
+}
+
+export function e2bSdkConnectionOptions(
+  apiKey: string,
+  env: EnvMap,
+  apiBase?: string,
+): E2BSdkConnectionOptions {
+  const options: E2BSdkConnectionOptions = { apiKey };
+  const resolvedApiUrl = apiBase || env.E2B_API_URL;
+  if (resolvedApiUrl) options.apiUrl = resolvedApiUrl;
+  if (env.E2B_DOMAIN) options.domain = env.E2B_DOMAIN;
+  if (env.E2B_SANDBOX_URL) options.sandboxUrl = env.E2B_SANDBOX_URL;
+  return options;
+}
+
+function sandboxDomainFromUrl(rawUrl: string): string | undefined {
+  try {
+    const url = new URL(rawUrl);
+    const host = url.host;
+    return host.startsWith("sandbox.") ? host.slice("sandbox.".length) : host;
+  } catch {
+    const host = rawUrl.replace(/^https?:\/\//, "").replace(/\/.*$/, "");
+    if (!host) return undefined;
+    return host.startsWith("sandbox.") ? host.slice("sandbox.".length) : host;
+  }
+}
+
+function configuredSandboxDomain(env: EnvMap): string | undefined {
+  if (env.E2B_DOMAIN) return env.E2B_DOMAIN;
+  if (env.E2B_SANDBOX_URL) return sandboxDomainFromUrl(env.E2B_SANDBOX_URL);
+  return undefined;
+}
+
+export function sandboxPortHost(sandbox: E2BSandboxInfo, port: number, env: EnvMap = {}): string {
+  const domain = sandbox.domain || configuredSandboxDomain(env) || "e2b.app";
+  if (domain.includes(sandbox.sandboxID)) {
+    return `${port}-${domain}`;
+  }
+  return `${port}-${sandbox.sandboxID}.${domain}`;
+}
+
+export function sandboxPortUrl(sandbox: E2BSandboxInfo, port: number, env: EnvMap = {}): string {
+  return `https://${sandboxPortHost(sandbox, port, env)}`;
+}
+
+async function readResponseBody(response: Response): Promise<string> {
+  const text = await response.text();
+  return text.trim();
+}
+
+export async function e2bFetchJson<T>(
+  path: string,
+  apiKey: string,
+  init: RequestInit = {},
+  apiBase = DEFAULT_E2B_API_BASE,
+): Promise<T> {
+  const response = await fetch(`${apiBase}${path}`, {
+    ...init,
+    headers: {
+      ...e2bHeaders(apiKey),
+      ...(init.headers ?? {}),
+    },
+  });
+
+  if (!response.ok) {
+    const body = await readResponseBody(response);
+    throw new Error(`E2B API ${response.status} ${response.statusText}: ${body}`);
+  }
+
+  if (response.status === 204) {
+    return undefined as T;
+  }
+
+  return (await response.json()) as T;
+}
+
+export async function createSandbox(opts: CreateSandboxOptions): Promise<E2BSandboxInfo> {
+  return e2bFetchJson<E2BSandboxInfo>(
+    "/sandboxes",
+    opts.apiKey,
+    {
+      method: "POST",
+      body: JSON.stringify({
+        templateID: opts.template,
+        timeout: opts.timeoutSec,
+        secure: true,
+        allow_internet_access: opts.allowInternetAccess ?? true,
+        metadata: opts.metadata,
+        envVars: opts.envVars,
+      }),
+    },
+    opts.apiBase,
+  );
+}
+
+export async function killSandbox(
+  sandboxId: string,
+  apiKey: string,
+  apiBase = DEFAULT_E2B_API_BASE,
+): Promise<void> {
+  await e2bFetchJson<void>(
+    `/sandboxes/${encodeURIComponent(sandboxId)}`,
+    apiKey,
+    { method: "DELETE" },
+    apiBase,
+  );
+}
+
+export async function listSandboxes(
+  apiKey: string,
+  apiBase = DEFAULT_E2B_API_BASE,
+): Promise<E2BSandboxInfo[]> {
+  return e2bFetchJson<E2BSandboxInfo[]>("/sandboxes", apiKey, {}, apiBase);
+}
+
+export async function startDetachedProcess(opts: StartDetachedOptions): Promise<string> {
+  const logPath = `/tmp/agent-swarm-e2b-${opts.role}.log`;
+  const pidPath = `/tmp/agent-swarm-e2b-${opts.role}.pid`;
+  const shell = buildDetachedShell(opts.command, logPath, pidPath);
+
+  const { Sandbox } = await import("e2b");
+  const sandbox = await Sandbox.connect(
+    opts.sandbox.sandboxID,
+    e2bSdkConnectionOptions(opts.apiKey, opts.e2bEnv ?? {}, opts.apiBase),
+  );
+  const result = await sandbox.commands.run(shell, {
+    user: opts.user ?? "root",
+    cwd: opts.cwd ?? "/",
+    envs: opts.env,
+    timeoutMs: 30_000,
+  });
+
+  if (result.exitCode !== 0) {
+    throw new Error(`E2B start command failed: ${redactWithEnv(result.stderr, opts.env)}`);
+  }
+  return result.stdout.trim();
+}
+
+export async function waitForAgentRegistration(
+  apiUrl: string,
+  agentId: string,
+  apiKey: string,
+  timeoutMs: number,
+): Promise<void> {
+  const baseUrl = apiUrl.replace(/\/+$/, "");
+  const url = `${baseUrl}/api/agents/${encodeURIComponent(agentId)}`;
+  const started = Date.now();
+  let lastError = "";
+
+  while (Date.now() - started < timeoutMs) {
+    try {
+      const response = await fetch(url, {
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+        },
+      });
+      if (response.ok) return;
+      lastError = `${response.status} ${response.statusText}`;
+    } catch (err) {
+      lastError = err instanceof Error ? err.message : String(err);
+    }
+    await Bun.sleep(1_000);
+  }
+
+  throw new Error(
+    `Timed out waiting for worker ${agentId} to register at ${url}${
+      lastError ? ` (${lastError})` : ""
+    }`,
+  );
+}
+
+export async function waitForHttpOk(url: string, timeoutMs: number): Promise<void> {
+  const started = Date.now();
+  let lastError = "";
+  while (Date.now() - started < timeoutMs) {
+    try {
+      const response = await fetch(url);
+      if (response.ok) return;
+      lastError = `${response.status} ${response.statusText}`;
+    } catch (err) {
+      lastError = err instanceof Error ? err.message : String(err);
+    }
+    await Bun.sleep(1_000);
+  }
+  throw new Error(`Timed out waiting for ${url}${lastError ? ` (${lastError})` : ""}`);
+}
+
+export function buildTemplateArgs(opts: BuildTemplateOptions): string[] {
+  const args = [
+    "template",
+    "create",
+    "-p",
+    opts.cwd,
+    "-d",
+    opts.dockerfile,
+    "-c",
+    "sleep infinity",
+    "--ready-cmd",
+    "sleep 0",
+    "--cpu-count",
+    String(opts.cpuCount),
+    "--memory-mb",
+    String(opts.memoryMb),
+  ];
+
+  if (opts.noCache) {
+    args.push("--no-cache");
+  }
+
+  args.push(opts.name);
+  return args;
+}
+
+export async function runE2BCommand(args: string[], env: EnvMap): Promise<E2BCommandResult> {
+  const child = Bun.spawn(["e2b", ...args], {
+    env: { ...process.env, ...env },
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(child.stdout).text(),
+    new Response(child.stderr).text(),
+    child.exited,
+  ]);
+  return { stdout: redactWithEnv(stdout, env), stderr: redactWithEnv(stderr, env), exitCode };
+}
+
+export async function buildTemplate(opts: BuildTemplateOptions): Promise<E2BCommandResult> {
+  const args = buildTemplateArgs(opts);
+  if (opts.dryRun) {
+    return { exitCode: 0, stdout: `e2b ${args.join(" ")}\n`, stderr: "" };
+  }
+  return runE2BCommand(args, opts.e2bEnv);
+}
+
+export async function buildImageTemplate(
+  opts: BuildImageTemplateOptions,
+): Promise<E2BCommandResult> {
+  if (opts.dryRun) {
+    return {
+      exitCode: 0,
+      stdout: [
+        `e2b-sdk template build --from-image ${opts.image}`,
+        `  --name ${opts.name}`,
+        `  --start-cmd "sleep infinity"`,
+        `  --ready-cmd "sleep 0"`,
+        `  --cpu-count ${opts.cpuCount}`,
+        `  --memory-mb ${opts.memoryMb}`,
+        opts.noCache ? `  --no-cache` : "",
+      ]
+        .filter(Boolean)
+        .join("\n")
+        .concat("\n"),
+      stderr: "",
+    };
+  }
+
+  const apiKey = opts.e2bEnv.E2B_API_KEY;
+  if (!apiKey) {
+    throw new Error("Missing E2B_API_KEY");
+  }
+
+  const { Template } = await import("e2b");
+  const template = Template().fromImage(opts.image).setStartCmd("sleep infinity", "sleep 0");
+  const buildInfo = await Template.build(template, opts.name, {
+    ...e2bSdkConnectionOptions(apiKey, opts.e2bEnv),
+    cpuCount: opts.cpuCount,
+    memoryMB: opts.memoryMb,
+    skipCache: opts.noCache,
+  });
+
+  return {
+    exitCode: 0,
+    stdout: `Built E2B ${opts.role} template ${buildInfo.name} (${buildInfo.templateId}, build ${buildInfo.buildId})\n`,
+    stderr: "",
+  };
+}
+
+export async function deleteTemplate(opts: DeleteTemplateOptions): Promise<E2BCommandResult> {
+  const args = ["template", "delete", opts.name, "-y"];
+  if (opts.dryRun) {
+    return { exitCode: 0, stdout: `e2b ${args.join(" ")}\n`, stderr: "" };
+  }
+  return runE2BCommand(args, opts.e2bEnv);
+}
+
+export async function setTemplateVisibility(
+  opts: TemplateVisibilityOptions,
+): Promise<E2BCommandResult> {
+  const path = `/v2/templates/${encodeURIComponent(opts.name)}`;
+  if (opts.dryRun) {
+    return {
+      exitCode: 0,
+      stdout: `PATCH ${path} {"public":${opts.public}}\n`,
+      stderr: "",
+    };
+  }
+
+  const apiKey = opts.e2bEnv.E2B_API_KEY;
+  if (!apiKey) {
+    throw new Error("Missing E2B_API_KEY");
+  }
+
+  const result = await e2bFetchJson<E2BTemplateVisibilityResponse>(
+    path,
+    apiKey,
+    {
+      method: "PATCH",
+      body: JSON.stringify({ public: opts.public }),
+    },
+    opts.e2bEnv.E2B_API_URL || DEFAULT_E2B_API_BASE,
+  );
+  const names = result.names.length > 0 ? ` (${result.names.join(", ")})` : "";
+  const visibility = opts.public ? "public" : "private";
+  return {
+    exitCode: 0,
+    stdout: `Set E2B template ${opts.name} visibility to ${visibility}${names}\n`,
+    stderr: "",
+  };
+}

package/src/e2b/env.ts

@@ -0,0 +1,206 @@
+import { resolve } from "node:path";
+import { getApiKey } from "../utils/api-key";
+import { isSensitiveKey, scrubSecrets } from "../utils/secret-scrubber";
+
+export type EnvMap = Record<string, string>;
+
+export const DEFAULT_E2B_API_BASE = "https://api.e2b.app";
+export const DEFAULT_E2B_ENVD_PORT = 49_983;
+
+export const DEFAULT_E2B_TEMPLATE_NAMES = {
+  api: "agent-swarm-api",
+  worker: "agent-swarm-worker",
+} as const;
+
+export const DEFAULT_E2B_FORWARD_KEYS = [
+  "AGENT_SWARM_API_KEY",
+  "API_KEY",
+  "SECRETS_ENCRYPTION_KEY",
+  "ANTHROPIC_API_KEY",
+  "CLAUDE_CODE_OAUTH_TOKEN",
+  "OPENAI_API_KEY",
+  "OPENROUTER_API_KEY",
+  "GITHUB_TOKEN",
+  "GITLAB_TOKEN",
+  "LINEAR_API_KEY",
+  "SLACK_BOT_TOKEN",
+  "SLACK_SIGNING_SECRET",
+  "BUSINESS_USE_API_KEY",
+  "SENTRY_AUTH_TOKEN",
+  "OTEL_EXPORTER_OTLP_ENDPOINT",
+  "OTEL_EXPORTER_OTLP_HEADERS",
+  "SIGNOZ_INGESTION_KEY",
+  "DEVIN_API_KEY",
+  "DEVIN_ORG_ID",
+  "MANAGED_AGENT_ID",
+  "MANAGED_ENVIRONMENT_ID",
+  "MANAGED_AGENT_MODEL",
+  "MANAGED_GITHUB_TOKEN",
+  "ARCHIL_MOUNT_TOKEN",
+  "ARCHIL_REGION",
+  "ARCHIL_SHARED_DISK_NAME",
+  "ARCHIL_PERSONAL_DISK_NAME",
+  "HARNESS_PROVIDER",
+  "MODEL_OVERRIDE",
+  "STARTUP_SCRIPT_STRICT",
+] as const;
+
+export type SwarmRole = "api" | "worker";
+
+function decodeDoubleQuotedValue(value: string): string {
+  return value
+    .replace(/\\n/g, "\n")
+    .replace(/\\r/g, "\r")
+    .replace(/\\t/g, "\t")
+    .replace(/\\"/g, '"')
+    .replace(/\\\\/g, "\\");
+}
+
+function parseQuotedValue(value: string, quote: '"' | "'"): string | null {
+  let escaped = false;
+  for (let i = 1; i < value.length; i++) {
+    const char = value[i];
+    if (quote === '"' && escaped) {
+      escaped = false;
+      continue;
+    }
+    if (quote === '"' && char === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (char !== quote) continue;
+
+    const rest = value.slice(i + 1).trim();
+    if (rest && !rest.startsWith("#")) return null;
+
+    const inner = value.slice(1, i);
+    return quote === '"' ? decodeDoubleQuotedValue(inner) : inner;
+  }
+  return null;
+}
+
+export function parseDotenv(source: string): EnvMap {
+  const out: EnvMap = {};
+
+  for (const rawLine of source.split(/\r?\n/)) {
+    let line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+    if (line.startsWith("export ")) {
+      line = line.slice("export ".length).trimStart();
+    }
+
+    const eq = line.indexOf("=");
+    if (eq <= 0) continue;
+
+    const key = line.slice(0, eq).trim();
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) continue;
+
+    let value = line.slice(eq + 1).trim();
+    const quote = value[0];
+    const quoted = quote === '"' || quote === "'" ? parseQuotedValue(value, quote) : null;
+    if (quoted !== null) {
+      value = quoted;
+    } else {
+      value = value.replace(/\s+#.*$/, "").trim();
+    }
+
+    out[key] = value;
+  }
+
+  return out;
+}
+
+export async function readDotenvFile(path: string): Promise<EnvMap> {
+  const file = Bun.file(path);
+  if (!(await file.exists())) {
+    throw new Error(`Env file not found: ${path}`);
+  }
+  return parseDotenv(await file.text());
+}
+
+export async function maybeReadDotenvFile(path: string): Promise<EnvMap> {
+  const file = Bun.file(path);
+  if (!(await file.exists())) return {};
+  return parseDotenv(await file.text());
+}
+
+export function parseKeyValue(raw: string, label: string): [string, string] {
+  const eq = raw.indexOf("=");
+  if (eq <= 0) {
+    throw new Error(`${label} must be KEY=VALUE`);
+  }
+  const key = raw.slice(0, eq);
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
+    throw new Error(`${label} has invalid env key: ${key}`);
+  }
+  return [key, raw.slice(eq + 1)];
+}
+
+export function splitKeys(values: string[]): string[] {
+  return values
+    .flatMap((value) => value.split(","))
+    .map((value) => value.trim())
+    .filter(Boolean);
+}
+
+export function selectEnv(source: NodeJS.ProcessEnv | EnvMap, keys: readonly string[]): EnvMap {
+  const out: EnvMap = {};
+  for (const key of keys) {
+    const value = source[key];
+    if (typeof value === "string" && value.length > 0) {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+
+export function resolveSwarmApiKey(env: EnvMap, explicit?: string): string {
+  const apiKey = explicit || env.AGENT_SWARM_API_KEY || env.API_KEY || getApiKey();
+  if (!apiKey) {
+    throw new Error(
+      "Missing swarm API key. Pass --api-key or set AGENT_SWARM_API_KEY/API_KEY for E2B sandboxes.",
+    );
+  }
+  return apiKey;
+}
+
+export function redactWithEnv(text: string, env: EnvMap): string {
+  let out = text;
+  const entries = Object.entries(env)
+    .filter(([key, value]) => isSensitiveKey(key) && value.length >= 8)
+    .sort((a, b) => b[1].length - a[1].length);
+
+  for (const [key, value] of entries) {
+    out = out.split(value).join(`[REDACTED:${key}]`);
+  }
+
+  return scrubSecrets(out);
+}
+
+export function redactObjectWithEnv<T>(value: T, env: EnvMap, seen = new WeakSet<object>()): T {
+  if (value === null || value === undefined) return value;
+  if (typeof value === "string") return redactWithEnv(value, env) as T;
+  if (typeof value !== "object") return value;
+
+  if (seen.has(value)) return "[Circular]" as T;
+  seen.add(value);
+
+  if (Array.isArray(value)) {
+    return value.map((item) => redactObjectWithEnv(item, env, seen)) as T;
+  }
+
+  const out: Record<string, unknown> = {};
+  for (const [key, child] of Object.entries(value as Record<string, unknown>)) {
+    const normalized = key.replace(/([a-z])([A-Z])/g, "$1_$2").toUpperCase();
+    if (isSensitiveKey(normalized) || /TOKEN|SECRET|PASSWORD|PRIVATE_KEY/.test(normalized)) {
+      out[key] = `[REDACTED:${key}]`;
+      continue;
+    }
+    out[key] = redactObjectWithEnv(child, env, seen);
+  }
+  return out as T;
+}
+
+export function absolutePath(path: string, cwd = process.cwd()): string {
+  return resolve(cwd, path);
+}