@ozaiya/openclaw-channel 0.1.0

package/dist/src/channel.js

@@ -0,0 +1,643 @@
+import { registerPluginHttpRoute } from "openclaw/plugin-sdk";
+import { unwrapGroupKey, decryptMessage, encryptMessage } from "./crypto.js";
+import { sendMessage, probeApi, fetchGroups, toggleReaction, editMessage, deleteMessage, pinMessage, unpinMessage, uploadFile, } from "./api.js";
+import { createOzaiyaWebhookHandler } from "./webhook.js";
+import { getOzaiyaRuntime } from "./runtime.js";
+const DEFAULT_API_BASE_URL = "https://api.ozai.dev";
+const DEFAULT_WEBHOOK_PATH = "/ozaiya/webhook";
+const DEFAULT_ACCOUNT_ID = "default";
+// In-memory cache of unwrapped group keys (groupId → Uint8Array)
+const unwrappedKeys = new Map();
+// Runtime state tracking
+const runtimeState = new Map();
+function recordState(accountId, patch) {
+    const key = `ozaiya:${accountId}`;
+    const existing = runtimeState.get(key) ?? {
+        running: false,
+        lastStartAt: null,
+        lastStopAt: null,
+        lastError: null,
+        lastInboundAt: null,
+        lastOutboundAt: null,
+    };
+    runtimeState.set(key, { ...existing, ...patch });
+}
+function getState(accountId) {
+    return runtimeState.get(`ozaiya:${accountId}`);
+}
+/** Resolve the Ozaiya channel config from OpenClaw config */
+function resolveConfig(cfg) {
+    const channels = cfg.channels;
+    const ozaiya = channels?.ozaiya;
+    return ozaiya ?? null;
+}
+/** List all configured account IDs (default + named) */
+function listAccountIds(cfg) {
+    const ozaiya = resolveConfig(cfg);
+    if (!ozaiya)
+        return [];
+    const ids = [];
+    if (ozaiya.botToken?.trim()) {
+        ids.push(DEFAULT_ACCOUNT_ID);
+    }
+    if (ozaiya.accounts) {
+        for (const id of Object.keys(ozaiya.accounts)) {
+            ids.push(id);
+        }
+    }
+    if (ids.length === 0 && ozaiya.enabled !== false) {
+        ids.push(DEFAULT_ACCOUNT_ID);
+    }
+    return ids;
+}
+/** Resolve a full account from config */
+function resolveAccount(cfg, accountId) {
+    const ozaiya = resolveConfig(cfg);
+    const id = accountId || DEFAULT_ACCOUNT_ID;
+    const apiBaseUrl = ozaiya?.apiBaseUrl ?? DEFAULT_API_BASE_URL;
+    // Named account from accounts map
+    if (id !== DEFAULT_ACCOUNT_ID && ozaiya?.accounts?.[id]) {
+        const acc = ozaiya.accounts[id];
+        return {
+            accountId: id,
+            enabled: acc.enabled !== false,
+            botToken: acc.botToken ?? "",
+            botPrivateKey: acc.botPrivateKey ?? "",
+            webhookSecret: acc.webhookSecret ?? "",
+            apiBaseUrl,
+            webhookPath: acc.webhookPath ?? `${DEFAULT_WEBHOOK_PATH}/${id}`,
+        };
+    }
+    // Default account (top-level fields)
+    return {
+        accountId: DEFAULT_ACCOUNT_ID,
+        enabled: ozaiya?.enabled !== false,
+        botToken: ozaiya?.botToken ?? "",
+        botPrivateKey: ozaiya?.botPrivateKey ?? "",
+        webhookSecret: ozaiya?.webhookSecret ?? "",
+        apiBaseUrl,
+        webhookPath: ozaiya?.webhookPath ?? DEFAULT_WEBHOOK_PATH,
+    };
+}
+/** Fetch group keys from API and unwrap them into the cache */
+async function fetchAndUnwrapGroupKeys(account) {
+    const groups = await fetchGroups(account.apiBaseUrl, account.botToken);
+    let count = 0;
+    for (const g of groups) {
+        if (unwrappedKeys.has(g.id)) {
+            count++;
+            continue;
+        }
+        const key = await unwrapGroupKey(g.wrappedGroupKey, account.botPrivateKey);
+        if (key) {
+            unwrappedKeys.set(g.id, key);
+            count++;
+        }
+    }
+    return count;
+}
+/** Wait for an AbortSignal to fire */
+function waitForAbort(signal) {
+    if (signal.aborted)
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        signal.addEventListener("abort", () => resolve(), { once: true });
+    });
+}
+export const ozaiyaPlugin = {
+    id: "ozaiya",
+    meta: {
+        id: "ozaiya",
+        label: "Ozaiya",
+        selectionLabel: "Ozaiya Chat",
+        docsPath: "/channels/ozaiya",
+        blurb: "E2E encrypted group chat with Ozaiya.",
+    },
+    capabilities: {
+        chatTypes: ["group", "direct"],
+        reactions: true,
+        threads: false,
+        media: true,
+        nativeCommands: false,
+        blockStreaming: true,
+    },
+    reload: { configPrefixes: ["channels.ozaiya"] },
+    config: {
+        listAccountIds: (cfg) => listAccountIds(cfg),
+        resolveAccount: (cfg, accountId) => resolveAccount(cfg, accountId),
+        defaultAccountId: () => DEFAULT_ACCOUNT_ID,
+        isConfigured: (account) => Boolean(account.botToken?.trim() && account.botPrivateKey?.trim() && account.webhookSecret?.trim()),
+        describeAccount: (account) => ({
+            accountId: account.accountId,
+            enabled: account.enabled,
+            configured: Boolean(account.botToken?.trim() && account.botPrivateKey?.trim()),
+            webhookPath: account.webhookPath,
+            baseUrl: account.apiBaseUrl,
+        }),
+    },
+    security: {
+        resolveDmPolicy: () => ({
+            policy: "open",
+            allowFrom: [],
+            policyPath: "channels.ozaiya.dmPolicy",
+            allowFromPath: "channels.ozaiya.",
+            approveHint: "N/A (group-only)",
+        }),
+    },
+    messaging: {
+        normalizeTarget: (target) => target.trim() || undefined,
+        targetResolver: {
+            looksLikeId: (id) => Boolean(id?.trim()),
+            hint: "<groupId>",
+        },
+    },
+    directory: {
+        self: async () => null,
+        listPeers: async () => [],
+        listGroups: async ({ cfg, accountId }) => {
+            const account = resolveAccount(cfg, accountId);
+            if (!account.botToken?.trim())
+                return [];
+            try {
+                const groups = await fetchGroups(account.apiBaseUrl, account.botToken);
+                return groups.map((g) => ({
+                    id: g.id,
+                    name: g.name ?? g.id,
+                }));
+            }
+            catch {
+                return [];
+            }
+        },
+    },
+    setup: {
+        applyAccountConfig: ({ cfg, input }) => {
+            const ozaiyaConfig = resolveConfig(cfg) ?? {};
+            return {
+                ...cfg,
+                channels: {
+                    ...cfg.channels,
+                    ozaiya: {
+                        ...ozaiyaConfig,
+                        enabled: true,
+                        ...(input.token ? { botToken: input.token } : {}),
+                    },
+                },
+            };
+        },
+    },
+    outbound: {
+        deliveryMode: "direct",
+        textChunkLimit: 4000,
+        sendText: async ({ to, text, cfg, accountId }) => {
+            const account = resolveAccount(cfg, accountId);
+            const groupId = to.replace(/^ozaiya:group:/, "");
+            let groupKey = unwrappedKeys.get(groupId);
+            if (!groupKey) {
+                // On-demand fetch for groups added after startup
+                await fetchAndUnwrapGroupKeys(account);
+                groupKey = unwrappedKeys.get(groupId);
+                if (!groupKey) {
+                    throw new Error(`No group key available for group ${groupId}`);
+                }
+            }
+            const encrypted = encryptMessage({ text }, groupKey);
+            const result = await sendMessage(account.apiBaseUrl, account.botToken, groupId, encrypted);
+            recordState(account.accountId, { lastOutboundAt: Date.now() });
+            return {
+                channel: "ozaiya",
+                messageId: result.message.id,
+                chatId: groupId,
+            };
+        },
+        sendMedia: async ({ to, text, mediaUrl, cfg, accountId }) => {
+            const account = resolveAccount(cfg, accountId);
+            const groupId = to.replace(/^ozaiya:group:/, "");
+            let groupKey = unwrappedKeys.get(groupId);
+            if (!groupKey) {
+                await fetchAndUnwrapGroupKeys(account);
+                groupKey = unwrappedKeys.get(groupId);
+                if (!groupKey) {
+                    throw new Error(`No group key available for group ${groupId}`);
+                }
+            }
+            let fileInfo;
+            if (mediaUrl) {
+                const mediaRes = await fetch(mediaUrl, { signal: AbortSignal.timeout(60_000) });
+                if (!mediaRes.ok) {
+                    throw new Error(`Failed to download media: ${mediaRes.status}`);
+                }
+                const buffer = Buffer.from(await mediaRes.arrayBuffer());
+                const filename = new URL(mediaUrl).pathname.split("/").pop() || "file";
+                const mime = mediaRes.headers.get("content-type") || "application/octet-stream";
+                fileInfo = await uploadFile(account.apiBaseUrl, account.botToken, groupId, filename, mime, buffer);
+            }
+            const content = {
+                text: text || undefined,
+                files: fileInfo ? [fileInfo] : undefined,
+            };
+            const encrypted = encryptMessage(content, groupKey);
+            const result = await sendMessage(account.apiBaseUrl, account.botToken, groupId, encrypted);
+            recordState(account.accountId, { lastOutboundAt: Date.now() });
+            return {
+                channel: "ozaiya",
+                messageId: result.message.id,
+                chatId: groupId,
+            };
+        },
+    },
+    mentions: {
+        stripMentions: ({ text }) => {
+            // Strip leading @mention trigger (e.g. "@codex remind me..." → "remind me...")
+            return text.replace(/^@\S+\s*/u, "").trim() || text;
+        },
+    },
+    groups: {
+        // requireMention is enforced server-side via replyAllowed in the webhook payload;
+        // return undefined here to defer to the framework's default group policy.
+        resolveRequireMention: () => undefined,
+    },
+    actions: {
+        listActions: (_params) => ["send", "react", "edit", "unsend", "pin", "unpin"],
+        supportsButtons: (_params) => true,
+        handleAction: async (ctx) => {
+            const { action, params, cfg, accountId } = ctx;
+            const account = resolveAccount(cfg, accountId);
+            switch (action) {
+                case "react": {
+                    const messageId = params.messageId;
+                    const emoji = params.emoji;
+                    const result = await toggleReaction(account.apiBaseUrl, account.botToken, messageId, emoji);
+                    return { ok: true, ...result };
+                }
+                case "edit": {
+                    const messageId = params.messageId;
+                    const content = params.content;
+                    const groupId = params.chatId;
+                    let groupKey = unwrappedKeys.get(groupId);
+                    if (!groupKey) {
+                        await fetchAndUnwrapGroupKeys(account);
+                        groupKey = unwrappedKeys.get(groupId);
+                        if (!groupKey) {
+                            throw new Error(`No group key available for group ${groupId}`);
+                        }
+                    }
+                    const encrypted = encryptMessage({ text: content }, groupKey);
+                    await editMessage(account.apiBaseUrl, account.botToken, messageId, encrypted);
+                    return { ok: true };
+                }
+                case "unsend": {
+                    const messageId = params.messageId;
+                    await deleteMessage(account.apiBaseUrl, account.botToken, messageId);
+                    return { ok: true, deleted: true };
+                }
+                case "pin": {
+                    const messageId = params.messageId;
+                    await pinMessage(account.apiBaseUrl, account.botToken, messageId);
+                    return { ok: true };
+                }
+                case "unpin": {
+                    const messageId = params.messageId;
+                    await unpinMessage(account.apiBaseUrl, account.botToken, messageId);
+                    return { ok: true };
+                }
+                default:
+                    throw new Error(`Action "${action}" not supported`);
+            }
+        },
+    },
+    status: {
+        defaultRuntime: {
+            accountId: DEFAULT_ACCOUNT_ID,
+            running: false,
+            lastStartAt: null,
+            lastStopAt: null,
+            lastError: null,
+        },
+        probeAccount: async ({ account, timeoutMs }) => probeApi(account.apiBaseUrl, account.botToken, timeoutMs),
+        buildAccountSnapshot: ({ account, runtime, probe }) => {
+            const configured = Boolean(account.botToken?.trim() && account.botPrivateKey?.trim() && account.webhookSecret?.trim());
+            const state = getState(account.accountId);
+            return {
+                accountId: account.accountId,
+                enabled: account.enabled,
+                configured,
+                running: state?.running ?? runtime?.running ?? false,
+                lastStartAt: state?.lastStartAt ?? runtime?.lastStartAt ?? null,
+                lastStopAt: state?.lastStopAt ?? runtime?.lastStopAt ?? null,
+                lastError: state?.lastError ?? runtime?.lastError ?? null,
+                lastInboundAt: state?.lastInboundAt ?? runtime?.lastInboundAt ?? null,
+                lastOutboundAt: state?.lastOutboundAt ?? runtime?.lastOutboundAt ?? null,
+                mode: "webhook",
+                probe,
+                webhookPath: account.webhookPath,
+                baseUrl: account.apiBaseUrl,
+            };
+        },
+    },
+    agentTools: (({ cfg }) => {
+        if (!cfg)
+            return [];
+        const account = resolveAccount(cfg);
+        if (!account.botToken?.trim())
+            return [];
+        return [createScheduleMessageTool(account)];
+    }),
+    gateway: {
+        startAccount: async (ctx) => {
+            const account = ctx.account;
+            // Validate config
+            if (!account.botToken?.trim()) {
+                throw new Error("Ozaiya: botToken is required");
+            }
+            if (!account.botPrivateKey?.trim()) {
+                throw new Error("Ozaiya: botPrivateKey is required");
+            }
+            if (!account.webhookSecret?.trim()) {
+                throw new Error("Ozaiya: webhookSecret is required");
+            }
+            ctx.log?.info(`[${account.accountId}] starting Ozaiya provider`);
+            // Record starting state
+            recordState(account.accountId, { running: true, lastStartAt: Date.now() });
+            // Fetch and unwrap group keys from API
+            const keyCount = await fetchAndUnwrapGroupKeys(account);
+            ctx.log?.info(`[${account.accountId}] unwrapped ${keyCount} group key(s)`);
+            // Register webhook HTTP handler
+            const unregisterHttp = registerPluginHttpRoute({
+                path: account.webhookPath,
+                auth: "plugin",
+                replaceExisting: true,
+                pluginId: "ozaiya",
+                source: "ozaiya-channel",
+                log: (msg) => ctx.log?.info(msg),
+                handler: createOzaiyaWebhookHandler({
+                    webhookSecret: account.webhookSecret,
+                    log: (msg) => ctx.log?.info(msg),
+                    onMessage: async (payload) => {
+                        await handleInboundMessage(payload, ctx);
+                    },
+                }),
+            });
+            ctx.log?.info(`[${account.accountId}] registered webhook at ${account.webhookPath}`);
+            // Block until abort
+            const stopHandler = () => {
+                ctx.log?.info(`[${account.accountId}] stopping Ozaiya provider`);
+                unregisterHttp();
+                recordState(account.accountId, { running: false, lastStopAt: Date.now() });
+            };
+            if (ctx.abortSignal.aborted) {
+                stopHandler();
+            }
+            else {
+                ctx.abortSignal.addEventListener("abort", stopHandler, { once: true });
+                await waitForAbort(ctx.abortSignal);
+            }
+        },
+    },
+};
+/**
+ * Create the schedule_message agent tool for a specific account.
+ *
+ * Uses an in-memory setTimeout, so scheduled messages survive only until the
+ * process restarts. For persistent scheduling, pair with a server-side BullMQ queue.
+ */
+function createScheduleMessageTool(account) {
+    return {
+        label: "Schedule Message",
+        name: "schedule_message",
+        ownerOnly: false,
+        description: "Schedule an encrypted message to be sent to an Ozaiya group at a future time. " +
+            "Provide either delaySeconds (1–86400) for a relative delay, " +
+            "or atTime (ISO-8601) for an absolute send time. " +
+            "Note: scheduled messages are held in memory and will be lost if the gateway restarts.",
+        // Plain JSON Schema — cast as `any` because openclaw's ChannelAgentTool
+        // expects a TypeBox TObject, but JSON Schema objects are accepted at runtime.
+        parameters: {
+            type: "object",
+            properties: {
+                groupId: {
+                    type: "string",
+                    description: "The Ozaiya group ID to send the message to.",
+                },
+                message: {
+                    type: "string",
+                    description: "The message text to send.",
+                },
+                delaySeconds: {
+                    type: "number",
+                    minimum: 1,
+                    maximum: 86400,
+                    description: "Delay in seconds before sending (1–86400). Use this OR atTime.",
+                },
+                atTime: {
+                    type: "string",
+                    description: "ISO-8601 datetime when to send, e.g. 2026-03-09T20:00:00Z. Use this OR delaySeconds.",
+                },
+            },
+            required: ["groupId", "message"],
+        },
+        execute: async (_toolCallId, rawArgs) => {
+            const args = rawArgs;
+            const { groupId, message, delaySeconds, atTime } = args;
+            if (!groupId?.trim()) {
+                return { content: [{ type: "text", text: "Error: groupId is required." }] };
+            }
+            if (!message?.trim()) {
+                return { content: [{ type: "text", text: "Error: message is required." }] };
+            }
+            let delayMs;
+            if (atTime) {
+                const ts = new Date(atTime).getTime();
+                if (isNaN(ts)) {
+                    return { content: [{ type: "text", text: `Error: invalid atTime "${atTime}".` }] };
+                }
+                delayMs = ts - Date.now();
+            }
+            else {
+                delayMs = (delaySeconds ?? 0) * 1000;
+            }
+            if (delayMs < 0) {
+                return { content: [{ type: "text", text: "Error: scheduled time is in the past." }] };
+            }
+            if (delayMs > 86_400_000) {
+                return { content: [{ type: "text", text: "Error: cannot schedule more than 24 hours in advance." }] };
+            }
+            const scheduledAt = new Date(Date.now() + delayMs).toISOString();
+            setTimeout(async () => {
+                let groupKey = unwrappedKeys.get(groupId);
+                if (!groupKey) {
+                    try {
+                        await fetchAndUnwrapGroupKeys(account);
+                        groupKey = unwrappedKeys.get(groupId);
+                    }
+                    catch {
+                        // ignore key-fetch errors silently
+                    }
+                }
+                if (!groupKey)
+                    return;
+                const encrypted = encryptMessage({ text: message }, groupKey);
+                await sendMessage(account.apiBaseUrl, account.botToken, groupId, encrypted).catch(() => { });
+                recordState(account.accountId, { lastOutboundAt: Date.now() });
+            }, delayMs);
+            const delayHuman = delayMs < 60_000
+                ? `${Math.round(delayMs / 1000)} seconds`
+                : delayMs < 3_600_000
+                    ? `${Math.round(delayMs / 60_000)} minutes`
+                    : `${(delayMs / 3_600_000).toFixed(1)} hours`;
+            return {
+                content: [{ type: "text", text: `Message scheduled for ${scheduledAt} (in ${delayHuman}).` }],
+            };
+        },
+    };
+}
+/**
+ * Handle an inbound webhook message:
+ * 1. Decrypt message content
+ * 2. Resolve agent route via PluginRuntime
+ * 3. Build inbound envelope
+ * 4. Dispatch to agent via buffered block dispatcher
+ * 5. Deliver reply (encrypt + send)
+ */
+async function handleInboundMessage(payload, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+ctx) {
+    const { groupId, message, replyAllowed = true, context } = payload;
+    const account = ctx.account;
+    // Record inbound activity
+    recordState(account.accountId, { lastInboundAt: Date.now() });
+    // Get group key (on-demand fetch if not cached)
+    let groupKey = unwrappedKeys.get(groupId);
+    if (!groupKey) {
+        ctx.log?.info?.(`ozaiya: group key not cached for ${groupId}, fetching from API`);
+        try {
+            await fetchAndUnwrapGroupKeys(account);
+            groupKey = unwrappedKeys.get(groupId);
+        }
+        catch (err) {
+            ctx.log?.warn?.(`ozaiya: failed to fetch group keys: ${String(err)}`);
+        }
+        if (!groupKey) {
+            ctx.log?.warn?.(`ozaiya: no group key for group ${groupId}, skipping message`);
+            return;
+        }
+    }
+    // Decrypt message
+    const content = decryptMessage(message.content, groupKey);
+    if (!content?.text) {
+        ctx.log?.warn?.("ozaiya: failed to decrypt message or empty text");
+        return;
+    }
+    ctx.log?.info(`ozaiya: received message from ${message.senderName} in group ${groupId}`);
+    // Skip reply when server indicates reply is not allowed (mentionToReply setting)
+    if (!replyAllowed) {
+        ctx.log?.info(`ozaiya: replyAllowed=false, skipping reply`);
+        return;
+    }
+    // Decrypt context messages for InboundHistory (recent chat history for agent context)
+    const inboundHistory = [];
+    if (context && context.length > 0) {
+        for (const ctxMsg of context) {
+            const decrypted = decryptMessage(ctxMsg.content, groupKey);
+            if (decrypted?.text) {
+                inboundHistory.push({
+                    sender: ctxMsg.senderName,
+                    body: decrypted.text,
+                    timestamp: ctxMsg.createdAt,
+                });
+            }
+        }
+        ctx.log?.info(`ozaiya: decrypted ${inboundHistory.length} context messages for InboundHistory`);
+    }
+    // Access agent dispatch APIs via PluginRuntime (set during plugin registration)
+    const runtime = getOzaiyaRuntime();
+    const ch = runtime.channel;
+    // Resolve agent route
+    const route = ch.routing.resolveAgentRoute({
+        cfg: ctx.cfg,
+        channel: "ozaiya",
+        accountId: account.accountId,
+        peer: {
+            kind: "group",
+            id: groupId,
+        },
+    });
+    const fromAddress = `ozaiya:group:${groupId}`;
+    const conversationLabel = `group:${groupId}`;
+    // Build inbound session envelope context
+    const storePath = ch.session.resolveStorePath(undefined, {
+        agentId: route.agentId,
+    });
+    const previousTimestamp = ch.session.readSessionUpdatedAt({
+        storePath,
+        sessionKey: route.sessionKey,
+    });
+    const envelopeOptions = ch.reply.resolveEnvelopeFormatOptions(ctx.cfg);
+    const body = ch.reply.formatAgentEnvelope({
+        channel: "Ozaiya",
+        from: `${message.senderName} (${conversationLabel})`,
+        timestamp: message.createdAt,
+        previousTimestamp,
+        envelope: envelopeOptions,
+        body: content.text,
+    });
+    // Build finalized context for dispatch
+    const msgCtx = ch.reply.finalizeInboundContext({
+        Body: body,
+        BodyForAgent: content.text,
+        RawBody: content.text,
+        CommandBody: content.text,
+        From: fromAddress,
+        To: fromAddress,
+        SessionKey: route.sessionKey,
+        AccountId: route.accountId,
+        ChatType: "group",
+        ConversationLabel: conversationLabel,
+        GroupSubject: groupId,
+        SenderId: message.senderId,
+        SenderName: message.senderName,
+        Provider: "ozaiya",
+        Surface: "ozaiya",
+        MessageSid: message.id,
+        Timestamp: message.createdAt,
+        ReplyToId: message.replyToId ?? undefined,
+        CommandAuthorized: true,
+        InboundHistory: inboundHistory.length > 0 ? inboundHistory : undefined,
+        OriginatingChannel: "ozaiya",
+        OriginatingTo: fromAddress,
+    });
+    // Record inbound session
+    void ch.session.recordInboundSession({
+        storePath,
+        sessionKey: route.sessionKey,
+        ctx: msgCtx,
+        onRecordError: (err) => {
+            ctx.log?.warn?.(`ozaiya: failed recording session: ${String(err)}`);
+        },
+    }).catch((err) => {
+        ctx.log?.warn?.(`ozaiya: failed recording session: ${String(err)}`);
+    });
+    // Dispatch to agent with buffered block dispatcher
+    await ch.reply.dispatchReplyWithBufferedBlockDispatcher({
+        ctx: msgCtx,
+        cfg: ctx.cfg,
+        dispatcherOptions: {
+            deliver: async (replyPayload, _info) => {
+                const replyText = replyPayload.text;
+                ctx.log?.info?.(`ozaiya: deliver called, text length=${replyText?.length ?? 0}, empty=${!replyText?.trim()}`);
+                if (!replyText?.trim())
+                    return;
+                // Encrypt and send response
+                const encrypted = encryptMessage({ text: replyText }, groupKey);
+                ctx.log?.info?.(`ozaiya: sending reply to group ${groupId}`);
+                await sendMessage(account.apiBaseUrl, account.botToken, groupId, encrypted);
+                recordState(account.accountId, { lastOutboundAt: Date.now() });
+                ctx.log?.info?.(`ozaiya: reply sent successfully`);
+            },
+            onError: (err) => {
+                ctx.log?.warn?.(`ozaiya: reply dispatch error: ${String(err)}`);
+            },
+        },
+    });
+}
+//# sourceMappingURL=channel.js.map