clawdbot 2026.1.4-1

package/dist/gateway/server-methods/nodes.js

@@ -0,0 +1,294 @@
+import { approveNodePairing, listNodePairing, rejectNodePairing, renamePairedNode, requestNodePairing, verifyNodeToken, } from "../../infra/node-pairing.js";
+import { ErrorCodes, errorShape, formatValidationErrors, validateNodeDescribeParams, validateNodeInvokeParams, validateNodeListParams, validateNodePairApproveParams, validateNodePairListParams, validateNodePairRejectParams, validateNodePairRequestParams, validateNodePairVerifyParams, validateNodeRenameParams, } from "../protocol/index.js";
+import { formatForLog } from "../ws-log.js";
+export const nodeHandlers = {
+    "node.pair.request": async ({ params, respond, context }) => {
+        if (!validateNodePairRequestParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid node.pair.request params: ${formatValidationErrors(validateNodePairRequestParams.errors)}`));
+            return;
+        }
+        const p = params;
+        try {
+            const result = await requestNodePairing({
+                nodeId: p.nodeId,
+                displayName: p.displayName,
+                platform: p.platform,
+                version: p.version,
+                deviceFamily: p.deviceFamily,
+                modelIdentifier: p.modelIdentifier,
+                caps: p.caps,
+                commands: p.commands,
+                remoteIp: p.remoteIp,
+                silent: p.silent,
+            });
+            if (result.status === "pending" && result.created) {
+                context.broadcast("node.pair.requested", result.request, {
+                    dropIfSlow: true,
+                });
+            }
+            respond(true, result, undefined);
+        }
+        catch (err) {
+            respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, formatForLog(err)));
+        }
+    },
+    "node.pair.list": async ({ params, respond }) => {
+        if (!validateNodePairListParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid node.pair.list params: ${formatValidationErrors(validateNodePairListParams.errors)}`));
+            return;
+        }
+        try {
+            const list = await listNodePairing();
+            respond(true, list, undefined);
+        }
+        catch (err) {
+            respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, formatForLog(err)));
+        }
+    },
+    "node.pair.approve": async ({ params, respond, context }) => {
+        if (!validateNodePairApproveParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid node.pair.approve params: ${formatValidationErrors(validateNodePairApproveParams.errors)}`));
+            return;
+        }
+        const { requestId } = params;
+        try {
+            const approved = await approveNodePairing(requestId);
+            if (!approved) {
+                respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "unknown requestId"));
+                return;
+            }
+            context.broadcast("node.pair.resolved", {
+                requestId,
+                nodeId: approved.node.nodeId,
+                decision: "approved",
+                ts: Date.now(),
+            }, { dropIfSlow: true });
+            respond(true, approved, undefined);
+        }
+        catch (err) {
+            respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, formatForLog(err)));
+        }
+    },
+    "node.pair.reject": async ({ params, respond, context }) => {
+        if (!validateNodePairRejectParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid node.pair.reject params: ${formatValidationErrors(validateNodePairRejectParams.errors)}`));
+            return;
+        }
+        const { requestId } = params;
+        try {
+            const rejected = await rejectNodePairing(requestId);
+            if (!rejected) {
+                respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "unknown requestId"));
+                return;
+            }
+            context.broadcast("node.pair.resolved", {
+                requestId,
+                nodeId: rejected.nodeId,
+                decision: "rejected",
+                ts: Date.now(),
+            }, { dropIfSlow: true });
+            respond(true, rejected, undefined);
+        }
+        catch (err) {
+            respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, formatForLog(err)));
+        }
+    },
+    "node.pair.verify": async ({ params, respond }) => {
+        if (!validateNodePairVerifyParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid node.pair.verify params: ${formatValidationErrors(validateNodePairVerifyParams.errors)}`));
+            return;
+        }
+        const { nodeId, token } = params;
+        try {
+            const result = await verifyNodeToken(nodeId, token);
+            respond(true, result, undefined);
+        }
+        catch (err) {
+            respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, formatForLog(err)));
+        }
+    },
+    "node.rename": async ({ params, respond }) => {
+        if (!validateNodeRenameParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid node.rename params: ${formatValidationErrors(validateNodeRenameParams.errors)}`));
+            return;
+        }
+        const { nodeId, displayName } = params;
+        try {
+            const trimmed = displayName.trim();
+            if (!trimmed) {
+                respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "displayName required"));
+                return;
+            }
+            const updated = await renamePairedNode(nodeId, trimmed);
+            if (!updated) {
+                respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "unknown nodeId"));
+                return;
+            }
+            respond(true, { nodeId: updated.nodeId, displayName: updated.displayName }, undefined);
+        }
+        catch (err) {
+            respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, formatForLog(err)));
+        }
+    },
+    "node.list": async ({ params, respond, context }) => {
+        if (!validateNodeListParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid node.list params: ${formatValidationErrors(validateNodeListParams.errors)}`));
+            return;
+        }
+        try {
+            const list = await listNodePairing();
+            const pairedById = new Map(list.paired.map((n) => [n.nodeId, n]));
+            const connected = context.bridge?.listConnected?.() ?? [];
+            const connectedById = new Map(connected.map((n) => [n.nodeId, n]));
+            const nodeIds = new Set([
+                ...pairedById.keys(),
+                ...connectedById.keys(),
+            ]);
+            const nodes = [...nodeIds].map((nodeId) => {
+                const paired = pairedById.get(nodeId);
+                const live = connectedById.get(nodeId);
+                const caps = [
+                    ...new Set((live?.caps ?? paired?.caps ?? [])
+                        .map((c) => String(c).trim())
+                        .filter(Boolean)),
+                ].sort();
+                const commands = [
+                    ...new Set((live?.commands ?? paired?.commands ?? [])
+                        .map((c) => String(c).trim())
+                        .filter(Boolean)),
+                ].sort();
+                return {
+                    nodeId,
+                    displayName: live?.displayName ?? paired?.displayName,
+                    platform: live?.platform ?? paired?.platform,
+                    version: live?.version ?? paired?.version,
+                    deviceFamily: live?.deviceFamily ?? paired?.deviceFamily,
+                    modelIdentifier: live?.modelIdentifier ?? paired?.modelIdentifier,
+                    remoteIp: live?.remoteIp ?? paired?.remoteIp,
+                    caps,
+                    commands,
+                    permissions: live?.permissions ?? paired?.permissions,
+                    paired: Boolean(paired),
+                    connected: Boolean(live),
+                };
+            });
+            nodes.sort((a, b) => {
+                if (a.connected !== b.connected)
+                    return a.connected ? -1 : 1;
+                const an = (a.displayName ?? a.nodeId).toLowerCase();
+                const bn = (b.displayName ?? b.nodeId).toLowerCase();
+                if (an < bn)
+                    return -1;
+                if (an > bn)
+                    return 1;
+                return a.nodeId.localeCompare(b.nodeId);
+            });
+            respond(true, { ts: Date.now(), nodes }, undefined);
+        }
+        catch (err) {
+            respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, formatForLog(err)));
+        }
+    },
+    "node.describe": async ({ params, respond, context }) => {
+        if (!validateNodeDescribeParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid node.describe params: ${formatValidationErrors(validateNodeDescribeParams.errors)}`));
+            return;
+        }
+        const { nodeId } = params;
+        const id = String(nodeId ?? "").trim();
+        if (!id) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "nodeId required"));
+            return;
+        }
+        try {
+            const list = await listNodePairing();
+            const paired = list.paired.find((n) => n.nodeId === id);
+            const connected = context.bridge?.listConnected?.() ?? [];
+            const live = connected.find((n) => n.nodeId === id);
+            if (!paired && !live) {
+                respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "unknown nodeId"));
+                return;
+            }
+            const caps = [
+                ...new Set((live?.caps ?? paired?.caps ?? [])
+                    .map((c) => String(c).trim())
+                    .filter(Boolean)),
+            ].sort();
+            const commands = [
+                ...new Set((live?.commands ?? paired?.commands ?? [])
+                    .map((c) => String(c).trim())
+                    .filter(Boolean)),
+            ].sort();
+            respond(true, {
+                ts: Date.now(),
+                nodeId: id,
+                displayName: live?.displayName ?? paired?.displayName,
+                platform: live?.platform ?? paired?.platform,
+                version: live?.version ?? paired?.version,
+                deviceFamily: live?.deviceFamily ?? paired?.deviceFamily,
+                modelIdentifier: live?.modelIdentifier ?? paired?.modelIdentifier,
+                remoteIp: live?.remoteIp ?? paired?.remoteIp,
+                caps,
+                commands,
+                permissions: live?.permissions ?? paired?.permissions,
+                paired: Boolean(paired),
+                connected: Boolean(live),
+            }, undefined);
+        }
+        catch (err) {
+            respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, formatForLog(err)));
+        }
+    },
+    "node.invoke": async ({ params, respond, context }) => {
+        if (!validateNodeInvokeParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid node.invoke params: ${formatValidationErrors(validateNodeInvokeParams.errors)}`));
+            return;
+        }
+        if (!context.bridge) {
+            respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, "bridge not running"));
+            return;
+        }
+        const p = params;
+        const nodeId = String(p.nodeId ?? "").trim();
+        const command = String(p.command ?? "").trim();
+        if (!nodeId || !command) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "nodeId and command required"));
+            return;
+        }
+        try {
+            const paramsJSON = "params" in p && p.params !== undefined
+                ? JSON.stringify(p.params)
+                : null;
+            const res = await context.bridge.invoke({
+                nodeId,
+                command,
+                paramsJSON,
+                timeoutMs: p.timeoutMs,
+            });
+            if (!res.ok) {
+                respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, res.error?.message ?? "node invoke failed", { details: { nodeError: res.error ?? null } }));
+                return;
+            }
+            const payload = typeof res.payloadJSON === "string" && res.payloadJSON.trim()
+                ? (() => {
+                    try {
+                        return JSON.parse(res.payloadJSON);
+                    }
+                    catch {
+                        return { payloadJSON: res.payloadJSON };
+                    }
+                })()
+                : undefined;
+            respond(true, {
+                ok: true,
+                nodeId,
+                command,
+                payload,
+                payloadJSON: res.payloadJSON ?? null,
+            }, undefined);
+        }
+        catch (err) {
+            respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, formatForLog(err)));
+        }
+    },
+};

package/dist/gateway/server-methods/providers.js

@@ -0,0 +1,217 @@
+import { loadConfig, readConfigFileSnapshot, writeConfigFile, } from "../../config/config.js";
+import { probeDiscord } from "../../discord/probe.js";
+import { probeIMessage } from "../../imessage/probe.js";
+import { webAuthExists } from "../../providers/web/index.js";
+import { probeSignal } from "../../signal/probe.js";
+import { probeSlack } from "../../slack/probe.js";
+import { resolveSlackAppToken, resolveSlackBotToken, } from "../../slack/token.js";
+import { probeTelegram } from "../../telegram/probe.js";
+import { resolveTelegramToken } from "../../telegram/token.js";
+import { getWebAuthAgeMs, readWebSelfId } from "../../web/session.js";
+import { ErrorCodes, errorShape, formatValidationErrors, validateProvidersStatusParams, } from "../protocol/index.js";
+import { formatForLog } from "../ws-log.js";
+export const providersHandlers = {
+    "providers.status": async ({ params, respond, context }) => {
+        if (!validateProvidersStatusParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid providers.status params: ${formatValidationErrors(validateProvidersStatusParams.errors)}`));
+            return;
+        }
+        const probe = params.probe === true;
+        const timeoutMsRaw = params.timeoutMs;
+        const timeoutMs = typeof timeoutMsRaw === "number" ? Math.max(1000, timeoutMsRaw) : 10_000;
+        const cfg = loadConfig();
+        const telegramCfg = cfg.telegram;
+        const telegramEnabled = Boolean(telegramCfg) && telegramCfg?.enabled !== false;
+        const { token: telegramToken, source: tokenSource } = telegramEnabled
+            ? resolveTelegramToken(cfg)
+            : { token: "", source: "none" };
+        let telegramProbe;
+        let lastProbeAt = null;
+        if (probe && telegramToken && telegramEnabled) {
+            telegramProbe = await probeTelegram(telegramToken, timeoutMs, telegramCfg?.proxy);
+            lastProbeAt = Date.now();
+        }
+        const discordCfg = cfg.discord;
+        const discordEnabled = Boolean(discordCfg) && discordCfg?.enabled !== false;
+        const discordEnvToken = discordEnabled
+            ? process.env.DISCORD_BOT_TOKEN?.trim()
+            : "";
+        const discordConfigToken = discordEnabled ? discordCfg?.token?.trim() : "";
+        const discordToken = discordEnvToken || discordConfigToken || "";
+        const discordTokenSource = discordEnvToken
+            ? "env"
+            : discordConfigToken
+                ? "config"
+                : "none";
+        let discordProbe;
+        let discordLastProbeAt = null;
+        if (probe && discordToken && discordEnabled) {
+            discordProbe = await probeDiscord(discordToken, timeoutMs);
+            discordLastProbeAt = Date.now();
+        }
+        const slackCfg = cfg.slack;
+        const slackEnabled = slackCfg?.enabled !== false;
+        const slackBotEnvToken = slackEnabled
+            ? resolveSlackBotToken(process.env.SLACK_BOT_TOKEN)
+            : undefined;
+        const slackBotConfigToken = slackEnabled
+            ? resolveSlackBotToken(slackCfg?.botToken)
+            : undefined;
+        const slackBotToken = slackBotEnvToken ?? slackBotConfigToken ?? "";
+        const slackBotTokenSource = slackBotEnvToken
+            ? "env"
+            : slackBotConfigToken
+                ? "config"
+                : "none";
+        const slackAppEnvToken = slackEnabled
+            ? resolveSlackAppToken(process.env.SLACK_APP_TOKEN)
+            : undefined;
+        const slackAppConfigToken = slackEnabled
+            ? resolveSlackAppToken(slackCfg?.appToken)
+            : undefined;
+        const slackAppToken = slackAppEnvToken ?? slackAppConfigToken ?? "";
+        const slackAppTokenSource = slackAppEnvToken
+            ? "env"
+            : slackAppConfigToken
+                ? "config"
+                : "none";
+        const slackConfigured = slackEnabled && Boolean(slackBotToken) && Boolean(slackAppToken);
+        let slackProbe;
+        let slackLastProbeAt = null;
+        if (probe && slackConfigured) {
+            slackProbe = await probeSlack(slackBotToken, timeoutMs);
+            slackLastProbeAt = Date.now();
+        }
+        const signalCfg = cfg.signal;
+        const signalEnabled = signalCfg?.enabled !== false;
+        const signalHost = signalCfg?.httpHost?.trim() || "127.0.0.1";
+        const signalPort = signalCfg?.httpPort ?? 8080;
+        const signalBaseUrl = signalCfg?.httpUrl?.trim() || `http://${signalHost}:${signalPort}`;
+        const signalConfigured = Boolean(signalCfg) &&
+            signalEnabled &&
+            Boolean(signalCfg?.account?.trim() ||
+                signalCfg?.httpUrl?.trim() ||
+                signalCfg?.cliPath?.trim() ||
+                signalCfg?.httpHost?.trim() ||
+                typeof signalCfg?.httpPort === "number" ||
+                typeof signalCfg?.autoStart === "boolean");
+        let signalProbe;
+        let signalLastProbeAt = null;
+        if (probe && signalConfigured) {
+            signalProbe = await probeSignal(signalBaseUrl, timeoutMs);
+            signalLastProbeAt = Date.now();
+        }
+        const imessageCfg = cfg.imessage;
+        const imessageEnabled = imessageCfg?.enabled !== false;
+        const imessageConfigured = Boolean(imessageCfg) && imessageEnabled;
+        let imessageProbe;
+        let imessageLastProbeAt = null;
+        if (probe && imessageConfigured) {
+            imessageProbe = await probeIMessage(timeoutMs);
+            imessageLastProbeAt = Date.now();
+        }
+        const linked = await webAuthExists();
+        const authAgeMs = getWebAuthAgeMs();
+        const self = readWebSelfId();
+        const runtime = context.getRuntimeSnapshot();
+        respond(true, {
+            ts: Date.now(),
+            whatsapp: {
+                configured: linked,
+                linked,
+                authAgeMs,
+                self,
+                running: runtime.whatsapp.running,
+                connected: runtime.whatsapp.connected,
+                lastConnectedAt: runtime.whatsapp.lastConnectedAt ?? null,
+                lastDisconnect: runtime.whatsapp.lastDisconnect ?? null,
+                reconnectAttempts: runtime.whatsapp.reconnectAttempts,
+                lastMessageAt: runtime.whatsapp.lastMessageAt ?? null,
+                lastEventAt: runtime.whatsapp.lastEventAt ?? null,
+                lastError: runtime.whatsapp.lastError ?? null,
+            },
+            telegram: {
+                configured: telegramEnabled && Boolean(telegramToken),
+                tokenSource,
+                running: runtime.telegram.running,
+                mode: runtime.telegram.mode ?? null,
+                lastStartAt: runtime.telegram.lastStartAt ?? null,
+                lastStopAt: runtime.telegram.lastStopAt ?? null,
+                lastError: runtime.telegram.lastError ?? null,
+                probe: telegramProbe,
+                lastProbeAt,
+            },
+            discord: {
+                configured: discordEnabled && Boolean(discordToken),
+                tokenSource: discordTokenSource,
+                running: runtime.discord.running,
+                lastStartAt: runtime.discord.lastStartAt ?? null,
+                lastStopAt: runtime.discord.lastStopAt ?? null,
+                lastError: runtime.discord.lastError ?? null,
+                probe: discordProbe,
+                lastProbeAt: discordLastProbeAt,
+            },
+            slack: {
+                configured: slackConfigured,
+                botTokenSource: slackBotTokenSource,
+                appTokenSource: slackAppTokenSource,
+                running: runtime.slack.running,
+                lastStartAt: runtime.slack.lastStartAt ?? null,
+                lastStopAt: runtime.slack.lastStopAt ?? null,
+                lastError: runtime.slack.lastError ?? null,
+                probe: slackProbe,
+                lastProbeAt: slackLastProbeAt,
+            },
+            signal: {
+                configured: signalConfigured,
+                baseUrl: signalBaseUrl,
+                running: runtime.signal.running,
+                lastStartAt: runtime.signal.lastStartAt ?? null,
+                lastStopAt: runtime.signal.lastStopAt ?? null,
+                lastError: runtime.signal.lastError ?? null,
+                probe: signalProbe,
+                lastProbeAt: signalLastProbeAt,
+            },
+            imessage: {
+                configured: imessageConfigured,
+                running: runtime.imessage.running,
+                lastStartAt: runtime.imessage.lastStartAt ?? null,
+                lastStopAt: runtime.imessage.lastStopAt ?? null,
+                lastError: runtime.imessage.lastError ?? null,
+                cliPath: runtime.imessage.cliPath ?? null,
+                dbPath: runtime.imessage.dbPath ?? null,
+                probe: imessageProbe,
+                lastProbeAt: imessageLastProbeAt,
+            },
+        }, undefined);
+    },
+    "telegram.logout": async ({ respond, context }) => {
+        try {
+            await context.stopTelegramProvider();
+            const snapshot = await readConfigFileSnapshot();
+            if (!snapshot.valid) {
+                respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "config invalid; fix it before logging out"));
+                return;
+            }
+            const cfg = snapshot.config ?? {};
+            const envToken = process.env.TELEGRAM_BOT_TOKEN?.trim() ?? "";
+            const hadToken = Boolean(cfg.telegram?.botToken);
+            const nextTelegram = cfg.telegram ? { ...cfg.telegram } : undefined;
+            if (nextTelegram) {
+                delete nextTelegram.botToken;
+            }
+            const nextCfg = { ...cfg };
+            if (nextTelegram && Object.keys(nextTelegram).length > 0) {
+                nextCfg.telegram = nextTelegram;
+            }
+            else {
+                delete nextCfg.telegram;
+            }
+            await writeConfigFile(nextCfg);
+            respond(true, { cleared: hadToken, envToken: Boolean(envToken) }, undefined);
+        }
+        catch (err) {
+            respond(false, undefined, errorShape(ErrorCodes.UNAVAILABLE, formatForLog(err)));
+        }
+    },
+};

package/dist/gateway/server-methods/send.js

@@ -0,0 +1,166 @@
+import { loadConfig } from "../../config/config.js";
+import { sendMessageDiscord } from "../../discord/index.js";
+import { shouldLogVerbose } from "../../globals.js";
+import { sendMessageIMessage } from "../../imessage/index.js";
+import { sendMessageSignal } from "../../signal/index.js";
+import { sendMessageSlack } from "../../slack/send.js";
+import { sendMessageTelegram } from "../../telegram/send.js";
+import { resolveTelegramToken } from "../../telegram/token.js";
+import { sendMessageWhatsApp } from "../../web/outbound.js";
+import { ErrorCodes, errorShape, formatValidationErrors, validateSendParams, } from "../protocol/index.js";
+import { formatForLog } from "../ws-log.js";
+export const sendHandlers = {
+    send: async ({ params, respond, context }) => {
+        const p = params;
+        if (!validateSendParams(p)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid send params: ${formatValidationErrors(validateSendParams.errors)}`));
+            return;
+        }
+        const request = p;
+        const idem = request.idempotencyKey;
+        const cached = context.dedupe.get(`send:${idem}`);
+        if (cached) {
+            respond(cached.ok, cached.payload, cached.error, {
+                cached: true,
+            });
+            return;
+        }
+        const to = request.to.trim();
+        const message = request.message.trim();
+        const providerRaw = (request.provider ?? "whatsapp").toLowerCase();
+        const provider = providerRaw === "imsg" ? "imessage" : providerRaw;
+        try {
+            if (provider === "telegram") {
+                const cfg = loadConfig();
+                const { token } = resolveTelegramToken(cfg);
+                const result = await sendMessageTelegram(to, message, {
+                    mediaUrl: request.mediaUrl,
+                    verbose: shouldLogVerbose(),
+                    token: token || undefined,
+                });
+                const payload = {
+                    runId: idem,
+                    messageId: result.messageId,
+                    chatId: result.chatId,
+                    provider,
+                };
+                context.dedupe.set(`send:${idem}`, {
+                    ts: Date.now(),
+                    ok: true,
+                    payload,
+                });
+                respond(true, payload, undefined, { provider });
+            }
+            else if (provider === "discord") {
+                const result = await sendMessageDiscord(to, message, {
+                    mediaUrl: request.mediaUrl,
+                    token: process.env.DISCORD_BOT_TOKEN,
+                });
+                const payload = {
+                    runId: idem,
+                    messageId: result.messageId,
+                    channelId: result.channelId,
+                    provider,
+                };
+                context.dedupe.set(`send:${idem}`, {
+                    ts: Date.now(),
+                    ok: true,
+                    payload,
+                });
+                respond(true, payload, undefined, { provider });
+            }
+            else if (provider === "slack") {
+                const result = await sendMessageSlack(to, message, {
+                    mediaUrl: request.mediaUrl,
+                });
+                const payload = {
+                    runId: idem,
+                    messageId: result.messageId,
+                    channelId: result.channelId,
+                    provider,
+                };
+                context.dedupe.set(`send:${idem}`, {
+                    ts: Date.now(),
+                    ok: true,
+                    payload,
+                });
+                respond(true, payload, undefined, { provider });
+            }
+            else if (provider === "signal") {
+                const cfg = loadConfig();
+                const host = cfg.signal?.httpHost?.trim() || "127.0.0.1";
+                const port = cfg.signal?.httpPort ?? 8080;
+                const baseUrl = cfg.signal?.httpUrl?.trim() || `http://${host}:${port}`;
+                const result = await sendMessageSignal(to, message, {
+                    mediaUrl: request.mediaUrl,
+                    baseUrl,
+                    account: cfg.signal?.account,
+                });
+                const payload = {
+                    runId: idem,
+                    messageId: result.messageId,
+                    provider,
+                };
+                context.dedupe.set(`send:${idem}`, {
+                    ts: Date.now(),
+                    ok: true,
+                    payload,
+                });
+                respond(true, payload, undefined, { provider });
+            }
+            else if (provider === "imessage") {
+                const cfg = loadConfig();
+                const result = await sendMessageIMessage(to, message, {
+                    mediaUrl: request.mediaUrl,
+                    cliPath: cfg.imessage?.cliPath,
+                    dbPath: cfg.imessage?.dbPath,
+                    maxBytes: cfg.imessage?.mediaMaxMb
+                        ? cfg.imessage.mediaMaxMb * 1024 * 1024
+                        : undefined,
+                });
+                const payload = {
+                    runId: idem,
+                    messageId: result.messageId,
+                    provider,
+                };
+                context.dedupe.set(`send:${idem}`, {
+                    ts: Date.now(),
+                    ok: true,
+                    payload,
+                });
+                respond(true, payload, undefined, { provider });
+            }
+            else {
+                const result = await sendMessageWhatsApp(to, message, {
+                    mediaUrl: request.mediaUrl,
+                    verbose: shouldLogVerbose(),
+                    gifPlayback: request.gifPlayback,
+                });
+                const payload = {
+                    runId: idem,
+                    messageId: result.messageId,
+                    toJid: result.toJid ?? `${to}@s.whatsapp.net`,
+                    provider,
+                };
+                context.dedupe.set(`send:${idem}`, {
+                    ts: Date.now(),
+                    ok: true,
+                    payload,
+                });
+                respond(true, payload, undefined, { provider });
+            }
+        }
+        catch (err) {
+            const error = errorShape(ErrorCodes.UNAVAILABLE, String(err));
+            context.dedupe.set(`send:${idem}`, {
+                ts: Date.now(),
+                ok: false,
+                error,
+            });
+            respond(false, undefined, error, {
+                provider,
+                error: formatForLog(err),
+            });
+        }
+    },
+};