@desplega.ai/agent-swarm 1.20.0 → 1.51.2

package/src/slack/blocks.ts

@@ -0,0 +1,233 @@
+/**
+ * Block Kit message builders for structured Slack messages.
+ *
+ * Consolidates getTaskLink and markdownToSlack (previously duplicated
+ * across responses.ts, handlers.ts, thread-buffer.ts).
+ */
+
+const appUrl = process.env.APP_URL || "";
+
+// Slack limits section text to 3000 chars; we use 2900 for safety
+const MAX_SECTION_LENGTH = 2900;
+
+// biome-ignore lint/suspicious/noExplicitAny: Slack block types are complex unions; we build plain objects
+type SlackBlock = any;
+
+// --- Shared utilities ---
+
+/**
+ * Get a Slack-formatted link to the task in the dashboard, or just the short ID.
+ */
+export function getTaskLink(taskId: string): string {
+  const shortId = taskId.slice(0, 8);
+  if (appUrl) {
+    return `<${appUrl}?tab=tasks&task=${taskId}&expand=true|\`${shortId}\`>`;
+  }
+  return `\`${shortId}\``;
+}
+
+/**
+ * Get a raw dashboard URL for a task (for link buttons).
+ */
+export function getTaskUrl(taskId: string): string {
+  if (appUrl) {
+    return `${appUrl}?tab=tasks&task=${taskId}&expand=true`;
+  }
+  return "";
+}
+
+/**
+ * Convert GitHub-flavored markdown to Slack mrkdwn format.
+ *
+ * Key differences:
+ * - GitHub: **bold**, *italic*, ~~strike~~, [text](url)
+ * - Slack:  *bold*,  _italic_, ~strike~,   <url|text>
+ */
+export function markdownToSlack(text: string): string {
+  return (
+    text
+      // Headers to bold placeholder (# Header -> bold, protected from italic)
+      .replace(/^#{1,6}\s+(.+)$/gm, "\uE000$1\uE001")
+      // Bold **text** -> placeholder (to avoid italic chain converting *bold* to _italic_)
+      .replace(/\*\*(.+?)\*\*/g, "\uE000$1\uE001")
+      // Italic *text* -> _text_ (single asterisks, now safe from bold placeholders)
+      .replace(/(?<!\*)\*([^*]+)\*(?!\*)/g, "_$1_")
+      // Restore bold from placeholder -> *text*
+      .replace(/\uE000(.+?)\uE001/g, "*$1*")
+      // Strikethrough ~~text~~ -> ~text~
+      .replace(/~~(.+?)~~/g, "~$1~")
+      // Links [text](url) -> <url|text>
+      .replace(/\[([^\]]+)\]\(([^)]+)\)/g, "<$2|$1>")
+      // Inline code already works the same
+      // Bullet points already work the same
+      // Remove excessive blank lines
+      .replace(/\n{3,}/g, "\n\n")
+  );
+}
+
+/**
+ * Split text into chunks that fit within Slack's section text limit.
+ */
+function splitText(text: string): string[] {
+  if (text.length <= MAX_SECTION_LENGTH) return [text];
+
+  const chunks: string[] = [];
+  let remaining = text;
+  while (remaining.length > 0) {
+    if (remaining.length <= MAX_SECTION_LENGTH) {
+      chunks.push(remaining);
+      break;
+    }
+    // Try to split at a newline
+    let splitIdx = remaining.lastIndexOf("\n", MAX_SECTION_LENGTH);
+    if (splitIdx < MAX_SECTION_LENGTH / 2) {
+      // No good newline break, try splitting at space
+      splitIdx = remaining.lastIndexOf(" ", MAX_SECTION_LENGTH);
+    }
+    if (splitIdx < MAX_SECTION_LENGTH / 2) {
+      // No good break point at all, hard split
+      splitIdx = MAX_SECTION_LENGTH;
+    }
+    chunks.push(remaining.slice(0, splitIdx));
+    remaining = remaining.slice(splitIdx).trimStart();
+  }
+  return chunks;
+}
+
+// --- Block primitives ---
+
+function contextBlock(...elements: string[]): SlackBlock {
+  return {
+    type: "context",
+    elements: elements.map((text) => ({ type: "mrkdwn", text })),
+  };
+}
+
+function sectionBlock(text: string): SlackBlock {
+  return { type: "section", text: { type: "mrkdwn", text } };
+}
+
+function cancelActionBlock(taskId: string): SlackBlock {
+  return {
+    type: "actions",
+    elements: [
+      {
+        type: "button",
+        text: { type: "plain_text", text: "Cancel" },
+        action_id: "cancel_task",
+        value: taskId,
+        style: "danger",
+        confirm: {
+          title: { type: "plain_text", text: "Cancel task?" },
+          text: { type: "mrkdwn", text: "This will cancel the task. Are you sure?" },
+          confirm: { type: "plain_text", text: "Yes, cancel" },
+          deny: { type: "plain_text", text: "Never mind" },
+        },
+      },
+    ],
+  };
+}
+
+// --- High-level block builders ---
+
+/**
+ * Build blocks for a completed task response.
+ * Single-line header with agent/task metadata, then body content.
+ */
+export function buildCompletedBlocks(opts: {
+  agentName: string;
+  taskId: string;
+  body: string;
+  duration?: string;
+}): SlackBlock[] {
+  const taskLink = getTaskLink(opts.taskId);
+  let line = `✅ *${opts.agentName}* (${taskLink})`;
+  if (opts.duration) line += ` · ${opts.duration}`;
+
+  const blocks: SlackBlock[] = [sectionBlock(line)];
+  for (const chunk of splitText(opts.body)) {
+    blocks.push(sectionBlock(chunk));
+  }
+  return blocks;
+}
+
+/**
+ * Build blocks for a failed task response.
+ * Single-line header, then error in code block.
+ */
+export function buildFailedBlocks(opts: {
+  agentName: string;
+  taskId: string;
+  reason: string;
+  duration?: string;
+}): SlackBlock[] {
+  const taskLink = getTaskLink(opts.taskId);
+  let line = `❌ *${opts.agentName}* (${taskLink})`;
+  if (opts.duration) line += ` · ${opts.duration}`;
+
+  return [sectionBlock(line), sectionBlock(`\`\`\`${opts.reason}\`\`\``)];
+}
+
+/**
+ * Build blocks for a progress update.
+ * Single line with cancel button.
+ */
+export function buildProgressBlocks(opts: {
+  agentName: string;
+  taskId: string;
+  progress: string;
+}): SlackBlock[] {
+  const shortId = opts.taskId.slice(0, 8);
+  return [
+    sectionBlock(`⏳ *${opts.agentName}* (\`${shortId}\`): ${opts.progress}`),
+    cancelActionBlock(opts.taskId),
+  ];
+}
+
+/**
+ * Build blocks for a cancelled task card (used when cancel button is clicked).
+ */
+export function buildCancelledBlocks(opts: { agentName: string; taskId: string }): SlackBlock[] {
+  const taskLink = getTaskLink(opts.taskId);
+  return [sectionBlock(`🚫 *${opts.agentName}* (${taskLink}) — Cancelled`)];
+}
+
+/**
+ * Build blocks for a consolidated task assignment summary.
+ * Each assignment/queue/failure is a single line.
+ */
+export function buildAssignmentSummaryBlocks(results: {
+  assigned: Array<{ agentName: string; taskId: string }>;
+  queued: Array<{ agentName: string; taskId: string }>;
+  failed: Array<{ agentName: string; reason: string }>;
+}): SlackBlock[] {
+  const lines: string[] = [];
+
+  for (const a of results.assigned) {
+    lines.push(`📡 Task assigned to: *${a.agentName}* (${getTaskLink(a.taskId)})`);
+  }
+  for (const q of results.queued) {
+    lines.push(`📡 Task queued for: *${q.agentName}* (${getTaskLink(q.taskId)})`);
+  }
+  for (const f of results.failed) {
+    lines.push(`⚠️ Could not assign to: *${f.agentName}* — ${f.reason}`);
+  }
+
+  return [sectionBlock(lines.join("\n"))];
+}
+
+/**
+ * Build blocks for buffer flush feedback.
+ */
+export function buildBufferFlushBlocks(opts: {
+  messageCount: number;
+  taskId: string;
+  hasDependency: boolean;
+}): SlackBlock[] {
+  const taskLink = getTaskLink(opts.taskId);
+  const text = opts.hasDependency
+    ? `${opts.messageCount} follow-up message(s) queued pending completion of current task`
+    : `${opts.messageCount} follow-up message(s) batched into task`;
+
+  return [contextBlock(`📡 _${text}_ (${taskLink})`)];
+}

package/src/slack/channel-activity.ts

@@ -0,0 +1,177 @@
+import { getSlackApp } from "./app";
+
+export interface ChannelMessage {
+  channelId: string;
+  channelName?: string;
+  ts: string;
+  user: string;
+  text: string;
+}
+
+// ─── Caches ─────────────────────────────────────────────────────────────────
+
+let cachedBotUserId: string | null = null;
+
+interface ChannelCache {
+  channels: Array<{ id: string; name?: string }>;
+  fetchedAt: number;
+}
+let channelCache: ChannelCache | null = null;
+const CHANNEL_CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
+
+// ─── Public API ─────────────────────────────────────────────────────────────
+
+/**
+ * Fetch recent non-bot messages from channels the bot is in,
+ * filtering to only messages newer than the provided cursors.
+ *
+ * For channels with no cursor (first run), returns the latest message ts
+ * as a seed cursor without triggering — prevents cold-start flood.
+ *
+ * Returns messages sorted oldest-first, plus seed cursors for new channels.
+ */
+export async function fetchChannelActivity(
+  cursors: Map<string, string>,
+  allowedChannelIds?: string[],
+  limit = 10,
+): Promise<{ messages: ChannelMessage[]; seedCursors: Map<string, string> }> {
+  const app = getSlackApp();
+  if (!app) return { messages: [], seedCursors: new Map() };
+
+  const client = app.client;
+
+  // Get channels the bot is a member of (cached, with pagination)
+  let channels = getCachedChannels();
+  if (!channels) {
+    channels = await fetchAllBotChannels(client);
+    setCachedChannels(channels);
+  }
+
+  // Filter by allowlist if configured
+  if (allowedChannelIds && allowedChannelIds.length > 0) {
+    const allowed = new Set(allowedChannelIds);
+    channels = channels.filter((ch) => allowed.has(ch.id));
+  }
+
+  if (channels.length === 0) return { messages: [], seedCursors: new Map() };
+
+  const messages: ChannelMessage[] = [];
+  const seedCursors = new Map<string, string>();
+
+  // Cache bot user ID (never changes during runtime)
+  if (!cachedBotUserId) {
+    const authResult = await client.auth.test();
+    cachedBotUserId = authResult.user_id as string;
+  }
+  const botUserId = cachedBotUserId;
+
+  for (const channel of channels) {
+    const channelId = channel.id;
+    const cursor = cursors.get(channelId);
+
+    try {
+      // Cold-start: no cursor for this channel — seed it without triggering
+      if (!cursor) {
+        const seedResult = await client.conversations.history({
+          channel: channelId,
+          limit: 1,
+        });
+        const latestMsg = seedResult.messages?.[0];
+        if (latestMsg?.ts) {
+          seedCursors.set(channelId, latestMsg.ts);
+        }
+        continue; // Don't trigger on first run
+      }
+
+      const historyResult = await client.conversations.history({
+        channel: channelId,
+        oldest: cursor,
+        limit,
+      });
+
+      for (const msg of historyResult.messages || []) {
+        // Skip the cursor message itself (oldest is inclusive)
+        if (msg.ts === cursor) continue;
+        // Skip bot messages (bot_id present, or subtype bot_message)
+        if (msg.bot_id || msg.subtype === "bot_message") continue;
+        // Skip our own bot's messages
+        if (msg.user === botUserId) continue;
+        // Skip messages without text or user
+        if (!msg.text?.trim() || !msg.user) continue;
+        // Skip thread replies (only top-level channel messages)
+        if (msg.thread_ts && msg.thread_ts !== msg.ts) continue;
+
+        messages.push({
+          channelId,
+          channelName: channel.name,
+          ts: msg.ts!,
+          user: msg.user,
+          text: msg.text,
+        });
+      }
+    } catch (err) {
+      // Log but don't fail — channel might have been archived or bot removed
+      console.warn(`[channel-activity] Failed to fetch history for ${channelId}: ${err}`);
+    }
+  }
+
+  // Sort by timestamp ascending (oldest first)
+  messages.sort((a, b) => Number.parseFloat(a.ts) - Number.parseFloat(b.ts));
+
+  return { messages, seedCursors };
+}
+
+// ─── Internal helpers ───────────────────────────────────────────────────────
+
+function getCachedChannels(): Array<{ id: string; name?: string }> | null {
+  if (!channelCache) return null;
+  if (Date.now() - channelCache.fetchedAt > CHANNEL_CACHE_TTL_MS) {
+    channelCache = null;
+    return null;
+  }
+  return channelCache.channels;
+}
+
+function setCachedChannels(channels: Array<{ id: string; name?: string }>): void {
+  channelCache = { channels, fetchedAt: Date.now() };
+}
+
+/** Fetch all channels the bot is a member of, handling pagination */
+async function fetchAllBotChannels(
+  client: ReturnType<typeof getSlackApp> extends infer A
+    ? A extends { client: infer C }
+      ? C
+      : never
+    : never,
+): Promise<Array<{ id: string; name?: string }>> {
+  const channels: Array<{ id: string; name?: string }> = [];
+  let nextCursor: string | undefined;
+
+  do {
+    const result = await (
+      client as {
+        conversations: {
+          list: (args: Record<string, unknown>) => Promise<{
+            channels?: Array<{ id?: string; name?: string; is_member?: boolean }>;
+            response_metadata?: { next_cursor?: string };
+          }>;
+        };
+      }
+    ).conversations.list({
+      types: "public_channel,private_channel",
+      exclude_archived: true,
+      limit: 200,
+      cursor: nextCursor || undefined,
+    });
+
+    for (const ch of result.channels || []) {
+      if (ch.id && ch.is_member) {
+        channels.push({ id: ch.id, name: ch.name });
+      }
+    }
+
+    nextCursor = result.response_metadata?.next_cursor || undefined;
+  } while (nextCursor);
+
+  return channels;
+}

package/src/slack/commands.ts

@@ -59,30 +59,44 @@ export function registerCommandHandler(app: App): void {
 
   app.command("/agent-swarm-help", async ({ ack, respond }) => {
     await ack();
+    console.log("[Slack] /agent-swarm-help command invoked");
 
-    await respond({
-      response_type: "ephemeral",
-      blocks: [
-        {
-          type: "header",
-          text: { type: "plain_text", text: "Agent Swarm Help" },
-        },
-        {
-          type: "section",
-          text: {
-            type: "mrkdwn",
-            text: `*How to assign tasks:*
+    const additiveSlack = process.env.ADDITIVE_SLACK === "true";
+
+    const sections = [
+      `*How to assign tasks:*
 • Mention an agent by name: \`Hey Alpha, can you review this code?\`
 • Use explicit ID: \`swarm#<uuid> please analyze the logs\`
 • Broadcast to all: \`swarm#all status report please\`
 • Mention the bot: \`@agent-swarm help me\` (routes to lead agent)
+• Thread @mentions auto-route to the worker already active in that thread`,
+    ];
+
+    if (additiveSlack) {
+      sections.push(`*Additive Slack (enabled):*
+• Thread replies (no @mention needed) are automatically buffered and batched into follow-up tasks
+• \`!now <message>\` in a thread — Flush buffer immediately, skip dependency queue
+• Follow-up tasks auto-depend on the active task in the thread for natural sequencing`);
+    }
 
-*Commands:*
+    sections.push(`*Commands:*
 • \`/agent-swarm-status\` - Show all agents and their current status
-• \`/agent-swarm-help\` - Show this help message`,
-          },
-        },
-      ],
+• \`/agent-swarm-help\` - Show this help message`);
+
+    const blocks = [
+      {
+        type: "header" as const,
+        text: { type: "plain_text" as const, text: "Agent Swarm Help" },
+      },
+      ...sections.map((text) => ({
+        type: "section" as const,
+        text: { type: "mrkdwn" as const, text },
+      })),
+    ];
+
+    await respond({
+      response_type: "ephemeral",
+      blocks,
     });
   });
 }

package/src/slack/files.ts

@@ -11,7 +11,7 @@ export const MAX_FILE_SIZE = 1073741824;
 /**
  * Default download directory for Slack files
  */
-export const DEFAULT_DOWNLOAD_DIR = "/workspace/shared/downloads/slack";
+export const DEFAULT_DOWNLOAD_DIR = `/workspace/shared/downloads/${process.env.AGENT_ID || "default"}/slack`;
 
 /**
  * File object from Slack API (partial, commonly used fields)

package/src/slack/handlers.test.ts

@@ -1,5 +1,12 @@
 import { describe, expect, test } from "bun:test";
-import { checkUserAccess, type UserFilterConfig } from "./handlers";
+import type { SlackFile } from "./files";
+import {
+  buildAttachmentText,
+  buildEffectiveText,
+  checkUserAccess,
+  formatFileSize,
+  type UserFilterConfig,
+} from "./handlers";
 
 describe("checkUserAccess", () => {
   describe("when filtering is disabled (empty config)", () => {
@@ -163,3 +170,109 @@ describe("checkUserAccess", () => {
     });
   });
 });
+
+// Helper to create a minimal SlackFile for testing
+function makeFile(overrides: Partial<SlackFile> = {}): SlackFile {
+  return {
+    id: "F0TEST123",
+    name: "test_file.txt",
+    mimetype: "text/plain",
+    filetype: "txt",
+    size: 1024,
+    url_private: "https://files.slack.com/private",
+    url_private_download: "https://files.slack.com/download",
+    ...overrides,
+  };
+}
+
+describe("formatFileSize", () => {
+  test("formats bytes", () => {
+    expect(formatFileSize(0)).toBe("0 B");
+    expect(formatFileSize(512)).toBe("512 B");
+    expect(formatFileSize(1023)).toBe("1023 B");
+  });
+
+  test("formats kilobytes", () => {
+    expect(formatFileSize(1024)).toBe("1.0 KB");
+    expect(formatFileSize(1536)).toBe("1.5 KB");
+    expect(formatFileSize(1024 * 100)).toBe("100.0 KB");
+  });
+
+  test("formats megabytes", () => {
+    expect(formatFileSize(1024 * 1024)).toBe("1.0 MB");
+    expect(formatFileSize(1024 * 1024 * 2.5)).toBe("2.5 MB");
+  });
+
+  test("formats gigabytes", () => {
+    expect(formatFileSize(1024 * 1024 * 1024)).toBe("1.0 GB");
+    expect(formatFileSize(1024 * 1024 * 1024 * 1.5)).toBe("1.5 GB");
+  });
+});
+
+describe("buildAttachmentText", () => {
+  test("formats a single file", () => {
+    const files = [
+      makeFile({ id: "F001", name: "voice.m4a", mimetype: "audio/mp4", size: 156000 }),
+    ];
+    expect(buildAttachmentText(files)).toBe("[File: voice.m4a (audio/mp4, 152.3 KB) id=F001]");
+  });
+
+  test("formats multiple files", () => {
+    const files = [
+      makeFile({ id: "F001", name: "photo.png", mimetype: "image/png", size: 2048000 }),
+      makeFile({ id: "F002", name: "doc.pdf", mimetype: "application/pdf", size: 512000 }),
+    ];
+    const result = buildAttachmentText(files);
+    expect(result).toContain("[File: photo.png (image/png,");
+    expect(result).toContain("[File: doc.pdf (application/pdf,");
+    expect(result).toContain("id=F001");
+    expect(result).toContain("id=F002");
+    expect(result.split("\n")).toHaveLength(2);
+  });
+
+  test("handles empty array", () => {
+    expect(buildAttachmentText([])).toBe("");
+  });
+});
+
+describe("buildEffectiveText", () => {
+  test("returns text as-is when no files", () => {
+    expect(buildEffectiveText("hello world")).toBe("hello world");
+    expect(buildEffectiveText("hello world", undefined)).toBe("hello world");
+    expect(buildEffectiveText("hello world", [])).toBe("hello world");
+  });
+
+  test("returns attachment text when no text", () => {
+    const files = [makeFile({ id: "F001", name: "voice.m4a", mimetype: "audio/mp4", size: 1024 })];
+    const result = buildEffectiveText(undefined, files);
+    expect(result).toBe("[File: voice.m4a (audio/mp4, 1.0 KB) id=F001]");
+  });
+
+  test("returns attachment text when text is empty string", () => {
+    const files = [makeFile({ id: "F001", name: "voice.m4a", mimetype: "audio/mp4", size: 1024 })];
+    const result = buildEffectiveText("", files);
+    expect(result).toBe("[File: voice.m4a (audio/mp4, 1.0 KB) id=F001]");
+  });
+
+  test("returns attachment text when text is whitespace only", () => {
+    const files = [makeFile({ id: "F001", name: "voice.m4a", mimetype: "audio/mp4", size: 1024 })];
+    const result = buildEffectiveText("   ", files);
+    expect(result).toBe("[File: voice.m4a (audio/mp4, 1.0 KB) id=F001]");
+  });
+
+  test("combines text and files when both present", () => {
+    const files = [
+      makeFile({ id: "F001", name: "screenshot.png", mimetype: "image/png", size: 2048 }),
+    ];
+    const result = buildEffectiveText("<@UBOT> fix this bug", files);
+    expect(result).toContain("<@UBOT> fix this bug");
+    expect(result).toContain("[File: screenshot.png (image/png,");
+    expect(result).toContain("\n\n");
+  });
+
+  test("returns empty string when neither text nor files", () => {
+    expect(buildEffectiveText(undefined)).toBe("");
+    expect(buildEffectiveText(undefined, [])).toBe("");
+    expect(buildEffectiveText("")).toBe("");
+  });
+});