@desplega.ai/agent-swarm 1.165.0 → 1.167.0

package/src/providers/pricing-sources.md

@@ -178,6 +178,8 @@ and heartbeat-classified roots are omitted, and the metrics remain separate.
 - **Codex usage:** the app-server reports cumulative token counters, including cache writes.
   The adapter calculates each turn's delta before adding it to the session total.
   This prevents repeated billing of earlier turns when the adapter processes queued input.
+  Context occupancy is separate: it comes from the per-request `tokenUsage.last`
+  snapshot (and `modelContextWindow` when present), never from the turn delta.
 - **Claude breakdown validity is all-or-nothing:** the claude adapter drops the
   entire `modelUsage` breakdown when any entry carries a missing, non-finite,
   or negative token counter — zero-filling would let the server price a

package/src/script-workflows/supervisor.ts

@@ -1,11 +1,13 @@
 import {
   getRunningScriptRuns,
   getScriptRun,
+  getScriptRunExecutionArgs,
   updateScriptRun,
   updateScriptRunIfRunning,
 } from "../be/db";
 import type { ScriptRun } from "../types";
 import { getApiKey } from "../utils/api-key";
+import { scrubSecrets } from "../utils/secret-scrubber";
 import {
   localProcessScriptExecutor,
   type ScriptExecutionHandle,
@@ -44,7 +46,10 @@ export async function startScriptRunProcess(
     );
   }
 
-  const execution = await scriptExecutor.start({ run, baseUrl, apiKey });
+  // `run.args` is the redacted view; launch with the exact sealed value.
+  const sealedArgs = await getScriptRunExecutionArgs(run.id);
+  const args = sealedArgs === undefined ? run.args : sealedArgs;
+  const execution = await scriptExecutor.start({ run: { ...run, args }, baseUrl, apiKey });
   managed.set(run.id, { execution });
   await updateScriptRun(run.id, {
     status: "running",
@@ -57,8 +62,12 @@ export async function startScriptRunProcess(
       const current = await getScriptRun(run.id);
       if (current && current.status === "running") {
         if (exitCode !== 0) {
+          // Script stderr can echo whatever the script printed; scrub at the
+          // log egress. The `error` column below is scrubbed by the DB writer.
           console.error(
-            `[script-workflows] run ${run.id} subprocess exited ${exitCode}: ${stderr.trim() || "(no stderr)"}`,
+            scrubSecrets(
+              `[script-workflows] run ${run.id} subprocess exited ${exitCode}: ${stderr.trim() || "(no stderr)"}`,
+            ),
           );
         }
         // Guarded write: the read above is followed by an await, so the

package/src/scripts-runtime/eval-harness.ts

@@ -1,6 +1,7 @@
 import { buildCtx } from "./ctx";
 import { patchFetchWithEgressSubstitution } from "./egress-secrets";
 import type { SwarmConfigPayload } from "./executors/types";
+import { ctxSignatureHintFor } from "./script-error-hints";
 import { SwarmConfig } from "./swarm-config";
 
 function requiredEnv(name: string): string {
@@ -20,14 +21,6 @@ type StructuredError = {
   ctxSignatureHint?: string;
 };
 
-// Matches runtime errors that look like a swapped/misused (args, ctx) signature,
-// e.g. destructuring `ctx.api`/`ctx.kv`/`ctx.fetchJson`/`ctx.log` off `undefined`/`null`
-// because the script read them off `args` instead.
-const CTX_UNDEFINED_ACCESS_RE = /cannot read propert(?:y|ies)(?: .*)? of (?:undefined|null)/i;
-const CTX_MEMBER_RE = /\b(api|kv|fetchJson|log)\b/i;
-const CTX_SIGNATURE_HINT =
-  "Hint: swarm scripts export default async function (args, ctx) — args comes first, ctx second.";
-
 function buildStructuredError(err: unknown, userModulePath: string): StructuredError {
   const errObj = err instanceof Error ? err : new Error(String(err));
   const name = errObj.name || "Error";
@@ -57,10 +50,7 @@ function buildStructuredError(err: unknown, userModulePath: string): StructuredE
     }
   }
 
-  const ctxSignatureHint =
-    CTX_UNDEFINED_ACCESS_RE.test(message) && CTX_MEMBER_RE.test(message)
-      ? CTX_SIGNATURE_HINT
-      : undefined;
+  const ctxSignatureHint = ctxSignatureHintFor(message);
 
   return {
     name,

package/src/scripts-runtime/executors/quickjs-bundle.ts

@@ -0,0 +1,152 @@
+import { SourceMapReader } from "./sourcemap";
+
+/**
+ * Bundles a user script for the quickjs executor. QuickJS runs plain
+ * JavaScript only, so Bun strips the types and inlines the imports into one
+ * IIFE. The bundle sets `globalThis.__swarm_module` to the module namespace.
+ *
+ * Bare imports:
+ *  - `zod` is inlined from its ESM sources, so Bun tree-shakes it. Each run
+ *    evaluates only the zod code that the script uses.
+ *  - `stdlib` and `swarm-sdk` resolve to small virtual modules that read the
+ *    sandbox globals the quickjs runner installs.
+ */
+
+export const USER_SCRIPT_FILE = "user-script.ts";
+const VIRTUAL_DIR = "/swarm-virtual";
+const ENTRY_PATH = `${VIRTUAL_DIR}/entry.ts`;
+const USER_PATH = `${VIRTUAL_DIR}/${USER_SCRIPT_FILE}`;
+
+const STDLIB_MODULE = `const s = globalThis.__swarm_stdlib;
+export const fetch = s.fetch;
+export const fetchJson = s.fetchJson;
+export const glob = s.glob;
+export const grep = s.grep;
+export const table = s.table;
+export const Redacted = s.Redacted;
+`;
+
+const SWARM_SDK_MODULE = `export function createSwarmSdk() {
+  return globalThis.__swarm_ctx.swarm;
+}
+`;
+
+export type QuickJSBundle =
+  | { ok: true; code: string; map: SourceMapReader | undefined }
+  | { ok: false; diagnostic: string };
+
+type BuildConfigWithFiles = Parameters<typeof Bun.build>[0] & { files: Record<string, string> };
+
+let zodEntryCache: string | null | undefined;
+
+/**
+ * Prefer zod's real ESM sources, which tree-shake well. The prebuilt
+ * `zod.bundle.js` of the API image barely tree-shakes (~340 KB against ~87 KB
+ * for z.object + z.string().email()), so it is only the last fallback.
+ */
+export async function resolveZodEntry(): Promise<string | null> {
+  if (zodEntryCache !== undefined) return zodEntryCache;
+  const runtimeDir = process.env.SCRIPT_RUNTIME_DIR;
+  const candidates: Array<() => string | undefined> = [
+    () => (runtimeDir ? `${runtimeDir}/zod-esm/index.js` : undefined),
+    () => Bun.resolveSync("zod", import.meta.dir),
+    () => (runtimeDir ? `${runtimeDir}/zod.bundle.js` : undefined),
+  ];
+  for (const candidate of candidates) {
+    try {
+      const path = candidate();
+      if (path && (await Bun.file(path).exists())) {
+        zodEntryCache = path;
+        return path;
+      }
+    } catch {
+      // Try the next candidate. Bun.resolveSync throws inside the compiled binary.
+    }
+  }
+  zodEntryCache = null;
+  return null;
+}
+
+const CACHE_LIMIT = 128;
+const cache = new Map<string, QuickJSBundle>();
+
+function remember(key: string, bundle: QuickJSBundle): QuickJSBundle {
+  if (cache.size >= CACHE_LIMIT) {
+    const oldest = cache.keys().next().value;
+    if (oldest !== undefined) cache.delete(oldest);
+  }
+  cache.set(key, bundle);
+  return bundle;
+}
+
+export async function bundleForQuickJS(source: string): Promise<QuickJSBundle> {
+  const key = Bun.hash(source).toString(36);
+  const cached = cache.get(key);
+  if (cached) {
+    // Refresh the LRU position.
+    cache.delete(key);
+    cache.set(key, cached);
+    return cached;
+  }
+
+  const zodEntry = await resolveZodEntry();
+  let result: Awaited<ReturnType<typeof Bun.build>>;
+  try {
+    result = await Bun.build({
+      entrypoints: [ENTRY_PATH],
+      // In-memory sources (Bun >= 1.3). The pinned bun-types predate the option.
+      files: {
+        [ENTRY_PATH]: `import * as m from "./${USER_SCRIPT_FILE}";\nglobalThis.__swarm_module = m;\n`,
+        [USER_PATH]: source,
+      },
+      format: "iife",
+      target: "browser",
+      sourcemap: "external",
+      // Less source for QuickJS to parse on every run. Identifiers stay, so
+      // stack frames keep their function names; the source map keeps lines.
+      minify: { whitespace: true, syntax: true, identifiers: false },
+      plugins: [
+        {
+          name: "swarm-script-imports",
+          setup(build) {
+            build.onResolve({ filter: /^(stdlib|swarm-sdk)$/ }, (args) => ({
+              path: args.path,
+              namespace: "swarm-virtual",
+            }));
+            build.onLoad({ filter: /.*/, namespace: "swarm-virtual" }, (args) => ({
+              contents: args.path === "stdlib" ? STDLIB_MODULE : SWARM_SDK_MODULE,
+              loader: "js",
+            }));
+            build.onResolve({ filter: /^zod$/ }, () => {
+              if (!zodEntry) {
+                throw new Error("zod is not available to the quickjs executor in this deployment");
+              }
+              return { path: zodEntry };
+            });
+          },
+        },
+      ],
+    } as BuildConfigWithFiles);
+  } catch (error) {
+    // Bun.build throws an AggregateError for syntax and resolve errors.
+    const messages =
+      error instanceof AggregateError
+        ? error.errors.map((entry) => String(entry?.message ?? entry))
+        : [error instanceof Error ? error.message : String(error)];
+    return { ok: false, diagnostic: messages.join("\n") };
+  }
+
+  if (!result.success) {
+    return {
+      ok: false,
+      diagnostic: result.logs.map((log) => String(log.message ?? log)).join("\n"),
+    };
+  }
+
+  const output = result.outputs.find((artifact) => artifact.kind === "entry-point");
+  if (!output) return { ok: false, diagnostic: "quickjs bundle produced no entry point" };
+  const code = await output.text();
+  const mapArtifact = result.outputs.find((artifact) => artifact.kind === "sourcemap");
+  const map = mapArtifact ? new SourceMapReader(JSON.parse(await mapArtifact.text())) : undefined;
+  return remember(key, { ok: true, code, map });
+}

package/src/scripts-runtime/executors/quickjs-prelude.ts

@@ -0,0 +1,285 @@
+/**
+ * JavaScript that the quickjs runner evaluates inside the sandbox before the
+ * user bundle. It rebuilds the script `ctx` (swarm, api, mcp, stdlib, logger)
+ * on top of the host functions:
+ *
+ *  - `__host_call(path, argsJson)`: async host call, resolves to a JSON envelope.
+ *  - `__host_sync(op, json)`: sync host call, returns a JSON envelope.
+ *  - `__host_log(stream, text)`: append to the captured stdout or stderr.
+ *  - `__host_sleep(ms)`: resolves after `ms` on the host clock.
+ *  - `__host_done(json)`: reports the final outcome of the run.
+ *
+ * Every value crosses the boundary as JSON. The sandbox has no other way out.
+ * `__swarm_shape` (injected before this file) lists the configured api/mcp
+ * connections so `ctx.api.<slug>` matches the native executor exactly.
+ */
+export const SANDBOX_PRELUDE = String.raw`(() => {
+"use strict";
+const shape = globalThis.__swarm_shape;
+
+const unwrap = (json) => {
+  const envelope = JSON.parse(json);
+  if (envelope.error !== undefined) {
+    const error = new Error(envelope.error.message);
+    if (envelope.error.name) error.name = envelope.error.name;
+    throw error;
+  }
+  return envelope.value;
+};
+const hostCall = async (path, args) =>
+  unwrap(await __host_call(path, JSON.stringify(args === undefined ? null : args)));
+const hostSync = (op, value) => unwrap(__host_sync(op, JSON.stringify(value === undefined ? null : value)));
+
+// ── console ──
+const format = (value) => {
+  if (typeof value === "string") return value;
+  if (value instanceof Error) return value.stack ? value.name + ": " + value.message + "\n" + value.stack : String(value);
+  try {
+    const json = JSON.stringify(value);
+    return json === undefined ? String(value) : json;
+  } catch {
+    return String(value);
+  }
+};
+const logTo = (stream) => (...args) => __host_log(stream, args.map(format).join(" ") + "\n");
+const console = {
+  log: logTo("stdout"),
+  info: logTo("stdout"),
+  debug: logTo("stdout"),
+  warn: logTo("stderr"),
+  error: logTo("stderr"),
+};
+
+// ── timers ──
+let timerSeq = 0;
+const timers = new Set();
+const setTimeout = (fn, ms, ...args) => {
+  const id = ++timerSeq;
+  timers.add(id);
+  __host_sleep(Number(ms) || 0).then(() => {
+    if (timers.delete(id)) fn(...args);
+  });
+  return id;
+};
+const clearTimeout = (id) => {
+  timers.delete(id);
+};
+
+// ── Redacted ──
+const redactedEntries = new WeakMap();
+const redactedProto = Object.freeze({
+  toString() {
+    return "<redacted>";
+  },
+  toJSON() {
+    return "<redacted>";
+  },
+});
+const entryOf = (self) => {
+  const entry = redactedEntries.get(self);
+  if (!entry) throw new Error("Redacted value was not in registry");
+  return entry;
+};
+const hostRedacted = (hostId) => {
+  const value = Object.create(redactedProto);
+  redactedEntries.set(value, { hostId });
+  return value;
+};
+const Redacted = Object.freeze({
+  make(value, meta = { type: "user", isSecret: false }) {
+    const redacted = Object.create(redactedProto);
+    redactedEntries.set(redacted, { value, meta });
+    return redacted;
+  },
+  value(self) {
+    const entry = entryOf(self);
+    return "hostId" in entry ? hostSync("redacted.value", entry.hostId) : entry.value;
+  },
+  meta(self) {
+    const entry = entryOf(self);
+    return "hostId" in entry ? hostSync("redacted.meta", entry.hostId) : entry.meta;
+  },
+  isSecret(self) {
+    return Redacted.meta(self).isSecret;
+  },
+});
+
+const config = Object.freeze({
+  apiKey: hostRedacted("system:apiKey"),
+  agentId: hostRedacted("system:agentId"),
+  mcpBaseUrl: hostRedacted("system:mcpBaseUrl"),
+  runtimeInstanceId: shape.hasRuntimeInstanceId ? hostRedacted("system:runtimeInstanceId") : undefined,
+  extensionToken: undefined,
+  get(key) {
+    return hostSync("config.has", key) ? hostRedacted("user:" + key) : undefined;
+  },
+});
+
+// ── fetch (text bodies only) ──
+class Headers {
+  constructor(init) {
+    this._map = new Map();
+    const pairs = init == null ? [] : Array.isArray(init) ? init
+      : typeof init.entries === "function" ? Array.from(init.entries()) : Object.entries(init);
+    for (const [key, value] of pairs) this._map.set(String(key).toLowerCase(), String(value));
+  }
+  get(key) {
+    const value = this._map.get(String(key).toLowerCase());
+    return value === undefined ? null : value;
+  }
+  has(key) {
+    return this._map.has(String(key).toLowerCase());
+  }
+  set(key, value) {
+    this._map.set(String(key).toLowerCase(), String(value));
+  }
+  entries() {
+    return this._map.entries();
+  }
+  keys() {
+    return this._map.keys();
+  }
+  forEach(callback) {
+    this._map.forEach((value, key) => callback(value, key, this));
+  }
+  [Symbol.iterator]() {
+    return this._map.entries();
+  }
+}
+class Response {
+  constructor(raw) {
+    this.status = raw.status;
+    this.statusText = raw.statusText;
+    this.ok = raw.ok;
+    this.url = raw.url;
+    this.headers = new Headers(raw.headers);
+    this._body = raw.body;
+    this.bodyUsed = false;
+  }
+  async text() {
+    this.bodyUsed = true;
+    return this._body;
+  }
+  async json() {
+    this.bodyUsed = true;
+    return JSON.parse(this._body);
+  }
+}
+const toRequest = (input, init) => {
+  const options = init || {};
+  const url = typeof input === "string" ? input : input && (input.href || input.url) ? input.href || input.url : String(input);
+  if (options.body != null && typeof options.body !== "string") {
+    throw new TypeError("quickjs executor: fetch body must be a string (JSON.stringify it first)");
+  }
+  const headers = options.headers == null ? undefined : Array.from(new Headers(options.headers).entries());
+  const request = { url, method: options.method, headers, body: options.body == null ? undefined : options.body };
+  if (options.retries !== undefined) request.retries = options.retries;
+  if (options.timeoutMs !== undefined) request.timeoutMs = options.timeoutMs;
+  return request;
+};
+const fetch = async (input, init) => new Response(await hostCall("fetch", [toRequest(input, init)]));
+
+const unavailable = (name) => () => {
+  throw new Error(name + " is not available in the quickjs executor (no filesystem access)");
+};
+const stdlib = Object.freeze({
+  fetch: async (input, options) => new Response(await hostCall("stdlib.fetch", [toRequest(input, options)])),
+  fetchJson: async (input, options) => hostCall("stdlib.fetchJson", [toRequest(input, options)]),
+  glob: unavailable("ctx.stdlib.glob"),
+  grep: unavailable("ctx.stdlib.grep"),
+  table: (rows) => hostSync("table", rows),
+  Redacted,
+});
+
+// ── ctx ──
+const method = (path) => (...args) => hostCall(path, args);
+const room = Object.freeze({
+  get: method("swarm.room.get"),
+  change: method("swarm.room.change"),
+  reset: method("swarm.room.reset"),
+  decode: method("swarm.room.decode"),
+});
+const swarm = new Proxy({ room, config }, {
+  get(target, prop) {
+    if (typeof prop !== "string") return undefined;
+    if (prop in target) return target[prop];
+    if (prop === "then") return undefined;
+    return method("swarm." + prop);
+  },
+});
+const registry = (kind) => {
+  const out = {};
+  for (const [slug, names] of Object.entries(shape[kind])) {
+    const client = {};
+    for (const name of names) client[name] = method(kind + "." + slug + "." + name);
+    out[slug] = client;
+  }
+  return out;
+};
+const ctx = Object.freeze({ swarm, api: registry("api"), mcp: registry("mcp"), stdlib, logger: console });
+
+const define = (name, value) =>
+  Object.defineProperty(globalThis, name, { value, writable: true, configurable: true, enumerable: false });
+define("console", console);
+define("setTimeout", setTimeout);
+define("clearTimeout", clearTimeout);
+define("fetch", fetch);
+define("Headers", Headers);
+define("Response", Response);
+define("__swarm_stdlib", stdlib);
+define("__swarm_ctx", ctx);
+})();
+`;
+
+/**
+ * Runs the script's default export with `(args, ctx)` after the optional
+ * zod `argsSchema` check, the same contract as `eval-harness.ts`.
+ */
+export const SANDBOX_EPILOGUE = String.raw`(async () => {
+  const mod = globalThis.__swarm_module;
+  if (!mod || typeof mod.default !== "function") {
+    throw new Error(
+      "Swarm script must export a default function. Script must export default async function (args, ctx): args FIRST, ctx second.",
+    );
+  }
+  let args = globalThis.__swarm_args;
+  if (mod.argsSchema && typeof mod.argsSchema === "object" && "parse" in mod.argsSchema) {
+    try {
+      args = mod.argsSchema.parse(args);
+    } catch (error) {
+      if (error && typeof error === "object" && Array.isArray(error.issues)) {
+        const issues = error.issues
+          .map((issue) => "  " + (issue.path.length ? issue.path.join(".") : "(root)") + ": " + issue.message)
+          .join("\n");
+        throw new Error("argsSchema validation failed:\n" + issues);
+      }
+      throw error;
+    }
+  }
+  return await mod.default(args, globalThis.__swarm_ctx);
+})().then(
+  (value) => {
+    let json;
+    try {
+      json = JSON.stringify({ ok: true, result: value === undefined ? null : value });
+    } catch (error) {
+      json = JSON.stringify({
+        ok: false,
+        error: { name: "TypeError", message: "Script result is not JSON-serializable: " + error.message, stack: "" },
+      });
+    }
+    __host_done(json);
+  },
+  (error) =>
+    __host_done(
+      JSON.stringify({
+        ok: false,
+        error: {
+          name: (error && error.name) || "Error",
+          message: error && error.message !== undefined ? String(error.message) : String(error),
+          stack: (error && error.stack) || "",
+        },
+      }),
+    ),
+);
+`;