@desplega.ai/agent-swarm 1.20.0 → 1.51.2

package/src/slack/handlers.ts

@@ -1,7 +1,23 @@
 import type { App } from "@slack/bolt";
 import type { WebClient } from "@slack/web-api";
-import { createInboxMessage, createTask, getAgentById, getTasksByAgentId } from "../be/db";
+import {
+  createTask,
+  createTaskExtended,
+  getAgentById,
+  getAgentWorkingOnThread,
+  getLeadAgent,
+  getMostRecentTaskInThread,
+  getTasksByAgentId,
+} from "../be/db";
+import { resolveTemplate } from "../prompts/resolver";
+import { workflowEventBus } from "../workflows/event-bus";
+import { buildAssignmentSummaryBlocks } from "./blocks";
+import type { SlackFile } from "./files";
 import { extractTaskFromMessage, routeMessage } from "./router";
+// Side-effect import: registers all Slack event templates in the in-memory registry
+import "./templates";
+import { bufferThreadMessage, getBufferMessageCount, instantFlush } from "./thread-buffer";
+import { registerTaskMessage } from "./watcher";
 
 // User filtering configuration from environment variables
 const allowedEmailDomains = (process.env.SLACK_ALLOWED_EMAIL_DOMAINS || "")
@@ -132,6 +148,7 @@ interface MessageEvent {
   channel: string;
   ts: string;
   thread_ts?: string;
+  files?: SlackFile[];
 }
 
 interface ThreadMessage {
@@ -210,17 +227,43 @@ async function getThreadContext(
   }
 }
 
-const appUrl = process.env.APP_URL || "";
+/**
+ * Format a file size in bytes to a human-readable string.
+ */
+export function formatFileSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+}
+
+/**
+ * Build a text representation of file attachments for inclusion in messages.
+ * Each file is formatted as: [File: filename.ext (mimetype, size) id=FILE_ID]
+ */
+export function buildAttachmentText(files: SlackFile[]): string {
+  return files
+    .map((f) => `[File: ${f.name} (${f.mimetype}, ${formatFileSize(f.size)}) id=${f.id}]`)
+    .join("\n");
+}
 
 /**
- * Get a link to the task in the dashboard, or just the task ID if no APP_URL.
+ * Build the effective message text from the original text and any file attachments.
+ * - Text only: returns the text as-is
+ * - Files only: returns the attachment metadata
+ * - Both: returns text followed by attachment metadata
  */
-function getTaskLink(taskId: string): string {
-  const shortId = taskId.slice(0, 8);
-  if (appUrl) {
-    return `<${appUrl}?tab=tasks&task=${taskId}&expand=true|\`${shortId}\`>`;
+export function buildEffectiveText(text: string | undefined, files?: SlackFile[]): string {
+  const hasText = !!text?.trim();
+  const hasFiles = files && files.length > 0;
+
+  if (hasText && hasFiles) {
+    return `${text}\n\n${buildAttachmentText(files)}`;
   }
-  return `\`${shortId}\``;
+  if (hasFiles) {
+    return buildAttachmentText(files);
+  }
+  return text || "";
 }
 
 // Message deduplication (prevents duplicate event processing)
@@ -275,7 +318,11 @@ export function registerMessageHandler(app: App): void {
     }
 
     const msg = event as MessageEvent;
-    if (!msg.text || !msg.user) return;
+    const hasText = !!msg.text?.trim();
+    const hasFiles = !!(msg.files && msg.files.length > 0);
+
+    // Require either text or files, and always require a user
+    if ((!hasText && !hasFiles) || !msg.user) return;
 
     // Deduplicate events (Slack can send same event twice)
     const messageKey = `${msg.channel}:${msg.ts}`;
@@ -289,29 +336,141 @@ export function registerMessageHandler(app: App): void {
       return;
     }
 
+    // Emit workflow trigger event for Slack messages
+    workflowEventBus.emit("slack.message", {
+      channel: msg.channel,
+      text: msg.text,
+      user: msg.user,
+      ts: msg.ts,
+      threadTs: msg.thread_ts,
+    });
+
+    // Build effective text that includes attachment metadata
+    const effectiveText = buildEffectiveText(msg.text, msg.files);
+
     // Get bot's user ID
     const authResult = await client.auth.test();
     const botUserId = authResult.user_id as string;
 
-    // Check if bot was mentioned
-    const botMentioned = msg.text.includes(`<@${botUserId}>`);
+    // Check if bot was mentioned (in original text only)
+    const botMentioned = !!msg.text?.includes(`<@${botUserId}>`);
+
+    // ADDITIVE_SLACK: Check for !now command in threads
+    const additiveSlack = process.env.ADDITIVE_SLACK === "true";
+    if (additiveSlack && msg.thread_ts) {
+      const stripped = effectiveText.replace(/<@[A-Z0-9]+>/g, "").trim();
+      if (stripped.startsWith("!now")) {
+        const nowMessage = stripped.replace(/^!now\s*/, "").trim();
+        const threadKey = `${msg.channel}:${msg.thread_ts}`;
+
+        console.log(
+          `[Slack] !now command detected in thread ${threadKey}${nowMessage ? ` with message: "${nowMessage}"` : ""}`,
+        );
 
-    // Build thread context for routing (if we're in a thread)
+        if (nowMessage) {
+          bufferThreadMessage(msg.channel, msg.thread_ts, nowMessage, msg.user, msg.ts);
+        }
+
+        // Instant flush — no dependency
+        await instantFlush(threadKey);
+
+        try {
+          await client.reactions.add({ channel: msg.channel, name: "zap", timestamp: msg.ts });
+        } catch (e) {
+          console.log(`[Slack] Reaction failed: ${e instanceof Error ? e.message : e}`);
+        }
+
+        return;
+      }
+    }
+
+    // ADDITIVE_SLACK: Buffer non-mention thread messages
+    if (additiveSlack && !botMentioned && msg.thread_ts) {
+      // Check if this thread has any swarm activity (existing tasks)
+      const hasSwarmActivity = getAgentWorkingOnThread(msg.channel, msg.thread_ts) !== null;
+
+      if (hasSwarmActivity) {
+        const threadKey = `${msg.channel}:${msg.thread_ts}`;
+        bufferThreadMessage(msg.channel, msg.thread_ts, effectiveText, msg.user, msg.ts);
+
+        // Slack feedback: react with :eyes: on first buffer, :heavy_plus_sign: on appends
+        const count = getBufferMessageCount(threadKey);
+        console.log(
+          `[Slack] Additive buffer: ${threadKey} (message #${count}, reaction: ${count === 1 ? "eyes" : "heavy_plus_sign"})`,
+        );
+        try {
+          await client.reactions.add({
+            channel: msg.channel,
+            name: count === 1 ? "eyes" : "heavy_plus_sign",
+            timestamp: msg.ts,
+          });
+        } catch (e) {
+          console.log(`[Slack] Reaction failed: ${e instanceof Error ? e.message : e}`);
+        }
+
+        return; // Don't process further — buffer will flush
+      }
+    }
+
+    // Route message to agents (use original text for routing to preserve mention/name matching)
+    const routingText = msg.text || effectiveText;
     const routingThreadContext = msg.thread_ts
       ? { channelId: msg.channel, threadTs: msg.thread_ts }
       : undefined;
-
-    // Route message to agents
-    const matches = routeMessage(msg.text, botUserId, botMentioned, routingThreadContext);
+    const matches = routeMessage(routingText, botUserId, botMentioned, routingThreadContext);
 
     if (matches.length === 0) {
-      // No agents matched - ignore message unless bot was directly mentioned
-      if (botMentioned) {
+      if (!botMentioned) return;
+
+      // Bot was mentioned but no online agents matched — queue the request
+      if (!checkRateLimit(msg.user)) {
         await say({
-          text: ":satellite: _No agents are currently available. Use `/agent-swarm-status` to check the swarm._",
+          text: ":satellite: _You're sending too many requests. Please slow down._",
           thread_ts: msg.thread_ts || msg.ts,
         });
+        return;
       }
+
+      const taskDescription = extractTaskFromMessage(effectiveText, botUserId);
+      if (!taskDescription) {
+        await say({
+          text: ":satellite: _Please provide a task description after mentioning an agent._",
+          thread_ts: msg.thread_ts || msg.ts,
+        });
+        return;
+      }
+
+      const threadTs = msg.thread_ts || msg.ts;
+      const threadContext = await getThreadContext(
+        client,
+        msg.channel,
+        msg.thread_ts,
+        msg.ts,
+        botUserId,
+      );
+      let fullTaskDescription: string;
+      if (threadContext) {
+        const ctxResult = resolveTemplate("slack.message.thread_context", {
+          thread_messages: threadContext,
+        });
+        fullTaskDescription = `${ctxResult.text}\n\n${taskDescription}`;
+      } else {
+        fullTaskDescription = taskDescription;
+      }
+
+      const lead = getLeadAgent();
+      createTaskExtended(fullTaskDescription, {
+        agentId: lead?.id,
+        source: "slack",
+        slackChannelId: msg.channel,
+        slackThreadTs: threadTs,
+        slackUserId: msg.user,
+      });
+
+      await say({
+        text: ":satellite: _No agents are online right now. Your request has been queued and will be processed when agents come back up._",
+        thread_ts: threadTs,
+      });
       return;
     }
 
@@ -324,8 +483,8 @@ export function registerMessageHandler(app: App): void {
       return;
     }
 
-    // Extract task description
-    const taskDescription = extractTaskFromMessage(msg.text, botUserId);
+    // Extract task description (using effective text which includes attachment metadata)
+    const taskDescription = extractTaskFromMessage(effectiveText, botUserId);
     if (!taskDescription) {
       await say({
         text: ":satellite: _Please provide a task description after mentioning an agent._",
@@ -345,39 +504,41 @@ export function registerMessageHandler(app: App): void {
       msg.ts,
       botUserId,
     );
-    // Structure content with clear separation for inbox messages
-    const structuredContent = threadContext
-      ? `<new_message>\n${taskDescription}\n</new_message>\n\n<thread_history>\n${threadContext}\n</thread_history>`
-      : taskDescription;
-    // For workers (tasks), keep using the old format for backwards compatibility
-    const fullTaskDescription = threadContext
-      ? `<thread_context>\n${threadContext}\n</thread_context>\n\n${taskDescription}`
-      : taskDescription;
-    const results: { assigned: string[]; queued: string[]; failed: string[] } = {
-      assigned: [],
-      queued: [],
-      failed: [],
-    };
+    let fullTaskDescription: string;
+    if (threadContext) {
+      const ctxResult = resolveTemplate("slack.message.thread_context", {
+        thread_messages: threadContext,
+      });
+      fullTaskDescription = `${ctxResult.text}\n\n${taskDescription}`;
+    } else {
+      fullTaskDescription = taskDescription;
+    }
+    const results: {
+      assigned: Array<{ agentName: string; taskId: string }>;
+      queued: Array<{ agentName: string; taskId: string }>;
+      failed: Array<{ agentName: string; reason: string }>;
+    } = { assigned: [], queued: [], failed: [] };
 
     for (const match of matches) {
       const agent = getAgentById(match.agent.id);
 
       if (!agent) {
-        results.failed.push(`\`${match.agent.name}\` (not found)`);
+        results.failed.push({ agentName: match.agent.name, reason: "not found" });
         continue;
       }
 
       try {
-        // Lead agents receive inbox messages, not tasks
+        const latestTask = getMostRecentTaskInThread(msg.channel, threadTs);
         if (agent.isLead) {
-          createInboxMessage(agent.id, structuredContent, {
+          const task = createTaskExtended(fullTaskDescription, {
+            agentId: agent.id,
             source: "slack",
             slackChannelId: msg.channel,
             slackThreadTs: threadTs,
             slackUserId: msg.user,
-            matchedText: match.matchedText,
+            parentTaskId: latestTask?.id,
           });
-          results.assigned.push(`*${agent.name}* (inbox)`);
+          results.assigned.push({ agentName: agent.name, taskId: task.id });
           continue;
         }
 
@@ -396,32 +557,46 @@ export function registerMessageHandler(app: App): void {
         );
 
         if (inProgressInThread) {
-          results.queued.push(`*${agent.name}* (${getTaskLink(task.id)})`);
+          results.queued.push({ agentName: agent.name, taskId: task.id });
         } else {
-          results.assigned.push(`*${agent.name}* (${getTaskLink(task.id)})`);
+          results.assigned.push({ agentName: agent.name, taskId: task.id });
         }
       } catch {
-        results.failed.push(`\`${agent.name}\` (error)`);
+        results.failed.push({ agentName: agent.name, reason: "error" });
       }
     }
 
-    // Send consolidated summary
-    const parts: string[] = [];
-    if (results.assigned.length > 0) {
-      parts.push(`:satellite: _Task assigned to: ${results.assigned.join(", ")}_`);
-    }
-    if (results.queued.length > 0) {
-      parts.push(`:satellite: _Task queued for: ${results.queued.join(", ")}_`);
-    }
-    if (results.failed.length > 0) {
-      parts.push(`:satellite: _Could not assign to: ${results.failed.join(", ")}_`);
-    }
+    // Send consolidated summary with Block Kit
+    const totalResults = results.assigned.length + results.queued.length + results.failed.length;
+    if (totalResults > 0) {
+      // Build plain-text fallback
+      const parts: string[] = [];
+      if (results.assigned.length > 0) {
+        const names = results.assigned.map((a) => `${a.agentName}`).join(", ");
+        parts.push(`Task assigned to: ${names}`);
+      }
+      if (results.queued.length > 0) {
+        const names = results.queued.map((q) => `${q.agentName}`).join(", ");
+        parts.push(`Task queued for: ${names}`);
+      }
+      if (results.failed.length > 0) {
+        const names = results.failed.map((f) => `${f.agentName}`).join(", ");
+        parts.push(`Could not assign to: ${names}`);
+      }
 
-    if (parts.length > 0) {
-      await say({
-        text: parts.join("\n"),
+      const resp = await say({
+        text: parts.join(". "),
+        blocks: buildAssignmentSummaryBlocks(results),
         thread_ts: msg.thread_ts || msg.ts,
       });
+
+      // Register the assignment message so the watcher can update it in-place
+      // (assignment → progress → completion all in one evolving message)
+      if (resp?.ts) {
+        for (const { taskId } of results.assigned) {
+          registerTaskMessage(taskId, msg.channel, threadTs, resp.ts);
+        }
+      }
     }
   });
 

package/src/slack/responses.ts

@@ -2,36 +2,18 @@ import type { WebClient } from "@slack/web-api";
 import { getAgentById } from "../be/db";
 import type { Agent, AgentTask } from "../types";
 import { getSlackApp } from "./app";
+import {
+  buildCancelledBlocks,
+  buildCompletedBlocks,
+  buildFailedBlocks,
+  buildProgressBlocks,
+  markdownToSlack,
+} from "./blocks";
 
-const isDev = process.env.ENV === "development";
-const appUrl = process.env.APP_URL || "";
+// Re-export for backward compatibility
+export { markdownToSlack } from "./blocks";
 
-/**
- * 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 (# Header -> *Header*)
-      .replace(/^#{1,6}\s+(.+)$/gm, "*$1*")
-      // Bold **text** -> *text* (must be before italic)
-      .replace(/\*\*(.+?)\*\*/g, "*$1*")
-      // Italic *text* -> _text_ (single asterisks, after bold is converted)
-      .replace(/(?<!\*)\*([^*]+)\*(?!\*)/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")
-  );
-}
+const isDev = process.env.ENV === "development";
 
 /**
  * Get the display name for an agent, with (dev) prefix if in development mode.
@@ -40,17 +22,6 @@ function getAgentDisplayName(agent: Agent): string {
   return isDev ? `(dev) ${agent.name}` : agent.name;
 }
 
-/**
- * Get a link to the task in the dashboard, or just the task ID if no APP_URL.
- */
-function getTaskLink(taskId: string): string {
-  const shortId = taskId.slice(0, 8);
-  if (appUrl) {
-    return `<${appUrl}?tab=tasks&task=${taskId}&expand=true|\`${shortId}\`>`;
-  }
-  return `\`${shortId}\``;
-}
-
 /**
  * Send a task completion message to Slack with the agent's persona.
  */
@@ -72,28 +43,31 @@ export async function sendTaskResponse(task: AgentTask): Promise<boolean> {
   }
 
   const client = app.client;
-  const taskLink = getTaskLink(task.id);
-  const footer = `_Check the full logs at ${taskLink}_`;
+  const agentName = agent.name;
 
   try {
     if (task.status === "completed") {
-      const output = task.output || "_Task completed._";
+      const output = task.output || "Task completed.";
       const slackOutput = markdownToSlack(output);
+      const blocks = buildCompletedBlocks({ agentName, taskId: task.id, body: slackOutput });
       await sendWithPersona(client, {
         channel: task.slackChannelId,
         thread_ts: task.slackThreadTs,
-        text: `${slackOutput}\n\n${footer}`,
+        text: slackOutput,
         username: getAgentDisplayName(agent),
         icon_emoji: getAgentEmoji(agent),
+        blocks,
       });
     } else if (task.status === "failed") {
       const reason = task.failureReason || "Unknown error";
+      const blocks = buildFailedBlocks({ agentName, taskId: task.id, reason });
       await sendWithPersona(client, {
         channel: task.slackChannelId,
         thread_ts: task.slackThreadTs,
-        text: `:x: *Task failed*\n\`\`\`${reason}\`\`\`\n${footer}`,
+        text: `Task failed: ${reason}`,
         username: getAgentDisplayName(agent),
         icon_emoji: getAgentEmoji(agent),
+        blocks,
       });
     }
 
@@ -105,33 +79,110 @@ export async function sendTaskResponse(task: AgentTask): Promise<boolean> {
 }
 
 /**
- * Send a progress update to Slack.
+ * Send a progress update to Slack. Returns the message ts for chat.update tracking.
  */
-export async function sendProgressUpdate(task: AgentTask, progress: string): Promise<boolean> {
+export async function sendProgressUpdate(
+  task: AgentTask,
+  progress: string,
+): Promise<string | undefined> {
   const app = getSlackApp();
   if (!app || !task.slackChannelId || !task.slackThreadTs) {
-    return false;
+    return undefined;
   }
 
-  if (!task.agentId) return false;
+  if (!task.agentId) return undefined;
 
   const agent = getAgentById(task.agentId);
-  if (!agent) return false;
+  if (!agent) return undefined;
 
-  const taskLink = getTaskLink(task.id);
-  const footer = `_Check progress at ${taskLink}_`;
+  const blocks = buildProgressBlocks({ agentName: agent.name, taskId: task.id, progress });
 
   try {
-    await sendWithPersona(app.client, {
+    return await sendWithPersona(app.client, {
       channel: task.slackChannelId,
       thread_ts: task.slackThreadTs,
-      text: `:hourglass_flowing_sand: _${progress}_\n\n${footer}`,
+      text: progress,
       username: getAgentDisplayName(agent),
       icon_emoji: getAgentEmoji(agent),
+      blocks,
     });
-    return true;
   } catch (error) {
     console.error(`[Slack] Failed to send progress update:`, error);
+    return undefined;
+  }
+}
+
+/**
+ * Update an existing progress message in-place via chat.update.
+ */
+export async function updateProgressInPlace(
+  task: AgentTask,
+  progress: string,
+  messageTs: string,
+): Promise<boolean> {
+  const app = getSlackApp();
+  if (!app || !task.slackChannelId || !task.agentId) return false;
+
+  const agent = getAgentById(task.agentId);
+  if (!agent) return false;
+
+  const blocks = buildProgressBlocks({ agentName: agent.name, taskId: task.id, progress });
+
+  try {
+    await app.client.chat.update({
+      channel: task.slackChannelId,
+      ts: messageTs,
+      text: progress,
+      // biome-ignore lint/suspicious/noExplicitAny: Block Kit objects
+      blocks: blocks as any,
+    });
+    return true;
+  } catch (error) {
+    console.error(`[Slack] Failed to update progress in-place:`, error);
+    return false;
+  }
+}
+
+/**
+ * Update the task message to its final state (completed/failed) via chat.update.
+ * Uses full blocks (not compact) since this is the only message for the task.
+ */
+export async function updateToFinal(task: AgentTask, messageTs: string): Promise<boolean> {
+  const app = getSlackApp();
+  if (!app || !task.slackChannelId || !task.agentId) return false;
+
+  const agent = getAgentById(task.agentId);
+  if (!agent) return false;
+
+  const agentName = agent.name;
+  let blocks: unknown[];
+  let text: string;
+
+  if (task.status === "completed") {
+    const output = task.output || "Task completed.";
+    const slackOutput = markdownToSlack(output);
+    blocks = buildCompletedBlocks({ agentName, taskId: task.id, body: slackOutput });
+    text = slackOutput;
+  } else if (task.status === "cancelled") {
+    blocks = buildCancelledBlocks({ agentName, taskId: task.id });
+    text = "Task cancelled";
+  } else {
+    const reason = task.failureReason || "Unknown error";
+    blocks = buildFailedBlocks({ agentName, taskId: task.id, reason });
+    text = `Task failed: ${reason}`;
+  }
+
+  try {
+    await app.client.chat.update({
+      channel: task.slackChannelId,
+      ts: messageTs,
+      text,
+      // biome-ignore lint/suspicious/noExplicitAny: Block Kit objects
+      blocks: blocks as any,
+    });
+    return true;
+  } catch (error) {
+    console.error(`[Slack] Failed to update task message to final state:`, error);
     return false;
   }
 }
@@ -144,24 +195,26 @@ async function sendWithPersona(
     text: string;
     username: string;
     icon_emoji: string;
+    blocks?: unknown[];
   },
-): Promise<void> {
-  await client.chat.postMessage({
+): Promise<string | undefined> {
+  const blocks = options.blocks ?? [
+    { type: "section", text: { type: "mrkdwn", text: options.text } },
+  ];
+
+  // Skip persona overrides in DM channels (assistant threads use the app's own identity)
+  const isDM = options.channel.startsWith("D");
+
+  const result = await client.chat.postMessage({
     channel: options.channel,
     thread_ts: options.thread_ts,
     text: options.text, // Fallback for notifications
-    username: options.username,
-    icon_emoji: options.icon_emoji,
-    blocks: [
-      {
-        type: "section",
-        text: {
-          type: "mrkdwn",
-          text: options.text,
-        },
-      },
-    ],
+    ...(isDM ? {} : { username: options.username, icon_emoji: options.icon_emoji }),
+    // biome-ignore lint/suspicious/noExplicitAny: Block Kit objects are typed as plain JSON
+    blocks: blocks as any,
   });
+
+  return result.ts;
 }
 
 function getAgentEmoji(agent: Agent): string {