@poolzin/pool-bot 2026.2.17 → 2026.2.19

package/dist/slack/monitor/events/interactions.js

@@ -0,0 +1,462 @@
+import { enqueueSystemEvent } from "../../../infra/system-events.js";
+import { parseSlackModalPrivateMetadata } from "../../modal-metadata.js";
+// Prefix for OpenClaw-generated action IDs to scope our handler
+const POOLBOT_ACTION_PREFIX = "openclaw:";
+function readOptionValues(options) {
+    if (!Array.isArray(options)) {
+        return undefined;
+    }
+    const values = options
+        .map((option) => (option && typeof option === "object" ? option.value : null))
+        .filter((value) => typeof value === "string" && value.trim().length > 0);
+    return values.length > 0 ? values : undefined;
+}
+function readOptionLabels(options) {
+    if (!Array.isArray(options)) {
+        return undefined;
+    }
+    const labels = options
+        .map((option) => option && typeof option === "object" ? (option.text?.text ?? null) : null)
+        .filter((label) => typeof label === "string" && label.trim().length > 0);
+    return labels.length > 0 ? labels : undefined;
+}
+function uniqueNonEmptyStrings(values) {
+    const unique = [];
+    const seen = new Set();
+    for (const entry of values) {
+        if (typeof entry !== "string") {
+            continue;
+        }
+        const trimmed = entry.trim();
+        if (!trimmed || seen.has(trimmed)) {
+            continue;
+        }
+        seen.add(trimmed);
+        unique.push(trimmed);
+    }
+    return unique;
+}
+function escapeSlackMrkdwn(value) {
+    return value
+        .replaceAll("\\", "\\\\")
+        .replaceAll("&", "&")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replace(/([*_`~])/g, "\\$1");
+}
+function collectRichTextFragments(value, out) {
+    if (!value || typeof value !== "object") {
+        return;
+    }
+    const typed = value;
+    if (typeof typed.text === "string" && typed.text.trim().length > 0) {
+        out.push(typed.text.trim());
+    }
+    if (Array.isArray(typed.elements)) {
+        for (const child of typed.elements) {
+            collectRichTextFragments(child, out);
+        }
+    }
+}
+function summarizeRichTextPreview(value) {
+    const fragments = [];
+    collectRichTextFragments(value, fragments);
+    if (fragments.length === 0) {
+        return undefined;
+    }
+    const joined = fragments.join(" ").replace(/\s+/g, " ").trim();
+    if (!joined) {
+        return undefined;
+    }
+    const max = 120;
+    return joined.length <= max ? joined : `${joined.slice(0, max - 1)}…`;
+}
+function readInteractionAction(raw) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        return undefined;
+    }
+    return raw;
+}
+function summarizeAction(action) {
+    const typed = action;
+    const actionType = typed.type;
+    const selectedUsers = uniqueNonEmptyStrings([
+        ...(typed.selected_user ? [typed.selected_user] : []),
+        ...(Array.isArray(typed.selected_users) ? typed.selected_users : []),
+    ]);
+    const selectedChannels = uniqueNonEmptyStrings([
+        ...(typed.selected_channel ? [typed.selected_channel] : []),
+        ...(Array.isArray(typed.selected_channels) ? typed.selected_channels : []),
+    ]);
+    const selectedConversations = uniqueNonEmptyStrings([
+        ...(typed.selected_conversation ? [typed.selected_conversation] : []),
+        ...(Array.isArray(typed.selected_conversations) ? typed.selected_conversations : []),
+    ]);
+    const selectedValues = uniqueNonEmptyStrings([
+        ...(typed.selected_option?.value ? [typed.selected_option.value] : []),
+        ...(readOptionValues(typed.selected_options) ?? []),
+        ...selectedUsers,
+        ...selectedChannels,
+        ...selectedConversations,
+    ]);
+    const selectedLabels = uniqueNonEmptyStrings([
+        ...(typed.selected_option?.text?.text ? [typed.selected_option.text.text] : []),
+        ...(readOptionLabels(typed.selected_options) ?? []),
+    ]);
+    const inputValue = typeof typed.value === "string" ? typed.value : undefined;
+    const inputNumber = actionType === "number_input" && inputValue != null ? Number.parseFloat(inputValue) : undefined;
+    const parsedNumber = Number.isFinite(inputNumber) ? inputNumber : undefined;
+    const inputEmail = actionType === "email_text_input" && inputValue?.includes("@") ? inputValue : undefined;
+    let inputUrl;
+    if (actionType === "url_text_input" && inputValue) {
+        try {
+            // Normalize to a canonical URL string so downstream handlers do not need to reparse.
+            inputUrl = new URL(inputValue).toString();
+        }
+        catch {
+            inputUrl = undefined;
+        }
+    }
+    const richTextValue = actionType === "rich_text_input" ? typed.rich_text_value : undefined;
+    const richTextPreview = summarizeRichTextPreview(richTextValue);
+    const inputKind = actionType === "number_input"
+        ? "number"
+        : actionType === "email_text_input"
+            ? "email"
+            : actionType === "url_text_input"
+                ? "url"
+                : actionType === "rich_text_input"
+                    ? "rich_text"
+                    : inputValue != null
+                        ? "text"
+                        : undefined;
+    return {
+        actionType,
+        inputKind,
+        value: typed.value,
+        selectedValues: selectedValues.length > 0 ? selectedValues : undefined,
+        selectedUsers: selectedUsers.length > 0 ? selectedUsers : undefined,
+        selectedChannels: selectedChannels.length > 0 ? selectedChannels : undefined,
+        selectedConversations: selectedConversations.length > 0 ? selectedConversations : undefined,
+        selectedLabels: selectedLabels.length > 0 ? selectedLabels : undefined,
+        selectedDate: typed.selected_date,
+        selectedTime: typed.selected_time,
+        selectedDateTime: typeof typed.selected_date_time === "number" ? typed.selected_date_time : undefined,
+        inputValue,
+        inputNumber: parsedNumber,
+        inputEmail,
+        inputUrl,
+        richTextValue,
+        richTextPreview,
+        workflowTriggerUrl: typed.workflow?.trigger_url,
+        workflowId: typed.workflow?.workflow_id,
+    };
+}
+function isBulkActionsBlock(block) {
+    return (block.type === "actions" &&
+        Array.isArray(block.elements) &&
+        block.elements.length > 0 &&
+        block.elements.every((el) => typeof el.action_id === "string" && el.action_id.includes("_all_")));
+}
+function formatInteractionSelectionLabel(params) {
+    if (params.summary.actionType === "button" && params.buttonText?.trim()) {
+        return params.buttonText.trim();
+    }
+    if (params.summary.selectedLabels?.length) {
+        if (params.summary.selectedLabels.length <= 3) {
+            return params.summary.selectedLabels.join(", ");
+        }
+        return `${params.summary.selectedLabels.slice(0, 3).join(", ")} +${params.summary.selectedLabels.length - 3}`;
+    }
+    if (params.summary.selectedValues?.length) {
+        if (params.summary.selectedValues.length <= 3) {
+            return params.summary.selectedValues.join(", ");
+        }
+        return `${params.summary.selectedValues.slice(0, 3).join(", ")} +${params.summary.selectedValues.length - 3}`;
+    }
+    if (params.summary.selectedDate) {
+        return params.summary.selectedDate;
+    }
+    if (params.summary.selectedTime) {
+        return params.summary.selectedTime;
+    }
+    if (typeof params.summary.selectedDateTime === "number") {
+        return new Date(params.summary.selectedDateTime * 1000).toISOString();
+    }
+    if (params.summary.richTextPreview) {
+        return params.summary.richTextPreview;
+    }
+    if (params.summary.value?.trim()) {
+        return params.summary.value.trim();
+    }
+    return params.actionId;
+}
+function formatInteractionConfirmationText(params) {
+    const actor = params.userId?.trim() ? ` by <@${params.userId.trim()}>` : "";
+    return `:white_check_mark: *${escapeSlackMrkdwn(params.selectedLabel)}* selected${actor}`;
+}
+function summarizeViewState(values) {
+    if (!values || typeof values !== "object") {
+        return [];
+    }
+    const entries = [];
+    for (const [blockId, blockValue] of Object.entries(values)) {
+        if (!blockValue || typeof blockValue !== "object") {
+            continue;
+        }
+        for (const [actionId, rawAction] of Object.entries(blockValue)) {
+            if (!rawAction || typeof rawAction !== "object") {
+                continue;
+            }
+            const actionSummary = summarizeAction(rawAction);
+            entries.push({
+                blockId,
+                actionId,
+                ...actionSummary,
+            });
+        }
+    }
+    return entries;
+}
+function resolveModalSessionRouting(params) {
+    const metadata = parseSlackModalPrivateMetadata(params.privateMetadata);
+    if (metadata.sessionKey) {
+        return { sessionKey: metadata.sessionKey };
+    }
+    if (metadata.channelId) {
+        return {
+            sessionKey: params.ctx.resolveSlackSystemEventSessionKey({
+                channelId: metadata.channelId,
+                channelType: metadata.channelType,
+            }),
+            channelId: metadata.channelId,
+            channelType: metadata.channelType,
+        };
+    }
+    return {
+        sessionKey: params.ctx.resolveSlackSystemEventSessionKey({}),
+    };
+}
+function summarizeSlackViewLifecycleContext(view) {
+    const rootViewId = view.root_view_id;
+    const previousViewId = view.previous_view_id;
+    const externalId = view.external_id;
+    const viewHash = view.hash;
+    return {
+        rootViewId,
+        previousViewId,
+        externalId,
+        viewHash,
+        isStackedView: Boolean(previousViewId),
+    };
+}
+export function registerSlackInteractionEvents(params) {
+    const { ctx } = params;
+    if (typeof ctx.app.action !== "function") {
+        return;
+    }
+    // Handle Block Kit button clicks from OpenClaw-generated messages
+    // Only matches action_ids that start with our prefix to avoid interfering
+    // with other Slack integrations or future features
+    ctx.app.action(new RegExp(`^${POOLBOT_ACTION_PREFIX}`), async (args) => {
+        const { ack, body, action, respond } = args;
+        const typedBody = body;
+        // Acknowledge the action immediately to prevent the warning icon
+        await ack();
+        // Extract action details using proper Bolt types
+        const typedAction = readInteractionAction(action);
+        if (!typedAction) {
+            ctx.runtime.log?.(`slack:interaction malformed action payload channel=${typedBody.channel?.id ?? typedBody.container?.channel_id ?? "unknown"} user=${typedBody.user?.id ?? "unknown"}`);
+            return;
+        }
+        const typedActionWithText = typedAction;
+        const actionId = typeof typedActionWithText.action_id === "string"
+            ? typedActionWithText.action_id
+            : "unknown";
+        const blockId = typedActionWithText.block_id;
+        const userId = typedBody.user?.id ?? "unknown";
+        const channelId = typedBody.channel?.id ?? typedBody.container?.channel_id;
+        const messageTs = typedBody.message?.ts ?? typedBody.container?.message_ts;
+        const threadTs = typedBody.container?.thread_ts;
+        const actionSummary = summarizeAction(typedAction);
+        const eventPayload = {
+            interactionType: "block_action",
+            actionId,
+            blockId,
+            ...actionSummary,
+            userId,
+            teamId: typedBody.team?.id,
+            triggerId: typedBody.trigger_id,
+            responseUrl: typedBody.response_url,
+            channelId,
+            messageTs,
+            threadTs,
+        };
+        // Log the interaction for debugging
+        ctx.runtime.log?.(`slack:interaction action=${actionId} type=${actionSummary.actionType ?? "unknown"} user=${userId} channel=${channelId}`);
+        // Send a system event to notify the agent about the button click
+        // Pass undefined (not "unknown") to allow proper main session fallback
+        const sessionKey = ctx.resolveSlackSystemEventSessionKey({
+            channelId: channelId,
+            channelType: undefined,
+        });
+        // Build context key - only include defined values to avoid "unknown" noise
+        const contextParts = ["slack:interaction", channelId, messageTs, actionId].filter(Boolean);
+        const contextKey = contextParts.join(":");
+        enqueueSystemEvent(`Slack interaction: ${JSON.stringify(eventPayload)}`, {
+            sessionKey,
+            contextKey,
+        });
+        const originalBlocks = typedBody.message?.blocks;
+        if (!Array.isArray(originalBlocks) || !channelId || !messageTs) {
+            return;
+        }
+        if (!blockId) {
+            return;
+        }
+        const selectedLabel = formatInteractionSelectionLabel({
+            actionId,
+            summary: actionSummary,
+            buttonText: typedActionWithText.text?.text,
+        });
+        let updatedBlocks = originalBlocks.map((block) => {
+            const typedBlock = block;
+            if (typedBlock.type === "actions" && typedBlock.block_id === blockId) {
+                return {
+                    type: "context",
+                    elements: [
+                        {
+                            type: "mrkdwn",
+                            text: formatInteractionConfirmationText({ selectedLabel, userId }),
+                        },
+                    ],
+                };
+            }
+            return block;
+        });
+        const hasRemainingIndividualActionRows = updatedBlocks.some((block) => {
+            const typedBlock = block;
+            return typedBlock.type === "actions" && !isBulkActionsBlock(typedBlock);
+        });
+        if (!hasRemainingIndividualActionRows) {
+            updatedBlocks = updatedBlocks.filter((block, index) => {
+                const typedBlock = block;
+                if (isBulkActionsBlock(typedBlock)) {
+                    return false;
+                }
+                if (typedBlock.type !== "divider") {
+                    return true;
+                }
+                const next = updatedBlocks[index + 1];
+                return !next || !isBulkActionsBlock(next);
+            });
+        }
+        try {
+            await ctx.app.client.chat.update({
+                channel: channelId,
+                ts: messageTs,
+                text: typedBody.message?.text ?? "",
+                blocks: updatedBlocks,
+            });
+        }
+        catch {
+            // If update fails, fallback to ephemeral confirmation for immediate UX feedback.
+            if (!respond) {
+                return;
+            }
+            try {
+                await respond({
+                    text: `Button "${actionId}" clicked!`,
+                    response_type: "ephemeral",
+                });
+            }
+            catch {
+                // Action was acknowledged and system event enqueued even when response updates fail.
+            }
+        }
+    });
+    if (typeof ctx.app.view !== "function") {
+        return;
+    }
+    // Handle OpenClaw modal submissions with callback_ids scoped by our prefix.
+    ctx.app.view(new RegExp(`^${POOLBOT_ACTION_PREFIX}`), async ({ ack, body }) => {
+        await ack();
+        const typedBody = body;
+        const callbackId = typedBody.view?.callback_id ?? "unknown";
+        const userId = typedBody.user?.id ?? "unknown";
+        const viewId = typedBody.view?.id;
+        const inputs = summarizeViewState(typedBody.view?.state?.values);
+        const sessionRouting = resolveModalSessionRouting({
+            ctx,
+            privateMetadata: typedBody.view?.private_metadata,
+        });
+        const eventPayload = {
+            interactionType: "view_submission",
+            actionId: `view:${callbackId}`,
+            callbackId,
+            viewId,
+            userId,
+            teamId: typedBody.team?.id,
+            ...summarizeSlackViewLifecycleContext({
+                root_view_id: typedBody.view?.root_view_id,
+                previous_view_id: typedBody.view?.previous_view_id,
+                external_id: typedBody.view?.external_id,
+                hash: typedBody.view?.hash,
+            }),
+            privateMetadata: typedBody.view?.private_metadata,
+            routedChannelId: sessionRouting.channelId,
+            routedChannelType: sessionRouting.channelType,
+            inputs,
+        };
+        ctx.runtime.log?.(`slack:interaction view_submission callback=${callbackId} user=${userId} inputs=${inputs.length}`);
+        enqueueSystemEvent(`Slack interaction: ${JSON.stringify(eventPayload)}`, {
+            sessionKey: sessionRouting.sessionKey,
+            contextKey: ["slack:interaction:view", callbackId, viewId, userId]
+                .filter(Boolean)
+                .join(":"),
+        });
+    });
+    const viewClosed = ctx.app.viewClosed;
+    if (typeof viewClosed !== "function") {
+        return;
+    }
+    // Handle modal close events so agent workflows can react to cancelled forms.
+    viewClosed(new RegExp(`^${POOLBOT_ACTION_PREFIX}`), async ({ ack, body }) => {
+        await ack();
+        const typedBody = body;
+        const callbackId = typedBody.view?.callback_id ?? "unknown";
+        const userId = typedBody.user?.id ?? "unknown";
+        const viewId = typedBody.view?.id;
+        const inputs = summarizeViewState(typedBody.view?.state?.values);
+        const sessionRouting = resolveModalSessionRouting({
+            ctx,
+            privateMetadata: typedBody.view?.private_metadata,
+        });
+        const eventPayload = {
+            interactionType: "view_closed",
+            actionId: `view:${callbackId}`,
+            callbackId,
+            viewId,
+            userId,
+            teamId: typedBody.team?.id,
+            ...summarizeSlackViewLifecycleContext({
+                root_view_id: typedBody.view?.root_view_id,
+                previous_view_id: typedBody.view?.previous_view_id,
+                external_id: typedBody.view?.external_id,
+                hash: typedBody.view?.hash,
+            }),
+            isCleared: typedBody.is_cleared === true,
+            privateMetadata: typedBody.view?.private_metadata,
+            routedChannelId: sessionRouting.channelId,
+            routedChannelType: sessionRouting.channelType,
+            inputs,
+        };
+        ctx.runtime.log?.(`slack:interaction view_closed callback=${callbackId} user=${userId} cleared=${typedBody.is_cleared === true}`);
+        enqueueSystemEvent(`Slack interaction: ${JSON.stringify(eventPayload)}`, {
+            sessionKey: sessionRouting.sessionKey,
+            contextKey: ["slack:interaction:view-closed", callbackId, viewId, userId]
+                .filter(Boolean)
+                .join(":"),
+        });
+    });
+}

package/dist/slack/monitor/room-context.js

@@ -0,0 +1,17 @@
+import { buildUntrustedChannelMetadata } from "../../security/channel-metadata.js";
+export function resolveSlackRoomContextHints(params) {
+    if (!params.isRoomish) {
+        return {};
+    }
+    const untrustedChannelMetadata = buildUntrustedChannelMetadata({
+        source: "slack",
+        label: "Slack channel description",
+        entries: [params.channelInfo?.topic, params.channelInfo?.purpose],
+    });
+    const systemPromptParts = [params.channelConfig?.systemPrompt?.trim() || null].filter((entry) => Boolean(entry));
+    const groupSystemPrompt = systemPromptParts.length > 0 ? systemPromptParts.join("\n\n") : undefined;
+    return {
+        untrustedChannelMetadata,
+        groupSystemPrompt,
+    };
+}

package/dist/slack/stream-mode.js

@@ -0,0 +1,41 @@
+const DEFAULT_STREAM_MODE = "replace";
+export function resolveSlackStreamMode(raw) {
+    if (typeof raw !== "string") {
+        return DEFAULT_STREAM_MODE;
+    }
+    const normalized = raw.trim().toLowerCase();
+    if (normalized === "replace" || normalized === "status_final" || normalized === "append") {
+        return normalized;
+    }
+    return DEFAULT_STREAM_MODE;
+}
+export function applyAppendOnlyStreamUpdate(params) {
+    const incoming = params.incoming.trimEnd();
+    if (!incoming) {
+        return { rendered: params.rendered, source: params.source, changed: false };
+    }
+    if (!params.rendered) {
+        return { rendered: incoming, source: incoming, changed: true };
+    }
+    if (incoming === params.source) {
+        return { rendered: params.rendered, source: params.source, changed: false };
+    }
+    // Typical model partials are cumulative prefixes.
+    if (incoming.startsWith(params.source) || incoming.startsWith(params.rendered)) {
+        return { rendered: incoming, source: incoming, changed: incoming !== params.rendered };
+    }
+    // Ignore regressive shorter variants of the same stream.
+    if (params.source.startsWith(incoming)) {
+        return { rendered: params.rendered, source: params.source, changed: false };
+    }
+    const separator = params.rendered.endsWith("\n") ? "" : "\n";
+    return {
+        rendered: `${params.rendered}${separator}${incoming}`,
+        source: incoming,
+        changed: true,
+    };
+}
+export function buildStatusFinalPreviewText(updateCount) {
+    const dots = ".".repeat((Math.max(1, updateCount) % 3) + 1);
+    return `Status: thinking${dots}`;
+}

package/dist/telegram/bot-native-command-menu.js

@@ -0,0 +1,64 @@
+import { normalizeTelegramCommandName, TELEGRAM_COMMAND_NAME_PATTERN, } from "../config/telegram-custom-commands.js";
+import { withTelegramApiErrorLogging } from "./api-logging.js";
+export const TELEGRAM_MAX_COMMANDS = 100;
+export function buildPluginTelegramMenuCommands(params) {
+    const { specs, existingCommands } = params;
+    const commands = [];
+    const issues = [];
+    const pluginCommandNames = new Set();
+    for (const spec of specs) {
+        const normalized = normalizeTelegramCommandName(spec.name);
+        if (!normalized || !TELEGRAM_COMMAND_NAME_PATTERN.test(normalized)) {
+            issues.push(`Plugin command "/${spec.name}" is invalid for Telegram (use a-z, 0-9, underscore; max 32 chars).`);
+            continue;
+        }
+        const description = spec.description.trim();
+        if (!description) {
+            issues.push(`Plugin command "/${normalized}" is missing a description.`);
+            continue;
+        }
+        if (existingCommands.has(normalized)) {
+            if (pluginCommandNames.has(normalized)) {
+                issues.push(`Plugin command "/${normalized}" is duplicated.`);
+            }
+            else {
+                issues.push(`Plugin command "/${normalized}" conflicts with an existing Telegram command.`);
+            }
+            continue;
+        }
+        pluginCommandNames.add(normalized);
+        existingCommands.add(normalized);
+        commands.push({ command: normalized, description });
+    }
+    return { commands, issues };
+}
+export function buildCappedTelegramMenuCommands(params) {
+    const { allCommands } = params;
+    const maxCommands = params.maxCommands ?? TELEGRAM_MAX_COMMANDS;
+    const totalCommands = allCommands.length;
+    const overflowCount = Math.max(0, totalCommands - maxCommands);
+    const commandsToRegister = allCommands.slice(0, maxCommands);
+    return { commandsToRegister, totalCommands, maxCommands, overflowCount };
+}
+export function syncTelegramMenuCommands(params) {
+    const { bot, runtime, commandsToRegister } = params;
+    const sync = async () => {
+        // Keep delete -> set ordering to avoid stale deletions racing after fresh registrations.
+        if (typeof bot.api.deleteMyCommands === "function") {
+            await withTelegramApiErrorLogging({
+                operation: "deleteMyCommands",
+                runtime,
+                fn: () => bot.api.deleteMyCommands(),
+            }).catch(() => { });
+        }
+        if (commandsToRegister.length === 0) {
+            return;
+        }
+        await withTelegramApiErrorLogging({
+            operation: "setMyCommands",
+            runtime,
+            fn: () => bot.api.setMyCommands(commandsToRegister),
+        });
+    };
+    void sync().catch(() => { });
+}

package/dist/telegram/bot.media.e2e-harness.js

@@ -0,0 +1,81 @@
+import { beforeEach, vi } from "vitest";
+import { resetInboundDedupe } from "../auto-reply/reply/inbound-dedupe.js";
+export const useSpy = vi.fn();
+export const middlewareUseSpy = vi.fn();
+export const onSpy = vi.fn();
+export const stopSpy = vi.fn();
+export const sendChatActionSpy = vi.fn();
+const apiStub = {
+    config: { use: useSpy },
+    sendChatAction: sendChatActionSpy,
+    setMyCommands: vi.fn(async () => undefined),
+};
+beforeEach(() => {
+    resetInboundDedupe();
+});
+vi.mock("grammy", () => ({
+    Bot: class {
+        token;
+        api = apiStub;
+        use = middlewareUseSpy;
+        on = onSpy;
+        command = vi.fn();
+        stop = stopSpy;
+        catch = vi.fn();
+        constructor(token) {
+            this.token = token;
+        }
+    },
+    InputFile: class {
+    },
+    webhookCallback: vi.fn(),
+}));
+vi.mock("@grammyjs/runner", () => ({
+    sequentialize: () => vi.fn(),
+}));
+const throttlerSpy = vi.fn(() => "throttler");
+vi.mock("@grammyjs/transformer-throttler", () => ({
+    apiThrottler: () => throttlerSpy(),
+}));
+vi.mock("../media/store.js", async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        saveMediaBuffer: vi.fn(async (buffer, contentType) => ({
+            id: "media",
+            path: "/tmp/telegram-media",
+            size: buffer.byteLength,
+            contentType: contentType ?? "application/octet-stream",
+        })),
+    };
+});
+vi.mock("../config/config.js", async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        loadConfig: () => ({
+            channels: { telegram: { dmPolicy: "open", allowFrom: ["*"] } },
+        }),
+    };
+});
+vi.mock("../config/sessions.js", async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        updateLastRoute: vi.fn(async () => undefined),
+    };
+});
+vi.mock("../pairing/pairing-store.js", () => ({
+    readChannelAllowFromStore: vi.fn(async () => []),
+    upsertChannelPairingRequest: vi.fn(async () => ({
+        code: "PAIRCODE",
+        created: true,
+    })),
+}));
+vi.mock("../auto-reply/reply.js", () => {
+    const replySpy = vi.fn(async (_ctx, opts) => {
+        await opts?.onReplyStart?.();
+        return undefined;
+    });
+    return { getReplyFromConfig: replySpy, __replySpy: replySpy };
+});

package/dist/telegram/button-types.js

@@ -0,0 +1 @@
+export {};