@gugu910/pi-slack-bridge 0.1.3

package/dist/reaction-triggers.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_REACTION_COMMANDS = void 0;
+exports.normalizeReactionName = normalizeReactionName;
+exports.resolveReactionCommands = resolveReactionCommands;
+exports.formatReactionDisplay = formatReactionDisplay;
+exports.buildReactionTriggerMessage = buildReactionTriggerMessage;
+exports.buildReactionPromptGuidelines = buildReactionPromptGuidelines;
+const REACTION_ALIASES = {
+    "📝": "memo",
+    memo: "memo",
+    "🐛": "bug",
+    bug: "bug",
+    "🔍": "mag",
+    mag: "mag",
+    mag_right: "mag_right",
+    "📌": "pushpin",
+    pushpin: "pushpin",
+    "🌐": "globe_with_meridians",
+    globe_with_meridians: "globe_with_meridians",
+    "🔄": "repeat",
+    repeat: "repeat",
+    "👀": "eyes",
+    eyes: "eyes",
+    "✅": "white_check_mark",
+    white_check_mark: "white_check_mark",
+};
+const REACTION_DISPLAY = {
+    memo: "📝",
+    bug: "🐛",
+    mag: "🔍",
+    mag_right: "🔎",
+    pushpin: "📌",
+    globe_with_meridians: "🌐",
+    repeat: "🔄",
+    eyes: "👀",
+    white_check_mark: "✅",
+};
+exports.DEFAULT_REACTION_COMMANDS = {
+    memo: {
+        action: "summarize",
+        prompt: "Summarize the reacted-to message and the surrounding thread. Focus on key decisions, action items, and open questions.",
+    },
+    bug: {
+        action: "file-issue",
+        prompt: "Turn the reacted-to message or thread into a GitHub issue. Capture the problem, context, reproduction clues, and a sensible next step.",
+    },
+    eyes: {
+        action: "review",
+        prompt: "Review the referenced message, code, or work item and report what needs attention. If the context points to a PR or diff, review that artifact.",
+    },
+    white_check_mark: {
+        action: "approve",
+        prompt: "Evaluate whether the referenced work should be approved. If it looks good, say so clearly and note any final caveats.",
+    },
+    repeat: {
+        action: "retry",
+        prompt: "Retry or regenerate the requested work using the reacted message and surrounding thread as the source of truth.",
+    },
+    mag: {
+        action: "search",
+        prompt: "Search the codebase for code related to the reacted message and report the most relevant files or findings.",
+    },
+    pushpin: {
+        action: "track",
+        prompt: "Treat the reacted message as something to preserve and track. Pin or record it in the most appropriate project artifact, such as a Slack canvas.",
+    },
+    globe_with_meridians: {
+        action: "fetch-url",
+        prompt: "If the reacted message contains a URL, fetch the linked page and summarize the important information for the user.",
+    },
+};
+function normalizeReactionNameOrNull(input) {
+    const trimmed = input.trim();
+    if (!trimmed)
+        return null;
+    const withoutColons = trimmed.replace(/^:+|:+$/g, "").toLowerCase();
+    return (REACTION_ALIASES[trimmed] ??
+        REACTION_ALIASES[withoutColons] ??
+        (/^[a-z0-9_+-]+$/.test(withoutColons) ? withoutColons : null));
+}
+function normalizeReactionName(input) {
+    const normalized = normalizeReactionNameOrNull(input);
+    if (!normalized) {
+        throw new Error(`Unsupported reaction ${JSON.stringify(input)}. Use a Slack reaction name like "eyes" or a supported emoji such as 👀, ✅, 🔄, 📝, or 🐛.`);
+    }
+    return normalized;
+}
+function buildDefaultPromptForAction(action) {
+    switch (action) {
+        case "summarize":
+            return exports.DEFAULT_REACTION_COMMANDS.memo.prompt;
+        case "file-issue":
+            return exports.DEFAULT_REACTION_COMMANDS.bug.prompt;
+        case "review":
+            return exports.DEFAULT_REACTION_COMMANDS.eyes.prompt;
+        case "approve":
+            return exports.DEFAULT_REACTION_COMMANDS.white_check_mark.prompt;
+        case "retry":
+            return exports.DEFAULT_REACTION_COMMANDS.repeat.prompt;
+        case "search":
+            return exports.DEFAULT_REACTION_COMMANDS.mag.prompt;
+        case "track":
+            return exports.DEFAULT_REACTION_COMMANDS.pushpin.prompt;
+        case "fetch-url":
+            return exports.DEFAULT_REACTION_COMMANDS.globe_with_meridians.prompt;
+        default:
+            return `Carry out the "${action}" action for the reacted Slack message or thread, using the included context before you decide what to do.`;
+    }
+}
+function resolveReactionCommands(settings) {
+    const resolved = new Map(Object.entries(exports.DEFAULT_REACTION_COMMANDS));
+    if (!settings) {
+        return resolved;
+    }
+    for (const [rawReaction, config] of Object.entries(settings)) {
+        const normalizedReaction = normalizeReactionNameOrNull(rawReaction);
+        if (!normalizedReaction)
+            continue;
+        if (typeof config === "string") {
+            resolved.set(normalizedReaction, {
+                action: config,
+                prompt: buildDefaultPromptForAction(config),
+            });
+            continue;
+        }
+        if (!config || typeof config !== "object")
+            continue;
+        const action = config.action?.trim() || resolved.get(normalizedReaction)?.action || normalizedReaction;
+        const prompt = config.prompt?.trim() || buildDefaultPromptForAction(action);
+        resolved.set(normalizedReaction, { action, prompt });
+    }
+    return resolved;
+}
+function formatReactionDisplay(reactionName) {
+    return `${REACTION_DISPLAY[reactionName] ?? `:${reactionName}:`} (:${reactionName}:)`;
+}
+function buildReactionTriggerMessage(input) {
+    const reactedMessageText = input.reactedMessageText.trim() || "(no text)";
+    return [
+        "Reaction trigger from Slack:",
+        `- reaction: ${formatReactionDisplay(input.reactionName)}`,
+        `- action: ${input.command.action}`,
+        `- reactor: ${input.reactorName}`,
+        `- channel: <#${input.channel}>`,
+        `- thread_ts: ${input.threadTs}`,
+        `- message_ts: ${input.messageTs}`,
+        `- reacted_message_author: ${input.reactedMessageAuthor}`,
+        `- reacted_message_text: ${reactedMessageText}`,
+        "",
+        `Requested action: ${input.command.prompt}`,
+        "Treat this reaction as an explicit user request, but still verify context before acting.",
+    ].join("\n");
+}
+function buildReactionPromptGuidelines() {
+    return [
+        "Reaction-triggered requests may appear in your Slack inbox as structured 'Reaction trigger from Slack:' messages.",
+        "Treat them as explicit user requests keyed off emoji reactions. Use the included action, reacted message text, and thread context to decide what to do.",
+    ];
+}

package/dist/scheduled-wakeups.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseScheduledWakeupDelay = parseScheduledWakeupDelay;
+exports.resolveScheduledWakeupFireAt = resolveScheduledWakeupFireAt;
+exports.buildScheduledWakeupThreadId = buildScheduledWakeupThreadId;
+exports.buildScheduledWakeupMetadata = buildScheduledWakeupMetadata;
+const DELAY_UNITS_MS = {
+    ms: 1,
+    s: 1_000,
+    m: 60_000,
+    h: 60 * 60_000,
+    d: 24 * 60 * 60_000,
+};
+function parseScheduledWakeupDelay(delay) {
+    const normalized = delay.trim().toLowerCase().replace(/\s+/g, "");
+    if (!normalized) {
+        return null;
+    }
+    const tokenRegex = /(\d+)(ms|s|m|h|d)/g;
+    let totalMs = 0;
+    let matchedLength = 0;
+    for (const match of normalized.matchAll(tokenRegex)) {
+        const [token, amountText, unit] = match;
+        if (!token || !amountText || !unit || match.index !== matchedLength) {
+            return null;
+        }
+        const amount = Number.parseInt(amountText, 10);
+        if (!Number.isFinite(amount) || amount < 0) {
+            return null;
+        }
+        totalMs += amount * DELAY_UNITS_MS[unit];
+        matchedLength += token.length;
+    }
+    if (matchedLength !== normalized.length || totalMs <= 0) {
+        return null;
+    }
+    return totalMs;
+}
+function resolveScheduledWakeupFireAt(input, now = Date.now()) {
+    const hasDelay = typeof input.delay === "string" && input.delay.trim().length > 0;
+    const hasAt = typeof input.at === "string" && input.at.trim().length > 0;
+    if (hasDelay === hasAt) {
+        throw new Error("Provide exactly one of delay or at.");
+    }
+    if (hasDelay) {
+        const delayMs = parseScheduledWakeupDelay(input.delay);
+        if (delayMs == null) {
+            throw new Error("Invalid delay. Use values like 5m, 30s, 1h30m, or 1d.");
+        }
+        return new Date(now + delayMs).toISOString();
+    }
+    const fireAtMs = Date.parse(input.at);
+    if (Number.isNaN(fireAtMs)) {
+        throw new Error("Invalid timestamp. Use an ISO-8601 time like 2026-04-02T14:30:00Z.");
+    }
+    if (fireAtMs <= now) {
+        throw new Error("Scheduled wake-up time must be in the future.");
+    }
+    return new Date(fireAtMs).toISOString();
+}
+function buildScheduledWakeupThreadId(agentId) {
+    return `wakeup:${agentId}`;
+}
+function buildScheduledWakeupMetadata(wakeupId, fireAt) {
+    return {
+        senderAgent: "Pinet Scheduler",
+        scheduledWakeup: true,
+        wakeupId,
+        fireAt,
+    };
+}

package/dist/slack-api.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callSlackApi = void 0;
+var helpers_js_1 = require("./helpers.js");
+Object.defineProperty(exports, "callSlackApi", { enumerable: true, get: function () { return helpers_js_1.callSlackAPI; } });

package/dist/slack-block-kit.js

@@ -0,0 +1,425 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeSlackBlocksInput = normalizeSlackBlocksInput;
+exports.summarizeSlackBlocksForPolicy = summarizeSlackBlocksForPolicy;
+exports.encodeSlackBlockActionValue = encodeSlackBlockActionValue;
+exports.buildSlackBlockKitPromptGuidelines = buildSlackBlockKitPromptGuidelines;
+exports.buildSlackBlocksTemplate = buildSlackBlocksTemplate;
+exports.extractSlackInteractivePayloadFromEnvelope = extractSlackInteractivePayloadFromEnvelope;
+exports.extractSlackBlockActionsPayloadFromEnvelope = extractSlackBlockActionsPayloadFromEnvelope;
+exports.normalizeSlackBlockActionPayload = normalizeSlackBlockActionPayload;
+exports.normalizeSlackViewSubmissionPayload = normalizeSlackViewSubmissionPayload;
+exports.normalizeSlackInteractivePayload = normalizeSlackInteractivePayload;
+const slack_modals_js_1 = require("./slack-modals.js");
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asString(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function asRecord(value) {
+    return isRecord(value) ? value : undefined;
+}
+function asRecordArray(value) {
+    if (!Array.isArray(value) || value.some((item) => !isRecord(item))) {
+        throw new Error("Slack blocks must be a JSON array of objects.");
+    }
+    return value;
+}
+function tryParseJson(value) {
+    if (!value)
+        return undefined;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function normalizeViewStateValue(value) {
+    const result = {};
+    if (typeof value.type === "string") {
+        result.type = value.type;
+    }
+    if (typeof value.value === "string") {
+        result.value = value.value;
+    }
+    if (typeof value.selected_date === "string") {
+        result.selectedDate = value.selected_date;
+    }
+    if (typeof value.selected_time === "string") {
+        result.selectedTime = value.selected_time;
+    }
+    if (typeof value.selected_conversation === "string") {
+        result.selectedConversation = value.selected_conversation;
+    }
+    if (typeof value.selected_channel === "string") {
+        result.selectedChannel = value.selected_channel;
+    }
+    if (typeof value.selected_user === "string") {
+        result.selectedUser = value.selected_user;
+    }
+    if (typeof value.selected_option === "object" && value.selected_option !== null) {
+        result.selectedOption = value.selected_option;
+    }
+    if (Array.isArray(value.selected_options)) {
+        result.selectedOptions = value.selected_options;
+    }
+    if (Array.isArray(value.selected_conversations)) {
+        result.selectedConversations = value.selected_conversations;
+    }
+    if (Array.isArray(value.selected_channels)) {
+        result.selectedChannels = value.selected_channels;
+    }
+    if (Array.isArray(value.selected_users)) {
+        result.selectedUsers = value.selected_users;
+    }
+    return result;
+}
+function joinNonEmpty(parts) {
+    return parts.filter((part) => Boolean(part && part.trim())).join("\n\n");
+}
+function buildHeaderBlock(title) {
+    if (!title?.trim())
+        return [];
+    return [
+        {
+            type: "header",
+            text: {
+                type: "plain_text",
+                text: title.trim().slice(0, 150),
+            },
+        },
+    ];
+}
+function buildSectionBlock(text) {
+    if (!text?.trim())
+        return [];
+    return [
+        {
+            type: "section",
+            text: {
+                type: "mrkdwn",
+                text: text.trim(),
+            },
+        },
+    ];
+}
+function buildFooterBlocks(footer) {
+    if (!footer?.trim())
+        return [];
+    return [
+        { type: "divider" },
+        {
+            type: "context",
+            elements: [{ type: "mrkdwn", text: footer.trim() }],
+        },
+    ];
+}
+function prefixDiffLines(text, prefix) {
+    return text
+        .split("\n")
+        .map((line) => `${prefix}${line}`)
+        .join("\n");
+}
+function getActionText(action) {
+    const text = asRecord(action.text);
+    return asString(text?.text);
+}
+function normalizeAction(action) {
+    const actionId = asString(action.action_id);
+    if (!actionId)
+        return null;
+    const value = asString(action.value);
+    return {
+        actionId,
+        blockId: asString(action.block_id),
+        text: getActionText(action),
+        type: asString(action.type),
+        style: asString(action.style),
+        value,
+        parsedValue: tryParseJson(value),
+        actionTs: asString(action.action_ts),
+    };
+}
+function sanitizeNormalizedActions(actions) {
+    return actions.map((action) => ({
+        actionId: action.actionId,
+        blockId: action.blockId ?? null,
+        text: action.text ?? null,
+        type: action.type ?? null,
+        style: action.style ?? null,
+        value: action.value ?? null,
+        parsedValue: action.parsedValue ?? null,
+        actionTs: action.actionTs ?? null,
+    }));
+}
+function normalizeSlackBlocksInput(blocks) {
+    return asRecordArray(blocks).map((block) => ({ ...block }));
+}
+function summarizeSlackBlocksForPolicy(blocks) {
+    if (!Array.isArray(blocks))
+        return "0";
+    return String(blocks.length);
+}
+function encodeSlackBlockActionValue(value) {
+    if (typeof value === "string")
+        return value;
+    return JSON.stringify(value);
+}
+function buildSlackBlockKitPromptGuidelines() {
+    return [
+        "Slack supports an optional blocks parameter for rich Block Kit messages. text stays required as fallback / notification text.",
+        "Use slack_blocks_build when you want a template-generated blocks array instead of hand-writing JSON.",
+        "A block kit payload is a JSON array of block objects, for example:",
+        '[{"type":"section","text":{"type":"mrkdwn","text":"*Deploy complete*\\nBranch: `main`"}},{"type":"actions","elements":[{"type":"button","text":{"type":"plain_text","text":"Rollback"},"action_id":"deploy.rollback","style":"danger","value":"rollback:prod"}]}]',
+        "Button actions should set stable action_id values. Put machine-readable context in the button value string (plain text or JSON string).",
+    ];
+}
+function buildSlackBlocksTemplate(input) {
+    switch (input.template) {
+        case "code_snippet": {
+            if (!input.code?.trim()) {
+                throw new Error('Template "code_snippet" requires a non-empty code value.');
+            }
+            const language = input.language?.trim() || "text";
+            const codeFence = `\`\`\`${language}\n${input.code.trim()}\n\`\`\``;
+            const blocks = [
+                ...buildHeaderBlock(input.title ?? "Code snippet"),
+                ...buildSectionBlock(joinNonEmpty([input.text, codeFence])),
+                ...buildFooterBlocks(input.footer),
+            ];
+            return {
+                blocks,
+                fallbackText: joinNonEmpty([input.title ?? "Code snippet", input.text, input.code]),
+            };
+        }
+        case "status_report": {
+            if (!input.title?.trim()) {
+                throw new Error('Template "status_report" requires a title.');
+            }
+            const fields = (input.fields ?? []).slice(0, 10).map((field) => ({
+                type: "mrkdwn",
+                text: `*${field.label.trim()}*\n${field.value.trim()}`,
+            }));
+            const blocks = [
+                ...buildHeaderBlock(input.title),
+                ...buildSectionBlock(input.text),
+            ];
+            if (fields.length > 0) {
+                blocks.push({ type: "section", fields });
+            }
+            blocks.push(...buildFooterBlocks(input.footer));
+            const fieldLines = (input.fields ?? []).map((field) => `${field.label}: ${field.value}`);
+            return {
+                blocks,
+                fallbackText: joinNonEmpty([input.title, input.text, fieldLines.join("\n"), input.footer]),
+            };
+        }
+        case "action_buttons": {
+            if (!input.text?.trim()) {
+                throw new Error('Template "action_buttons" requires text.');
+            }
+            const buttons = (input.buttons ?? []).map((button) => {
+                const element = {
+                    type: "button",
+                    text: { type: "plain_text", text: button.text.trim().slice(0, 75) },
+                    action_id: button.action_id.trim(),
+                };
+                if (button.value)
+                    element.value = button.value;
+                if (button.style)
+                    element.style = button.style;
+                if (button.url)
+                    element.url = button.url;
+                return element;
+            });
+            if (buttons.length === 0) {
+                throw new Error('Template "action_buttons" requires at least one button.');
+            }
+            const blocks = [
+                ...buildHeaderBlock(input.title),
+                ...buildSectionBlock(input.text),
+                { type: "actions", elements: buttons },
+                ...buildFooterBlocks(input.footer),
+            ];
+            return {
+                blocks,
+                fallbackText: joinNonEmpty([
+                    input.title,
+                    input.text,
+                    `Actions: ${buttons
+                        .map((button) => String(button.text.text ?? "action"))
+                        .join(", ")}`,
+                ]),
+            };
+        }
+        case "diff_view": {
+            if (!input.before?.trim() && !input.after?.trim()) {
+                throw new Error('Template "diff_view" requires before and/or after text.');
+            }
+            const removed = input.before?.trim()
+                ? `*Removed*\n\`\`\`diff\n${prefixDiffLines(input.before.trim(), "-")}\n\`\`\``
+                : undefined;
+            const added = input.after?.trim()
+                ? `*Added*\n\`\`\`diff\n${prefixDiffLines(input.after.trim(), "+")}\n\`\`\``
+                : undefined;
+            const blocks = [
+                ...buildHeaderBlock(input.title ?? "Diff view"),
+                ...buildSectionBlock(joinNonEmpty([input.text, removed, added])),
+                ...buildFooterBlocks(input.footer),
+            ];
+            return {
+                blocks,
+                fallbackText: joinNonEmpty([
+                    input.title ?? "Diff view",
+                    input.text,
+                    input.before,
+                    input.after,
+                ]),
+            };
+        }
+        default:
+            throw new Error(`Unknown block template ${JSON.stringify(input.template)}. Use one of: code_snippet, status_report, action_buttons, diff_view.`);
+    }
+}
+function extractSlackInteractivePayloadFromEnvelope(envelope) {
+    if (envelope.type !== "interactive")
+        return null;
+    const payloadValue = envelope.payload;
+    let payload = payloadValue;
+    if (typeof payloadValue === "string") {
+        try {
+            payload = JSON.parse(payloadValue);
+        }
+        catch {
+            return null;
+        }
+    }
+    if (!isRecord(payload))
+        return null;
+    return payload;
+}
+function extractSlackBlockActionsPayloadFromEnvelope(envelope) {
+    const payload = extractSlackInteractivePayloadFromEnvelope(envelope);
+    return payload?.type === "block_actions" ? payload : null;
+}
+function normalizeSlackBlockActionPayload(payload) {
+    const user = asRecord(payload.user);
+    const container = asRecord(payload.container);
+    const channel = asRecord(payload.channel);
+    const message = asRecord(payload.message);
+    const view = asRecord(payload.view);
+    const actions = Array.isArray(payload.actions)
+        ? payload.actions
+            .map((entry) => asRecord(entry))
+            .filter((entry) => Boolean(entry))
+        : [];
+    const normalizedActions = actions
+        .map(normalizeAction)
+        .filter((action) => Boolean(action));
+    if (normalizedActions.length === 0)
+        return null;
+    const modalMetadata = (0, slack_modals_js_1.decodeSlackModalPrivateMetadata)(asString(view?.private_metadata));
+    const channelId = asString(container?.channel_id) ??
+        asString(channel?.id) ??
+        asString(message?.channel?.id) ??
+        modalMetadata.threadContext?.channel;
+    const messageTs = asString(container?.message_ts) ?? asString(message?.ts);
+    const threadTs = asString(container?.thread_ts) ??
+        asString(message?.thread_ts) ??
+        messageTs ??
+        modalMetadata.threadContext?.threadTs;
+    const userId = asString(user?.id);
+    if (!channelId || !threadTs || !userId)
+        return null;
+    const primaryAction = normalizedActions[0];
+    const label = primaryAction.text?.trim() ? `"${primaryAction.text.trim()}"` : "button";
+    const timestamp = primaryAction.actionTs ??
+        asString(payload.action_ts) ??
+        asString(view?.hash) ??
+        messageTs ??
+        threadTs;
+    return {
+        channel: channelId,
+        threadTs,
+        userId,
+        text: `Clicked Slack ${label} (action_id: ${primaryAction.actionId}).`,
+        timestamp,
+        metadata: {
+            kind: "slack_block_action",
+            triggerId: asString(payload.trigger_id) ?? null,
+            viewId: asString(view?.id) ?? null,
+            callbackId: asString(view?.callback_id) ?? null,
+            viewHash: asString(view?.hash) ?? null,
+            blockId: primaryAction.blockId ?? null,
+            actionId: primaryAction.actionId,
+            value: primaryAction.value ?? null,
+            parsedValue: primaryAction.parsedValue ?? null,
+            actionText: primaryAction.text ?? null,
+            channel: channelId,
+            threadTs,
+            messageTs: messageTs ?? null,
+            modalPrivateMetadata: modalMetadata.value ?? null,
+            actions: sanitizeNormalizedActions(normalizedActions),
+        },
+    };
+}
+function normalizeSlackViewSubmissionPayload(payload) {
+    if (payload.type !== "view_submission") {
+        return null;
+    }
+    const user = asRecord(payload.user);
+    const view = asRecord(payload.view);
+    const state = asRecord(view?.state);
+    const stateValues = asRecord(state?.values);
+    const userId = asString(user?.id);
+    const viewId = asString(view?.id);
+    const modalMetadata = (0, slack_modals_js_1.decodeSlackModalPrivateMetadata)(asString(view?.private_metadata));
+    const threadTs = modalMetadata.threadContext?.threadTs;
+    const channel = modalMetadata.threadContext?.channel;
+    if (!userId || !threadTs || !channel || !viewId || !stateValues) {
+        return null;
+    }
+    const normalizedValues = {};
+    for (const [blockId, rawActions] of Object.entries(stateValues)) {
+        const actionMap = asRecord(rawActions);
+        if (!actionMap)
+            continue;
+        normalizedValues[blockId] = Object.fromEntries(Object.entries(actionMap).map(([actionId, rawValue]) => [
+            actionId,
+            normalizeViewStateValue(asRecord(rawValue) ?? {}),
+        ]));
+    }
+    const callbackId = asString(view?.callback_id);
+    const titleText = asString((asRecord(view?.title) ?? {}).text);
+    const timestamp = asString(payload.hash) ?? viewId;
+    return {
+        channel,
+        threadTs,
+        userId,
+        text: `Submitted Slack modal ${callbackId ? `(${callbackId}) ` : ""}${titleText ? `"${titleText}"` : `view ${viewId}`}.`,
+        timestamp,
+        metadata: {
+            kind: "slack_view_submission",
+            triggerId: asString(payload.trigger_id) ?? null,
+            callbackId: callbackId ?? null,
+            viewId,
+            externalId: asString(view?.external_id) ?? null,
+            viewHash: asString(view?.hash) ?? null,
+            channel,
+            threadTs,
+            privateMetadata: modalMetadata.value ?? null,
+            stateValues: normalizedValues,
+        },
+    };
+}
+function normalizeSlackInteractivePayload(payload) {
+    if (payload.type === "block_actions") {
+        return normalizeSlackBlockActionPayload(payload);
+    }
+    if (payload.type === "view_submission") {
+        return normalizeSlackViewSubmissionPayload(payload);
+    }
+    return null;
+}