paperclip-plugin-slack-socket 0.1.0

package/dist/chat.js

@@ -0,0 +1,184 @@
+import { STATE_KEYS, stateScope } from "./constants.js";
+import { markdownToMrkdwn } from "./mrkdwn.js";
+import { errString } from "./redact.js";
+import { updateIndex } from "./state-index.js";
+// Slack's chat.update rejects payloads with roughly >4000-character text.
+// Stay comfortably under that for both the rolling streamed update and each
+// chunk of an overlong final reply.
+const MAX_MESSAGE_LENGTH = 3900;
+function truncateForStreaming(text) {
+    return text.length > MAX_MESSAGE_LENGTH ? `${text.slice(0, MAX_MESSAGE_LENGTH)}…` : text;
+}
+function splitIntoChunks(text, size) {
+    const chunks = [];
+    for (let i = 0; i < text.length; i += size)
+        chunks.push(text.slice(i, i + size));
+    return chunks;
+}
+export function createChat(deps) {
+    const { ctx, gateway, getConfig } = deps;
+    const updateIntervalMs = deps.updateIntervalMs ?? 1000;
+    // Guards against two concurrent "first messages" in the same thread both
+    // passing the "no existing session" check and creating duplicate sessions.
+    const inFlightSessions = new Map();
+    function stripMention(text) {
+        const botId = gateway.botUserId();
+        return (botId ? text.replaceAll(`<@${botId}>`, "") : text).trim();
+    }
+    async function getOrCreateSession(cfg, channel, threadTs) {
+        const key = STATE_KEYS.session(channel, threadTs);
+        const inFlight = inFlightSessions.get(key);
+        if (inFlight)
+            return inFlight;
+        const promise = (async () => {
+            const existing = (await ctx.state.get(stateScope(key)));
+            if (existing) {
+                const updated = { ...existing, lastActivityAt: new Date().toISOString() };
+                await ctx.state.set(stateScope(key), updated);
+                return updated;
+            }
+            const session = await ctx.agents.sessions.create(cfg.defaultAgentId, cfg.companyId, {
+                reason: "slack-thread",
+            });
+            const entry = {
+                sessionId: session.sessionId,
+                channel,
+                threadTs,
+                lastActivityAt: new Date().toISOString(),
+            };
+            await ctx.state.set(stateScope(key), entry);
+            await updateIndex(ctx, STATE_KEYS.sessionIndex, (current) => current.includes(key) ? current : [...current, key]);
+            return entry;
+        })();
+        inFlightSessions.set(key, promise);
+        try {
+            return await promise;
+        }
+        finally {
+            inFlightSessions.delete(key);
+        }
+    }
+    async function streamReply(cfg, entry, channel, threadTs, prompt) {
+        const placeholder = await gateway.postMessage({ channel, threadTs, text: "_Thinking…_" });
+        let buffer = "";
+        let timer = null;
+        let updateChain = Promise.resolve();
+        const pushUpdate = (text) => {
+            const truncated = truncateForStreaming(text);
+            updateChain = updateChain
+                .then(() => gateway.updateMessage({ channel: placeholder.channel, ts: placeholder.ts, text: truncated }))
+                .catch((err) => ctx.logger.warn("Slack chat.update failed", { err: errString(err) }));
+        };
+        // Final reply: update the placeholder with the first MAX_MESSAGE_LENGTH
+        // chars and, if the reply is longer than that, post the remainder as
+        // additional messages in the same thread rather than silently truncating.
+        const finalizeMessage = (text) => {
+            const chunks = splitIntoChunks(text, MAX_MESSAGE_LENGTH);
+            const first = chunks[0] ?? (text || "_(no reply)_");
+            const rest = chunks.slice(1);
+            updateChain = updateChain
+                .then(() => gateway.updateMessage({ channel: placeholder.channel, ts: placeholder.ts, text: first }))
+                .then(async () => {
+                for (const extra of rest) {
+                    await gateway.postMessage({ channel: placeholder.channel, threadTs, text: extra });
+                }
+            })
+                .catch((err) => ctx.logger.warn("Slack chat.update failed", { err: errString(err) }));
+        };
+        const clearPendingTimer = () => {
+            if (timer) {
+                clearTimeout(timer);
+                timer = null;
+            }
+        };
+        const scheduleUpdate = () => {
+            if (timer)
+                return;
+            timer = setTimeout(() => {
+                timer = null;
+                // Convert Markdown -> Slack mrkdwn before truncation so the 3900
+                // char limit applies to the text Slack will actually render.
+                if (buffer)
+                    pushUpdate(markdownToMrkdwn(buffer));
+            }, updateIntervalMs);
+        };
+        await new Promise((resolve) => {
+            ctx.agents.sessions
+                .sendMessage(entry.sessionId, cfg.companyId, {
+                prompt,
+                onEvent: (event) => {
+                    const e = event;
+                    if (e.eventType === "chunk" && e.stream === "stdout" && e.message) {
+                        buffer += e.message;
+                        scheduleUpdate();
+                    }
+                    else if (e.eventType === "done") {
+                        clearPendingTimer();
+                        // Convert before finalizeMessage's split/truncate so the
+                        // 3900-char limit is applied to the mrkdwn-converted text.
+                        finalizeMessage(markdownToMrkdwn(e.message ?? (buffer || "_(no reply)_")));
+                        resolve();
+                    }
+                    else if (e.eventType === "error") {
+                        clearPendingTimer();
+                        pushUpdate(`:warning: Agent error: ${e.message ?? "unknown error"}`);
+                        resolve();
+                    }
+                },
+            })
+                .catch((err) => {
+                // Clear any pending chunk-scheduled update so it can't fire later
+                // and overwrite this error message with a stale partial buffer.
+                clearPendingTimer();
+                pushUpdate(`:warning: Failed to reach the agent: ${errString(err)}`);
+                resolve();
+            });
+        });
+        await updateChain;
+    }
+    async function converse(msg) {
+        const threadTs = msg.threadTs ?? msg.ts;
+        try {
+            const cfg = await getConfig();
+            const prompt = stripMention(msg.text);
+            if (!prompt)
+                return;
+            const entry = await getOrCreateSession(cfg, msg.channel, threadTs);
+            await streamReply(cfg, entry, msg.channel, threadTs, prompt);
+        }
+        catch (err) {
+            ctx.logger.error("Slack chat failed", { err: errString(err), channel: msg.channel });
+            await gateway
+                .postMessage({
+                channel: msg.channel,
+                threadTs,
+                text: ":warning: Sorry — something went wrong talking to the agent. Please try again.",
+            })
+                .catch(() => { });
+        }
+    }
+    return {
+        async handleMention(msg) {
+            await converse(msg);
+        },
+        async handleMessage(msg) {
+            const botId = gateway.botUserId();
+            if (botId && msg.text.includes(`<@${botId}>`))
+                return; // the app_mention event handles it
+            if (msg.channelType === "im") {
+                await converse(msg);
+                return;
+            }
+            if (!msg.threadTs)
+                return;
+            try {
+                const entry = await ctx.state.get(stateScope(STATE_KEYS.session(msg.channel, msg.threadTs)));
+                if (entry)
+                    await converse(msg);
+            }
+            catch (err) {
+                ctx.logger.error("Slack handleMessage routing failed", { err: errString(err), channel: msg.channel });
+            }
+        },
+    };
+}

package/dist/cleanup.d.ts

@@ -0,0 +1,3 @@
+import type { PluginContext } from "@paperclipai/plugin-sdk";
+import type { SlackGateway, SlackSocketConfig } from "./types.js";
+export declare function runCleanup(ctx: PluginContext, gateway: SlackGateway, cfg: SlackSocketConfig): Promise<void>;

package/dist/cleanup.js

@@ -0,0 +1,75 @@
+import { STATE_KEYS, stateScope } from "./constants.js";
+import { formatQuestionExpired } from "./formatters.js";
+import { errString } from "./redact.js";
+import { updateIndex } from "./state-index.js";
+const ISSUE_THREAD_MAX_AGE_MS = 30 * 24 * 3_600_000; // 30 days
+export async function runCleanup(ctx, gateway, cfg) {
+    const now = Date.now();
+    const sessionIndex = (await ctx.state.get(stateScope(STATE_KEYS.sessionIndex))) ?? [];
+    const removedSessions = [];
+    for (const key of sessionIndex) {
+        const entry = (await ctx.state.get(stateScope(key)));
+        if (!entry) {
+            removedSessions.push(key);
+            continue;
+        }
+        const idleMs = now - Date.parse(entry.lastActivityAt);
+        if (idleMs > cfg.sessionIdleHours * 3_600_000) {
+            try {
+                await ctx.agents.sessions.close(entry.sessionId, cfg.companyId);
+            }
+            catch (err) {
+                ctx.logger.warn("Failed to close idle session", { err: errString(err), sessionId: entry.sessionId });
+            }
+            await ctx.state.delete(stateScope(key));
+            removedSessions.push(key);
+        }
+    }
+    await updateIndex(ctx, STATE_KEYS.sessionIndex, (current) => current.filter((k) => !removedSessions.includes(k)));
+    const questionIndex = (await ctx.state.get(stateScope(STATE_KEYS.questionIndex))) ?? [];
+    const removedQuestions = [];
+    for (const key of questionIndex) {
+        const pending = (await ctx.state.get(stateScope(key)));
+        if (!pending) {
+            removedQuestions.push(key);
+            continue;
+        }
+        const ageMs = now - Date.parse(pending.askedAt);
+        if (ageMs > pending.timeoutMinutes * 60_000) {
+            try {
+                await ctx.issues.createComment(pending.issueId, `No Slack response to: "${pending.question}" within ${pending.timeoutMinutes} minutes.`, pending.companyId);
+                await gateway.updateMessage({
+                    channel: pending.channel,
+                    ts: pending.ts,
+                    ...formatQuestionExpired(pending.question),
+                });
+            }
+            catch (err) {
+                ctx.logger.warn("Failed to expire question", {
+                    err: errString(err),
+                    issueId: pending.issueId,
+                    channel: pending.channel,
+                    ts: pending.ts,
+                });
+            }
+            await ctx.state.delete(stateScope(key));
+            removedQuestions.push(key);
+        }
+    }
+    await updateIndex(ctx, STATE_KEYS.questionIndex, (current) => current.filter((k) => !removedQuestions.includes(k)));
+    const issueThreadIndex = (await ctx.state.get(stateScope(STATE_KEYS.issueThreadIndex))) ?? [];
+    const removedIssueThreads = [];
+    for (const key of issueThreadIndex) {
+        const entry = (await ctx.state.get(stateScope(key)));
+        if (!entry) {
+            removedIssueThreads.push(key);
+            continue;
+        }
+        const ageMs = now - Date.parse(entry.createdAt);
+        if (ageMs > ISSUE_THREAD_MAX_AGE_MS) {
+            await ctx.state.delete(stateScope(key));
+            removedIssueThreads.push(key);
+        }
+    }
+    await updateIndex(ctx, STATE_KEYS.issueThreadIndex, (current) => current.filter((k) => !removedIssueThreads.includes(k)));
+}

package/dist/commands.d.ts

@@ -0,0 +1,11 @@
+import type { PluginContext } from "@paperclipai/plugin-sdk";
+import type { InboundCommand, SlackGateway, SlackSocketConfig } from "./types.js";
+export interface CommandDeps {
+    ctx: PluginContext;
+    gateway: SlackGateway;
+    getConfig: () => Promise<SlackSocketConfig>;
+}
+export interface Commands {
+    handleCommand(cmd: InboundCommand): Promise<void>;
+}
+export declare function createCommands({ ctx, gateway, getConfig }: CommandDeps): Commands;

package/dist/commands.js

@@ -0,0 +1,57 @@
+import { errString } from "./redact.js";
+const HELP = [
+    "*Paperclip commands*",
+    "• `/paperclip issue <title>` — create a Paperclip issue",
+    "• `/paperclip help` — show this help",
+].join("\n");
+export function createCommands({ ctx, gateway, getConfig }) {
+    return {
+        async handleCommand(cmd) {
+            const cfg = await getConfig();
+            const [sub, ...rest] = cmd.text.trim().split(/\s+/);
+            const subcommand = sub === "issue" ? "issue" : "help";
+            await ctx.metrics.write("slack.commands.invoked", 1, { subcommand }).catch(() => { });
+            if (sub === "issue") {
+                const title = rest.join(" ").trim();
+                if (!title) {
+                    await gateway.postEphemeral({
+                        channel: cmd.channel, user: cmd.user, text: "Usage: `/paperclip issue <title>`",
+                    });
+                    return;
+                }
+                let issue;
+                try {
+                    issue = await ctx.issues.create({ companyId: cfg.companyId, title, status: "todo" });
+                }
+                catch (err) {
+                    ctx.logger.warn("Slash issue creation failed", { err: errString(err) });
+                    await ctx.metrics.write("slack.commands.failed", 1, { subcommand }).catch(() => { });
+                    await gateway.postEphemeral({
+                        channel: cmd.channel,
+                        user: cmd.user,
+                        text: ":x: Failed to create the issue. Check the plugin configuration.",
+                    });
+                    return;
+                }
+                // The issue now exists even if this confirmation fails (e.g. the bot
+                // isn't a member of the channel) — never report a false "Failed" for
+                // a success ephemeral failure.
+                try {
+                    await gateway.postEphemeral({
+                        channel: cmd.channel,
+                        user: cmd.user,
+                        text: `:white_check_mark: Created issue: ${cfg.paperclipBaseUrl}/issues/${issue.id}`,
+                    });
+                }
+                catch (err) {
+                    ctx.logger.warn("Slash issue confirmation ephemeral failed (issue was created)", {
+                        err: errString(err),
+                        issueId: issue.id,
+                    });
+                }
+                return;
+            }
+            await gateway.postEphemeral({ channel: cmd.channel, user: cmd.user, text: HELP });
+        },
+    };
+}

package/dist/config.d.ts

@@ -0,0 +1,3 @@
+import type { PluginContext } from "@paperclipai/plugin-sdk";
+import type { SlackSocketConfig } from "./types.js";
+export declare function loadConfig(ctx: PluginContext): Promise<SlackSocketConfig>;

package/dist/config.js

@@ -0,0 +1,5 @@
+import { DEFAULT_CONFIG } from "./constants.js";
+export async function loadConfig(ctx) {
+    const raw = await ctx.config.get();
+    return { ...DEFAULT_CONFIG, ...raw };
+}

package/dist/constants.d.ts

@@ -0,0 +1,27 @@
+import type { PluginToolDeclaration, ScopeKey } from "@paperclipai/plugin-sdk";
+import type { SlackSocketConfig } from "./types.js";
+export declare const PLUGIN_ID = "cvh.slack-socket";
+export declare const PLUGIN_VERSION = "0.1.0";
+export declare const ACTION_IDS: {
+    readonly approvalApprove: "approval_approve";
+    readonly approvalReject: "approval_reject";
+};
+export declare const JOB_KEYS: {
+    readonly cleanup: "cleanup";
+};
+export declare const TOOL_NAMES: {
+    readonly askHuman: "ask_human";
+};
+export declare const SLASH_COMMAND = "/paperclip";
+export declare const STATE_NAMESPACE = "slack-socket";
+export declare const STATE_KEYS: {
+    readonly sessionIndex: "session-index";
+    readonly session: (channel: string, threadTs: string) => string;
+    readonly questionIndex: "question-index";
+    readonly question: (channel: string, ts: string) => string;
+    readonly issueThreadIndex: "issue-thread-index";
+    readonly issueThread: (issueId: string) => string;
+};
+export declare function stateScope(stateKey: string): ScopeKey;
+export declare const ASK_HUMAN_TOOL_DECLARATION: PluginToolDeclaration;
+export declare const DEFAULT_CONFIG: SlackSocketConfig;

package/dist/constants.js

@@ -0,0 +1,64 @@
+export const PLUGIN_ID = "cvh.slack-socket";
+export const PLUGIN_VERSION = "0.1.0";
+export const ACTION_IDS = {
+    approvalApprove: "approval_approve",
+    approvalReject: "approval_reject",
+};
+export const JOB_KEYS = {
+    cleanup: "cleanup",
+};
+export const TOOL_NAMES = {
+    askHuman: "ask_human",
+};
+export const SLASH_COMMAND = "/paperclip";
+export const STATE_NAMESPACE = "slack-socket";
+export const STATE_KEYS = {
+    sessionIndex: "session-index",
+    session: (channel, threadTs) => `session:${channel}:${threadTs}`,
+    questionIndex: "question-index",
+    question: (channel, ts) => `question:${channel}:${ts}`,
+    issueThreadIndex: "issue-thread-index",
+    issueThread: (issueId) => `issue-thread:${issueId}`,
+};
+export function stateScope(stateKey) {
+    return { scopeKind: "instance", namespace: STATE_NAMESPACE, stateKey };
+}
+export const ASK_HUMAN_TOOL_DECLARATION = {
+    name: TOOL_NAMES.askHuman,
+    displayName: "Ask a human via Slack",
+    description: "Post a question to a Slack channel or user (DM). mode 'reaction' asks the human to react with an emoji; mode 'answer' asks for a text reply in the question's thread. The response is recorded as a comment on the given issue and the issue's assignee is woken.",
+    parametersSchema: {
+        type: "object",
+        properties: {
+            question: { type: "string", description: "The question to ask." },
+            target: {
+                type: "string",
+                description: "Slack channel ID (C…) to post in, or Slack user ID (U…) to DM.",
+            },
+            mode: { type: "string", enum: ["reaction", "answer"] },
+            issueId: { type: "string", description: "Paperclip issue UUID the response is recorded on." },
+            timeoutMinutes: {
+                type: "number",
+                description: "Minutes to wait before marking the question expired (default 1440).",
+            },
+        },
+        required: ["question", "target", "mode", "issueId"],
+    },
+};
+export const DEFAULT_CONFIG = {
+    slackBotTokenRef: "",
+    slackAppTokenRef: "",
+    companyId: "",
+    defaultAgentId: "",
+    defaultChannelId: "",
+    notifyOnIssueCreated: true,
+    notifyOnIssueDone: true,
+    notifyOnAgentRunFailed: true,
+    notifyOnApprovalCreated: true,
+    issuesChannelId: "",
+    errorsChannelId: "",
+    approvalsChannelId: "",
+    paperclipApiKeyRef: "",
+    paperclipBaseUrl: "http://localhost:3010",
+    sessionIdleHours: 24,
+};

package/dist/event-dedup.d.ts

@@ -0,0 +1,16 @@
+export interface EventDeduperOptions {
+    /** Maximum number of keys retained before the oldest are evicted. Default 5000. */
+    maxEntries?: number;
+    /** Events older than this (ts vs now()) are treated as stale. Default 5 minutes. */
+    maxAgeMs?: number;
+    /** Injectable clock for tests. Defaults to Date.now. */
+    now?: () => number;
+}
+export interface EventDeduper {
+    /**
+     * Returns false (and does not record the key) for a duplicate or stale
+     * event; otherwise records the key and returns true.
+     */
+    shouldProcess(key: string): boolean;
+}
+export declare function createEventDeduper(opts?: EventDeduperOptions): EventDeduper;

package/dist/event-dedup.js

@@ -0,0 +1,37 @@
+// Guards inbound Slack event dispatch against duplicate deliveries (Slack's
+// at-least-once delivery under Socket Mode can redeliver the same event) and
+// against acting on stale events replayed long after the fact (e.g. after a
+// reconnect backlog). Callers key entries as `${channel}:${ts}` — the Slack
+// `ts` is epoch seconds with a decimal fraction, so it doubles as the event's
+// wall-clock time for the staleness check.
+const DEFAULT_MAX_ENTRIES = 5000;
+const DEFAULT_MAX_AGE_MS = 5 * 60_000;
+function parseTsSeconds(key) {
+    const suffix = key.slice(key.lastIndexOf(":") + 1);
+    const seconds = Number(suffix);
+    return Number.isFinite(seconds) ? seconds : null;
+}
+export function createEventDeduper(opts = {}) {
+    const maxEntries = opts.maxEntries ?? DEFAULT_MAX_ENTRIES;
+    const maxAgeMs = opts.maxAgeMs ?? DEFAULT_MAX_AGE_MS;
+    const now = opts.now ?? Date.now;
+    // Insertion-ordered set of seen keys, bounded to maxEntries with
+    // oldest-first eviction (Set preserves insertion order in JS).
+    const seen = new Set();
+    return {
+        shouldProcess(key) {
+            if (seen.has(key))
+                return false;
+            const tsSeconds = parseTsSeconds(key);
+            if (tsSeconds !== null && now() - tsSeconds * 1000 > maxAgeMs)
+                return false;
+            seen.add(key);
+            if (seen.size > maxEntries) {
+                const oldest = seen.values().next().value;
+                if (oldest !== undefined)
+                    seen.delete(oldest);
+            }
+            return true;
+        },
+    };
+}

package/dist/formatters.d.ts

@@ -0,0 +1,23 @@
+import type { QuestionMode } from "./types.js";
+export interface SlackContent {
+    text: string;
+    blocks: unknown[];
+}
+type Payload = Record<string, unknown> | null | undefined;
+/**
+ * Escapes Slack mrkdwn's three special characters in a string that comes
+ * from plugin/event payload data or a Slack user profile — i.e. anything we
+ * didn't author ourselves. Must NOT be applied to our own literal markup
+ * (section/context text templates, emoji codes, link syntax we construct).
+ * See https://api.slack.com/reference/surfaces/formatting#escaping
+ */
+export declare function escapeMrkdwn(s: string): string;
+export declare function formatIssueCreated(payload: Payload, issueId: string, baseUrl: string): SlackContent;
+export declare function formatIssueDone(payload: Payload, issueId: string, baseUrl: string): SlackContent;
+export declare function formatAgentRunFailed(payload: Payload): SlackContent;
+export declare function formatApprovalCreated(approvalId: string, payload: Payload, baseUrl: string): SlackContent;
+export declare function formatApprovalDecided(approvalId: string, decision: "approve" | "reject", deciderName: string): SlackContent;
+export declare function formatQuestion(question: string, mode: QuestionMode): SlackContent;
+export declare function formatQuestionResolved(question: string, response: string, responderName: string): SlackContent;
+export declare function formatQuestionExpired(question: string): SlackContent;
+export {};

package/dist/formatters.js

@@ -0,0 +1,119 @@
+import { ACTION_IDS } from "./constants.js";
+const section = (text) => ({ type: "section", text: { type: "mrkdwn", text } });
+const context = (text) => ({ type: "context", elements: [{ type: "mrkdwn", text }] });
+function str(payload, key) {
+    const value = payload?.[key];
+    return typeof value === "string" ? value : "";
+}
+/**
+ * Escapes Slack mrkdwn's three special characters in a string that comes
+ * from plugin/event payload data or a Slack user profile — i.e. anything we
+ * didn't author ourselves. Must NOT be applied to our own literal markup
+ * (section/context text templates, emoji codes, link syntax we construct).
+ * See https://api.slack.com/reference/surfaces/formatting#escaping
+ */
+export function escapeMrkdwn(s) {
+    return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+export function formatIssueCreated(payload, issueId, baseUrl) {
+    const title = escapeMrkdwn(str(payload, "title") || issueId);
+    const status = escapeMrkdwn(str(payload, "status") || "todo");
+    const priority = escapeMrkdwn(str(payload, "priority"));
+    const meta = [`Status: ${status}`, priority ? `Priority: ${priority}` : ""].filter(Boolean).join(" · ");
+    return {
+        text: `New issue created: ${title}`,
+        blocks: [
+            section(`:new: *Issue created*\n<${baseUrl}/issues/${issueId}|${title}>`),
+            context(meta),
+        ],
+    };
+}
+export function formatIssueDone(payload, issueId, baseUrl) {
+    const title = escapeMrkdwn(str(payload, "title") || issueId);
+    return {
+        text: `Issue completed: ${title}`,
+        blocks: [section(`:white_check_mark: *Issue completed*\n<${baseUrl}/issues/${issueId}|${title}>`)],
+    };
+}
+export function formatAgentRunFailed(payload) {
+    const error = escapeMrkdwn(str(payload, "error") || str(payload, "message") || "Unknown error");
+    const agentName = escapeMrkdwn(str(payload, "agentName") || str(payload, "agentId"));
+    return {
+        text: `Agent run failed${agentName ? ` (${agentName})` : ""}`,
+        blocks: [
+            section(`:x: *Agent run failed*${agentName ? ` — ${agentName}` : ""}`),
+            section(`\`\`\`${error.slice(0, 2800)}\`\`\``),
+        ],
+    };
+}
+export function formatApprovalCreated(approvalId, payload, baseUrl) {
+    const title = escapeMrkdwn(str(payload, "title") || str(payload, "description") || approvalId);
+    return {
+        text: `Approval requested: ${title}`,
+        blocks: [
+            section(`:raised_hand: *Approval requested*\n${title}`),
+            {
+                type: "actions",
+                elements: [
+                    {
+                        type: "button",
+                        action_id: ACTION_IDS.approvalApprove,
+                        style: "primary",
+                        text: { type: "plain_text", text: "Approve" },
+                        value: approvalId,
+                    },
+                    {
+                        type: "button",
+                        action_id: ACTION_IDS.approvalReject,
+                        style: "danger",
+                        text: { type: "plain_text", text: "Reject" },
+                        value: approvalId,
+                    },
+                    {
+                        type: "button",
+                        text: { type: "plain_text", text: "View" },
+                        url: `${baseUrl}/approvals/${approvalId}`,
+                    },
+                ],
+            },
+        ],
+    };
+}
+export function formatApprovalDecided(approvalId, decision, deciderName) {
+    const name = escapeMrkdwn(deciderName);
+    const label = decision === "approve" ? ":white_check_mark: Approved" : ":no_entry: Rejected";
+    const text = `${label} by ${name} (approval ${approvalId})`;
+    return { text, blocks: [section(text)] };
+}
+export function formatQuestion(question, mode) {
+    const q = escapeMrkdwn(question);
+    const hint = mode === "reaction"
+        ? "React to this message with an emoji to answer. Your reaction will be recorded on the issue."
+        : "Reply in this thread to answer. Your reply will be recorded on the issue.";
+    return {
+        text: `Question from a Paperclip agent: ${q}`,
+        blocks: [section(`:question: *A Paperclip agent asks:*\n${q}`), context(hint)],
+    };
+}
+export function formatQuestionResolved(question, response, responderName) {
+    const q = escapeMrkdwn(question);
+    const resp = escapeMrkdwn(response);
+    const name = escapeMrkdwn(responderName);
+    const text = `Answered by ${name}: ${resp}`;
+    return {
+        text,
+        blocks: [
+            section(`:question: ~${q}~`),
+            section(`:speech_balloon: *${name}* answered: ${resp}`),
+            context("Recorded on the issue."),
+        ],
+    };
+}
+export function formatQuestionExpired(question) {
+    const q = escapeMrkdwn(question);
+    const text = `Question expired without a response: ${q}`;
+    return {
+        text,
+        blocks: [section(`:hourglass: ~${q}~`), context("Expired without a response.")],
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { default as manifest } from "./manifest.js";

package/dist/index.js

@@ -0,0 +1 @@
+export { default as manifest } from "./manifest.js";

package/dist/manifest.d.ts

@@ -0,0 +1,3 @@
+import type { PaperclipPluginManifestV1 } from "@paperclipai/plugin-sdk";
+declare const manifest: PaperclipPluginManifestV1;
+export default manifest;