@desplega.ai/agent-swarm 1.169.0 → 1.171.0

package/dist/{cli-wt7ccy4r.js → cli-d161g69q.js}

@@ -2468,6 +2468,14 @@ function registerVolatileSecret(value, name) {
     volatileGeneration++;
   }
 }
+function unregisterVolatileSecret(name) {
+  for (const [value, registeredName] of volatileSecrets) {
+    if (registeredName !== name)
+      continue;
+    volatileSecrets.delete(value);
+    volatileGeneration++;
+  }
+}
 function registerSensitiveKeyName(key) {
   if (registeredSensitiveKeys.has(key))
     return;
@@ -2651,4 +2659,4 @@ var init_secret_scrubber = __esm(() => {
   sensitiveKeyVerdicts = new Map;
 });
 
-export { SCRUBBER_RULES_VERSION, isSensitiveKey, scrubSecrets, findSecretsIn, scrubObject, refreshSecretScrubberCache, registerVolatileSecret, registerSensitiveKeyName, init_secret_scrubber };
+export { SCRUBBER_RULES_VERSION, isSensitiveKey, scrubSecrets, findSecretsIn, scrubObject, refreshSecretScrubberCache, registerVolatileSecret, unregisterVolatileSecret, registerSensitiveKeyName, init_secret_scrubber };

package/dist/cli-db3m6zdt.js

@@ -0,0 +1,362 @@
+import {
+  DEFAULT_E2B_API_BASE,
+  init_env,
+  redactWithEnv
+} from "./cli-0p3enk35.js";
+import {
+  __esm,
+  __require,
+  __toESM
+} from "./cli-bc05qbss.js";
+
+// src/e2b/dispatch.ts
+function e2bHeaders(apiKey) {
+  return {
+    "Content-Type": "application/json",
+    "X-API-Key": apiKey
+  };
+}
+function buildTrackedShell(command, logPath) {
+  return `set -o pipefail; ${command} 2>&1 | tee ${logPath}`;
+}
+function e2bSdkConnectionOptions(apiKey, env, apiBase) {
+  const options = { 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) {
+  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;
+    return host.startsWith("sandbox.") ? host.slice("sandbox.".length) : host;
+  }
+}
+function configuredSandboxDomain(env) {
+  if (env.E2B_DOMAIN)
+    return env.E2B_DOMAIN;
+  if (env.E2B_SANDBOX_URL)
+    return sandboxDomainFromUrl(env.E2B_SANDBOX_URL);
+  return;
+}
+function sandboxPortHost(sandbox, port, env = {}) {
+  const domain = sandbox.domain || configuredSandboxDomain(env) || "e2b.app";
+  if (domain.includes(sandbox.sandboxID)) {
+    return `${port}-${domain}`;
+  }
+  return `${port}-${sandbox.sandboxID}.${domain}`;
+}
+function sandboxPortUrl(sandbox, port, env = {}) {
+  return `https://${sandboxPortHost(sandbox, port, env)}`;
+}
+async function readResponseBody(response) {
+  const text = await response.text();
+  return text.trim();
+}
+async function e2bFetchJson(path, apiKey, init = {}, apiBase = DEFAULT_E2B_API_BASE) {
+  const response = await fetch(`${apiBase}${path}`, {
+    ...init,
+    headers: {
+      ...e2bHeaders(apiKey),
+      ...init.headers ?? {}
+    }
+  });
+  if (!response.ok) {
+    const body = await readResponseBody(response);
+    throw new E2BApiError(response.status, `E2B API ${response.status} ${response.statusText}: ${body}`);
+  }
+  if (response.status === 204) {
+    return;
+  }
+  return await response.json();
+}
+async function createSandbox(opts) {
+  const createdAt = Date.now();
+  const sandbox = await e2bFetchJson("/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);
+  if (!sandbox.endAt && !sandbox.expiresAt) {
+    sandbox.expiresAt = new Date(createdAt + opts.timeoutSec * 1000).toISOString();
+  }
+  return sandbox;
+}
+function ttlRemaining(sandbox) {
+  const expiresAt = sandbox.endAt ?? sandbox.expiresAt;
+  if (!expiresAt)
+    return {};
+  const expiryMs = Date.parse(expiresAt);
+  if (Number.isNaN(expiryMs))
+    return {};
+  const secondsLeft = Math.max(0, Math.round((expiryMs - Date.now()) / 1000));
+  return { expiresAt, secondsLeft };
+}
+async function setSandboxTimeout(opts) {
+  const { Sandbox } = await import("./index-etdrp7yp.js").then((m)=>__toESM(m.default,1));
+  let sandbox;
+  try {
+    sandbox = await Sandbox.connect(opts.sandboxId, e2bSdkConnectionOptions(opts.apiKey, opts.e2bEnv ?? {}, opts.apiBase));
+  } catch {
+    throw new Error(`sandbox ${opts.sandboxId} not found / already expired`);
+  }
+  await sandbox.setTimeout(opts.timeoutMs);
+  const info = await sandbox.getInfo();
+  const expiresAt = info.endAt instanceof Date ? info.endAt.toISOString() : String(info.endAt);
+  return ttlRemaining({
+    sandboxID: opts.sandboxId,
+    templateID: info.templateId,
+    endAt: expiresAt
+  });
+}
+async function killSandbox(sandboxId, apiKey, apiBase = DEFAULT_E2B_API_BASE) {
+  await e2bFetchJson(`/sandboxes/${encodeURIComponent(sandboxId)}`, apiKey, { method: "DELETE" }, apiBase);
+}
+async function listSandboxes(apiKey, apiBase = DEFAULT_E2B_API_BASE) {
+  return e2bFetchJson("/sandboxes", apiKey, {}, apiBase);
+}
+function sandboxLogPath(role) {
+  return `/tmp/agent-swarm-e2b-${role}.log`;
+}
+async function startDetachedProcess(opts) {
+  const logPath = sandboxLogPath(opts.role);
+  const shell = buildTrackedShell(opts.command, logPath);
+  const { Sandbox } = await import("./index-etdrp7yp.js").then((m)=>__toESM(m.default,1));
+  const sandbox = await Sandbox.connect(opts.sandbox.sandboxID, e2bSdkConnectionOptions(opts.apiKey, opts.e2bEnv ?? {}, opts.apiBase));
+  const handle = await sandbox.commands.run(`bash -lc ${shellQuote(shell)}`, {
+    user: opts.user ?? "root",
+    cwd: opts.cwd ?? "/",
+    envs: opts.env,
+    background: true,
+    timeoutMs: 0
+  });
+  await Bun.sleep(2000);
+  if (typeof handle.exitCode === "number" && handle.exitCode !== 0) {
+    const detail = redactWithEnv(`${handle.stdout}
+${handle.stderr}`.trim(), opts.env);
+    throw new Error(`E2B start command exited ${handle.exitCode} at launch: ${detail}`);
+  }
+  return String(handle.pid);
+}
+function shellQuote(value) {
+  return `'${value.split("'").join(`'\\''`)}'`;
+}
+async function streamSandboxLog(opts) {
+  const logPath = sandboxLogPath(opts.role);
+  const tailLines = opts.tailLines ?? 200;
+  const { Sandbox } = await import("./index-etdrp7yp.js").then((m)=>__toESM(m.default,1));
+  const sandbox = await Sandbox.connect(opts.sandboxId, e2bSdkConnectionOptions(opts.apiKey, opts.e2bEnv ?? {}, opts.apiBase));
+  if (!opts.follow) {
+    const result = await sandbox.commands.run(`bash -lc ${shellQuote(`tail -n ${tailLines} ${logPath} 2>&1 || true`)}`, { user: "root", timeoutMs: 30000 });
+    if (result.stdout)
+      opts.onChunk(result.stdout);
+    if (result.stderr)
+      opts.onChunk(result.stderr);
+    return;
+  }
+  const handle = await sandbox.commands.run(`bash -lc ${shellQuote(`tail -n ${tailLines} -F ${logPath}`)}`, {
+    user: "root",
+    background: true,
+    onStdout: (data) => opts.onChunk(data),
+    onStderr: (data) => opts.onChunk(data)
+  });
+  const stop = async () => {
+    try {
+      await handle.kill();
+    } catch {}
+  };
+  if (opts.signal) {
+    if (opts.signal.aborted) {
+      await stop();
+      return;
+    }
+    opts.signal.addEventListener("abort", stop, { once: true });
+  }
+  try {
+    await handle.wait();
+  } catch {}
+}
+async function waitForAgentRegistration(apiUrl, agentId, apiKey, timeoutMs) {
+  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(1000);
+  }
+  throw new Error(`Timed out waiting for worker ${agentId} to register at ${url}${lastError ? ` (${lastError})` : ""}`);
+}
+async function waitForHttpOk(url, timeoutMs) {
+  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(1000);
+  }
+  throw new Error(`Timed out waiting for ${url}${lastError ? ` (${lastError})` : ""}`);
+}
+function buildTemplateArgs(opts) {
+  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;
+}
+async function runE2BCommand(args, env) {
+  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 };
+}
+async function buildTemplate(opts) {
+  const args = buildTemplateArgs(opts);
+  if (opts.dryRun) {
+    return { exitCode: 0, stdout: `e2b ${args.join(" ")}
+`, stderr: "" };
+  }
+  return runE2BCommand(args, opts.e2bEnv);
+}
+async function buildImageTemplate(opts) {
+  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(`
+`).concat(`
+`),
+      stderr: ""
+    };
+  }
+  const apiKey = opts.e2bEnv.E2B_API_KEY;
+  if (!apiKey) {
+    throw new Error("Missing E2B_API_KEY");
+  }
+  const { Template } = await import("./index-etdrp7yp.js").then((m)=>__toESM(m.default,1));
+  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,
+    signal: opts.signal
+  });
+  return {
+    exitCode: 0,
+    stdout: `Built E2B ${opts.role} template ${buildInfo.name} (${buildInfo.templateId}, build ${buildInfo.buildId})
+`,
+    stderr: ""
+  };
+}
+async function deleteTemplate(opts) {
+  const args = ["template", "delete", opts.name, "-y"];
+  if (opts.dryRun) {
+    return { exitCode: 0, stdout: `e2b ${args.join(" ")}
+`, stderr: "" };
+  }
+  return runE2BCommand(args, opts.e2bEnv);
+}
+async function setTemplateVisibility(opts) {
+  const path = `/v2/templates/${encodeURIComponent(opts.name)}`;
+  if (opts.dryRun) {
+    return {
+      exitCode: 0,
+      stdout: `PATCH ${path} {"public":${opts.public}}
+`,
+      stderr: ""
+    };
+  }
+  const apiKey = opts.e2bEnv.E2B_API_KEY;
+  if (!apiKey) {
+    throw new Error("Missing E2B_API_KEY");
+  }
+  const result = await e2bFetchJson(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}
+`,
+    stderr: ""
+  };
+}
+var E2BApiError;
+var init_dispatch = __esm(() => {
+  init_env();
+  E2BApiError = class E2BApiError extends Error {
+    statusCode;
+    constructor(statusCode, message) {
+      super(message);
+      this.statusCode = statusCode;
+    }
+  };
+});
+
+export { e2bSdkConnectionOptions, sandboxPortUrl, E2BApiError, createSandbox, ttlRemaining, setSandboxTimeout, killSandbox, listSandboxes, startDetachedProcess, streamSandboxLog, waitForAgentRegistration, waitForHttpOk, buildTemplate, buildImageTemplate, deleteTemplate, setTemplateVisibility, init_dispatch };

package/dist/{cli-hf5s9pgf.js → cli-e3pmyt39.js}

@@ -1,7 +1,7 @@
 import {
   init_secret_scrubber,
   scrubSecrets
-} from "./cli-wt7ccy4r.js";
+} from "./cli-d161g69q.js";
 
 // src/providers/devin-adapter.ts
 init_secret_scrubber();