@desplega.ai/agent-swarm 1.111.0 → 1.112.0

package/src/tests/slack-update.test.ts

@@ -0,0 +1,167 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, mock, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { closeDb, createAgent, initDb } from "../be/db";
+import { registerSlackUpdateTool } from "../tools/slack-update";
+
+const TEST_DB_PATH = "./test-slack-update.sqlite";
+
+const mockChatUpdate = mock(() => Promise.resolve({ ok: true, ts: "1783411554.596189" }));
+const mockGetSlackApp = mock(() => ({ client: { chat: { update: mockChatUpdate } } }));
+
+mock.module("../slack/app", () => ({
+  getSlackApp: mockGetSlackApp,
+}));
+
+type RegisteredTool = {
+  handler: (
+    args: unknown,
+    extra: unknown,
+  ) => Promise<{
+    structuredContent: { success: boolean; message: string; messageTs?: string };
+  }>;
+};
+
+function buildTool() {
+  const server = new McpServer({ name: "slack-update-test", version: "1.0.0" });
+  registerSlackUpdateTool(server);
+  const registered = (server as unknown as { _registeredTools: Record<string, RegisteredTool> })
+    ._registeredTools;
+  const tool = registered["slack-update"];
+  if (!tool) throw new Error("slack-update tool not registered");
+  return tool;
+}
+
+function meta(agentId?: string) {
+  return { sessionId: "s1", requestInfo: { headers: agentId ? { "x-agent-id": agentId } : {} } };
+}
+
+describe("slack-update", () => {
+  let leadAgentId: string;
+  let nonLeadAgentId: string;
+
+  beforeAll(async () => {
+    for (const suffix of ["", "-wal", "-shm"]) {
+      try {
+        await unlink(`${TEST_DB_PATH}${suffix}`);
+      } catch {}
+    }
+    initDb(TEST_DB_PATH);
+    leadAgentId = createAgent({ name: "Lead", isLead: true, status: "idle" }).id;
+    nonLeadAgentId = createAgent({ name: "Worker", isLead: false, status: "idle" }).id;
+  });
+
+  beforeEach(() => {
+    mockChatUpdate.mockClear();
+    mockGetSlackApp.mockClear();
+  });
+
+  afterAll(async () => {
+    closeDb();
+    for (const suffix of ["", "-wal", "-shm"]) {
+      try {
+        await unlink(`${TEST_DB_PATH}${suffix}`);
+      } catch {}
+    }
+  });
+
+  test("rejects when agentId header is missing, without touching Slack", async () => {
+    const tool = buildTool();
+    const result = await tool.handler(
+      { channelId: "C1", messageTs: "1783411554.596189", message: "corrected" },
+      meta(),
+    );
+
+    expect(result.structuredContent.success).toBe(false);
+    expect(result.structuredContent.message).toBe("Agent ID not found.");
+    expect(mockGetSlackApp).not.toHaveBeenCalled();
+    expect(mockChatUpdate).not.toHaveBeenCalled();
+  });
+
+  test("rejects when the agent does not exist, without touching Slack", async () => {
+    const tool = buildTool();
+    const result = await tool.handler(
+      { channelId: "C1", messageTs: "1783411554.596189", message: "corrected" },
+      meta("00000000-0000-0000-0000-000000000000"),
+    );
+
+    expect(result.structuredContent.success).toBe(false);
+    expect(result.structuredContent.message).toBe("Agent not found.");
+    expect(mockGetSlackApp).not.toHaveBeenCalled();
+    expect(mockChatUpdate).not.toHaveBeenCalled();
+  });
+
+  test("rejects non-lead agents without touching Slack", async () => {
+    const tool = buildTool();
+    const result = await tool.handler(
+      { channelId: "C1", messageTs: "1783411554.596189", message: "corrected" },
+      meta(nonLeadAgentId),
+    );
+
+    expect(result.structuredContent.success).toBe(false);
+    expect(result.structuredContent.message).toBe(
+      "Editing Slack messages requires lead privileges.",
+    );
+    expect(mockGetSlackApp).not.toHaveBeenCalled();
+    expect(mockChatUpdate).not.toHaveBeenCalled();
+  });
+
+  test("lead caller updates using the normalized timestamp", async () => {
+    const tool = buildTool();
+    // Full permalink form (with a thread_ts query param) must normalize to the dotted API form.
+    const result = await tool.handler(
+      {
+        channelId: "C1",
+        messageTs: "https://x.slack.com/archives/C1/p1783411554596189?thread_ts=123.456",
+        message: "corrected message",
+      },
+      meta(leadAgentId),
+    );
+
+    expect(result.structuredContent.success).toBe(true);
+    expect(result.structuredContent.messageTs).toBe("1783411554.596189");
+    expect(mockChatUpdate).toHaveBeenCalledTimes(1);
+    expect(mockChatUpdate.mock.calls[0][0]).toMatchObject({
+      channel: "C1",
+      ts: "1783411554.596189",
+      text: "corrected message",
+    });
+  });
+
+  test.each([
+    ["message_not_found", "No message found at that timestamp in this channel."],
+    [
+      "cant_update_message",
+      "Cannot edit this message — the bot can only edit messages it authored.",
+    ],
+    ["edit_window_closed", "The edit window for this message has closed."],
+    ["channel_not_found", "Channel not found or the bot has no access."],
+    ["not_in_channel", "The bot is not in that channel."],
+  ])("maps Slack error %s to a structured failure message", async (errorCode, expectedMessage) => {
+    mockChatUpdate.mockImplementationOnce(() =>
+      Promise.reject(Object.assign(new Error("slack error"), { data: { error: errorCode } })),
+    );
+
+    const tool = buildTool();
+    const result = await tool.handler(
+      { channelId: "C1", messageTs: "1783411554.596189", message: "corrected" },
+      meta(leadAgentId),
+    );
+
+    expect(result.structuredContent.success).toBe(false);
+    expect(result.structuredContent.message).toBe(expectedMessage);
+  });
+
+  test("falls back to the raw error message for unmapped Slack error codes", async () => {
+    mockChatUpdate.mockImplementationOnce(() => Promise.reject(new Error("boom")));
+
+    const tool = buildTool();
+    const result = await tool.handler(
+      { channelId: "C1", messageTs: "1783411554.596189", message: "corrected" },
+      meta(leadAgentId),
+    );
+
+    expect(result.structuredContent.success).toBe(false);
+    expect(result.structuredContent.message).toBe("Failed to update message: boom");
+  });
+});

package/src/tests/tool-annotations.test.ts

@@ -107,6 +107,7 @@ describe("Tool Annotations & Classification", () => {
       "delete-config",
       "delete-workflow",
       "unregister-service",
+      "slack-delete",
     ];
 
     for (const name of expectedDestructive) {
@@ -163,6 +164,8 @@ describe("Tool Annotations & Classification", () => {
       "slack-upload-file",
       "slack-download-file",
       "slack-list-channels",
+      "slack-delete",
+      "slack-update",
     ];
 
     for (const name of slackTools) {

package/src/tools/slack-delete.ts

@@ -0,0 +1,102 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as z from "zod";
+import { getAgentById } from "@/be/db";
+import { getSlackApp } from "@/slack/app";
+import { parseSlackTs } from "@/slack/message-text";
+import { createToolRegistrar } from "@/tools/utils";
+
+export const registerSlackDeleteTool = (server: McpServer) => {
+  createToolRegistrar(server)(
+    "slack-delete",
+    {
+      title: "Delete a Slack message",
+      description:
+        "Deletes a Slack message that THIS bot authored (e.g. a message previously posted via `slack-post`/`slack-reply`). Cannot delete messages authored by humans or other apps. Requires lead privileges.",
+      annotations: { openWorldHint: true, destructiveHint: true },
+
+      inputSchema: z.object({
+        channelId: z.string().min(1).describe("The Slack channel ID the message is in."),
+        messageTs: z
+          .string()
+          .min(1)
+          .describe(
+            "Timestamp of the message to delete. Accepts the dotted form (1783411554.596189), the 'p' deep-link form (p1783411554596189), or a full Slack permalink URL.",
+          ),
+      }),
+      outputSchema: z.object({
+        success: z.boolean(),
+        message: z.string(),
+      }),
+    },
+    async ({ channelId, messageTs }, requestInfo, _meta) => {
+      if (!requestInfo.agentId) {
+        return {
+          content: [{ type: "text", text: "Agent ID not found." }],
+          structuredContent: { success: false, message: "Agent ID not found." },
+        };
+      }
+
+      const agent = getAgentById(requestInfo.agentId);
+      if (!agent) {
+        return {
+          content: [{ type: "text", text: "Agent not found." }],
+          structuredContent: { success: false, message: "Agent not found." },
+        };
+      }
+
+      if (!agent.isLead) {
+        return {
+          content: [{ type: "text", text: "Deleting Slack messages requires lead privileges." }],
+          structuredContent: {
+            success: false,
+            message: "Deleting Slack messages requires lead privileges.",
+          },
+        };
+      }
+
+      const app = getSlackApp();
+      if (!app) {
+        return {
+          content: [{ type: "text", text: "Slack not configured." }],
+          structuredContent: { success: false, message: "Slack not configured." },
+        };
+      }
+
+      try {
+        const ts = parseSlackTs(messageTs);
+        await app.client.chat.delete({ channel: channelId, ts });
+
+        return {
+          content: [{ type: "text", text: "Message deleted successfully." }],
+          structuredContent: { success: true, message: "Message deleted successfully." },
+        };
+      } catch (error) {
+        const errorCode = (error as { data?: { error?: string } } | undefined)?.data?.error;
+        const errorMsg = error instanceof Error ? error.message : String(error);
+
+        let message: string;
+        switch (errorCode) {
+          case "message_not_found":
+            message = "No message found at that timestamp in this channel.";
+            break;
+          case "cant_delete_message":
+            message = "Cannot delete this message — the bot can only delete messages it authored.";
+            break;
+          case "channel_not_found":
+            message = "Channel not found or the bot has no access.";
+            break;
+          case "not_in_channel":
+            message = "The bot is not in that channel.";
+            break;
+          default:
+            message = `Failed to delete message: ${errorMsg}`;
+        }
+
+        return {
+          content: [{ type: "text", text: message }],
+          structuredContent: { success: false, message },
+        };
+      }
+    },
+  );
+};

package/src/tools/slack-reply.ts

@@ -35,6 +35,7 @@ export const registerSlackReplyTool = (server: McpServer) => {
       outputSchema: z.object({
         success: z.boolean(),
         message: z.string(),
+        messageTs: z.string().optional(),
       }),
     },
     async ({ inboxMessageId, taskId, message }, requestInfo, _meta) => {
@@ -119,7 +120,7 @@ export const registerSlackReplyTool = (server: McpServer) => {
       try {
         const slackMessage = markdownToSlack(message);
 
-        await withAutoJoin(app.client, slackChannelId, () =>
+        const result = await withAutoJoin(app.client, slackChannelId, () =>
           app.client.chat.postMessage({
             channel: slackChannelId,
             thread_ts: slackThreadTs,
@@ -138,6 +139,8 @@ export const registerSlackReplyTool = (server: McpServer) => {
           }),
         );
 
+        const messageTs = result.ts;
+
         // After successful postMessage, mark task as having a Slack reply
         if (taskId) {
           markTaskSlackReplySent(taskId);
@@ -145,8 +148,13 @@ export const registerSlackReplyTool = (server: McpServer) => {
         }
 
         return {
-          content: [{ type: "text", text: "Reply sent successfully." }],
-          structuredContent: { success: true, message: "Reply sent successfully." },
+          content: [
+            {
+              type: "text",
+              text: `Reply sent successfully.${messageTs ? ` Message timestamp: ${messageTs}` : ""}`,
+            },
+          ],
+          structuredContent: { success: true, message: "Reply sent successfully.", messageTs },
         };
       } catch (error) {
         return {

package/src/tools/slack-start-thread.ts

@@ -24,6 +24,7 @@ export const registerSlackStartThreadTool = (server: McpServer) => {
         message: z.string(),
         channelId: z.string().optional(),
         ts: z.string().optional(),
+        messageTs: z.string().optional(),
       }),
     },
     async ({ channelId, message }, requestInfo, _meta) => {
@@ -112,6 +113,7 @@ export const registerSlackStartThreadTool = (server: McpServer) => {
             message: "Thread started successfully.",
             channelId: resolvedChannelId,
             ts,
+            messageTs: ts,
           },
         };
       } catch (error) {

package/src/tools/slack-update.ts

@@ -0,0 +1,127 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as z from "zod";
+import { getAgentById } from "@/be/db";
+import { getSlackApp } from "@/slack/app";
+import { parseSlackTs } from "@/slack/message-text";
+import { markdownToSlack } from "@/slack/responses";
+import { createToolRegistrar } from "@/tools/utils";
+
+export const registerSlackUpdateTool = (server: McpServer) => {
+  createToolRegistrar(server)(
+    "slack-update",
+    {
+      title: "Edit a Slack message",
+      description:
+        "Edits (in place) the text of a Slack message that THIS bot authored — use it to post corrections to your own messages. Cannot edit messages authored by humans or other apps. Note: editing may reset the message's display name/icon to the app default (Slack's chat.update cannot set the crown persona). Requires lead privileges.",
+      annotations: { openWorldHint: true },
+
+      inputSchema: z.object({
+        channelId: z.string().min(1).describe("The Slack channel ID the message is in."),
+        messageTs: z
+          .string()
+          .min(1)
+          .describe(
+            "Timestamp of the message to edit (dotted, 'p' deep-link, or full permalink URL).",
+          ),
+        message: z.string().min(1).max(4000).describe("The new message content."),
+      }),
+      outputSchema: z.object({
+        success: z.boolean(),
+        message: z.string(),
+        messageTs: z.string().optional(),
+      }),
+    },
+    async ({ channelId, messageTs, message }, requestInfo, _meta) => {
+      if (!requestInfo.agentId) {
+        return {
+          content: [{ type: "text", text: "Agent ID not found." }],
+          structuredContent: { success: false, message: "Agent ID not found." },
+        };
+      }
+
+      const agent = getAgentById(requestInfo.agentId);
+      if (!agent) {
+        return {
+          content: [{ type: "text", text: "Agent not found." }],
+          structuredContent: { success: false, message: "Agent not found." },
+        };
+      }
+
+      if (!agent.isLead) {
+        return {
+          content: [{ type: "text", text: "Editing Slack messages requires lead privileges." }],
+          structuredContent: {
+            success: false,
+            message: "Editing Slack messages requires lead privileges.",
+          },
+        };
+      }
+
+      const app = getSlackApp();
+      if (!app) {
+        return {
+          content: [{ type: "text", text: "Slack not configured." }],
+          structuredContent: { success: false, message: "Slack not configured." },
+        };
+      }
+
+      try {
+        const ts = parseSlackTs(messageTs);
+        const slackMessage = markdownToSlack(message);
+
+        const result = await app.client.chat.update({
+          channel: channelId,
+          ts,
+          text: slackMessage,
+          blocks: [
+            {
+              type: "section",
+              text: {
+                type: "mrkdwn",
+                text: slackMessage,
+              },
+            },
+          ],
+        });
+
+        return {
+          content: [{ type: "text", text: "Message updated successfully." }],
+          structuredContent: {
+            success: true,
+            message: "Message updated successfully.",
+            messageTs: result.ts,
+          },
+        };
+      } catch (error) {
+        const errorCode = (error as { data?: { error?: string } } | undefined)?.data?.error;
+        const errorMsg = error instanceof Error ? error.message : String(error);
+
+        let message: string;
+        switch (errorCode) {
+          case "message_not_found":
+            message = "No message found at that timestamp in this channel.";
+            break;
+          case "cant_update_message":
+            message = "Cannot edit this message — the bot can only edit messages it authored.";
+            break;
+          case "edit_window_closed":
+            message = "The edit window for this message has closed.";
+            break;
+          case "channel_not_found":
+            message = "Channel not found or the bot has no access.";
+            break;
+          case "not_in_channel":
+            message = "The bot is not in that channel.";
+            break;
+          default:
+            message = `Failed to update message: ${errorMsg}`;
+        }
+
+        return {
+          content: [{ type: "text", text: message }],
+          structuredContent: { success: false, message },
+        };
+      }
+    },
+  );
+};

package/src/tools/tool-config.ts

@@ -86,7 +86,7 @@ export const DEFERRED_TOOLS = new Set([
   "context-history",
   "context-diff",
 
-  // Slack (7)
+  // Slack (9)
   "slack-reply",
   "slack-read",
   "slack-upload-file",
@@ -94,6 +94,8 @@ export const DEFERRED_TOOLS = new Set([
   "slack-list-channels",
   "slack-post",
   "slack-start-thread",
+  "slack-delete",
+  "slack-update",
 
   // Channel management (2)
   "create-channel",