Add Slack message event parity (#154)

* Add Slack message event parity

- Add deterministic chat permalinks for posted messages and threaded replies.

- Dispatch Slack-shaped message_changed and message_deleted events.

- Cover permalink and event flows across route, SDK, and docs.

* Add Slack event timestamps

* Format Slack chat route

* Fix Slack coverage note

Author: ctate

README.md

@@ -605,6 +605,7 @@ Fully stateful Slack Web API emulation with channels, messages, threads, reactio
 - `POST /api/chat.postMessage` - post message with text or rich payload fields (supports threads via `thread_ts`)
 - `POST /api/chat.update` - update message text and rich payload fields
 - `POST /api/chat.delete` - delete message
+- `GET /api/chat.getPermalink` / `POST /api/chat.getPermalink` - get message permalink
 - `POST /api/chat.meMessage` - /me message
 
 ### Conversations

apps/web/app/docs/slack/page.mdx

@@ -11,6 +11,7 @@ Fully stateful Slack Web API emulation with channels, messages, threads, reactio
 - `POST /api/chat.postMessage` - post message with text or rich payload fields (supports threads via `thread_ts`)
 - `POST /api/chat.update` - update message text and rich payload fields
 - `POST /api/chat.delete` - delete message
+- `GET /api/chat.getPermalink` / `POST /api/chat.getPermalink` - get message permalink
 - `POST /api/chat.meMessage` - /me message
 
 ## Conversations
@@ -55,9 +56,11 @@ Fully stateful Slack Web API emulation with channels, messages, threads, reactio
 
 ## Event Dispatching
 
-When messages are posted or reactions change, the emulator dispatches `event_callback` payloads to configured webhook URLs matching Slack's Events API format:
+When messages are posted, updated, deleted, or reactions change, the emulator dispatches `event_callback` payloads to configured webhook URLs matching Slack's Events API format:
 
 - `message` events on `chat.postMessage`
+- `message` with `subtype: message_changed` on `chat.update`
+- `message` with `subtype: message_deleted` on `chat.delete`
 - rich message fields are included on posted `message` events when present
 - `reaction_added` / `reaction_removed` events on `reactions.add` / `reactions.remove`
 - `message` with `subtype: bot_message` on incoming webhook posts

packages/@emulators/slack/README.md

@@ -17,6 +17,7 @@ npm install @emulators/slack
 - `POST /api/chat.postMessage` — post message with text or rich payload fields (supports threads via `thread_ts`)
 - `POST /api/chat.update` — update message text and rich payload fields
 - `POST /api/chat.delete` — delete message
+- `GET /api/chat.getPermalink` / `POST /api/chat.getPermalink` — get message permalink
 - `POST /api/chat.meMessage` — /me message
 
 ### Conversations

packages/@emulators/slack/src/__tests__/coverage.test.ts

@@ -15,6 +15,10 @@ function registeredSlackRoutes(): string[] {
   return routes.map((route) => `${route.method} ${route.compiled.pattern}`).sort();
 }
 
+function entryRoutes(entry: { route: string | string[] }): string[] {
+  return Array.isArray(entry.route) ? entry.route : [entry.route];
+}
+
 describe("Slack coverage matrix", () => {
   it("has unique method entries", () => {
     const methods = slackCoverageMatrix.map((entry) => entry.method);
@@ -24,10 +28,12 @@ describe("Slack coverage matrix", () => {
   it("maps every registered endpoint to at least one test file", () => {
     const currentEntries = slackCoverageMatrix.filter((entry) => entry.status !== "not_started");
     expect(currentEntries.length).toBeGreaterThan(0);
-    expect(currentEntries.map((entry) => entry.route).sort()).toEqual(registeredSlackRoutes());
+    expect(currentEntries.flatMap(entryRoutes).sort()).toEqual(registeredSlackRoutes());
 
     for (const entry of currentEntries) {
-      expect(entry.route).toMatch(/^(GET|POST) /);
+      for (const route of entryRoutes(entry)) {
+        expect(route).toMatch(/^(GET|POST) /);
+      }
       expect(entry.testedBy.length, entry.method).toBeGreaterThan(0);
     }
   });

packages/@emulators/slack/src/__tests__/slack-coverage.ts

@@ -3,7 +3,7 @@ export type SlackCoverageStatus = "supported" | "partial" | "not_started";
 export interface SlackCoverageEntry {
   family: string;
   method: string;
-  route: string;
+  route: string | string[];
   status: SlackCoverageStatus;
   testedBy: string[];
   notes: string;
@@ -25,23 +25,31 @@ export const slackCoverageMatrix: SlackCoverageEntry[] = [
     status: "partial",
     testedBy: ["slack.test.ts", "slack-sdk.test.ts", "slack-events.test.ts"],
     notes:
-      "Text, thread replies, blocks, attachments, metadata, formatting flags, unfurl flags, and client message ids round trip. DMs, permalinks, and membership checks are future work.",
+      "Text, thread replies, blocks, attachments, metadata, formatting flags, unfurl flags, and client message ids round trip. DMs and membership checks are future work.",
   },
   {
     family: "chat",
     method: "chat.update",
     route: "POST /api/chat.update",
     status: "partial",
-    testedBy: ["slack.test.ts", "slack-sdk.test.ts"],
-    notes: "Stored text and rich message fields are updated. Slack shaped message_changed events are future work.",
+    testedBy: ["slack.test.ts", "slack-sdk.test.ts", "slack-events.test.ts"],
+    notes: "Stored text and rich message fields are updated and message_changed events are dispatched.",
   },
   {
     family: "chat",
     method: "chat.delete",
     route: "POST /api/chat.delete",
     status: "partial",
+    testedBy: ["slack.test.ts", "slack-sdk.test.ts", "slack-events.test.ts"],
+    notes: "Stored messages are deleted and message_deleted events are dispatched.",
+  },
+  {
+    family: "chat",
+    method: "chat.getPermalink",
+    route: ["GET /api/chat.getPermalink", "POST /api/chat.getPermalink"],
+    status: "partial",
     testedBy: ["slack.test.ts", "slack-sdk.test.ts"],
-    notes: "Stored messages are deleted. Slack shaped message_deleted events are future work.",
+    notes: "Returns deterministic emulator permalinks for top-level messages and threaded replies.",
   },
   {
     family: "chat",

packages/@emulators/slack/src/__tests__/slack-events.test.ts

@@ -86,6 +86,95 @@ describe("Slack plugin - event dispatch baseline", () => {
     ]);
   });
 
+  it("dispatches message_changed events for chat.update", async () => {
+    const { app, store, webhooks } = createSlackTestApp();
+    const capture = captureFetchRequests();
+    registerSlackEventSubscription(webhooks, ["message"]);
+
+    const ch = getSlackStore(store).channels.findOneBy("name", "general")!;
+    const postRes = await app.request(`${base}/api/chat.postMessage`, {
+      method: "POST",
+      headers: authHeaders(),
+      body: JSON.stringify({ channel: ch.channel_id, text: "before update" }),
+    });
+    const posted = (await postRes.json()) as { ts: string };
+
+    await app.request(`${base}/api/chat.update`, {
+      method: "POST",
+      headers: authHeaders(),
+      body: JSON.stringify({ channel: ch.channel_id, ts: posted.ts, text: "after update" }),
+    });
+
+    expect(capture.requests).toHaveLength(2);
+    const event = capture.jsonBodies()[1] as any;
+    expect(event).toMatchObject({
+      type: "event_callback",
+      event: {
+        type: "message",
+        subtype: "message_changed",
+        hidden: true,
+        channel: ch.channel_id,
+        message: {
+          type: "message",
+          user: "U000000001",
+          text: "after update",
+          ts: posted.ts,
+          edited: { user: "U000000001" },
+        },
+        previous_message: {
+          type: "message",
+          user: "U000000001",
+          text: "before update",
+          ts: posted.ts,
+        },
+      },
+    });
+    expect(event.event.ts).not.toBe(posted.ts);
+    expect(event.event.event_ts).toBe(event.event.ts);
+    expect(event.event.message.edited.ts).toBe(event.event.ts);
+  });
+
+  it("dispatches message_deleted events for chat.delete", async () => {
+    const { app, store, webhooks } = createSlackTestApp();
+    const capture = captureFetchRequests();
+    registerSlackEventSubscription(webhooks, ["message"]);
+
+    const ch = getSlackStore(store).channels.findOneBy("name", "general")!;
+    const postRes = await app.request(`${base}/api/chat.postMessage`, {
+      method: "POST",
+      headers: authHeaders(),
+      body: JSON.stringify({ channel: ch.channel_id, text: "delete event baseline" }),
+    });
+    const posted = (await postRes.json()) as { ts: string };
+
+    await app.request(`${base}/api/chat.delete`, {
+      method: "POST",
+      headers: authHeaders(),
+      body: JSON.stringify({ channel: ch.channel_id, ts: posted.ts }),
+    });
+
+    expect(capture.requests).toHaveLength(2);
+    const event = capture.jsonBodies()[1] as any;
+    expect(event).toMatchObject({
+      type: "event_callback",
+      event: {
+        type: "message",
+        subtype: "message_deleted",
+        hidden: true,
+        channel: ch.channel_id,
+        deleted_ts: posted.ts,
+        previous_message: {
+          type: "message",
+          user: "U000000001",
+          text: "delete event baseline",
+          ts: posted.ts,
+        },
+      },
+    });
+    expect(event.event.ts).not.toBe(posted.ts);
+    expect(event.event.event_ts).toBe(event.event.ts);
+  });
+
   it("dispatches bot message events for incoming webhooks", async () => {
     const { app, store, webhooks } = createSlackTestApp();
     const capture = captureFetchRequests();

packages/@emulators/slack/src/__tests__/slack-sdk.test.ts

@@ -68,6 +68,12 @@ describe("Slack plugin - real @slack/web-api WebClient baseline", () => {
       "reply from WebClient",
     ]);
 
+    const permalink = await client.chat.getPermalink({ channel: channel!, message_ts: reply.ts! });
+    expect(permalink.ok).toBe(true);
+    expect(permalink.channel).toBe(channel);
+    expect(permalink.permalink).toContain(`/archives/${channel}/p${reply.ts!.replace(".", "")}`);
+    expect(permalink.permalink).toContain(`thread_ts=${posted.ts}`);
+
     const deleted = await client.chat.delete({ channel: channel!, ts: posted.ts! });
     expect(deleted.ok).toBe(true);
   });

packages/@emulators/slack/src/__tests__/slack.test.ts

@@ -365,6 +365,83 @@ describe("Slack plugin - chat.delete", () => {
   });
 });
 
+describe("Slack plugin - chat.getPermalink", () => {
+  let app: SlackTestApp["app"];
+  let store: Store;
+
+  beforeEach(() => {
+    ({ app, store } = createTestApp());
+  });
+
+  it("returns a deterministic permalink for a top-level message", async () => {
+    const ss = getSlackStore(store);
+    const ch = ss.channels.all()[0];
+
+    const postRes = await app.request(`${base}/api/chat.postMessage`, {
+      method: "POST",
+      headers: authHeaders(),
+      body: JSON.stringify({ channel: ch.channel_id, text: "link me" }),
+    });
+    const posted = (await postRes.json()) as any;
+
+    const permalinkRes = await app.request(
+      `${base}/api/chat.getPermalink?channel=${ch.channel_id}&message_ts=${posted.ts}`,
+      {
+        method: "GET",
+        headers: authHeaders(),
+      },
+    );
+    const permalink = (await permalinkRes.json()) as any;
+    expect(permalink.ok).toBe(true);
+    expect(permalink.channel).toBe(ch.channel_id);
+    expect(permalink.permalink).toBe(`${base}/archives/${ch.channel_id}/p${posted.ts.replace(".", "")}`);
+  });
+
+  it("returns threaded reply permalinks from JSON bodies", async () => {
+    const ss = getSlackStore(store);
+    const ch = ss.channels.all()[0];
+
+    const parentRes = await app.request(`${base}/api/chat.postMessage`, {
+      method: "POST",
+      headers: authHeaders(),
+      body: JSON.stringify({ channel: ch.channel_id, text: "parent" }),
+    });
+    const parent = (await parentRes.json()) as any;
+
+    const replyRes = await app.request(`${base}/api/chat.postMessage`, {
+      method: "POST",
+      headers: authHeaders(),
+      body: JSON.stringify({ channel: ch.channel_id, text: "reply", thread_ts: parent.ts }),
+    });
+    const reply = (await replyRes.json()) as any;
+
+    const permalinkRes = await app.request(`${base}/api/chat.getPermalink`, {
+      method: "POST",
+      headers: authHeaders(),
+      body: JSON.stringify({ channel: ch.channel_id, message_ts: reply.ts }),
+    });
+    const permalink = (await permalinkRes.json()) as any;
+    expect(permalink.ok).toBe(true);
+    expect(permalink.permalink).toBe(
+      `${base}/archives/${ch.channel_id}/p${reply.ts.replace(".", "")}?thread_ts=${parent.ts}&cid=${ch.channel_id}`,
+    );
+  });
+
+  it("returns message_not_found for an unknown timestamp", async () => {
+    const ss = getSlackStore(store);
+    const ch = ss.channels.all()[0];
+
+    const res = await app.request(`${base}/api/chat.getPermalink`, {
+      method: "POST",
+      headers: authHeaders(),
+      body: JSON.stringify({ channel: ch.channel_id, message_ts: "1234567890.000001" }),
+    });
+    const body = (await res.json()) as any;
+    expect(body.ok).toBe(false);
+    expect(body.error).toBe("message_not_found");
+  });
+});
+
 describe("Slack plugin - conversations", () => {
   let app: SlackTestApp["app"];
   let store: Store;

packages/@emulators/slack/src/entities.ts

@@ -62,6 +62,7 @@ export interface SlackMessage extends Entity {
   app_id?: string;
   client_msg_id?: string;
   reply_broadcast?: boolean;
+  edited?: { user: string; ts: string };
   thread_ts?: string;
   reply_count: number;
   reply_users: string[];

packages/@emulators/slack/src/helpers.ts

@@ -100,12 +100,21 @@ export function formatSlackMessage(msg: SlackMessage) {
     ...(msg.unfurl_links !== undefined ? { unfurl_links: msg.unfurl_links } : {}),
     ...(msg.unfurl_media !== undefined ? { unfurl_media: msg.unfurl_media } : {}),
     ...(msg.reply_broadcast !== undefined ? { reply_broadcast: msg.reply_broadcast } : {}),
+    ...(msg.edited ? { edited: msg.edited } : {}),
     ...(msg.thread_ts ? { thread_ts: msg.thread_ts } : {}),
     ...(msg.reply_count > 0 ? { reply_count: msg.reply_count, reply_users: msg.reply_users } : {}),
     ...(msg.reactions.length > 0 ? { reactions: msg.reactions } : {}),
   };
 }
 
+export function formatSlackPermalink(baseUrl: string, channel: string, msg: SlackMessage): string {
+  const permalink = `${baseUrl.replace(/\/$/, "")}/archives/${channel}/p${msg.ts.replace(".", "")}`;
+  if (!msg.thread_ts || msg.thread_ts === msg.ts) return permalink;
+
+  const params = new URLSearchParams({ thread_ts: msg.thread_ts, cid: channel });
+  return `${permalink}?${params.toString()}`;
+}
+
 export function parseSlackRichMessageFields(body: Record<string, unknown>): SlackRichMessageParseResult {
   const fields: SlackRichMessageFields = {};
   const providedFields: SlackRichMessageFieldName[] = [];