@open-everywhere/provider-slack 0.6.0 → 0.8.0

package/agent/channels/slack-follow-ups.ts

@@ -0,0 +1,148 @@
+// slack-follow-ups — a press on a suggested follow-up under an agent answer (OPE-2516).
+//
+// An answer in a 1:1 DM (the side panel included) can carry up to three follow-up buttons
+// (slack-reply-blocks.ts). Slack sends a press to the interactivity URL as a signed `block_actions`
+// payload whose action id starts `oe_followup:` and whose value is the button's text. The front route
+// classifies it (`slack-front.ts`, FrontDecision `followup-click`), runs the tenant fence, and then:
+//   1. marks the answer as answered: `chat.update` removes the button row and adds one line,
+//      "↳ You asked: <text>", so the conversation shows what the person sent and no second press
+//      can follow ({@link markFollowUpPressed});
+//   2. wakes the DM seat with the text as the person's next message ({@link followUpMessageEvent}),
+//      through the SAME `scheduleDmWake` road a typed DM takes — every gate on that road applies.
+//
+// 🔴 ONLY A 1:1 DM. A press counts only in a `D…` conversation, where the app and ONE person are the
+// only members, so the presser is the person the answer addressed. The choke point shows the buttons
+// nowhere else; this check is the backstop for a payload that names another conversation.
+//
+// 🔴 THE TEXT IS THE BUTTON'S OWN LABEL. Slack signs the payload and sends a `block_actions` only for
+// a block this app posted, so the value is the text this app wrote under the answer and the person
+// saw on the button. Core drops any follow-up too long to show whole, or holding a character that
+// draws nothing (`reply-follow-ups.ts`), and the parse below refuses both again.
+
+import type { ParsedMessageEvent } from "./slack-events.js";
+import { slackForm } from "./slack-events.js";
+import { SLACK_FOLLOW_UP_ACTION_PREFIX, SLACK_FOLLOW_UP_BLOCK_ID, SLACK_INVISIBLE_CHARACTER } from "./slack-reply-blocks.js";
+import { slackTsFromMs } from "./slack-shortcut.js";
+import { slackInteractivityTenantIds } from "./slack-tenant-fence.js";
+
+/** The longest value a press may carry: core's follow-up cap. A longer value is not one of ours. */
+const FOLLOW_UP_VALUE_MAX = 75;
+
+/** One parsed press on a follow-up button. IDS and the button's text only. */
+export interface ParsedSlackFollowUpClick {
+  readonly text: string;
+  readonly userId: string;
+  readonly channelId: string;
+  /** The answer the button sits under. */
+  readonly messageTs: string;
+  /** The answer's thread, when the answer sits in one (a side-panel or agent-session thread). */
+  readonly threadTs?: string;
+  readonly teamId?: string;
+  readonly enterpriseId?: string;
+  /** The answer's blocks as Slack sent them back, so the press can rewrite the message. */
+  readonly blocks?: readonly unknown[];
+  /** The answer's notification text, kept on the rewrite. */
+  readonly messageText?: string;
+}
+
+const obj = (v: unknown): Record<string, unknown> | undefined => (typeof v === "object" && v !== null ? (v as Record<string, unknown>) : undefined);
+const str = (v: unknown): string | undefined => (typeof v === "string" && v.length > 0 ? v : undefined);
+
+/**
+ * Parse a decoded interactivity payload into a follow-up press, or `undefined` when it is not one: not
+ * a `block_actions`, no `oe_followup:` action, an empty or over-long value, a conversation that is not
+ * a 1:1 DM, or a missing user, channel or message. Pure and total: it never throws.
+ */
+export function parseSlackFollowUpClick(payload: unknown): ParsedSlackFollowUpClick | undefined {
+  const p = obj(payload);
+  if (p?.type !== "block_actions" || !Array.isArray(p.actions)) return undefined;
+  const action = (p.actions as unknown[]).map(obj).find((a) => typeof a?.action_id === "string" && a.action_id.startsWith(SLACK_FOLLOW_UP_ACTION_PREFIX));
+  if (action === undefined) return undefined;
+  const text = str(action.value)?.trim();
+  if (text === undefined || text.length === 0 || Array.from(text).length > FOLLOW_UP_VALUE_MAX) return undefined;
+  // A value with a control or format character holds words no button shows, so it is not one of ours.
+  if (SLACK_INVISIBLE_CHARACTER.test(text)) return undefined;
+  const userId = str(obj(p.user)?.id);
+  const channelId = str(obj(p.channel)?.id) ?? str(obj(p.container)?.channel_id);
+  const message = obj(p.message);
+  const messageTs = str(message?.ts) ?? str(obj(p.container)?.message_ts);
+  if (userId === undefined || channelId === undefined || messageTs === undefined) return undefined;
+  if (!channelId.startsWith("D")) return undefined;
+  const threadTs = str(message?.thread_ts) ?? str(obj(p.container)?.thread_ts);
+  const { teamId, enterpriseId } = slackInteractivityTenantIds(p);
+  const blocks = Array.isArray(message?.blocks) ? (message.blocks as unknown[]) : undefined;
+  const messageText = str(message?.text);
+  return {
+    text,
+    userId,
+    channelId,
+    messageTs,
+    // A top-level answer names itself as its own thread root on some payloads: that is no thread.
+    ...(threadTs !== undefined && threadTs !== messageTs ? { threadTs } : {}),
+    ...(teamId === undefined ? {} : { teamId }),
+    ...(enterpriseId === undefined ? {} : { enterpriseId }),
+    ...(blocks === undefined ? {} : { blocks }),
+    ...(messageText === undefined ? {} : { messageText }),
+  };
+}
+
+/**
+ * The press as the person's next DM message. The ts is minted from the clock, as a global shortcut's
+ * is, because no Slack message stands behind the press. The thread is the answer's thread, so the
+ * answer to the follow-up lands where the answer it follows sits.
+ */
+export function followUpMessageEvent(click: ParsedSlackFollowUpClick, nowMs: number = Date.now()): ParsedMessageEvent {
+  return {
+    channelId: click.channelId,
+    ts: slackTsFromMs(nowMs),
+    ...(click.threadTs === undefined ? {} : { threadTs: click.threadTs }),
+    ...(click.teamId === undefined ? {} : { teamId: click.teamId }),
+    ...(click.enterpriseId === undefined ? {} : { enterpriseId: click.enterpriseId }),
+    userId: click.userId,
+    channelType: "im",
+    text: click.text,
+    // The person chose these words by pressing them, so they are the person's own text.
+    authoredText: click.text,
+    isAppMention: false,
+  };
+}
+
+/** The dedupe key of one press: one answer takes one press, so a double press or a redelivery wakes once. */
+export function followUpPressKey(click: ParsedSlackFollowUpClick): string {
+  return `slack-followup:${click.channelId}:${click.messageTs}`;
+}
+
+/** The line that replaces the buttons once the person pressed one. Plain text: it draws no mention. */
+export function followUpPressedLine(text: string): string {
+  return `↳ You asked: ${text}`;
+}
+
+/**
+ * The answer's blocks after a press: the follow-up row removed, and one context line naming what the
+ * person sent. `undefined` when the blocks hold no follow-up row — then there is nothing to rewrite.
+ */
+export function blocksAfterFollowUp(blocks: readonly unknown[], text: string): unknown[] | undefined {
+  const kept = blocks.filter((b) => obj(b)?.block_id !== SLACK_FOLLOW_UP_BLOCK_ID);
+  if (kept.length === blocks.length) return undefined;
+  return [...kept, { type: "context", elements: [{ type: "plain_text", text: followUpPressedLine(text), emoji: true }] }];
+}
+
+/**
+ * Rewrite the answer after a press (see the header). Answers whether Slack took the rewrite. Never
+ * throws: a refused rewrite costs only the line, never the person's message, which wakes regardless.
+ */
+export async function markFollowUpPressed(
+  click: ParsedSlackFollowUpClick,
+  form: (method: string, body: string) => Promise<Record<string, unknown> | undefined> = slackForm,
+): Promise<boolean> {
+  try {
+    const blocks = click.blocks === undefined ? undefined : blocksAfterFollowUp(click.blocks, click.text);
+    if (blocks === undefined) return false;
+    const body = new URLSearchParams({ channel: click.channelId, ts: click.messageTs, blocks: JSON.stringify(blocks) });
+    if (click.messageText !== undefined) body.set("text", click.messageText);
+    const res = await form("chat.update", body.toString());
+    return res?.ok === true;
+  } catch {
+    return false;
+  }
+}

package/agent/channels/slack-friendly-names.ts

@@ -0,0 +1,55 @@
+// slack-friendly-names — the Slack name resolver for the friendly-names guard (OPE-2482).
+//
+// The guard (core `channels/friendly-outbound.ts`) asks this resolver for a display name before it
+// renders a raw Slack id in text a person reads. A member id answers the person's display name, a
+// channel id answers `#name`, and the workspace id answers the install's recorded team name. Every
+// lookup rides a cache that already exists (`users.info`, `conversations.info`), so a name costs one
+// Slack call per id per instance. Any failure answers undefined: the id then renders as a mention or
+// plain words, never as itself.
+
+import type { FriendlyNameResolver } from "@open-everywhere/core/agent/adapter-api.js";
+import { fetchChannelDisplayName, fetchUserDisplayName } from "./slack-events.js";
+import { slackInstallState } from "../setup/install-state.js";
+
+/** The lookups the resolver uses. Live code passes none; a test injects each. */
+export interface SlackFriendlyNameDeps {
+  readonly userName?: (id: string) => Promise<string | undefined>;
+  readonly channelName?: (id: string) => Promise<string | undefined>;
+  readonly teamName?: (id: string) => Promise<string | undefined>;
+}
+
+// The install record is read at most once per TEAM_NAME_TTL_MS, and only a FOUND name is kept: a post
+// path must not read the store per message, and a deployment that installs (or renames its workspace)
+// after boot must still be named without a restart.
+const TEAM_NAME_TTL_MS = 30 * 60_000;
+let teamNameMemo: { readonly teamId: string; readonly name: string; readonly at: number } | undefined;
+
+/** The workspace name, when the recorded install is that workspace. */
+async function liveTeamName(id: string): Promise<string | undefined> {
+  if (teamNameMemo && teamNameMemo.teamId === id && Date.now() - teamNameMemo.at < TEAM_NAME_TTL_MS) return teamNameMemo.name;
+  const install = await slackInstallState().catch(() => undefined);
+  if (install?.teamId === id && install.teamName) {
+    teamNameMemo = { teamId: id, name: install.teamName, at: Date.now() };
+    return install.teamName;
+  }
+  return undefined;
+}
+
+/** Build the Slack resolver. */
+export function slackFriendlyNameResolver(deps: SlackFriendlyNameDeps = {}): FriendlyNameResolver {
+  return async (id) => {
+    if (/^[UW]/.test(id)) {
+      const name = await (deps.userName ?? fetchUserDisplayName)(id);
+      return name ? { label: name, kind: "person" } : undefined;
+    }
+    if (/^[CG]/.test(id)) {
+      const name = await (deps.channelName ?? fetchChannelDisplayName)(id);
+      return name ? { label: `#${name.replace(/^#/, "")}`, kind: "channel" } : undefined;
+    }
+    if (/^T/.test(id)) {
+      const name = await (deps.teamName ?? liveTeamName)(id);
+      return name ? { label: name, kind: "server" } : undefined;
+    }
+    return undefined;
+  };
+}