feat(slack): handle global and message shortcuts (#94881)

steipete · web-flow · commit 341ae21d038c · 2026-06-19T14:12:30.000+01:00
Merged via squash. Prepared head SHA: 32dea12 Co-authored-by: steipete <58493+steipete@users.noreply.github.com> Reviewed-by: @steipete
diff --git a/docs/channels/slack.md b/docs/channels/slack.md
@@ -1409,10 +1409,14 @@ Same-chat `/approve` also works in Slack channels and DMs that already support c
 - `channel_id_changed` can migrate channel config keys when `configWrites` is enabled.
 - Channel topic/purpose metadata is treated as untrusted context and can be injected into routing context.
 - Thread starter and initial thread-history context seeding are filtered by configured sender allowlists when applicable.
-- Block actions and modal interactions emit structured `Slack interaction: ...` system events with rich payload fields:
+- Block actions, shortcuts, and modal interactions emit structured `Slack interaction: ...` system events with rich payload fields:
   - block actions: selected values, labels, picker values, and `workflow_*` metadata
+  - global shortcuts: callback and actor metadata, routed to the actor's direct session
+  - message shortcuts: callback, actor, channel, thread, and selected-message context
   - modal `view_submission` and `view_closed` events with routed channel metadata and form inputs
 
+Define global or message shortcuts in your Slack app configuration and use any non-empty callback ID. OpenClaw acknowledges matching shortcut payloads, applies the same DM/channel sender policy as other Slack interactions, and queues the sanitized event for the routed agent session. Trigger IDs and response URLs are redacted from agent context.
+
 ## Configuration reference
 
 Primary reference: [Configuration reference - Slack](/gateway/config-channels#slack).
diff --git a/extensions/slack/src/monitor/context.test.ts b/extensions/slack/src/monitor/context.test.ts
@@ -5,11 +5,13 @@ import type { RuntimeEnv } from "openclaw/plugin-sdk/runtime-env";
 import { describe, expect, it } from "vitest";
 import { createSlackMonitorContext } from "./context.js";
 
-function createTestContext() {
+function createTestContext(params?: {
+  dmScope?: "main" | "per-peer" | "per-channel-peer" | "per-account-channel-peer";
+}) {
   return createSlackMonitorContext({
     cfg: {
       channels: { slack: { enabled: true } },
-      session: { dmScope: "main" },
+      session: { dmScope: params?.dmScope ?? "main" },
     } as OpenClawConfig,
     accountId: "default",
     botToken: "xoxb-test",
@@ -98,4 +100,15 @@ describe("createSlackMonitorContext resolveSlackSystemEventSessionKey", () => {
       }),
     ).toBe("agent:main:slack:channel:c_thread:thread:1712345678.123456");
   });
+
+  it("routes channel-less direct interactions to the sender session", () => {
+    const ctx = createTestContext({ dmScope: "per-channel-peer" });
+
+    expect(
+      ctx.resolveSlackSystemEventSessionKey({
+        channelType: "im",
+        senderId: "U_SHORTCUT",
+      }),
+    ).toBe("agent:main:slack:direct:u_shortcut");
+  });
 });
diff --git a/extensions/slack/src/monitor/context.ts b/extensions/slack/src/monitor/context.ts
@@ -308,20 +308,19 @@ export function createSlackMonitorContext(params: {
     threadTs?: string | null;
   }) => {
     const channelId = normalizeOptionalString(p.channelId) ?? "";
-    if (!channelId) {
-      return params.mainKey;
-    }
+    const senderId = normalizeOptionalString(p.senderId) ?? "";
     const channelType = normalizeSlackChannelType(p.channelType, channelId);
     const isDirectMessage = channelType === "im";
+    if (!channelId && (!isDirectMessage || !senderId)) {
+      return params.mainKey;
+    }
     const isGroup = channelType === "mpim";
     const from = isDirectMessage
-      ? `slack:${channelId}`
+      ? `slack:${channelId || senderId}`
       : isGroup
         ? `slack:group:${channelId}`
         : `slack:channel:${channelId}`;
     const chatType = isDirectMessage ? "direct" : isGroup ? "group" : "channel";
-    const senderId = normalizeOptionalString(p.senderId) ?? "";
-
     // Resolve through shared channel/account bindings so system events route to
     // the same agent session as regular inbound messages.
     try {
diff --git a/extensions/slack/src/monitor/events/interactions.shortcuts.ts b/extensions/slack/src/monitor/events/interactions.shortcuts.ts
@@ -0,0 +1,136 @@
+// Slack plugin module implements shortcut interaction behavior.
+import type { GlobalShortcut, MessageShortcut, SlackShortcutMiddlewareArgs } from "@slack/bolt";
+import { requestHeartbeat } from "openclaw/plugin-sdk/heartbeat-runtime";
+import { enqueueSystemEvent } from "openclaw/plugin-sdk/system-event-runtime";
+import { authorizeSlackSystemEventSender } from "../auth.js";
+import type { SlackMonitorContext } from "../context.js";
+
+type SlackShortcutBody = GlobalShortcut | MessageShortcut;
+
+function resolveMessageThreadTs(body: MessageShortcut): string | undefined {
+  const threadTs = body.message.thread_ts;
+  return typeof threadTs === "string" && threadTs.trim() ? threadTs.trim() : undefined;
+}
+
+async function handleSlackShortcut(params: {
+  ctx: SlackMonitorContext;
+  trackEvent?: () => void;
+  args: SlackShortcutMiddlewareArgs;
+  formatSystemEvent: (payload: Record<string, unknown>) => string;
+}): Promise<void> {
+  const { ack, body } = params.args;
+  await ack();
+  if (params.ctx.shouldDropMismatchedSlackEvent?.(body)) {
+    params.ctx.runtime.log?.("slack:interaction drop shortcut payload (mismatched app/team)");
+    return;
+  }
+
+  const callbackId = body.callback_id?.trim();
+  const userId = body.user?.id?.trim();
+  if (!callbackId || !userId) {
+    params.ctx.runtime.log?.("slack:interaction drop shortcut reason=invalid-payload");
+    return;
+  }
+  params.trackEvent?.();
+
+  const isMessageShortcut = body.type === "message_action";
+  const messageBody = isMessageShortcut ? body : undefined;
+  const channelId = messageBody?.channel.id?.trim() || undefined;
+  if (isMessageShortcut && !channelId) {
+    params.ctx.runtime.log?.(
+      `slack:interaction drop shortcut callback=${callbackId} user=${userId} reason=missing-channel`,
+    );
+    return;
+  }
+  const threadTs = messageBody ? resolveMessageThreadTs(messageBody) : undefined;
+  const auth = await authorizeSlackSystemEventSender({
+    ctx: params.ctx,
+    senderId: userId,
+    channelId,
+    channelType: isMessageShortcut ? undefined : "im",
+    expectedSenderId: userId,
+    interactiveEvent: true,
+  });
+  if (!auth.allowed) {
+    params.ctx.runtime.log?.(
+      `slack:interaction drop shortcut callback=${callbackId} user=${userId} reason=${auth.reason ?? "unauthorized"}`,
+    );
+    return;
+  }
+
+  const interactionType = isMessageShortcut ? "message_shortcut" : "global_shortcut";
+  const messageTs = messageBody?.message.ts || messageBody?.message_ts;
+  const eventPayload = {
+    interactionType,
+    actionId: `shortcut:${callbackId}`,
+    callbackId,
+    userId,
+    teamId: body.team?.id ?? body.user.team_id,
+    triggerId: body.trigger_id,
+    actionTs: body.action_ts,
+    channelId,
+    channelName: messageBody?.channel.name,
+    messageTs,
+    threadTs,
+    messageUserId: messageBody?.message.user,
+    messageText: messageBody?.message.text,
+    responseUrl: messageBody?.response_url,
+  };
+  const sessionKey = params.ctx.resolveSlackSystemEventSessionKey({
+    channelId,
+    channelType: auth.channelType,
+    senderId: userId,
+    threadTs,
+  });
+  const contextKey = [
+    "slack:interaction:shortcut",
+    interactionType,
+    callbackId,
+    channelId,
+    messageTs,
+    body.action_ts,
+  ]
+    .filter(Boolean)
+    .join(":");
+
+  params.ctx.runtime.log?.(
+    `slack:interaction ${interactionType} callback=${callbackId} user=${userId} channel=${channelId ?? "direct"}`,
+  );
+  const queued = enqueueSystemEvent(params.formatSystemEvent(eventPayload), {
+    sessionKey,
+    contextKey,
+    deliveryContext: {
+      channel: "slack",
+      to: auth.channelType === "im" ? `user:${userId}` : `channel:${channelId}`,
+      accountId: params.ctx.accountId,
+      threadId: threadTs,
+    },
+  });
+  if (queued) {
+    requestHeartbeat({
+      source: "hook",
+      intent: "immediate",
+      reason: "hook:slack-interaction",
+      sessionKey,
+      heartbeat: { target: "last" },
+    });
+  }
+}
+
+export function registerSlackShortcutHandler(params: {
+  ctx: SlackMonitorContext;
+  trackEvent?: () => void;
+  formatSystemEvent: (payload: Record<string, unknown>) => string;
+}): void {
+  if (typeof params.ctx.app.shortcut !== "function") {
+    return;
+  }
+  params.ctx.app.shortcut(/.+/, async (args: SlackShortcutMiddlewareArgs<SlackShortcutBody>) => {
+    await handleSlackShortcut({
+      ctx: params.ctx,
+      trackEvent: params.trackEvent,
+      args,
+      formatSystemEvent: params.formatSystemEvent,
+    });
+  });
+}
diff --git a/extensions/slack/src/monitor/events/interactions.test.ts b/extensions/slack/src/monitor/events/interactions.test.ts
diff --git a/extensions/slack/src/monitor/events/interactions.ts b/extensions/slack/src/monitor/events/interactions.ts
