@desplega.ai/agent-swarm 1.145.0 → 1.147.0

package/dist/cli-jnf5zghe.js

@@ -1,269 +0,0 @@
-import {
-  getAgentById,
-  getAgentWorkingOnThread,
-  getAllAgents,
-  init_db
-} from "./cli-f567d5c1.js";
-import {
-  init_env_flag,
-  isEnvFlagEnabled
-} from "./cli-ej6gbxfb.js";
-
-// src/slack/router.ts
-init_db();
-init_env_flag();
-function hasOtherUserMention(text, botUserId) {
-  const mentions = text.match(/<@([A-Z0-9]+)>/g) ?? [];
-  return mentions.some((m) => m !== `<@${botUserId}>`);
-}
-async function routeMessage(text, botUserId, botMentioned, threadContext) {
-  const matches = [];
-  const requireMentionForThreadFollowup = isEnvFlagEnabled("SLACK_THREAD_FOLLOWUP_REQUIRE_MENTION", false);
-  const agents = (await getAllAgents()).filter((a) => a.status !== "offline");
-  const idMatches = text.matchAll(/swarm#([a-f0-9-]{36})/gi);
-  for (const match of idMatches) {
-    const agentId = match[1];
-    if (!agentId)
-      continue;
-    const agent = await getAgentById(agentId);
-    if (agent && agent.status !== "offline") {
-      matches.push({ agent, matchedText: match[0] });
-    }
-  }
-  if (/swarm#all/i.test(text)) {
-    const nonLeadAgents = agents.filter((a) => !a.isLead);
-    for (const agent of nonLeadAgents) {
-      if (!matches.some((m) => m.agent.id === agent.id)) {
-        matches.push({ agent, matchedText: "swarm#all" });
-      }
-    }
-  }
-  if (matches.length === 0 && threadContext && (!requireMentionForThreadFollowup || botMentioned)) {
-    if (!botMentioned && hasOtherUserMention(text, botUserId)) {
-      console.log(`[Slack] Skipping thread follow-up in ${threadContext.channelId}/${threadContext.threadTs}: message mentions another user`);
-      return matches;
-    }
-    const workingAgent = await getAgentWorkingOnThread(threadContext.channelId, threadContext.threadTs);
-    if (workingAgent && workingAgent.status !== "offline") {
-      console.log(`[Slack] Thread follow-up: routing to agent ${workingAgent.name} (${workingAgent.id}) in thread ${threadContext.threadTs}`);
-      matches.push({ agent: workingAgent, matchedText: "thread follow-up" });
-    } else if (workingAgent) {
-      console.log(`[Slack] Thread follow-up: agent ${workingAgent.name} is offline, routing to lead`);
-      const allAgents = await getAllAgents();
-      const lead = allAgents.find((a) => a.isLead && a.status !== "offline");
-      if (lead) {
-        matches.push({ agent: lead, matchedText: "thread follow-up (lead fallback)" });
-      }
-    }
-  }
-  if (matches.length === 0 && botMentioned) {
-    const lead = agents.find((a) => a.isLead);
-    if (lead) {
-      matches.push({ agent: lead, matchedText: "@bot" });
-    }
-  }
-  return matches;
-}
-function extractTaskFromMessage(text, botUserId) {
-  return text.replace(new RegExp(`<@${botUserId}>`, "g"), "").replace(/swarm#[a-f0-9-]{36}/gi, "").replace(/swarm#all/gi, "").trim();
-}
-
-// src/slack/message-text.ts
-function collectRichTextParts(node, parts) {
-  if (node == null || typeof node !== "object")
-    return;
-  const n = node;
-  if (n.type === "text" && n.text) {
-    parts.push(n.text);
-  }
-  if (Array.isArray(n.elements)) {
-    for (const child of n.elements) {
-      collectRichTextParts(child, parts);
-    }
-  }
-}
-function extractSlackMessageText(msg) {
-  const topText = msg.text?.trim() ?? "";
-  const attachmentParts = [];
-  if (Array.isArray(msg.attachments) && msg.attachments.length > 0) {
-    for (const raw of msg.attachments) {
-      if (raw == null || typeof raw !== "object")
-        continue;
-      const a = raw;
-      const attParts = [];
-      const titleText = a.title_link && a.title ? `<${a.title_link}|${a.title}>` : a.title;
-      const seenPrimary = new Set;
-      for (const part of [a.pretext, titleText, a.text, a.fallback]) {
-        const s = part?.trim();
-        if (s && !seenPrimary.has(s)) {
-          seenPrimary.add(s);
-          attParts.push(s);
-        }
-      }
-      if (Array.isArray(a.fields)) {
-        for (const field of a.fields) {
-          if (field == null || typeof field !== "object")
-            continue;
-          const f = field;
-          if (f.title && f.value)
-            attParts.push(`${f.title}: ${f.value}`);
-          else if (f.title)
-            attParts.push(f.title);
-          else if (f.value)
-            attParts.push(f.value);
-        }
-      }
-      if (Array.isArray(a.actions)) {
-        for (const action of a.actions) {
-          if (action == null || typeof action !== "object")
-            continue;
-          const act = action;
-          if (act.url) {
-            attParts.push(act.text ? `<${act.url}|${act.text}>` : act.url);
-          }
-        }
-      }
-      if (attParts.length > 0)
-        attachmentParts.push(attParts.join(`
-`));
-    }
-  }
-  const blockParts = [];
-  if (Array.isArray(msg.blocks) && msg.blocks.length > 0) {
-    for (const rawBlock of msg.blocks) {
-      if (rawBlock == null || typeof rawBlock !== "object")
-        continue;
-      const block = rawBlock;
-      if (block.type === "section") {
-        if (block.text?.text)
-          blockParts.push(block.text.text);
-        if (Array.isArray(block.fields)) {
-          for (const field of block.fields) {
-            if (field != null && typeof field === "object" && field.text) {
-              blockParts.push(field.text);
-            }
-          }
-        }
-      } else if (block.type === "rich_text" && Array.isArray(block.elements)) {
-        for (const el of block.elements) {
-          collectRichTextParts(el, blockParts);
-        }
-      } else if (block.type === "header") {
-        if (block.text?.text)
-          blockParts.push(block.text.text);
-      } else if (block.type === "context" && Array.isArray(block.elements)) {
-        for (const el of block.elements) {
-          if (el == null || typeof el !== "object")
-            continue;
-          const e = el;
-          if (e.text)
-            blockParts.push(e.text);
-        }
-      } else if (block.type === "actions" && Array.isArray(block.elements)) {
-        for (const el of block.elements) {
-          if (el == null || typeof el !== "object")
-            continue;
-          const e = el;
-          const label = e.text?.text;
-          const url = e.url;
-          if (label && url)
-            blockParts.push(`<${url}|${label}>`);
-          else if (label)
-            blockParts.push(label);
-          else if (url)
-            blockParts.push(url);
-        }
-      }
-    }
-  }
-  const bodyText = [...attachmentParts, ...blockParts].filter(Boolean).join(`
-`);
-  const bodyLines = new Set(bodyText.split(`
-`).map((l) => l.trim()).filter(Boolean));
-  if (topText && !bodyLines.has(topText)) {
-    return bodyText ? `${topText}
-${bodyText}` : topText;
-  }
-  return bodyText || topText;
-}
-function parseSlackTs(input) {
-  const trimmed = input.trim();
-  if (/^\d{6,}\.\d{1,}$/.test(trimmed))
-    return trimmed;
-  const m = trimmed.match(/p?(\d{10})(\d{6})(?:\D|$)/);
-  if (m)
-    return `${m[1]}.${m[2]}`;
-  return trimmed;
-}
-
-// src/tasks/additive-buffer.ts
-function createAdditiveBuffer(options) {
-  const { timeoutMs, onFlush, label } = options;
-  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
-    throw new Error(`additive-buffer: timeoutMs must be a positive number, got ${timeoutMs}`);
-  }
-  const buffers = new Map;
-  const prefix = label ? `[buffer:${label}]` : "[buffer]";
-  function scheduleFlush(key) {
-    return setTimeout(() => {
-      doFlush(key, "timer");
-    }, timeoutMs);
-  }
-  async function doFlush(key, reason) {
-    const entry = buffers.get(key);
-    if (!entry || entry.items.length === 0) {
-      buffers.delete(key);
-      return;
-    }
-    clearTimeout(entry.timer);
-    buffers.delete(key);
-    try {
-      await onFlush(entry.items, key, reason);
-    } catch (error) {
-      console.error(`${prefix} onFlush threw for key=${key}:`, error);
-    }
-  }
-  return {
-    enqueue(contextKey, item) {
-      if (!contextKey) {
-        throw new Error("additive-buffer: contextKey is required");
-      }
-      const existing = buffers.get(contextKey);
-      if (existing) {
-        clearTimeout(existing.timer);
-        existing.items.push(item);
-        existing.timer = scheduleFlush(contextKey);
-        console.log(`${prefix} append: ${contextKey} (${existing.items.length} items, timer reset to ${timeoutMs}ms)`);
-      } else {
-        const entry = {
-          items: [item],
-          timer: scheduleFlush(contextKey)
-        };
-        buffers.set(contextKey, entry);
-        console.log(`${prefix} created: ${contextKey} (timer set to ${timeoutMs}ms)`);
-      }
-    },
-    isBuffered(contextKey) {
-      return buffers.has(contextKey);
-    },
-    count(contextKey) {
-      return buffers.get(contextKey)?.items.length ?? 0;
-    },
-    instantFlush(contextKey) {
-      return doFlush(contextKey, "manual");
-    },
-    cancel(contextKey) {
-      const entry = buffers.get(contextKey);
-      if (!entry)
-        return false;
-      clearTimeout(entry.timer);
-      buffers.delete(contextKey);
-      return true;
-    },
-    keys() {
-      return Array.from(buffers.keys());
-    }
-  };
-}
-
-export { createAdditiveBuffer, hasOtherUserMention, routeMessage, extractTaskFromMessage, extractSlackMessageText, parseSlackTs };

package/dist/cli-n1q8q14d.js

@@ -1,177 +0,0 @@
-import {
-  AgentFsProvider,
-  FilesError,
-  providerPath
-} from "./cli-fhsz3twr.js";
-
-// src/fs/local-fs-provider.ts
-import { mkdir, readdir, rm, stat } from "node:fs/promises";
-import { dirname, join, relative, sep } from "node:path";
-var DEFAULT_ROOT_DIR = "./data/fs";
-
-class LocalFsProvider {
-  id = "local-fs";
-  capabilities = {
-    signedUrl: { supported: false }
-  };
-  rootDir;
-  constructor(options = {}) {
-    this.rootDir = options.rootDir ?? process.env.AGENT_FS_LOCAL_DIR ?? DEFAULT_ROOT_DIR;
-  }
-  async upload(scope, body, options = {}) {
-    const target = this.localPath(scope);
-    await mkdir(dirname(target), { recursive: true });
-    if (options.ifNoneMatch === "*" && await this.exists(scope)) {
-      throw new FilesError("Conflict", "File already exists");
-    }
-    await Bun.write(target, await new Response(body).arrayBuffer());
-    if (options.contentType) {
-      await Bun.write(this.metaPath(target), JSON.stringify({ contentType: options.contentType }));
-    }
-    return this.head(scope);
-  }
-  async download(scope) {
-    const target = this.localPath(scope);
-    if (!await this.exists(scope)) {
-      throw new FilesError("NotFound", "File not found");
-    }
-    return new Response(Bun.file(target));
-  }
-  async head(scope) {
-    const target = this.localPath(scope);
-    try {
-      const info = await stat(target);
-      const storedContentType = await this.readStoredContentType(target);
-      return {
-        providerId: this.id,
-        key: providerPath(scope),
-        taskId: scope.taskId,
-        name: scope.name,
-        contentType: storedContentType ?? Bun.file(target).type ?? undefined,
-        sizeBytes: info.size,
-        updatedAt: info.mtime.toISOString()
-      };
-    } catch (error) {
-      if (error.code === "ENOENT") {
-        throw new FilesError("NotFound", "File not found", { cause: error });
-      }
-      throw new FilesError("Provider", "Unable to read file metadata", { cause: error });
-    }
-  }
-  async exists(scope) {
-    try {
-      await stat(this.localPath(scope));
-      return true;
-    } catch (error) {
-      if (error.code === "ENOENT") {
-        return false;
-      }
-      throw new FilesError("Provider", "Unable to check file existence", { cause: error });
-    }
-  }
-  async delete(scope) {
-    const target = this.localPath(scope);
-    await rm(target, { force: true });
-    await rm(this.metaPath(target), { force: true });
-  }
-  async copy(source, destination) {
-    const sourceHead = await this.head(source);
-    const response = await this.download(source);
-    await this.upload(destination, await response.arrayBuffer(), {
-      contentType: sourceHead.contentType
-    });
-    return this.head(destination);
-  }
-  async move(source, destination) {
-    const copied = await this.copy(source, destination);
-    await this.delete(source);
-    return copied;
-  }
-  async list(options) {
-    const taskRoot = join(this.rootDir, "tasks", encodeURIComponent(options.taskId));
-    const files = [];
-    await this.walk(taskRoot, async (path) => {
-      const rel = relative(taskRoot, path).split(sep).join("/");
-      const name = decodePath(rel);
-      if (options.prefix && !name.startsWith(options.prefix)) {
-        return;
-      }
-      files.push(await this.head({ taskId: options.taskId, name }));
-    });
-    return typeof options.limit === "number" ? files.slice(0, options.limit) : files;
-  }
-  async* listAll(options) {
-    for (const item of await this.list(options)) {
-      yield item;
-    }
-  }
-  async url(scope) {
-    return `/api/fs/tasks/${encodeURIComponent(scope.taskId)}/files/${encodeURIComponent(scope.name)}/raw`;
-  }
-  async signedUploadUrl() {
-    throw new FilesError("ReadOnly", "local-fs does not support signed upload URLs");
-  }
-  localPath(scope) {
-    return join(this.rootDir, providerPath(scope));
-  }
-  metaPath(target) {
-    return `${target}.meta.json`;
-  }
-  async readStoredContentType(target) {
-    try {
-      const metaFile = Bun.file(this.metaPath(target));
-      if (!await metaFile.exists()) {
-        return;
-      }
-      const meta = await metaFile.json();
-      return typeof meta?.contentType === "string" ? meta.contentType : undefined;
-    } catch {
-      return;
-    }
-  }
-  async walk(dir, visit) {
-    let entries;
-    try {
-      entries = await readdir(dir, { withFileTypes: true });
-    } catch (error) {
-      if (error.code === "ENOENT") {
-        return;
-      }
-      throw new FilesError("Provider", "Unable to list files", { cause: error });
-    }
-    for (const entry of entries) {
-      const path = join(dir, entry.name);
-      if (entry.isDirectory()) {
-        await this.walk(path, visit);
-      } else if (entry.isFile() && !entry.name.endsWith(".meta.json")) {
-        await visit(path);
-      }
-    }
-  }
-}
-function decodePath(path) {
-  return path.split("/").map((part) => decodeURIComponent(part)).join("/");
-}
-
-// src/fs/registry.ts
-var memoizedProvider = null;
-function getFileStorageProvider() {
-  if (!memoizedProvider) {
-    memoizedProvider = selectProvider();
-  }
-  return memoizedProvider;
-}
-function selectProvider() {
-  if (process.env.AGENT_FS_API_URL && (process.env.API_AGENT_FS_API_KEY || process.env.AGENT_FS_API_KEY)) {
-    return new AgentFsProvider;
-  }
-  return new LocalFsProvider;
-}
-function resetFileStorageProvider() {
-  memoizedProvider = null;
-}
-function resetFileStorageProviderForTests() {
-  resetFileStorageProvider();
-}
-
-export { getFileStorageProvider, selectProvider, resetFileStorageProvider, resetFileStorageProviderForTests };