@desplega.ai/agent-swarm 2.3.0 → 2.4.0

package/dist/cli-02vhhssk.js

@@ -0,0 +1,848 @@
+import {
+  getRequestAuth,
+  init_request_auth_context,
+  getDbClient2,
+  getActiveTaskCount2,
+  getTaskById2,
+  getAgentCurrentTask2,
+  getActiveSessionById,
+  init_active_sessions,
+  getSteeringMessageById2,
+  init_db3
+} from "./cli-rg7ntypm.js";
+import {
+  getUserGrant2,
+  init_rbac_roles
+} from "./cli-5s5hx57y.js";
+import {
+  findUserById,
+  findUserByExternalId,
+  init_users
+} from "./cli-8cxkw1f5.js";
+import {
+  isRbacEnabled,
+  init_rbac
+} from "./cli-1pa3rz69.js";
+import {
+  init_zod
+} from "./cli-4chz1hye.js";
+import {
+  ZodError,
+  string2,
+  object2
+} from "./cli-d9f7gzeq.js";
+import {
+  getNodeEnv,
+  init_node_env
+} from "./cli-rgeadyvq.js";
+import {
+  isEnvFlagEnabled,
+  init_env_flag
+} from "./cli-0hyhdkdk.js";
+import {
+  scrubSecrets,
+  init_secret_scrubber
+} from "./cli-4mkvwgzr.js";
+
+// src/http/route-def.ts
+init_zod();
+init_node_env();
+init_secret_scrubber();
+
+// src/http/utils.ts
+init_db3();
+init_env_flag();
+init_node_env();
+init_secret_scrubber();
+function duplicateGuardedQueryKey(query) {
+  return ["agentId", "repoId", "includeSecrets", "resolveSecrets"].find((key) => query.getAll(key).length > 1);
+}
+var DEFAULT_ALLOWED_ORIGINS = [
+  "https://*.agent-swarm.dev",
+  "https://*.agent-swarm.cloud",
+  "http://localhost:5274",
+  "http://127.0.0.1:5274",
+  "http://[::1]:5274",
+  "https://ui.swarm.localhost:1355"
+];
+var warnedAboutAllowAnyOrigin = false;
+function warnIfCorsAllowsAnyOrigin() {
+  if (isEnvFlagEnabled("CORS_ALLOW_ANY_ORIGIN", false) && !warnedAboutAllowAnyOrigin) {
+    warnedAboutAllowAnyOrigin = true;
+    console.warn("[CORS] CORS_ALLOW_ANY_ORIGIN=true: any request origin can receive non-credentialed responses; cookie-authenticated responses still require CORS_ALLOWED_ORIGINS. Set CORS_ALLOWED_ORIGINS and disable CORS_ALLOW_ANY_ORIGIN to restrict access.");
+  }
+}
+function getAllowedOrigins() {
+  const raw = process.env.CORS_ALLOWED_ORIGINS;
+  if (!raw || !raw.trim())
+    return DEFAULT_ALLOWED_ORIGINS;
+  return raw.split(",").map((entry) => entry.trim()).filter(Boolean);
+}
+function isDevLoopbackOrigin(origin) {
+  if (getNodeEnv() !== "development")
+    return false;
+  return /^https?:\/\/(localhost|127\.0\.0\.1|\[::1\])(:\d{1,5})?$/.test(origin);
+}
+function originAllowedForCredentials(origin) {
+  if (isDevLoopbackOrigin(origin))
+    return true;
+  return getAllowedOrigins().some((entry) => {
+    if (!entry.includes("*"))
+      return entry === origin;
+    const pattern = /^([a-zA-Z][a-zA-Z0-9+.-]*):\/\/\*\.([a-zA-Z0-9.-]+)(:\d+)?$/.exec(entry);
+    const candidate = /^([a-zA-Z][a-zA-Z0-9+.-]*):\/\/([a-zA-Z0-9.-]+)(:\d+)?$/.exec(origin);
+    if (!pattern || !candidate)
+      return false;
+    if (pattern[1] !== candidate[1] || pattern[3] !== candidate[3])
+      return false;
+    const suffix = pattern[2].toLowerCase();
+    const hostname = candidate[2].toLowerCase();
+    const validLabel = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
+    if (![...suffix.split("."), ...hostname.split(".")].every((label) => validLabel.test(label))) {
+      return false;
+    }
+    return hostname.endsWith(`.${suffix}`);
+  });
+}
+function isOriginAllowedForCredentials(origin) {
+  const allowed = originAllowedForCredentials(origin);
+  if (!allowed) {
+    console.warn(`[CORS] Denied credentialed origin ${scrubSecrets(JSON.stringify(origin.slice(0, 512)))}; add the trusted SPA origin to CORS_ALLOWED_ORIGINS (custom values replace hosted/dev defaults).`);
+  }
+  return allowed;
+}
+function allowedCredentialRedirect(raw) {
+  if (!raw)
+    return;
+  try {
+    const redirect = new URL(raw);
+    if (redirect.protocol !== "http:" && redirect.protocol !== "https:")
+      return;
+    return originAllowedForCredentials(redirect.origin) ? redirect.toString() : undefined;
+  } catch {
+    return;
+  }
+}
+function setCorsHeaders(req, res) {
+  const rawOrigin = req.headers.origin;
+  const origin = Array.isArray(rawOrigin) ? rawOrigin[0] : rawOrigin;
+  const allowCredentials = origin ? isOriginAllowedForCredentials(origin) : false;
+  const allowAnyOrigin = isEnvFlagEnabled("CORS_ALLOW_ANY_ORIGIN", false);
+  if (allowAnyOrigin)
+    warnIfCorsAllowsAnyOrigin();
+  if (origin && !allowCredentials && !allowAnyOrigin) {
+    res.setHeader("Vary", "Origin");
+    return;
+  }
+  if (origin) {
+    res.setHeader("Access-Control-Allow-Origin", origin);
+    res.setHeader("Vary", "Origin");
+    if (allowCredentials)
+      res.setHeader("Access-Control-Allow-Credentials", "true");
+    const reqHeaders = req.headers["access-control-request-headers"];
+    const askedHeaders = Array.isArray(reqHeaders) ? reqHeaders.join(", ") : reqHeaders;
+    res.setHeader("Access-Control-Allow-Headers", askedHeaders ?? "Authorization, Content-Type, X-Agent-ID, X-Requested-With, X-Swarm-User-Id");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, PATCH, DELETE, OPTIONS");
+    res.setHeader("Access-Control-Expose-Headers", "Content-Type, Content-Length, ETag, Location");
+  } else {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, PATCH, DELETE, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "*");
+    res.setHeader("Access-Control-Expose-Headers", "*");
+  }
+}
+function parseQueryParams(url) {
+  const queryIndex = url.indexOf("?");
+  if (queryIndex === -1)
+    return new URLSearchParams;
+  return new URLSearchParams(url.slice(queryIndex + 1));
+}
+function getPathSegments(url) {
+  const pathEnd = url.indexOf("?");
+  const path = pathEnd === -1 ? url : url.slice(0, pathEnd);
+  return path.split("/").filter(Boolean);
+}
+function abortedStatusCodeAttribute(headersSent, statusCode) {
+  return headersSent ? statusCode : undefined;
+}
+function wireHttpSpanLifecycle(res, span, getStatusCode, startTime) {
+  let spanEnded = false;
+  res.on("finish", () => {
+    if (spanEnded)
+      return;
+    spanEnded = true;
+    const statusCode = getStatusCode();
+    span.setAttributes({
+      "http.response.status_code": statusCode,
+      "agentswarm.http.duration_ms": Math.round((performance.now() - startTime) * 10) / 10
+    });
+    if (statusCode >= 500) {
+      span.setStatus({ code: 2, message: `HTTP ${statusCode}` });
+    }
+    span.end();
+  });
+  res.on("error", (err) => {
+    if (spanEnded)
+      return;
+    spanEnded = true;
+    if (err)
+      span.recordException(err);
+    span.setStatus({ code: 2, message: err?.message });
+    span.end();
+  });
+  res.on("close", () => {
+    if (spanEnded)
+      return;
+    spanEnded = true;
+    span.setAttributes({
+      "http.response.status_code": abortedStatusCodeAttribute(res.headersSent, getStatusCode()),
+      "agentswarm.http.duration_ms": Math.round((performance.now() - startTime) * 10) / 10,
+      "agentswarm.http.aborted": true
+    });
+    span.end();
+  });
+}
+function safeRequestUrlForLog(rawUrl) {
+  if (!rawUrl)
+    return "";
+  try {
+    const url = new URL(rawUrl, "http://localhost");
+    const params = Array.from(url.searchParams.keys());
+    if (params.length === 0)
+      return url.pathname;
+    const redactedQuery = params.map((key) => `${key}=[REDACTED]`).join("&");
+    return `${url.pathname}?${redactedQuery}`;
+  } catch {
+    const pathOnly = rawUrl.split("?")[0] || rawUrl;
+    return scrubSecrets(pathOnly);
+  }
+}
+async function agentWithCapacity(agent) {
+  const activeCount = await getActiveTaskCount2(agent.id);
+  const max = agent.maxTasks ?? 1;
+  return {
+    ...agent,
+    capacity: {
+      current: activeCount,
+      max,
+      available: Math.max(0, max - activeCount)
+    }
+  };
+}
+
+class RequestBodyTooLargeError extends Error {
+  maxBytes;
+  constructor(maxBytes) {
+    super(`Payload too large (max ${maxBytes} bytes)`);
+    this.name = "RequestBodyTooLargeError";
+    this.maxBytes = maxBytes;
+  }
+}
+function requestContentLength(req) {
+  const raw = req.headers["content-length"];
+  const value = Array.isArray(raw) ? raw[0] : raw;
+  if (!value)
+    return;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : undefined;
+}
+async function parseBody(req, maxBytes = Number.POSITIVE_INFINITY) {
+  const contentLength = requestContentLength(req);
+  if (contentLength !== undefined && contentLength > maxBytes) {
+    req.resume();
+    throw new RequestBodyTooLargeError(maxBytes);
+  }
+  return await new Promise((resolve, reject) => {
+    const chunks = [];
+    let totalBytes = 0;
+    let settled = false;
+    const cleanup = () => {
+      req.off("data", onData);
+      req.off("end", onEnd);
+      req.off("error", onError);
+      req.off("aborted", onAborted);
+      req.off("close", onClose);
+    };
+    const rejectTooLarge = () => {
+      if (settled)
+        return;
+      settled = true;
+      reject(new RequestBodyTooLargeError(maxBytes));
+      req.resume();
+    };
+    const onData = (chunk) => {
+      if (settled)
+        return;
+      const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      totalBytes += buffer.byteLength;
+      if (totalBytes > maxBytes) {
+        rejectTooLarge();
+        return;
+      }
+      chunks.push(buffer);
+    };
+    const onEnd = () => {
+      if (settled) {
+        cleanup();
+        return;
+      }
+      settled = true;
+      cleanup();
+      const raw = Buffer.concat(chunks).toString();
+      if (raw.trim() === "") {
+        resolve({});
+        return;
+      }
+      try {
+        resolve(JSON.parse(raw));
+      } catch (error) {
+        reject(error);
+      }
+    };
+    const onError = (error) => {
+      cleanup();
+      if (!settled) {
+        settled = true;
+        reject(error);
+      }
+    };
+    const onAborted = () => onError(new Error("Request body was aborted"));
+    const onClose = () => {
+      if (!req.readableEnded)
+        onError(new Error("Request body closed before completion"));
+    };
+    req.on("data", onData);
+    req.on("end", onEnd);
+    req.on("error", onError);
+    req.on("aborted", onAborted);
+    req.on("close", onClose);
+    req.resume();
+  });
+}
+var BODY_TOO_LARGE = Symbol("body-too-large");
+function enforceContentLengthCap(req, res, maxBytes) {
+  const raw = req.headers["content-length"];
+  const val = Array.isArray(raw) ? raw[0] : raw;
+  if (!val)
+    return null;
+  const n = Number(val);
+  if (!Number.isFinite(n) || n < 0)
+    return null;
+  if (n > maxBytes) {
+    res.writeHead(413, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: `Payload too large (max ${maxBytes} bytes)` }));
+    return BODY_TOO_LARGE;
+  }
+  return null;
+}
+function json(res, data, status = 200) {
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(data));
+}
+function jsonError(res, error, status = 400) {
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify({ error: scrubSecrets(error) }));
+}
+function writeUnhandledError(res, err, req) {
+  const message = err instanceof Error ? err.message : String(err);
+  console.error(`[HTTP] ❌ ${req?.method ?? ""} ${safeRequestUrlForLog(req?.url)} → ${scrubSecrets(message)}`);
+  if (!res.headersSent) {
+    jsonError(res, message, 500);
+  } else if (!res.writableEnded) {
+    res.end();
+  }
+}
+function triggerSchemaErrorResponse(res, message, details) {
+  res.writeHead(400, { "Content-Type": "application/json" });
+  res.end(JSON.stringify({ error: "TriggerSchemaError", message, details }));
+}
+function deriveApiBaseUrl(req) {
+  const publicBase = process.env.PUBLIC_MCP_BASE_URL?.trim();
+  if (publicBase)
+    return publicBase.replace(/\/+$/, "");
+  const envBase = process.env.MCP_BASE_URL?.trim();
+  if (envBase)
+    return envBase.replace(/\/+$/, "");
+  const fwdProtoRaw = req.headers["x-forwarded-proto"];
+  const fwdHostRaw = req.headers["x-forwarded-host"];
+  const fwdProto = Array.isArray(fwdProtoRaw) ? fwdProtoRaw[0] : fwdProtoRaw;
+  const fwdHost = Array.isArray(fwdHostRaw) ? fwdHostRaw[0] : fwdHostRaw;
+  const proto = fwdProto?.split(",")[0]?.trim() || "http";
+  const host = fwdHost?.split(",")[0]?.trim() || req.headers.host;
+  if (host)
+    return `${proto}://${host}`;
+  return `http://localhost:${process.env.PORT || "3013"}`;
+}
+function httpServerSemconvAttributes(req) {
+  const headerValue = (v) => Array.isArray(v) ? v[0] : v;
+  const firstHop = (v) => headerValue(v)?.split(",")[0]?.trim() || undefined;
+  const fwdProto = firstHop(req.headers["x-forwarded-proto"]);
+  const host = firstHop(req.headers["x-forwarded-host"]) ?? headerValue(req.headers.host)?.trim();
+  return {
+    "server.address": host ? host.replace(/:\d+$/, "") || undefined : undefined,
+    "url.scheme": fwdProto ?? "http",
+    "network.protocol.version": req.httpVersion || undefined,
+    "user_agent.original": headerValue(req.headers["user-agent"])
+  };
+}
+function matchRoute(method, pathSegments, expectedMethod, pattern, exact = false) {
+  if (method !== expectedMethod)
+    return false;
+  for (let i = 0;i < pattern.length; i++) {
+    const seg = pattern[i];
+    if (seg === null) {
+      if (!pathSegments[i])
+        return false;
+    } else {
+      if (pathSegments[i] !== seg)
+        return false;
+    }
+  }
+  if (exact && pathSegments[pattern.length])
+    return false;
+  return true;
+}
+
+// src/http/route-def.ts
+var runtimeInstanceHeader = (operation) => object2({
+  "X-Runtime-Instance-ID": string2().optional().describe("Identifies the concrete runtime instance (worker process) making the call, " + `as generated at its boot. Required to ${operation} when multi-runtime mode ` + "(MULTI_RUNTIME_ENABLED) is on; ignored otherwise.")
+});
+function bodyTask(key) {
+  return { bodyTaskIds: (body) => [body?.[key]] };
+}
+function bodyListTask(listKey, key) {
+  return {
+    bodyTaskIds: (body) => {
+      const items = body?.[listKey];
+      return Array.isArray(items) ? items.map((item) => item?.[key]) : [];
+    }
+  };
+}
+function routePathParams(def, pathSegments) {
+  const params = {};
+  const paramNames = def.path.match(/\{(\w+)\}/g)?.map((p) => p.slice(1, -1)) ?? [];
+  for (let i = 0;i < def.pattern.length; i++) {
+    if (def.pattern[i] === null && paramNames.length > 0) {
+      params[paramNames.shift()] = pathSegments[i] ?? "";
+    }
+  }
+  return params;
+}
+var routeRegistry = [];
+function isPublicRoute(method, pathSegments) {
+  for (const def of routeRegistry) {
+    if (def.auth?.apiKey === false) {
+      if (matchRoute(method, pathSegments, def.method.toUpperCase(), def.pattern, def.exact ?? true)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function findRoute(method, pathSegments) {
+  for (const def of routeRegistry) {
+    if (matchRoute(method, pathSegments, def.method.toUpperCase(), def.pattern, def.exact ?? true)) {
+      return def;
+    }
+  }
+  return;
+}
+var CORE_ROUTE_TEMPLATES = {
+  health: { path: "/health" },
+  "openapi.json": { path: "/openapi.json" },
+  docs: { path: "/docs", toleratesTrailingSlash: true },
+  me: { path: "/me", methods: ["GET"], toleratesQueryString: true },
+  "cancelled-tasks": {
+    path: "/cancelled-tasks",
+    methods: ["GET"],
+    toleratesQueryString: true
+  },
+  "internal/reload-config": { path: "/internal/reload-config", methods: ["POST"] },
+  mcp: { path: "/mcp", methods: ["GET", "POST", "DELETE"] },
+  "mcp-user": { path: "/mcp-user", methods: ["GET", "POST", "DELETE"] }
+};
+function describeRequestRoute(method, pathSegments, hasQueryString = false, hasTrailingSlash = false) {
+  const m = (method ?? "").toUpperCase() || "UNKNOWN";
+  const matched = findRoute(method, pathSegments);
+  if (matched)
+    return { spanName: `${m} ${matched.path}`, httpRoute: matched.path };
+  const coreTemplate = CORE_ROUTE_TEMPLATES[pathSegments.join("/")];
+  if (coreTemplate && (!coreTemplate.methods || coreTemplate.methods.includes(m)) && (!hasQueryString || coreTemplate.toleratesQueryString) && (!hasTrailingSlash || coreTemplate.toleratesTrailingSlash)) {
+    return { spanName: `${m} ${coreTemplate.path}`, httpRoute: coreTemplate.path };
+  }
+  const first = pathSegments[0];
+  return { spanName: first ? `${m} /${first}` : m };
+}
+var VALIDATE_RESPONSES = getNodeEnv() === "test" || getNodeEnv() === "development" || process.env.VALIDATE_HTTP_RESPONSES === "true";
+function route(def) {
+  routeRegistry.push(def);
+  return {
+    def,
+    respond(res, code, data) {
+      if (VALIDATE_RESPONSES) {
+        const schema = def.responses[code]?.schema;
+        if (schema) {
+          const result = schema.safeParse(data);
+          if (!result.success) {
+            const detail = `Response schema violation: ${def.method.toUpperCase()} ${def.path} ${code} — ` + result.error.issues.map((i) => `${i.path.join(".") || "<root>"}: ${i.message}`).join("; ");
+            if (getNodeEnv() === "test") {
+              throw new Error(detail);
+            }
+            console.error(`[route-def] ${scrubSecrets(detail)}`);
+          }
+        }
+      }
+      res.writeHead(code, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(data));
+    },
+    match(method, pathSegments) {
+      return matchRoute(method, pathSegments, def.method.toUpperCase(), def.pattern, def.exact ?? true);
+    },
+    async parse(req, res, pathSegments, queryParams) {
+      try {
+        const rawBody = def.body ? await parseBody(req, def.maxBodyBytes) : undefined;
+        if (def.session && "bodyTaskIds" in def.session) {
+          const { bodySessionDenial } = await import("./session-access-fc3f9y12.js");
+          const denial = await bodySessionDenial(req, def.session.bodyTaskIds(rawBody));
+          if (denial) {
+            jsonError(res, denial, 403);
+            return null;
+          }
+        }
+        const params = def.params ? def.params.parse(routePathParams(def, pathSegments)) : undefined;
+        const query = def.query ? def.query.parse(Object.fromEntries(queryParams)) : undefined;
+        const body = def.body ? def.body.parse(rawBody) : undefined;
+        return { params, query, body };
+      } catch (err) {
+        if (err instanceof ZodError) {
+          jsonError(res, `Validation error: ${err.issues.map((e) => `${e.path.join(".")}: ${e.message}`).join(", ")}`, 400);
+          return null;
+        }
+        if (err instanceof RequestBodyTooLargeError) {
+          jsonError(res, err.message, 413);
+          return null;
+        }
+        throw err;
+      }
+    }
+  };
+}
+
+// src/http/session-access.ts
+init_db3();
+init_active_sessions();
+init_rbac_roles();
+
+// src/be/session-shares.ts
+init_db3();
+var RANK = { none: 0, read: 1, write: 2, owner: 3 };
+function hasSessionAccess(access, needed) {
+  return RANK[access] >= RANK[needed];
+}
+async function getSessionRoot(taskId) {
+  return (await getSessionRoots([taskId])).get(taskId) ?? null;
+}
+var ROOT_LOOKUP_CHUNK = 500;
+async function getSessionRoots(taskIds) {
+  const ids = [...new Set(taskIds)];
+  const tasks = new Map;
+  for (let start = 0;start < ids.length; start += ROOT_LOOKUP_CHUNK) {
+    const chunk = ids.slice(start, start + ROOT_LOOKUP_CHUNK).filter((id) => !tasks.has(id));
+    if (chunk.length === 0)
+      continue;
+    const rows = await getDbClient2().query(`WITH RECURSIVE up(id) AS (
+           SELECT id FROM agent_tasks WHERE id IN (${chunk.map(() => "?").join(", ")})
+           UNION
+           SELECT t.parentTaskId FROM agent_tasks t JOIN up ON t.id = up.id
+           WHERE t.parentTaskId IS NOT NULL
+         )
+         SELECT t.id, t.parentTaskId, t.requestedByUserId
+         FROM up CROSS JOIN agent_tasks t ON t.id = up.id`, chunk);
+    for (const row of rows)
+      tasks.set(row.id, row);
+  }
+  const resolved = new Map;
+  const rootOf = (taskId) => {
+    const path = [];
+    const onPath = new Set;
+    let current = tasks.get(taskId);
+    let root = null;
+    while (current) {
+      const known = resolved.get(current.id);
+      if (known !== undefined) {
+        root = known;
+        break;
+      }
+      if (onPath.has(current.id))
+        break;
+      path.push(current.id);
+      onPath.add(current.id);
+      const parent = current.parentTaskId ? tasks.get(current.parentTaskId) : undefined;
+      if (!parent) {
+        root = { id: current.id, requestedByUserId: current.requestedByUserId };
+        break;
+      }
+      current = parent;
+    }
+    for (const id of path)
+      resolved.set(id, root);
+    return root;
+  };
+  const roots = new Map;
+  for (const id of ids) {
+    const root = rootOf(id);
+    if (root)
+      roots.set(id, root);
+  }
+  return roots;
+}
+async function sessionAccessForRoot(actingUserId, root) {
+  if (!root.requestedByUserId)
+    return "owner";
+  if (actingUserId && root.requestedByUserId === actingUserId)
+    return "owner";
+  const rows = await getDbClient2().query(`SELECT access FROM session_shares
+     WHERE rootTaskId = ? AND revokedAt IS NULL AND (userId IS NULL OR userId = ?)`, [root.id, actingUserId]);
+  if (rows.some((row) => row.access === "write"))
+    return "write";
+  return rows.length > 0 ? "read" : "none";
+}
+async function sessionAccess(actingUserId, taskId) {
+  const root = await getSessionRoot(taskId);
+  return root ? sessionAccessForRoot(actingUserId, root) : "none";
+}
+async function listActiveSessionShares(rootTaskId) {
+  return getDbClient2().query(`SELECT id, rootTaskId, userId, access, createdAt, revokedAt, revokedBy
+     FROM session_shares
+     WHERE rootTaskId = ? AND revokedAt IS NULL
+     ORDER BY createdAt, rowid`, [rootTaskId]);
+}
+function toSessionSharesState(rows) {
+  const everyone = rows.find((row) => row.userId === null);
+  return {
+    everyone: everyone?.access ?? "none",
+    users: rows.filter((row) => row.userId !== null).map((row) => ({ userId: row.userId, access: row.access, createdAt: row.createdAt }))
+  };
+}
+async function setSessionShares(root, desired, actorUserId) {
+  const want = new Map;
+  if (desired.everyone !== "none")
+    want.set("*", desired.everyone);
+  for (const user of desired.users) {
+    if (user.userId !== root.requestedByUserId)
+      want.set(user.userId, user.access);
+  }
+  return getDbClient2().transaction(async (tx) => {
+    const now = new Date().toISOString();
+    const active = await tx.query(`SELECT id, rootTaskId, userId, access, createdAt, revokedAt, revokedBy
+       FROM session_shares WHERE rootTaskId = ? AND revokedAt IS NULL`, [root.id]);
+    const kept = new Set;
+    for (const row of active) {
+      const target = row.userId ?? "*";
+      if (want.get(target) === row.access) {
+        kept.add(target);
+        continue;
+      }
+      await tx.run("UPDATE session_shares SET revokedAt = ?, revokedBy = ?, updated_by = ? WHERE id = ?", [now, actorUserId, actorUserId, row.id]);
+    }
+    for (const [target, access] of want) {
+      if (kept.has(target))
+        continue;
+      await tx.run(`INSERT INTO session_shares (id, rootTaskId, userId, access, createdAt, created_by, updated_by)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`, [
+        crypto.randomUUID(),
+        root.id,
+        target === "*" ? null : target,
+        access,
+        now,
+        actorUserId,
+        actorUserId
+      ]);
+    }
+    const rows = await tx.query(`SELECT id, rootTaskId, userId, access, createdAt, revokedAt, revokedBy
+       FROM session_shares WHERE rootTaskId = ? AND revokedAt IS NULL
+       ORDER BY createdAt, rowid`, [root.id]);
+    return toSessionSharesState(rows);
+  });
+}
+
+// src/http/session-access.ts
+init_users();
+init_rbac();
+init_request_auth_context();
+
+// src/be/audit-user.ts
+init_request_auth_context();
+init_db3();
+init_users();
+async function resolveTaskAuditUserId(sourceTaskId, callerAgentId) {
+  if (!callerAgentId)
+    return null;
+  let resolvedSourceTaskId = sourceTaskId;
+  if (!resolvedSourceTaskId) {
+    const currentTask = await getAgentCurrentTask2(callerAgentId);
+    if (currentTask)
+      resolvedSourceTaskId = currentTask.id;
+  }
+  if (!resolvedSourceTaskId)
+    return null;
+  const task = await getTaskById2(resolvedSourceTaskId);
+  if (!task)
+    return null;
+  if (task.agentId !== callerAgentId)
+    return null;
+  if (task.requestedByUserId)
+    return task.requestedByUserId;
+  if (task.slackUserId) {
+    const user = await findUserByExternalId("slack", task.slackUserId);
+    if (user)
+      return user.id;
+  }
+  return null;
+}
+async function resolveHttpAuditUserId(req, callerAgentId) {
+  const auth = getRequestAuth(req);
+  if (auth?.kind === "user")
+    return auth.userId;
+  const header = req.headers["x-source-task-id"];
+  const sourceTaskId = Array.isArray(header) ? header[0] : header;
+  return resolveTaskAuditUserId(sourceTaskId, callerAgentId);
+}
+
+// src/http/favorite-owner.ts
+init_users();
+init_request_auth_context();
+var DASHBOARD_USER_HEADER = "x-swarm-user-id";
+function dashboardUserIdHeader(req) {
+  const raw = req.headers[DASHBOARD_USER_HEADER];
+  const value = (Array.isArray(raw) ? raw[0] : raw)?.trim();
+  return value ? value : null;
+}
+async function resolveHttpFavoriteOwner(req, callerAgentId, opts = {}) {
+  const auth = getRequestAuth(req);
+  if (auth?.kind === "user") {
+    return { scope: `user:${auth.userId}`, userId: auth.userId, actorId: auth.userId };
+  }
+  if (auth?.kind === "operator" && !callerAgentId) {
+    const pickedUserId = opts.dashboardUser === false || auth.page ? null : dashboardUserIdHeader(req);
+    if (pickedUserId) {
+      const user = await findUserById(pickedUserId);
+      if (user?.status === "active") {
+        return { scope: `user:${user.id}`, userId: user.id, actorId: user.id };
+      }
+    }
+    return {
+      scope: "operator",
+      userId: null,
+      actorId: auth.fingerprint
+    };
+  }
+  const userId = await resolveHttpAuditUserId(req, callerAgentId);
+  return userId ? { scope: `user:${userId}`, userId, actorId: userId } : null;
+}
+
+// src/http/session-access.ts
+var BYPASS = { kind: "bypass" };
+async function resolveSessionActor2(req, myAgentId) {
+  const auth = getRequestAuth(req);
+  if (auth?.kind === "user")
+    return { kind: "user", userId: auth.userId };
+  if (auth?.kind === "guest")
+    return { kind: "user", userId: null };
+  if (auth?.kind === "operator" && !myAgentId && !auth.page) {
+    const picked = dashboardUserIdHeader(req);
+    if (!picked)
+      return BYPASS;
+    const user = await findUserById(picked);
+    return user?.status === "active" ? { kind: "user", userId: user.id } : BYPASS;
+  }
+  return BYPASS;
+}
+async function sessionAccessFor2(actor, taskId) {
+  return actor.kind === "bypass" ? "owner" : sessionAccess(actor.userId, taskId);
+}
+var SESSION_READ_DENIED2 = "You don't have access to this session. Ask the owner to share it.";
+async function canReadSession2(req, myAgentId, taskId) {
+  const access = await sessionAccessFor2(await resolveSessionActor2(req, myAgentId), taskId);
+  return hasSessionAccess(access, "read");
+}
+function readableByFor2(actor) {
+  return actor.kind === "user" ? { userId: actor.userId } : undefined;
+}
+var SESSION_WRITE_DENIED2 = "You can't write in this session. Ask the owner to share it with edit access.";
+async function denialFor(actor, taskId, needed) {
+  if (actor.kind === "bypass")
+    return null;
+  const root = await getSessionRoot(taskId);
+  if (!root)
+    return null;
+  if (hasSessionAccess(await sessionAccessForRoot(actor.userId, root), needed))
+    return null;
+  return needed === "read" ? SESSION_READ_DENIED2 : SESSION_WRITE_DENIED2;
+}
+var SESSION_AGENT_WIDE_DENIED = "This changes sessions across a whole agent. Only the agent or the operator can call it.";
+async function pathSessionDenial2(req, myAgentId, def, pathSegments) {
+  const posture = def.session;
+  if (!posture || "bodyTaskIds" in posture || "none" in posture)
+    return null;
+  const actor = await resolveSessionActor2(req, myAgentId);
+  if (actor.kind === "bypass")
+    return null;
+  if ("agentWide" in posture)
+    return SESSION_AGENT_WIDE_DENIED;
+  const needed = def.method === "get" ? "read" : "write";
+  const params = routePathParams(def, pathSegments);
+  let taskId;
+  if ("taskParam" in posture) {
+    taskId = params[posture.taskParam];
+  } else if ("steeringParam" in posture) {
+    const message = await getSteeringMessageById2(params[posture.steeringParam] ?? "");
+    taskId = message?.taskId;
+  } else {
+    const row = await getActiveSessionById(params[posture.activeSessionParam] ?? "");
+    if (!row)
+      return null;
+    if (!row.taskId)
+      return needed === "read" ? SESSION_READ_DENIED2 : SESSION_WRITE_DENIED2;
+    taskId = row.taskId;
+  }
+  if (!taskId)
+    return null;
+  return denialFor(actor, taskId, needed);
+}
+async function bodySessionDenial2(req, taskIds) {
+  const ids = [...new Set(taskIds.filter((id) => typeof id === "string" && !!id))];
+  if (ids.length === 0)
+    return null;
+  const actor = await resolveSessionActor2(req, headerAgentId(req));
+  for (const id of ids) {
+    const denial = await denialFor(actor, id, "write");
+    if (denial)
+      return denial;
+  }
+  return null;
+}
+function headerAgentId(req) {
+  const header = req.headers["x-agent-id"];
+  return Array.isArray(header) ? header[0] : header;
+}
+var USER_AGENT_HEADER_DENIED = "A user token cannot act as an agent. Drop X-Agent-ID, or call with the agent's own credential.";
+async function userAgentIdentityDenial2(req, def, pathSegments) {
+  const auth = getRequestAuth(req);
+  if (auth?.kind !== "user" && auth?.kind !== "guest")
+    return null;
+  if (pathSegments.length === 1 && pathSegments[0] === "mcp")
+    return USER_AGENT_HEADER_DENIED;
+  if (req.headers["x-agent-id"] === undefined)
+    return null;
+  if (auth.kind === "user" && def?.auth?.userNamesAgent) {
+    if (!isRbacEnabled())
+      return null;
+    const grant = await getUserGrant2(auth.userId);
+    if (grant.grantsAll || grant.verbs.has("agent.act.any"))
+      return null;
+  }
+  return USER_AGENT_HEADER_DENIED;
+}
+
+export { duplicateGuardedQueryKey, warnIfCorsAllowsAnyOrigin, isOriginAllowedForCredentials, allowedCredentialRedirect, setCorsHeaders, parseQueryParams, getPathSegments, wireHttpSpanLifecycle, safeRequestUrlForLog, agentWithCapacity, parseBody, BODY_TOO_LARGE, enforceContentLengthCap, json, jsonError, writeUnhandledError, triggerSchemaErrorResponse, deriveApiBaseUrl, httpServerSemconvAttributes, hasSessionAccess, getSessionRoot, sessionAccessForRoot, listActiveSessionShares, toSessionSharesState, setSessionShares, resolveTaskAuditUserId, resolveHttpAuditUserId, dashboardUserIdHeader, resolveHttpFavoriteOwner, resolveSessionActor2, sessionAccessFor2, SESSION_READ_DENIED2, canReadSession2, readableByFor2, SESSION_WRITE_DENIED2, pathSessionDenial2, bodySessionDenial2, userAgentIdentityDenial2, runtimeInstanceHeader, bodyTask, bodyListTask, routeRegistry, isPublicRoute, findRoute, describeRequestRoute, route };