@desplega.ai/agent-swarm 1.172.0 → 2.0.0

package/dist/cli-9traj3dn.js

@@ -0,0 +1,638 @@
+import {
+  cardChildToFallbackText2,
+  convertEmojiPlaceholders,
+  isCardElement2,
+  tableElementToAscii
+} from "./cli-2m1ktfzz.js";
+
+// node_modules/@chat-adapter/shared/dist/index.js
+import crypto from "crypto";
+import { lookup as resolve } from "dns/promises";
+import { request as secure } from "https";
+import { BlockList, isIP } from "net";
+import { pipeline } from "stream";
+import { createBrotliDecompress, createGunzip, createInflate } from "zlib";
+function extractCard(message) {
+  if (isCardElement2(message)) {
+    return message;
+  }
+  if (typeof message === "object" && message !== null && "card" in message) {
+    return message.card;
+  }
+  return null;
+}
+function extractFiles(message) {
+  if (typeof message === "object" && message !== null && "files" in message) {
+    return message.files ?? [];
+  }
+  return [];
+}
+function extractPostableAttachments(message) {
+  if (typeof message === "object" && message !== null && "attachments" in message) {
+    return message.attachments ?? [];
+  }
+  return [];
+}
+var AdapterError = class extends Error {
+  adapter;
+  code;
+  constructor(message, adapter, code) {
+    super(message);
+    this.name = "AdapterError";
+    this.adapter = adapter;
+    this.code = code;
+  }
+};
+var AdapterRateLimitError = class extends AdapterError {
+  retryAfter;
+  constructor(adapter, retryAfter) {
+    super(`Rate limited by ${adapter}${retryAfter ? `, retry after ${retryAfter}s` : ""}`, adapter, "RATE_LIMITED");
+    this.name = "AdapterRateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var AuthenticationError = class extends AdapterError {
+  constructor(adapter, message) {
+    super(message || `Authentication failed for ${adapter}`, adapter, "AUTH_FAILED");
+    this.name = "AuthenticationError";
+  }
+};
+var ResourceNotFoundError = class extends AdapterError {
+  resourceType;
+  resourceId;
+  constructor(adapter, resourceType, resourceId) {
+    const idPart = resourceId ? ` '${resourceId}'` : "";
+    super(`${resourceType}${idPart} not found in ${adapter}`, adapter, "NOT_FOUND");
+    this.name = "ResourceNotFoundError";
+    this.resourceType = resourceType;
+    this.resourceId = resourceId;
+  }
+};
+var PermissionError = class extends AdapterError {
+  action;
+  requiredScope;
+  constructor(adapter, action, requiredScope) {
+    const scopePart = requiredScope ? ` (requires: ${requiredScope})` : "";
+    super(`Permission denied: cannot ${action} in ${adapter}${scopePart}`, adapter, "PERMISSION_DENIED");
+    this.name = "PermissionError";
+    this.action = action;
+    this.requiredScope = requiredScope;
+  }
+};
+var ValidationError = class extends AdapterError {
+  constructor(adapter, message) {
+    super(message, adapter, "VALIDATION_ERROR");
+    this.name = "ValidationError";
+  }
+};
+var NetworkError = class extends AdapterError {
+  originalError;
+  constructor(adapter, message, originalError) {
+    super(message || `Network error communicating with ${adapter}`, adapter, "NETWORK_ERROR");
+    this.name = "NetworkError";
+    this.originalError = originalError;
+  }
+};
+async function toBuffer(data, options) {
+  const { platform, throwOnUnsupported = true } = options;
+  if (Buffer.isBuffer(data)) {
+    return data;
+  }
+  if (data instanceof ArrayBuffer) {
+    return Buffer.from(data);
+  }
+  if (data instanceof Blob) {
+    const arrayBuffer = await data.arrayBuffer();
+    return Buffer.from(arrayBuffer);
+  }
+  if (throwOnUnsupported) {
+    throw new ValidationError(platform, "Unsupported file data type");
+  }
+  return null;
+}
+function bufferToDataUri(buffer, mimeType = "application/octet-stream") {
+  const base64 = buffer.toString("base64");
+  return `data:${mimeType};base64,${base64}`;
+}
+var BUTTON_STYLE_MAPPINGS = {
+  slack: { primary: "primary", danger: "danger" },
+  gchat: { primary: "primary", danger: "danger" },
+  teams: { primary: "positive", danger: "destructive" },
+  discord: { primary: "primary", danger: "danger" }
+};
+function createEmojiConverter(platform) {
+  return (text) => convertEmojiPlaceholders(text, platform);
+}
+function mapButtonStyle(style, platform) {
+  if (!style) {
+    return;
+  }
+  return BUTTON_STYLE_MAPPINGS[platform][style];
+}
+function cardToFallbackText(card, options = {}) {
+  const { boldFormat = "*", lineBreak = `
+`, platform } = options;
+  const convertText = platform ? createEmojiConverter(platform) : (t) => t;
+  const parts = [];
+  if (card.title) {
+    parts.push(`${boldFormat}${convertText(card.title)}${boldFormat}`);
+  }
+  if (card.subtitle) {
+    parts.push(convertText(card.subtitle));
+  }
+  for (const child of card.children) {
+    const text = childToFallbackText(child, convertText);
+    if (text) {
+      parts.push(text);
+    }
+  }
+  return parts.join(lineBreak);
+}
+function childToFallbackText(child, convertText) {
+  switch (child.type) {
+    case "text":
+      return convertText(child.content);
+    case "link":
+      return `${convertText(child.label)} (${child.url})`;
+    case "fields":
+      return child.children.map((f) => `${convertText(f.label)}: ${convertText(f.value)}`).join(`
+`);
+    case "actions":
+      return null;
+    case "section":
+      return child.children.map((c) => childToFallbackText(c, convertText)).filter(Boolean).join(`
+`);
+    case "table":
+      return tableElementToAscii(child.headers, child.rows);
+    case "divider":
+      return "---";
+    default:
+      return cardChildToFallbackText2(child);
+  }
+}
+function escapeTableCell(value) {
+  return value.replace(/\\/g, "\\\\").replace(/\|/g, "\\|").replace(/\n/g, " ");
+}
+function renderGfmTable(table) {
+  const headers = table.headers.map(escapeTableCell);
+  const lines = [];
+  lines.push(`| ${headers.join(" | ")} |`);
+  lines.push(`| ${headers.map(() => "---").join(" | ")} |`);
+  for (const row of table.rows) {
+    const cells = row.map(escapeTableCell);
+    lines.push(`| ${cells.join(" | ")} |`);
+  }
+  return lines;
+}
+var ALGORITHM = "aes-256-gcm";
+var IV_LENGTH = 12;
+var AUTH_TAG_LENGTH = 16;
+var HEX_KEY_PATTERN = /^[0-9a-fA-F]{64}$/;
+function encryptToken(plaintext, key) {
+  const iv = crypto.randomBytes(IV_LENGTH);
+  const cipher = crypto.createCipheriv(ALGORITHM, key, iv, {
+    authTagLength: AUTH_TAG_LENGTH
+  });
+  const ciphertext = Buffer.concat([
+    cipher.update(plaintext, "utf8"),
+    cipher.final()
+  ]);
+  const tag = cipher.getAuthTag();
+  return {
+    iv: iv.toString("base64"),
+    data: ciphertext.toString("base64"),
+    tag: tag.toString("base64")
+  };
+}
+function decryptToken(encrypted, key) {
+  const iv = Buffer.from(encrypted.iv, "base64");
+  const ciphertext = Buffer.from(encrypted.data, "base64");
+  const tag = Buffer.from(encrypted.tag, "base64");
+  const decipher = crypto.createDecipheriv(ALGORITHM, key, iv, {
+    authTagLength: AUTH_TAG_LENGTH
+  });
+  decipher.setAuthTag(tag);
+  return Buffer.concat([
+    decipher.update(ciphertext),
+    decipher.final()
+  ]).toString("utf8");
+}
+function isEncryptedTokenData(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const obj = value;
+  return typeof obj.iv === "string" && typeof obj.data === "string" && typeof obj.tag === "string";
+}
+function decodeKey(rawKey) {
+  const trimmed = rawKey.trim();
+  const isHex = HEX_KEY_PATTERN.test(trimmed);
+  const key = Buffer.from(trimmed, isHex ? "hex" : "base64");
+  if (key.length !== 32) {
+    throw new Error(`Encryption key must decode to exactly 32 bytes (received ${key.length}). Use a 64-char hex string or 44-char base64 string.`);
+  }
+  return key;
+}
+var LIMIT = 25 * 1024 * 1024;
+var REDIRECTS = 5;
+var TIMEOUT = 30000;
+var STATUSES = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
+var BRACKETS = /^\[|\]$/g;
+var IPV4 = [
+  ["0.0.0.0", 8],
+  ["10.0.0.0", 8],
+  ["100.64.0.0", 10],
+  ["127.0.0.0", 8],
+  ["169.254.0.0", 16],
+  ["172.16.0.0", 12],
+  ["192.0.0.0", 24],
+  ["192.0.2.0", 24],
+  ["192.88.99.0", 24],
+  ["192.168.0.0", 16],
+  ["198.18.0.0", 15],
+  ["198.51.100.0", 24],
+  ["203.0.113.0", 24],
+  ["224.0.0.0", 4],
+  ["240.0.0.0", 4]
+];
+var IPV6 = [
+  ["::", 3],
+  ["2001::", 23],
+  ["2001:db8::", 32],
+  ["2002::", 16],
+  ["3fff::", 20],
+  ["4000::", 2],
+  ["8000::", 1]
+];
+var DECODERS = {
+  br: createBrotliDecompress,
+  deflate: createInflate,
+  gzip: createGunzip,
+  "x-gzip": createGunzip
+};
+function blocklist(ranges, family) {
+  const list = new BlockList;
+  for (const [address, prefix] of ranges) {
+    list.addSubnet(address, prefix, family);
+  }
+  return list;
+}
+var BLOCKED4 = blocklist(IPV4, "ipv4");
+var BLOCKED6 = blocklist(IPV6, "ipv6");
+function blocked(address, family) {
+  if (family !== 4 && family !== 6) {
+    return true;
+  }
+  return family === 6 ? BLOCKED6.check(address, "ipv6") : BLOCKED4.check(address, "ipv4");
+}
+function refusal(adapter) {
+  return new NetworkError(adapter, "Refusing to fetch an internal attachment URL");
+}
+function createResolver(adapter, query = resolve) {
+  return (hostname, options, callback) => {
+    query(hostname, { ...options, all: true }).then((addresses) => {
+      if (addresses.length === 0) {
+        callback(new NetworkError(adapter, "Could not resolve the attachment host"), "", 0);
+        return;
+      }
+      if (addresses.some(({ address: address2, family }) => blocked(address2, family))) {
+        callback(refusal(adapter), "", 0);
+        return;
+      }
+      if (options.all) {
+        callback(null, addresses);
+        return;
+      }
+      const [address] = addresses;
+      callback(null, address.address, address.family);
+    }, (error) => {
+      callback(error instanceof Error ? error : new Error(String(error)), "", 0);
+    });
+  };
+}
+function validateAttachmentUrl(value, adapter, hosts) {
+  const url = value instanceof URL ? value : new URL(value);
+  const hostname = url.hostname.replace(BRACKETS, "");
+  const family = isIP(hostname);
+  if (family && blocked(hostname, family)) {
+    throw refusal(adapter);
+  }
+  if (url.protocol !== "https:" || hosts && !hosts.some((host) => {
+    const allowed = host.toLowerCase();
+    return hostname === allowed || hostname.endsWith(`.${allowed}`);
+  })) {
+    throw new NetworkError(adapter, "Refusing to fetch an untrusted attachment URL");
+  }
+  return url;
+}
+function createTransport(adapter) {
+  const lookup = createResolver(adapter);
+  return (url, signal, headers) => new Promise((fulfill, reject) => {
+    const request = secure(url, {
+      agent: false,
+      headers,
+      lookup,
+      signal
+    }, fulfill);
+    request.on("error", reject);
+    request.end();
+  });
+}
+async function readAttachmentBody(response, adapter, limit = LIMIT, signal) {
+  if (signal?.aborted) {
+    response.destroy();
+    throw new NetworkError(adapter, "Timed out fetching the attachment");
+  }
+  const abort = () => response.destroy(signalError(signal));
+  signal?.addEventListener("abort", abort, { once: true });
+  try {
+    return await readBody(response, adapter, limit);
+  } finally {
+    signal?.removeEventListener("abort", abort);
+  }
+}
+function signalError(signal) {
+  const reason = signal?.reason;
+  return reason instanceof Error ? reason : new Error(String(reason));
+}
+function awaitResponse(pending, signal, adapter) {
+  return new Promise((fulfill, reject) => {
+    const abort = () => reject(new NetworkError(adapter, "Timed out fetching the attachment"));
+    if (signal.aborted) {
+      abort();
+    } else {
+      signal.addEventListener("abort", abort, { once: true });
+    }
+    pending.then((response) => {
+      signal.removeEventListener("abort", abort);
+      if (signal.aborted) {
+        response.destroy();
+      }
+      fulfill(response);
+    }, (error) => {
+      signal.removeEventListener("abort", abort);
+      reject(error);
+    });
+  });
+}
+async function readBody(response, adapter, limit) {
+  const header = response.headers["content-encoding"]?.trim().toLowerCase() || "identity";
+  const decode = header === "identity" ? undefined : DECODERS[header];
+  if (header !== "identity" && !decode) {
+    response.destroy();
+    throw new NetworkError(adapter, `Unsupported attachment encoding: ${header}`);
+  }
+  const declared = decode ? Number.NaN : Number(response.headers["content-length"]);
+  if (Number.isFinite(declared) && declared > limit) {
+    response.destroy();
+    throw new NetworkError(adapter, "Attachment exceeds the download limit");
+  }
+  const source = decode ? pipeline(response, decode(), () => {
+    return;
+  }) : response;
+  if (Number.isFinite(declared)) {
+    const body = Buffer.allocUnsafe(declared);
+    let offset = 0;
+    for await (const chunk of source) {
+      const piece = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      if (offset + piece.length > declared) {
+        response.destroy();
+        throw new NetworkError(adapter, "Attachment body exceeds its declared length");
+      }
+      piece.copy(body, offset);
+      offset += piece.length;
+    }
+    return offset === declared ? body : body.subarray(0, offset);
+  }
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of source) {
+    const piece = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    size += piece.length;
+    if (size > limit) {
+      response.destroy();
+      throw new NetworkError(adapter, "Attachment exceeds the download limit");
+    }
+    chunks.push(piece);
+  }
+  return Buffer.concat(chunks, size);
+}
+async function downloadAttachment(value, options) {
+  const {
+    adapter,
+    headers,
+    hosts,
+    limit = LIMIT,
+    onResponse,
+    redirects = REDIRECTS,
+    timeoutMs = TIMEOUT,
+    transport
+  } = options;
+  const send = transport ?? createTransport(adapter);
+  const signal = AbortSignal.timeout(timeoutMs);
+  let url = validateAttachmentUrl(value, adapter, hosts);
+  try {
+    for (let hop = 0;hop <= redirects; hop += 1) {
+      const response = await awaitResponse(send(url, signal, {
+        "accept-encoding": "gzip, deflate, br",
+        "user-agent": "Vercel.ChatSDK",
+        ...typeof headers === "function" ? headers(url) : headers
+      }), signal, adapter);
+      const status = response.statusCode ?? 0;
+      if (STATUSES.has(status)) {
+        const location = response.headers.location;
+        response.destroy();
+        if (!location) {
+          throw new NetworkError(adapter, "Attachment redirect has no location");
+        }
+        if (hop === redirects) {
+          throw new NetworkError(adapter, "Too many attachment redirects");
+        }
+        url = validateAttachmentUrl(new URL(location, url), adapter, hosts);
+        continue;
+      }
+      if (status < 200 || status >= 300) {
+        response.destroy();
+        throw new NetworkError(adapter, `Failed to fetch file: ${status} ${response.statusMessage ?? ""}`.trim());
+      }
+      if (onResponse) {
+        try {
+          onResponse(response);
+        } catch (error) {
+          response.destroy();
+          throw error;
+        }
+      }
+      return await readAttachmentBody(response, adapter, limit, signal);
+    }
+    throw new NetworkError(adapter, "Too many attachment redirects");
+  } catch (error) {
+    if (signal.aborted && !(error instanceof NetworkError)) {
+      throw new NetworkError(adapter, "Timed out fetching the attachment", error instanceof Error ? error : undefined);
+    }
+    throw error;
+  }
+}
+var HTTP = "http://";
+var HTTPS = "https://";
+function isLetter(char) {
+  const code = char.charCodeAt(0);
+  return code >= 65 && code <= 90 || code >= 97 && code <= 122;
+}
+function isNumber(char) {
+  const code = char.charCodeAt(0);
+  return code >= 48 && code <= 57;
+}
+function isWord(char) {
+  return char !== undefined && (isLetter(char) || isNumber(char) || char === "_");
+}
+function isHost(char) {
+  return isLetter(char) || isNumber(char) || char === "." || char === "-";
+}
+function isBoundary(char) {
+  return char === "<" || char === ">" || char.trim() === "";
+}
+function startsWith(text, index, value) {
+  return text.slice(index, index + value.length).toLowerCase() === value;
+}
+function findUrlEnd(text, index, end) {
+  let prefix = 0;
+  if (startsWith(text, index, HTTPS)) {
+    prefix = HTTPS.length;
+  } else if (startsWith(text, index, HTTP)) {
+    prefix = HTTP.length;
+  }
+  if (prefix === 0 || index + prefix >= end) {
+    return index;
+  }
+  let cursor = index + prefix;
+  while (cursor < end && !isBoundary(text[cursor])) {
+    cursor += 1;
+  }
+  return cursor;
+}
+function findHostEnd(text, index, end) {
+  if (!(isLetter(text[index]) || isNumber(text[index]))) {
+    return index;
+  }
+  if (index > 0 && isHost(text[index - 1])) {
+    return index;
+  }
+  let cursor = index;
+  while (cursor < end && isHost(text[cursor])) {
+    cursor += 1;
+  }
+  const separator = text[cursor];
+  if (separator !== "/" && separator !== "?" && separator !== "#") {
+    return index;
+  }
+  const host = text.slice(index, cursor);
+  const dot = host.lastIndexOf(".");
+  const suffix = host.slice(dot + 1);
+  if (dot <= 0 || suffix.length < 2) {
+    return index;
+  }
+  for (const char of suffix) {
+    if (!isLetter(char)) {
+      return index;
+    }
+  }
+  cursor += 1;
+  while (cursor < end && !isBoundary(text[cursor])) {
+    cursor += 1;
+  }
+  return cursor;
+}
+function findCodeEnd(text, index, end) {
+  if (text[index] !== "`") {
+    return index;
+  }
+  const fence = text.startsWith("```", index);
+  const marker = fence ? "```" : "`";
+  const start = index + marker.length;
+  const close = text.indexOf(marker, start);
+  if (close === -1 || close >= end) {
+    return index;
+  }
+  if (!fence) {
+    const newline = text.indexOf(`
+`, start);
+    if (newline !== -1 && newline < close) {
+      return index;
+    }
+  }
+  return close + marker.length;
+}
+function replaceRange(text, start, end, replacer, angles) {
+  let result = "";
+  let index = start;
+  while (index < end) {
+    const codeEnd = findCodeEnd(text, index, end);
+    if (codeEnd > index) {
+      result += text.slice(index, codeEnd);
+      index = codeEnd;
+      continue;
+    }
+    if (angles && text[index] === "<") {
+      let cursor = index + 1;
+      while (cursor < end && text[cursor] !== ">" && text[cursor] !== `
+` && text[cursor] !== "\r") {
+        cursor += 1;
+      }
+      if (text[cursor] === ">") {
+        result += text.slice(index, cursor + 1);
+        index = cursor + 1;
+        continue;
+      }
+      result += replaceRange(text, index, cursor, replacer, false);
+      index = cursor;
+      continue;
+    }
+    const urlEnd = findUrlEnd(text, index, end);
+    if (urlEnd > index) {
+      result += text.slice(index, urlEnd);
+      index = urlEnd;
+      continue;
+    }
+    const hostEnd = findHostEnd(text, index, end);
+    if (hostEnd > index) {
+      result += text.slice(index, hostEnd);
+      index = hostEnd;
+      continue;
+    }
+    if (text[index] === "@" && text[index - 1] !== "<" && !isWord(text[index - 1]) && isWord(text[index + 1])) {
+      let cursor = index + 2;
+      while (cursor < end && isWord(text[cursor])) {
+        cursor += 1;
+      }
+      const mention = text.slice(index, cursor);
+      result += replacer(mention, mention.slice(1));
+      index = cursor;
+      continue;
+    }
+    result += text[index];
+    index += 1;
+  }
+  return result;
+}
+function replaceBareMentions(text, replacer) {
+  return replaceRange(text, 0, text.length, replacer, true);
+}
+function maskCodeSpans(text, replacement = " ") {
+  let result = "";
+  let index = 0;
+  const end = text.length;
+  while (index < end) {
+    const codeEnd = findCodeEnd(text, index, end);
+    if (codeEnd > index) {
+      result += replacement;
+      index = codeEnd;
+      continue;
+    }
+    result += text[index];
+    index += 1;
+  }
+  return result;
+}
+
+export { extractCard, extractFiles, extractPostableAttachments, AdapterRateLimitError, AuthenticationError, ResourceNotFoundError, PermissionError, ValidationError, NetworkError, toBuffer, bufferToDataUri, createEmojiConverter, mapButtonStyle, cardToFallbackText, escapeTableCell, renderGfmTable, encryptToken, decryptToken, isEncryptedTokenData, decodeKey, downloadAttachment, replaceBareMentions, maskCodeSpans };

package/dist/{cli-smcrrmhy.js → cli-agzebbd5.js}

@@ -1,10 +1,3 @@
-import {
-  ProjectTrustStore,
-  addMcpServerConfig,
-  loadMcpConfig,
-  openBrowser,
-  removeMcpServerConfig
-} from "./cli-c5km5znr.js";
 import {
   McpOAuthCredentialStore,
   McpServerConnection,
@@ -12,11 +5,18 @@ import {
   McpSignInCancelledError,
   createDefaultTransport,
   signInMcpServer
-} from "./cli-rcp5aqdw.js";
+} from "./cli-w7m81tb7.js";
+import {
+  ProjectTrustStore,
+  addMcpServerConfig,
+  loadMcpConfig,
+  openBrowser,
+  removeMcpServerConfig
+} from "./cli-c8r3kzzb.js";
 import {
   getMcpToolExposure,
   validateMcpServerConfig
-} from "./cli-r44t9wqc.js";
+} from "./cli-r106725k.js";
 import"./cli-ev91t6xp.js";
 import {
   source_default

package/dist/{cli-bf7485pm.js → cli-apx87jne.js}

@@ -1,6 +1,6 @@
 import {
   summarizeSession
-} from "./cli-cf69s3ew.js";
+} from "./cli-tr4sxp68.js";
 import {
   checkToolLoop,
   clearToolHistory
@@ -24,7 +24,7 @@ import {
 import {
   init_secret_scrubber,
   scrubSecrets
-} from "./cli-d161g69q.js";
+} from "./cli-p1x85d2t.js";
 
 // src/prompts/goal-reminder.ts
 init_session_templates();