clawgram 2.22.0 → 2.24.0

package/dist/outbound.js

@@ -0,0 +1,260 @@
+"use strict";
+// Исходящий контур канала: куда уходит текст и что при этом проверяется.
+//
+// Вынесено из channel.ts — файла на 3009 строк при следующем по величине
+// 1165 (находка A6-11). Замыкание использовало отсюда ровно две вещи:
+// карту рантаймов и журнал, поэтому блок отделяется фабрикой, а не
+// переписыванием.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOutbound = createOutbound;
+const core_1 = require("openclaw/plugin-sdk/core");
+const media_1 = require("./media");
+const send_scope_1 = require("./send-scope");
+const system_notice_1 = require("./system-notice");
+const group_reply_address_1 = require("./group-reply-address");
+const group_visible_reply_guard_1 = require("./group-visible-reply-guard");
+const helpers_1 = require("./helpers");
+const helpers_2 = require("./helpers");
+const actionLog = (0, core_1.createSubsystemLogger)("channels/clawgram");
+/** Исходящий контур для карты рантаймов канала. */
+function createOutbound(runtimes) {
+    return {
+        // Core's agent-delivery path (`--deliver`, subagent announces) calls this
+        // hook under three constraints, all learned live on 2026-08-06:
+        //
+        // - `to` may be undefined (no explicit target, session route yielded
+        //   none), and a rejection is NOT caught: a throw here is an unhandled
+        //   rejection that takes down the entire gateway process.
+        // - `resolveAgentDeliveryPlanWithSessionRoute` calls it WITHOUT await.
+        //   An async hook hands core a Promise, `promise.ok` reads undefined and
+        //   the error branch dereferences `promise.error.message` — the crash
+        //   every subagent announce died on. The hook must return a plain value;
+        //   the call sites that do await are unaffected, await of a value works.
+        // - In a not-ok result core reads `error.message`, so the error must be
+        //   Error-like, not a bare string.
+        //
+        // Peer resolution deliberately does not happen here: `sendText` resolves
+        // the peer itself, and doing it here would force the hook async again.
+        resolveTarget(ctx) {
+            try {
+                const raw = typeof ctx.to === "string" ? ctx.to.trim() : "";
+                actionLog.info("clawgram outbound resolveTarget", {
+                    accountId: ctx.accountId,
+                    rawTo: raw || null,
+                });
+                if (!raw) {
+                    return { ok: false, error: new Error("clawgram: no delivery target — pass `to` or use a session with a bound chat") };
+                }
+                const target = (0, helpers_1.normalizeOutboundTarget)(raw);
+                // Тот же барьер, что у `handleAction`: доставка ядра (`--deliver`,
+                // анонсы субагентов) идёт этим путём и мимо той проверки. Отказ
+                // здесь возвращается результатом, а не броском: бросок в этом хуке
+                // роняет весь gateway (грабли 06.08.2026, выше).
+                if (!(0, send_scope_1.isChatSendable)(target, (0, send_scope_1.sendScopeFor)(ctx.accountId))) {
+                    const reason = (0, send_scope_1.isPhoneNumberTarget)(target)
+                        ? "phone-number target"
+                        : "chat outside send scope";
+                    actionLog.warn("clawgram outbound resolveTarget refused", {
+                        accountId: ctx.accountId,
+                        target,
+                        reason,
+                    });
+                    return { ok: false, error: new Error(`clawgram: not-allowed-chat ${target}`) };
+                }
+                return { ok: true, to: target };
+            }
+            catch (err) {
+                return { ok: false, error: err instanceof Error ? err : new Error(String(err)) };
+            }
+        },
+        async sendText(ctx) {
+            // Never log `text`: outbound bodies are private correspondence and the
+            // channel log is a plain journald sink. Length is enough to tell an
+            // empty or truncated send apart from a real one.
+            actionLog.info("clawgram outbound sendText", {
+                accountId: ctx.accountId,
+                rawTo: ctx.to,
+                replyToId: ctx.replyToId ?? null,
+                threadId: ctx.threadId ?? null,
+                textLength: ctx.text.length,
+            });
+            // Core normalizes reply payloads and drops the silent token before a
+            // channel is called, so this should never see one. "Should never" is
+            // what the inbound path was assumed to be too, right until it posted a
+            // token — and the check costs a string comparison.
+            if (ctx.text.trim() && (0, helpers_1.isSilentReplyText)(ctx.text)) {
+                actionLog.info("clawgram suppressing silent outbound send", {
+                    accountId: ctx.accountId,
+                    rawTo: ctx.to,
+                });
+                return { skipped: "silent" };
+            }
+            // Core's operational chatter (tool-error warnings, fallback notices)
+            // stays out of group chats: it is telemetry for the operator, not a
+            // reply to the room, and it has already been seen carrying shell
+            // commands with secret-store paths. DMs keep it. The text itself is
+            // never logged — see system-notice.ts for why.
+            const suppressedNotice = (0, system_notice_1.shouldSuppressGroupSystemNotice)({
+                targetKind: (0, helpers_1.inferOutboundTargetKind)(ctx.to),
+                text: ctx.text,
+                to: ctx.to,
+                operatorIds: (0, system_notice_1.operatorIdsFor)(ctx.accountId),
+            });
+            if (suppressedNotice) {
+                actionLog.warn("clawgram suppressing system notice in group", {
+                    accountId: ctx.accountId,
+                    rawTo: ctx.to,
+                    noticeKind: suppressedNotice,
+                    textLength: ctx.text.length,
+                });
+                return { skipped: "system-notice" };
+            }
+            const gram = runtimes.get(ctx.accountId);
+            if (!gram) {
+                throw new Error(`clawgram: runtime not found for account ${ctx.accountId}`);
+            }
+            // The agent already answered this message with its own `send`, and this
+            // is core delivering the same turn's final text. Two messages for one
+            // answer is how 2026-08-10 read in a work chat: every request reported
+            // twice, in slightly different words, seconds apart.
+            //
+            // Core's own convention is that an agent which has sent a message
+            // returns NO_REPLY; this catches the turns that forget. The window is
+            // seconds wide, so a result the assistant comes back with later is
+            // still delivered.
+            if (ctx.replyToId !== null && ctx.replyToId !== undefined && (0, group_visible_reply_guard_1.hadTurnSendJustNow)({
+                accountId: ctx.accountId,
+                chatId: (0, helpers_1.normalizeOutboundTarget)(ctx.to),
+                currentMessageId: ctx.replyToId,
+            })) {
+                actionLog.warn("clawgram suppressing echo of a turn that already sent", {
+                    accountId: ctx.accountId,
+                    rawTo: ctx.to,
+                    replyToId: ctx.replyToId,
+                    textLength: ctx.text.length,
+                });
+                return { skipped: "duplicate" };
+            }
+            const groupReplyAddress = (0, group_reply_address_1.consumeGroupReplyAddress)({
+                accountId: ctx.accountId,
+                chatId: ctx.to,
+                replyToId: ctx.replyToId,
+            });
+            const targetKind = (0, helpers_1.inferOutboundTargetKind)(ctx.to);
+            const target = (0, helpers_1.normalizeOutboundTarget)(ctx.to);
+            const messageThreadId = (0, helpers_2.parseOptionalThreadId)(ctx.threadId);
+            const sent = await gram.sendText({
+                target,
+                text: (0, helpers_1.prefixReplyTextToAddress)(ctx.text, groupReplyAddress),
+                targetKind,
+                replyToMessageId: (0, helpers_1.resolveReplyToMessageIdForTarget)(ctx.to, ctx.replyToId),
+                messageThreadId,
+                parseMode: gram.replyParseMode,
+            });
+            actionLog.info("clawgram outbound sendText completed", {
+                accountId: ctx.accountId,
+                to: target,
+                targetKind,
+                replyToId: ctx.replyToId ?? null,
+                sentMessageId: String(sent?.id ?? ""),
+            });
+            return {
+                ok: true,
+                messageId: String(sent?.id ?? ""),
+            };
+        },
+        async sendMedia(ctx) {
+            const gram = runtimes.get(ctx.accountId);
+            if (!gram) {
+                throw new Error(`clawgram: runtime not found for account ${ctx.accountId}`);
+            }
+            // Same rule as the action path: a local file outside the declared
+            // roots is refused before anything is uploaded.
+            const outboundRoots = ctx.mediaLocalRoots ?? ctx.mediaAccess?.localRoots;
+            (0, media_1.assertLocalMediaWithinRoots)(ctx.filePath, outboundRoots);
+            (0, media_1.assertLocalMediaWithinRoots)(ctx.mediaUrl, outboundRoots);
+            actionLog.info("clawgram outbound sendMedia", {
+                accountId: ctx.accountId,
+                rawTo: ctx.to,
+                replyToId: ctx.replyToId ?? null,
+                threadId: ctx.threadId ?? null,
+                filePath: ctx.filePath ?? null,
+                mediaUrl: ctx.mediaUrl ?? null,
+                hasText: Boolean(ctx.text),
+                hasCaption: Boolean(ctx.caption),
+                asVoice: ctx.audioAsVoice === true,
+            });
+            const file = ctx.filePath ?? ctx.mediaUrl;
+            if (!file) {
+                throw new Error("clawgram: sendMedia requires filePath or mediaUrl");
+            }
+            // Ниже — проверки, которые у `sendText` были, а здесь не было ни
+            // одной: путь доставки медиа писался отдельно и обзавёлся только
+            // своими границами (находка A6-18).
+            const mediaTarget = (0, helpers_1.normalizeOutboundTarget)(ctx.to);
+            // Область отправки: файл наружу — такое же исходящее, как текст.
+            // `resolveTarget` ядро зовёт не на каждом пути, поэтому проверяем и тут.
+            if (!(0, send_scope_1.isChatSendable)(mediaTarget, (0, send_scope_1.sendScopeFor)(ctx.accountId))) {
+                actionLog.warn("clawgram outbound sendMedia refused", {
+                    accountId: ctx.accountId,
+                    target: mediaTarget,
+                    reason: (0, send_scope_1.isPhoneNumberTarget)(mediaTarget) ? "phone-number target" : "chat outside send scope",
+                });
+                return { skipped: "not-allowed" };
+            }
+            // Молчаливый ответ: подпись с токеном молчания означает «ничего не
+            // говорить», и отправлять файл с ним в подписи — тем более.
+            const mediaCaption = ctx.caption ?? ctx.text;
+            if (mediaCaption?.trim() && (0, helpers_1.isSilentReplyText)(mediaCaption)) {
+                actionLog.info("clawgram suppressing silent outbound media", {
+                    accountId: ctx.accountId,
+                    rawTo: ctx.to,
+                });
+                return { skipped: "silent" };
+            }
+            // Обращение в группе — то же, что у текста: адрес принадлежит
+            // конкретному входящему сообщению, а не последнему говорившему.
+            const mediaReplyAddress = (0, group_reply_address_1.consumeGroupReplyAddress)({
+                accountId: ctx.accountId,
+                chatId: ctx.to,
+                replyToId: ctx.replyToId,
+            });
+            // Чего здесь НЕТ намеренно:
+            // — подавление эха хода (`hadTurnSendJustNow`): у текста дубль стоит
+            //   лишнего сообщения, а у медиа отказ стоит потерянного файла —
+            //   картинку агент готовил, и второй раз она не появится;
+            // — подавление служебных сообщений ядра в группах: они текстовые,
+            //   медиа-доставка ими не бывает.
+            const messageThreadId = (0, helpers_2.parseOptionalThreadId)(ctx.threadId);
+            // Same normalization `sendText` does two functions up. Without it the
+            // channel prefix reaches peer resolution and the send throws — which is
+            // exactly how a synthesized group reply died on 2026-08-08, silently
+            // enough that the transcript fallback posted it as raw text instead.
+            const target = (0, helpers_1.normalizeOutboundTarget)(ctx.to);
+            const sent = await gram.sendMedia({
+                target,
+                file,
+                // Подпись получает то же обращение, что и текстовый ответ.
+                caption: mediaCaption
+                    ? (0, helpers_1.prefixReplyTextToAddress)(mediaCaption, mediaReplyAddress)
+                    : mediaCaption,
+                // Captions follow the account reply format like every other reply:
+                // they are the same agent prose, just attached to a file (2.15.0).
+                parseMode: gram.replyParseMode,
+                replyToMessageId: (0, helpers_1.resolveReplyToMessageIdForTarget)(ctx.to, ctx.replyToId),
+                messageThreadId,
+                asVoice: ctx.audioAsVoice === true,
+            });
+            actionLog.info("clawgram outbound sendMedia completed", {
+                accountId: ctx.accountId,
+                to: ctx.to,
+                replyToId: ctx.replyToId ?? null,
+                sentMessageId: String(sent?.id ?? ""),
+            });
+            return {
+                ok: true,
+                messageId: String(sent?.id ?? ""),
+            };
+        },
+    };
+}

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "clawgram",
   "name": "Clawgram",
   "description": "Clawgram — personal Telegram (MTProto userbot) channel for OpenClaw. Your AI assistant reads and responds as you.",
-  "version": "2.22.0",
+  "version": "2.24.0",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawgram",
-  "version": "2.22.0",
+  "version": "2.24.0",
   "description": "Clawgram — personal Telegram (MTProto userbot) channel for OpenClaw. Your AI assistant reads and responds as you.",
   "main": "./dist/index.js",
   "scripts": {