clawgram 2.24.0 → 2.26.0

package/dist/inbound-pipeline.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.visibleReplyText = visibleReplyText;
 exports.handleInboundEvent = handleInboundEvent;
 // Входящий контур: одно событие Telegram от нормализации до ответа.
 //
@@ -26,6 +27,7 @@ const normalize_1 = require("./normalize");
 const reactions_1 = require("./reactions");
 const silent_reaction_1 = require("./silent-reaction");
 const system_notice_1 = require("./system-notice");
+const account_registry_1 = require("./account-registry");
 const group_reply_address_1 = require("./group-reply-address");
 const helpers_1 = require("./helpers");
 const constants_2 = require("./constants");
@@ -67,8 +69,53 @@ async function reactToSilentMentionForAccount(params) {
     });
 }
 const actionLog = (0, core_1.createSubsystemLogger)("channels/clawgram");
+/**
+ * The text a reply may carry into a chat, after the filters every reply path
+ * shares — or `undefined` when nothing should go out.
+ *
+ * Three doors deliver an agent's words: the group `deliver` closure, the
+ * direct-message `deliver` closure and the transcript fallback. Each carried
+ * its own copy of the same two checks — drop the silent token, drop core's
+ * telemetry — and the copies drifted: the DM path had no notice filter at
+ * all until B5-01 (audit B5-13). One function now; the log lines keep their
+ * historical wording so journals stay greppable.
+ */
+function visibleReplyText(params) {
+    // Not destructured: a wiring ratchet in test/inbound-pipeline.test.ts finds
+    // handleInboundEvent's own destructuring of its context by pattern, and
+    // nothing shaped like it may stand in front.
+    const accountId = params.accountId;
+    const chatId = params.chatId;
+    const messageId = params.messageId;
+    const log = params.log;
+    const outboundText = typeof params.text === "string" ? params.text.trim() : "";
+    if (!outboundText) {
+        return undefined;
+    }
+    // The agent may decline to answer by returning the shared silent token.
+    // Dropped before addressing: otherwise the reply-address prefix turns it
+    // into a visible message.
+    const visibleText = (0, helpers_1.stripSilentReplyToken)(outboundText);
+    if (!visibleText) {
+        log?.info?.(`clawgram suppressing silent ${params.where}`, { accountId, chatId, messageId });
+        return undefined;
+    }
+    // Core glues its telemetry to the turn's payload and it arrives here the
+    // same way an answer does. In a group it never goes out; in a DM only the
+    // named operator may receive it (A5-10, A5-11, B5-01).
+    const notice = (0, system_notice_1.shouldSuppressGroupSystemNotice)(params.kind === "group"
+        ? { targetKind: "group", text: visibleText }
+        : { targetKind: "user", text: visibleText, to: chatId, operatorIds: (0, account_registry_1.operatorIdsFor)(accountId) });
+    if (notice) {
+        log?.warn?.(`clawgram suppressing system notice in ${params.where}`, {
+            accountId, chatId, messageId, noticeKind: notice, textLength: visibleText.length,
+        });
+        return undefined;
+    }
+    return visibleText;
+}
 async function handleInboundEvent(event, ctx) {
-    const { accountId, cfg, channelRuntime, client, gram, log, pairing, pluginRuntime, runtimes, selfId, selfLabel, selfUsername } = ctx;
+    const { accountId, cfg, channelRuntime, client, gram, log, pluginRuntime, runtimes, selfId, selfLabel, selfUsername } = ctx;
     try {
         const rawMessage = event?.message;
         const rawPeerUserId = rawMessage?.peerId?.userId;
@@ -101,30 +148,6 @@ async function handleInboundEvent(event, ctx) {
             }
             return;
         }
-        const directReplyTarget = normalized.chatType === "direct"
-            ? undefined
-            : await (0, helpers_1.resolveReplyTarget)(rawMessage);
-        const senderProfile = normalized.chatType === "direct"
-            ? await (0, helpers_1.resolveSenderProfileWithTimeout)(rawMessage, {
-                senderId: normalized.senderId,
-                client,
-            }, 1500)
-            : await (0, helpers_1.resolveSenderProfile)(rawMessage, {
-                senderId: normalized.senderId,
-                client,
-            });
-        const replyTarget = normalized.chatType === "direct"
-            ? normalized.chatId
-            : await (0, helpers_1.resolveChatTarget)(rawMessage);
-        if (replyTarget) {
-            normalized.replyTarget = replyTarget;
-        }
-        if (!normalized.senderUsername && senderProfile.username) {
-            normalized.senderUsername = senderProfile.username;
-        }
-        if (!normalized.senderDisplay && senderProfile.display) {
-            normalized.senderDisplay = senderProfile.display;
-        }
         if (normalized.isOutgoing) {
             if (normalized.chatType === "direct") {
                 log?.info?.("clawgram skipping outgoing direct event", {
@@ -145,6 +168,61 @@ async function handleInboundEvent(event, ctx) {
             });
             return;
         }
+        // Ворота — ДО сети. До 2.25.0 на каждое сообщение из любой группы,
+        // где сидит аккаунт, — включая группы вне `groups` — плагин делал
+        // до семи запросов к Telegram (профиль отправителя, адрес ответа,
+        // цель чата) и только потом отбрасывал сообщение как чужое.
+        // Посторонний, флудящий в такой группе, тратил соединение и
+        // rate-limit аккаунта (B5-04, остаток A5-06). Группа вне конфига
+        // и выключенная группа заканчиваются здесь, без единого вызова.
+        const earlyScopes = (0, helpers_1.resolveAccountScopes)(cfg, accountId);
+        const earlyGroupConfig = normalized.chatType === "group"
+            ? (0, helpers_1.resolveGroupConfig)(earlyScopes.groups, normalized.chatId)
+            : undefined;
+        if (normalized.chatType === "group") {
+            if (!earlyGroupConfig) {
+                log?.info?.("clawgram skipping group not present in groups config", {
+                    accountId,
+                    chatId: normalized.chatId,
+                    messageId: normalized.messageId,
+                });
+                return;
+            }
+            if (earlyGroupConfig.enabled === false) {
+                log?.info?.("clawgram skipping disabled group", {
+                    accountId,
+                    chatId: normalized.chatId,
+                    messageId: normalized.messageId,
+                });
+                return;
+            }
+        }
+        // Профиль отправителя нужен воротам только когда allowFrom
+        // называет кого-то по @handle, а сообщение handle не принесло;
+        // числовые id сверяются без сети.
+        const gateAllowFrom = normalized.chatType === "group"
+            ? earlyGroupConfig?.allowFrom
+            : earlyScopes.allowFrom;
+        const allowFromNeedsHandle = Array.isArray(gateAllowFrom)
+            && gateAllowFrom.some((entry) => String(entry).trim().startsWith("@"));
+        const needsProfile = !normalized.senderUsername && allowFromNeedsHandle;
+        const senderProfile = needsProfile
+            ? (normalized.chatType === "direct"
+                ? await (0, helpers_1.resolveSenderProfileWithTimeout)(rawMessage, {
+                    senderId: normalized.senderId,
+                    client,
+                }, 1500)
+                : await (0, helpers_1.resolveSenderProfile)(rawMessage, {
+                    senderId: normalized.senderId,
+                    client,
+                }))
+            : {};
+        if (!normalized.senderUsername && senderProfile.username) {
+            normalized.senderUsername = senderProfile.username;
+        }
+        if (!normalized.senderDisplay && senderProfile.display) {
+            normalized.senderDisplay = senderProfile.display;
+        }
         let text = normalized.text?.trim();
         // Whether this sender may reach the agent at all — decided before
         // the attachment is fetched.
@@ -180,6 +258,16 @@ async function handleInboundEvent(event, ctx) {
         // voice note and a screenshot alike, the attachment *is* the
         // message. A caption is kept and the reading appended, because
         // "look at this" plus the picture is one thought, not two.
+        // Адрес ответа и цель чата — сеть, и нужны только тому, кому
+        // отвечают: считаются после ворот (B5-04).
+        const directReplyTarget = normalized.chatType === "direct" ? undefined
+            : senderMayReachAgent ? await (0, helpers_1.resolveReplyTarget)(rawMessage) : undefined;
+        const replyTarget = normalized.chatType === "direct"
+            ? normalized.chatId
+            : senderMayReachAgent ? await (0, helpers_1.resolveChatTarget)(rawMessage) : undefined;
+        if (replyTarget) {
+            normalized.replyTarget = replyTarget;
+        }
         const attachment = senderMayReachAgent ? await (0, attachments_1.readInboundAttachment)({
             gram,
             event,
@@ -285,6 +373,12 @@ async function handleInboundEvent(event, ctx) {
         // the answer — and by the same resolver `resolveAccount` uses, so the
         // gate applied here is the one the account was started with.
         const { allowFrom: directAllowFrom } = inboundScopes;
+        // Fixed, not configurable: clawgram admits a DM by `allowFrom` alone
+        // (the roster) and offers no pairing challenge — a stranger cannot
+        // talk their way in. Core's resolver is still called for the block
+        // decision and `commandAuthorized`; with "open" it never answers
+        // "pairing", so the 30-line challenge branch that once followed it
+        // was unreachable and read like a barrier (audit B5-15).
         const dmPolicy = "open";
         if (normalized.chatType === "group") {
             const groupConfig = inboundGroupConfig;
@@ -315,7 +409,10 @@ async function handleInboundEvent(event, ctx) {
                     messageId: normalized.messageId,
                     senderId,
                     username: normalized.senderUsername,
-                    allowFrom: groupConfig.allowFrom,
+                    // Сам список — id владельца и допущенных — в журнал не идёт:
+                    // посторонний управлял бы числом его копий в journald (B5-09).
+                    allowFromCount: Array.isArray(groupConfig.allowFrom) ? groupConfig.allowFrom.length : 0,
+                    allowFromHasWildcard: Array.isArray(groupConfig.allowFrom) && groupConfig.allowFrom.some((e) => String(e).trim() === "*"),
                 });
                 return;
             }
@@ -511,38 +608,11 @@ async function handleInboundEvent(event, ctx) {
                                 payloadTextLength: outboundText.length,
                                 payloadReplyToId: payload.replyToId ?? null,
                             });
-                            if (!outboundText) {
-                                return;
-                            }
-                            // The agent may decline to answer by returning the shared
-                            // silent token. Drop it before addressing: otherwise the
-                            // reply-address prefix turns it into a visible message.
-                            const visibleText = (0, helpers_1.stripSilentReplyToken)(outboundText);
-                            if (!visibleText) {
-                                log?.info?.("clawgram suppressing silent group reply", {
-                                    accountId,
-                                    chatId: normalized.chatId,
-                                    messageId: normalized.messageId,
-                                });
-                                return;
-                            }
-                            // Ядро подклеивает свою телеметрию к полезной нагрузке
-                            // хода, и сюда она приходит тем же путём, что ответ.
-                            // Проверка стояла только в `outbound.sendText`, то есть
-                            // класс инцидента 30.08–01.09 был закрыт для рассылок и
-                            // открыт для обычного ответа на упоминание (A5-10).
-                            const groupNotice = (0, system_notice_1.shouldSuppressGroupSystemNotice)({
-                                targetKind: "group",
-                                text: visibleText,
+                            const visibleText = visibleReplyText({
+                                text: outboundText, kind: "group", where: "group reply",
+                                accountId, chatId: normalized.chatId, messageId: normalized.messageId, log,
                             });
-                            if (groupNotice) {
-                                log?.warn?.("clawgram suppressing system notice in group reply", {
-                                    accountId,
-                                    chatId: normalized.chatId,
-                                    messageId: normalized.messageId,
-                                    noticeKind: groupNotice,
-                                    textLength: visibleText.length,
-                                });
+                            if (!visibleText) {
                                 return;
                             }
                             const replyToMessageId = payload.replyToId ? Number(payload.replyToId) : Number(normalized.messageId);
@@ -603,19 +673,10 @@ async function handleInboundEvent(event, ctx) {
                         : "";
                     // Тот же фильтр и здесь: последняя реплика в стенограмме
                     // вполне может оказаться именно уведомлением об ошибке.
-                    const fallbackNotice = rawFallback
-                        ? (0, system_notice_1.shouldSuppressGroupSystemNotice)({ targetKind: "group", text: rawFallback })
-                        : undefined;
-                    if (fallbackNotice) {
-                        log?.warn?.("clawgram suppressing system notice in transcript fallback", {
-                            accountId,
-                            chatId: normalized.chatId,
-                            messageId: normalized.messageId,
-                            noticeKind: fallbackNotice,
-                            textLength: rawFallback.length,
-                        });
-                    }
-                    const visibleFallbackText = fallbackNotice ? "" : rawFallback;
+                    const visibleFallbackText = visibleReplyText({
+                        text: rawFallback, kind: "group", where: "transcript fallback",
+                        accountId, chatId: normalized.chatId, messageId: normalized.messageId, log,
+                    }) ?? "";
                     if (!visibleFallbackText) {
                         if (fallbackText) {
                             log?.info?.("clawgram skipping silent transcript fallback", {
@@ -706,7 +767,8 @@ async function handleInboundEvent(event, ctx) {
                 accountId,
                 senderId,
                 senderUsername: normalized.senderUsername,
-                allowFrom: directAllowFrom,
+                allowFromCount: Array.isArray(directAllowFrom) ? directAllowFrom.length : 0,
+                allowFromHasWildcard: Array.isArray(directAllowFrom) && directAllowFrom.some((e) => String(e).trim() === "*"),
             });
             return;
         }
@@ -724,7 +786,6 @@ async function handleInboundEvent(event, ctx) {
                 senderId,
                 senderUsername,
             }),
-            readStoreAllowFrom: pairing.readStoreForDmPolicy,
         });
         if (access.access.decision === "block") {
             log?.info?.("clawgram blocking inbound direct message", {
@@ -737,36 +798,6 @@ async function handleInboundEvent(event, ctx) {
             });
             return;
         }
-        if (access.access.decision === "pairing") {
-            await pairing.issueChallenge({
-                senderId,
-                senderIdLine: `Your Telegram user id: ${senderId}`,
-                meta: {
-                    username: normalized.senderUsername,
-                    name: normalized.senderDisplay,
-                },
-                sendPairingReply: async (pairingText) => {
-                    await sendTextToConversation({
-                        text: pairingText,
-                    });
-                },
-                onReplyError: (err) => {
-                    log?.info?.("clawgram pairing reply failed", {
-                        accountId,
-                        chatId: normalized.chatId,
-                        senderId,
-                        error: String(err),
-                    });
-                },
-            });
-            log?.info?.("clawgram pairing required for inbound direct message", {
-                accountId,
-                chatId: normalized.chatId,
-                messageId: normalized.messageId,
-                senderId,
-            });
-            return;
-        }
         // Same fetch as the group path. In a DM the parent is as often
         // the agent's own message as the person's — the owner answers a
         // notice she sent — and neither text is available any other way.
@@ -807,17 +838,13 @@ async function handleInboundEvent(event, ctx) {
                     NativeChannelId: normalized.chatId,
                 },
                 deliver: async (payload) => {
-                    const outboundText = typeof payload.text === "string" ? payload.text.trim() : "";
-                    if (!outboundText) {
-                        return;
-                    }
-                    const visibleText = (0, helpers_1.stripSilentReplyToken)(outboundText);
+                    // Тот же фильтр, что у группового ответа: личный ответ идёт
+                    // третьим путём, и закрытие A5-11 его не покрывало (B5-01).
+                    const visibleText = visibleReplyText({
+                        text: payload.text, kind: "user", where: "direct reply",
+                        accountId, chatId: normalized.chatId, messageId: normalized.messageId, log,
+                    });
                     if (!visibleText) {
-                        log?.info?.("clawgram suppressing silent direct reply", {
-                            accountId,
-                            chatId: normalized.chatId,
-                            messageId: normalized.messageId,
-                        });
                         return;
                     }
                     await sendTextToConversation({

package/dist/manage.js

@@ -202,12 +202,7 @@ function parseInviteLinkParams(params, toolContext) {
     };
 }
 function normalizeScope(manageChats) {
-    if (manageChats === undefined || manageChats === null) {
-        return [];
-    }
-    return (Array.isArray(manageChats) ? manageChats : [manageChats])
-        .map(history_1.normalizeChatKey)
-        .filter(Boolean);
+    return (0, history_1.normalizeScopeList)(manageChats) ?? [];
 }
 /** True while the account is allowed to manage anything at all. */
 function isManagementEnabled(manageChats) {

package/dist/media.js

@@ -22,6 +22,7 @@ exports.downloadMessageMediaToFile = downloadMessageMediaToFile;
 exports.pruneFetchedMedia = pruneFetchedMedia;
 exports.isLocalMediaPath = isLocalMediaPath;
 exports.assertLocalMediaWithinRoots = assertLocalMediaWithinRoots;
+exports.loadOutboundMedia = loadOutboundMedia;
 const node_fs_1 = require("node:fs");
 const node_path_1 = __importDefault(require("node:path"));
 const util_1 = require("./util");
@@ -292,3 +293,24 @@ function assertLocalMediaWithinRoots(file, roots) {
         throw new Error(`clawgram: ${file} is outside the media roots this agent may read`);
     }
 }
+/**
+ * The file an outbound send should hand to GramJS.
+ *
+ * Core scopes a call in two ways: `mediaLocalRoots` names the directories the
+ * agent may read from, and `mediaReadFile` is a reader that enforces them
+ * inside core. Bundled channels read local files through that reader; this
+ * one opened the path itself as the gateway process — the roots were checked
+ * here, the reader ignored, so a call core scoped with a reader and no roots
+ * (the default on the RPC and TTS paths) was not scoped at all (audit B5-14).
+ *
+ * Roots are still checked first, symlinks resolved. A local path is then read
+ * through core's reader when one is given, and sent as bytes under the file's
+ * own name; without a reader, or for a URL, the file goes to GramJS as before.
+ */
+async function loadOutboundMedia(file, roots, readFile) {
+    assertLocalMediaWithinRoots(file, roots);
+    if (!readFile || !isLocalMediaPath(file)) {
+        return file;
+    }
+    return { buffer: await readFile(file), fileName: node_path_1.default.basename(file) };
+}

package/dist/outbound.js

@@ -10,6 +10,7 @@ exports.createOutbound = createOutbound;
 const core_1 = require("openclaw/plugin-sdk/core");
 const media_1 = require("./media");
 const send_scope_1 = require("./send-scope");
+const account_registry_1 = require("./account-registry");
 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");
@@ -50,16 +51,14 @@ function createOutbound(runtimes) {
                 // анонсы субагентов) идёт этим путём и мимо той проверки. Отказ
                 // здесь возвращается результатом, а не броском: бросок в этом хуке
                 // роняет весь 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";
+                if (!(0, send_scope_1.isChatSendable)(target, (0, account_registry_1.sendScopeFor)(ctx.accountId))) {
+                    const refusal = (0, send_scope_1.describeSendRefusal)(target);
                     actionLog.warn("clawgram outbound resolveTarget refused", {
                         accountId: ctx.accountId,
-                        target,
-                        reason,
+                        reason: refusal.reason,
+                        ...refusal.logFields,
                     });
-                    return { ok: false, error: new Error(`clawgram: not-allowed-chat ${target}`) };
+                    return { ok: false, error: refusal.error };
                 }
                 return { ok: true, to: target };
             }
@@ -89,6 +88,20 @@ function createOutbound(runtimes) {
                 });
                 return { skipped: "silent" };
             }
+            // Область отправки — и здесь. Путь доставки ядра (`--deliver`,
+            // анонсы субагентов) зовёт sendText напрямую, минуя resolveTarget и
+            // handleAction, где барьер уже стоял: третий из трёх исходящих путей
+            // был открыт для любого адресата и телефонного номера (D2-01, A5-12).
+            const scopedTarget = (0, helpers_1.normalizeOutboundTarget)(ctx.to);
+            if (!(0, send_scope_1.isChatSendable)(scopedTarget, (0, account_registry_1.sendScopeFor)(ctx.accountId))) {
+                const refusal = (0, send_scope_1.describeSendRefusal)(scopedTarget);
+                actionLog.warn("clawgram outbound sendText refused", {
+                    accountId: ctx.accountId,
+                    reason: refusal.reason,
+                    ...refusal.logFields,
+                });
+                return { skipped: "not-allowed" };
+            }
             // 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
@@ -98,7 +111,7 @@ function createOutbound(runtimes) {
                 targetKind: (0, helpers_1.inferOutboundTargetKind)(ctx.to),
                 text: ctx.text,
                 to: ctx.to,
-                operatorIds: (0, system_notice_1.operatorIdsFor)(ctx.accountId),
+                operatorIds: (0, account_registry_1.operatorIdsFor)(ctx.accountId),
             });
             if (suppressedNotice) {
                 actionLog.warn("clawgram suppressing system notice in group", {
@@ -109,10 +122,7 @@ function createOutbound(runtimes) {
                 });
                 return { skipped: "system-notice" };
             }
-            const gram = runtimes.get(ctx.accountId);
-            if (!gram) {
-                throw new Error(`clawgram: runtime not found for account ${ctx.accountId}`);
-            }
+            const gram = (0, account_registry_1.requireRuntime)(runtimes, 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
@@ -164,10 +174,7 @@ function createOutbound(runtimes) {
             };
         },
         async sendMedia(ctx) {
-            const gram = runtimes.get(ctx.accountId);
-            if (!gram) {
-                throw new Error(`clawgram: runtime not found for account ${ctx.accountId}`);
-            }
+            const gram = (0, account_registry_1.requireRuntime)(runtimes, 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;
@@ -184,8 +191,8 @@ function createOutbound(runtimes) {
                 hasCaption: Boolean(ctx.caption),
                 asVoice: ctx.audioAsVoice === true,
             });
-            const file = ctx.filePath ?? ctx.mediaUrl;
-            if (!file) {
+            const named = ctx.filePath ?? ctx.mediaUrl;
+            if (!named) {
                 throw new Error("clawgram: sendMedia requires filePath or mediaUrl");
             }
             // Ниже — проверки, которые у `sendText` были, а здесь не было ни
@@ -194,11 +201,12 @@ function createOutbound(runtimes) {
             const mediaTarget = (0, helpers_1.normalizeOutboundTarget)(ctx.to);
             // Область отправки: файл наружу — такое же исходящее, как текст.
             // `resolveTarget` ядро зовёт не на каждом пути, поэтому проверяем и тут.
-            if (!(0, send_scope_1.isChatSendable)(mediaTarget, (0, send_scope_1.sendScopeFor)(ctx.accountId))) {
+            if (!(0, send_scope_1.isChatSendable)(mediaTarget, (0, account_registry_1.sendScopeFor)(ctx.accountId))) {
+                const refusal = (0, send_scope_1.describeSendRefusal)(mediaTarget);
                 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",
+                    reason: refusal.reason,
+                    ...refusal.logFields,
                 });
                 return { skipped: "not-allowed" };
             }
@@ -231,6 +239,9 @@ function createOutbound(runtimes) {
             // 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);
+            // Read last, through core's scoped reader when it gave one: every
+            // refusal above must have passed before the file is opened.
+            const file = await (0, media_1.loadOutboundMedia)(named, outboundRoots, ctx.mediaReadFile ?? ctx.mediaAccess?.readFile);
             const sent = await gram.sendMedia({
                 target,
                 file,

package/dist/send-scope.js

@@ -3,9 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isPhoneNumberTarget = isPhoneNumberTarget;
 exports.isSendScopeConfigured = isSendScopeConfigured;
 exports.isChatSendable = isChatSendable;
-exports.rememberSendScope = rememberSendScope;
-exports.sendScopeFor = sendScopeFor;
-exports.forgetSendScope = forgetSendScope;
+exports.describeSendRefusal = describeSendRefusal;
 const history_1 = require("./history");
 /**
  * Outbound scope for the account: who this account may write to.
@@ -49,11 +47,7 @@ function isPhoneNumberTarget(target) {
     return /[\s()\-.]/.test(raw) && /^\+?\d[\d\s()\-.]{5,}$/.test(raw);
 }
 function normalizeScope(sendChats) {
-    if (sendChats === undefined || sendChats === null)
-        return [];
-    return (Array.isArray(sendChats) ? sendChats : [sendChats])
-        .map(history_1.normalizeChatKey)
-        .filter(Boolean);
+    return (0, history_1.normalizeScopeList)(sendChats) ?? [];
 }
 /** True while the account has a declared outbound scope at all. */
 function isSendScopeConfigured(sendChats) {
@@ -74,24 +68,17 @@ function isChatSendable(target, sendChats) {
     return (0, history_1.chatKeyCandidates)(target).some((candidate) => entries.includes(candidate));
 }
 /**
- * Область отправки каждого аккаунта, запомненная при его старте.
+ * One refusal for every outbound door — `handleAction`, `outbound.resolveTarget`,
+ * `sendText`, `sendMedia` — so the four read the same and log the same.
  *
- * В `outbound.resolveTarget` и `sendText` конфига нет — ядро зовёт их с
- * `{ accountId, to }`, — а тащить её туда параметром значило бы менять
- * контракт ядра ради одной проверки. Тот же приём уже применён к списку
- * операторов (`system-notice.ts`), и по той же причине.
- *
- * Перезапуск канала при правке конфига обновляет запись; аккаунт, о котором
- * ничего не помним, ведёт себя как аккаунт без области — то есть отправка
- * разрешена, но телефонный адресат всё равно отвергнут.
+ * A phone number is personal data: the journal gets the kind of target, not
+ * the value (B5-09). Two of the four doors used to log it anyway (D2-11).
  */
-const sendScopeByAccount = new Map();
-function rememberSendScope(accountId, sendChats) {
-    sendScopeByAccount.set(accountId, sendChats);
-}
-function sendScopeFor(accountId) {
-    return sendScopeByAccount.get(accountId);
-}
-function forgetSendScope(accountId) {
-    sendScopeByAccount.delete(accountId);
+function describeSendRefusal(target) {
+    const phone = isPhoneNumberTarget(target);
+    return {
+        reason: phone ? "phone-number target" : "chat outside send scope",
+        logFields: phone ? { targetKind: "phone" } : { target },
+        error: new Error(`clawgram: not-allowed-chat ${target}`),
+    };
 }

package/dist/system-notice.js

@@ -28,9 +28,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.classifySystemNotice = classifySystemNotice;
 exports.shouldSuppressGroupSystemNotice = shouldSuppressGroupSystemNotice;
 exports.isOperatorRecipient = isOperatorRecipient;
-exports.rememberOperatorIds = rememberOperatorIds;
-exports.operatorIdsFor = operatorIdsFor;
-exports.forgetOperatorIds = forgetOperatorIds;
 const TOOL_WARNING_PREFIX = "⚠️ 🛠️ ";
 const MESSAGE_FAILED_PREFIX = "⚠️ ✉️ message failed";
 const FALLBACK_NOTICE_PREFIX = "↪️ model fallback";
@@ -96,20 +93,3 @@ function isOperatorRecipient(to, operatorIds) {
     const target = String(to).trim().replace(/^@/, "").toLowerCase();
     return operatorIds.some((id) => String(id).trim().replace(/^@/, "").toLowerCase() === target);
 }
-/**
- * Кто оператор у каждого аккаунта.
- *
- * Список запоминается при старте аккаунта: в `outbound.sendText` конфига нет,
- * а тащить её туда параметром значило бы менять контракт ради одной проверки.
- * Перезапуск канала при правке конфига обновляет запись.
- */
-const operatorIdsByAccount = new Map();
-function rememberOperatorIds(accountId, ids) {
-    operatorIdsByAccount.set(accountId, [...ids]);
-}
-function operatorIdsFor(accountId) {
-    return operatorIdsByAccount.get(accountId) ?? [];
-}
-function forgetOperatorIds(accountId) {
-    operatorIdsByAccount.delete(accountId);
-}

package/dist/update-config.js

@@ -36,14 +36,6 @@ function buildAccountPayload(auth) {
         sessionString: auth.sessionString,
     };
 }
-/** Первый конфиг закрыт: см. одноимённую функцию в cli-core.ts. */
-function buildAccountConfigFragment(auth) {
-    return {
-        ...buildAccountPayload(auth),
-        allowFrom: auth.selfId ? [auth.selfId] : [],
-        readChats: [],
-    };
-}
 /**
  * Credentials already moved into the secret store must survive re-auth.
  *

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "clawgram",
-  "version": "2.22.0",
+  "version": "2.26.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "clawgram",
-      "version": "2.22.0",
+      "version": "2.26.0",
       "license": "MIT",
       "dependencies": {
         "json5": "2.2.3",

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.24.0",
+  "version": "2.26.0",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,