clawgram 2.21.1 → 2.22.0

package/dist/reactions.js

@@ -14,6 +14,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveAgentReactionGuidance = resolveAgentReactionGuidance;
 exports.parseReactionParams = parseReactionParams;
 const helpers_1 = require("./helpers");
+const history_1 = require("./history");
 /**
  * How freely the agent may react, from the account's `reactionLevel`.
  *
@@ -59,24 +60,14 @@ function readBooleanFlag(value) {
  * some unrelated message, so anything else is refused rather than coerced —
  * the same reasoning as the history parser's id/date guard.
  */
-function parseMessageId(value) {
-    if (value === undefined || value === null || value === "") {
-        return undefined;
-    }
-    const parsed = Number(value);
-    if (!Number.isInteger(parsed) || parsed <= 0) {
-        throw new Error(`clawgram: react messageId must be a positive integer, got ${JSON.stringify(value)}`);
-    }
-    return parsed;
-}
 function parseReactionParams(params, toolContext) {
     const rawTarget = (0, helpers_1.readChatTargetParam)(params, toolContext);
     const target = typeof rawTarget === "string" ? rawTarget.trim() : "";
     if (!target) {
         throw new Error("clawgram: react requires a chatId");
     }
-    const messageId = parseMessageId(params.messageId ?? params.msgId ?? params.message_id)
-        ?? parseMessageId(toolContext?.currentMessageId);
+    const messageId = (0, history_1.parseMessageId)(params.messageId ?? params.msgId ?? params.message_id, "react messageId")
+        ?? (0, history_1.parseMessageId)(toolContext?.currentMessageId, "react messageId");
     if (messageId === undefined) {
         throw new Error("clawgram: react requires a messageId");
     }

package/dist/secret-refs.js

@@ -19,6 +19,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.secretRefKey = secretRefKey;
+exports.asSecretRef = asSecretRef;
 exports.collectAccountSecretRefs = collectAccountSecretRefs;
 exports.applyAccountSecrets = applyAccountSecrets;
 exports.hasUnresolvedSecretRef = hasUnresolvedSecretRef;

package/dist/send-scope.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPhoneNumberTarget = isPhoneNumberTarget;
+exports.isSendScopeConfigured = isSendScopeConfigured;
+exports.isChatSendable = isChatSendable;
+exports.rememberSendScope = rememberSendScope;
+exports.sendScopeFor = sendScopeFor;
+exports.forgetSendScope = forgetSendScope;
+const history_1 = require("./history");
+/**
+ * Outbound scope for the account: who this account may write to.
+ *
+ * Reading has had a declared scope since 2.x (`readChats`), management has
+ * one (`manageChats`), and sending had none: `send`, `upload-file` and
+ * `react` resolved whatever target the caller named and delivered it. The
+ * account is a person's own Telegram account, so an injected turn could
+ * message strangers under the owner's name, or carry a work chat's content
+ * into an attacker's DM one `send` at a time (finding A5-12).
+ *
+ * Two decisions worth stating, because both could reasonably have gone the
+ * other way:
+ *
+ * 1. **An absent `sendChats` still allows sending.** `manageChats` denies by
+ *    default because management arrived as a new capability; sending is what
+ *    this plugin has always done, and flipping it to "current conversation
+ *    only" would silence every existing deployment on upgrade — including
+ *    scheduled digests that legitimately write to an id nobody is talking to
+ *    right now. A deployment that wants the boundary writes `sendChats`, and
+ *    then it is a boundary in code rather than a sentence in a prompt.
+ *
+ * 2. **A phone number is refused in every configuration**, wildcard included.
+ *    Messaging a raw number starts a conversation with someone who never
+ *    interacted with the account and hands them the account's identity;
+ *    no deployment has a reason to do that from an assistant, and the
+ *    address book is not the model's to walk.
+ */
+/** Anything that looks like a dialable number rather than a chat we know. */
+function isPhoneNumberTarget(target) {
+    const raw = String(target ?? "").trim();
+    if (!raw)
+        return false;
+    // A Telegram chat id is digits (a user) or `-100…` (a group); a phone
+    // number is what a person writes with a plus, spaces, dashes or brackets.
+    // The `+` is the giveaway that survives normalisation, and a long digit
+    // string with separators is the other spelling of the same thing.
+    const compact = raw.replace(/[\s()\-.]/g, "");
+    if (/^\+\d{6,15}$/.test(compact))
+        return true;
+    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);
+}
+/** True while the account has a declared outbound scope at all. */
+function isSendScopeConfigured(sendChats) {
+    return sendChats !== undefined && sendChats !== null;
+}
+function isChatSendable(target, sendChats) {
+    if (isPhoneNumberTarget(target))
+        return false;
+    if (!isSendScopeConfigured(sendChats))
+        return true;
+    const entries = normalizeScope(sendChats);
+    // A configured empty list is a decision, not an oversight: deny, the same
+    // way `readChats: []` denies rather than reading everything.
+    if (entries.length === 0)
+        return false;
+    if (entries.includes("*"))
+        return true;
+    return (0, history_1.chatKeyCandidates)(target).some((candidate) => entries.includes(candidate));
+}
+/**
+ * Область отправки каждого аккаунта, запомненная при его старте.
+ *
+ * В `outbound.resolveTarget` и `sendText` конфига нет — ядро зовёт их с
+ * `{ accountId, to }`, — а тащить её туда параметром значило бы менять
+ * контракт ядра ради одной проверки. Тот же приём уже применён к списку
+ * операторов (`system-notice.ts`), и по той же причине.
+ *
+ * Перезапуск канала при правке конфига обновляет запись; аккаунт, о котором
+ * ничего не помним, ведёт себя как аккаунт без области — то есть отправка
+ * разрешена, но телефонный адресат всё равно отвергнут.
+ */
+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);
+}

package/dist/silent-reaction.js

@@ -20,14 +20,13 @@
  * tested without Telegram or a model.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TELEGRAM_REACTIONS = void 0;
 exports.buildEmojiSystemPrompt = buildEmojiSystemPrompt;
 exports.canonicalizeReactionEmoji = canonicalizeReactionEmoji;
 exports.parseEmojiChoice = parseEmojiChoice;
 exports.shouldReactToSilentTurn = shouldReactToSilentTurn;
 exports.reactToSilentMention = reactToSilentMention;
 function buildEmojiSystemPrompt(appetite, allowed) {
-    const choices = allowed === undefined || allowed.length === 0 ? exports.TELEGRAM_REACTIONS : allowed;
+    const choices = allowed === undefined || allowed.length === 0 ? TELEGRAM_REACTIONS : allowed;
     const shared = [
         "You pick a single emoji reaction for a chat message.",
         "The assistant was mentioned in this message but decided it needs no written reply.",
@@ -84,7 +83,9 @@ function buildEmojiSystemPrompt(appetite, allowed) {
  * difference is invisible in an editor and a stray U+FE0F would break them
  * again silently.
  */
-exports.TELEGRAM_REACTIONS = [
+// Модульная константа: снаружи её никто не читает, а `export` обещает
+// публичную поверхность, которой нет (A6-21).
+const TELEGRAM_REACTIONS = [
     "👍", "👎", "❤", "🔥", "🥰", "👏", "😁", "🤔", "🤯", "😱",
     "🤬", "😢", "🎉", "🤩", "🤮", "💩", "🙏", "👌", "\u{1F54A}", "🤡",
     "🥱", "🥴", "😍", "🐳", "🌚", "🌭", "💯", "🤣", "⚡", "🍌",
@@ -101,7 +102,10 @@ exports.TELEGRAM_REACTIONS = [
  * `👍🏽` is not a member of the set, `👍` is.
  */
 function canonicalizeReactionEmoji(value) {
-    return value.replace(/️/g, "").replace(/[\u{1F3FB}-\u{1F3FF}]/gu, "");
+    // U+FE0F записан кодом, а не символом: в исходнике он невидим, и
+    // регекс выглядел как `/ /g` — пустая на вид группа, которую при
+    // следующей правке легко «почистить» вместе со смыслом (S1-09).
+    return value.replace(/\u{FE0F}/gu, "").replace(/[\u{1F3FB}-\u{1F3FF}]/gu, "");
 }
 /**
  * Turns a model answer into an emoji Telegram will actually take, or nothing.
@@ -132,7 +136,7 @@ function parseEmojiChoice(raw, allowed) {
     // `ChatReactionsNone` — reactions switched off — and must permit nothing.
     // Collapsing the two would react in a chat that forbids reacting.
     const permitted = allowed === undefined
-        ? exports.TELEGRAM_REACTIONS
+        ? TELEGRAM_REACTIONS
         : allowed.map(canonicalizeReactionEmoji);
     return permitted.includes(candidate) ? candidate : undefined;
 }

package/dist/state-dir.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveStateDir = resolveStateDir;
+/**
+ * Где живёт состояние OpenClaw — одним ответом для всего плагина.
+ *
+ * `OPENCLAW_STATE_DIR` первичен, дом — запасной вариант. Правило не
+ * косметическое: изолированный Gateway, который AGENTS.md предписывает для
+ * любой локальной проверки («никогда не трогай `~/.openclaw` — всегда задавай
+ * `OPENCLAW_STATE_DIR`»), иначе продолжает писать в боевое состояние.
+ *
+ * Помощник по медиа переменную уже уважал, журнал присоединений — нет, и
+ * тестовый экземпляр дописывал записи в живой журнал, а на двух тысячах
+ * записей переписывал его (находка A6-07). Резолвер один, чтобы такие
+ * расхождения не заводились по одному на файл.
+ */
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+function resolveStateDir(env = process.env) {
+    const configured = env.OPENCLAW_STATE_DIR;
+    if (typeof configured === "string" && configured.trim())
+        return configured.trim();
+    return (0, node_path_1.join)((0, node_os_1.homedir)(), ".openclaw");
+}

package/dist/system-notice.js

@@ -27,6 +27,10 @@
 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";
@@ -62,9 +66,50 @@ function classifySystemNotice(text) {
  * so the text seen here is core's payload verbatim.
  */
 function shouldSuppressGroupSystemNotice(params) {
-    // DMs keep the telemetry: there the reader is the person running the agent.
-    if (params.targetKind !== "group" && params.targetKind !== "channel") {
-        return undefined;
+    if (params.targetKind === "group" || params.targetKind === "channel") {
+        return classifySystemNotice(params.text);
+    }
+    // Личка держала телеметрию на допущении «здесь читает тот, кто запустил
+    // агента». Допущение неверно: в личку пишет всякий, кто попал в `allowFrom`,
+    // и посторонний, чей ход уронил инструмент, получал `⚠️ 🛠️ Bash failed:`
+    // с полной командой и путями вроде /opt/openclaw-secrets/… (A5-11).
+    //
+    // Поэтому телеметрия уходит только названному оператору. Список пуст или
+    // содержит `*` — значит «оператор» не определён, и уведомление подавляется:
+    // потерять диагностику дешевле, чем отдать раскладку инфраструктуры
+    // незнакомцу, тем более что те же сбои лежат в диагностике прогона,
+    // в `lastError` джоба и в логе gateway.
+    if (!isOperatorRecipient(params.to, params.operatorIds)) {
+        return classifySystemNotice(params.text);
     }
-    return classifySystemNotice(params.text);
+    return undefined;
+}
+function isOperatorRecipient(to, operatorIds) {
+    if (to === undefined || to === null || String(to).trim() === "")
+        return false;
+    if (!operatorIds || operatorIds.length === 0)
+        return false;
+    // `*` здесь не «все операторы», а «оператор не назван»: в списке отправителей
+    // звёздочка означает «кто угодно», и телеметрию кому угодно слать нельзя.
+    if (operatorIds.some((id) => String(id).trim() === "*"))
+        return false;
+    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

@@ -3,12 +3,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.keepSecretRefs = keepSecretRefs;
 exports.createConfigBackup = createConfigBackup;
+exports.secretRefFieldsFor = secretRefFieldsFor;
 exports.updateConfigFileDirectly = updateConfigFileDirectly;
 const node_fs_1 = require("node:fs");
 const node_path_1 = __importDefault(require("node:path"));
 const json5_1 = __importDefault(require("json5"));
 const constants_1 = require("./constants");
+const secret_refs_1 = require("./secret-refs");
+const util_1 = require("./util");
 function formatBackupTimestamp(date) {
     const year = String(date.getUTCFullYear());
     const month = String(date.getUTCMonth() + 1).padStart(2, "0");
@@ -24,9 +28,6 @@ function buildConfigBackupPath(configPath) {
     const suffix = `${formatBackupTimestamp(new Date())}-clawgram-auth`;
     return node_path_1.default.join(dir, `${fileName}.bak-${suffix}`);
 }
-function isPlainObject(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 function buildAccountPayload(auth) {
     return {
         enabled: true,
@@ -35,19 +36,39 @@ function buildAccountPayload(auth) {
         sessionString: auth.sessionString,
     };
 }
+/** Первый конфиг закрыт: см. одноимённую функцию в cli-core.ts. */
 function buildAccountConfigFragment(auth) {
     return {
         ...buildAccountPayload(auth),
-        allowFrom: ["*"],
-        groups: {
-            "*": {
-                enabled: true,
-                groupPolicy: "mention",
-                allowFrom: ["*"],
-            },
-        },
+        allowFrom: auth.selfId ? [auth.selfId] : [],
+        readChats: [],
     };
 }
+/**
+ * Credentials already moved into the secret store must survive re-auth.
+ *
+ * An account whose apiHash/sessionString were migrated to `{source, provider,
+ * id}` had them overwritten with the literal strings typed during the
+ * interactive flow: the spread put the fresh payload on top of the reference.
+ * So an operator re-authorising after a session expiry silently undid the
+ * migration and left plaintext credentials in a file that gets backed up and
+ * synced — the exact thing secret-refs.ts was written to prevent.
+ *
+ * The reference wins. The new value is handed back so the caller can tell the
+ * operator to store it where the reference points; it is never written to the
+ * config, and never printed here.
+ */
+function keepSecretRefs(existingAccount, payload) {
+    const next = { ...payload };
+    const kept = [];
+    for (const field of ["apiHash", "sessionString"]) {
+        if ((0, secret_refs_1.asSecretRef)(existingAccount?.[field])) {
+            next[field] = existingAccount[field];
+            kept.push(field);
+        }
+    }
+    return { payload: next, kept };
+}
 function applyAuthToConfig(config, accountId, auth) {
     const channels = config.channels && typeof config.channels === "object" ? config.channels : {};
     const channelConfig = channels[constants_1.CHANNEL_ID] && typeof channels[constants_1.CHANNEL_ID] === "object" ? channels[constants_1.CHANNEL_ID] : {};
@@ -63,16 +84,12 @@ function applyAuthToConfig(config, accountId, auth) {
                     ...accounts,
                     [accountId]: {
                         ...existingAccount,
-                        ...buildAccountPayload(auth),
+                        ...keepSecretRefs(existingAccount, buildAccountPayload(auth)).payload,
                         enabled: existingAccount.enabled ?? true,
-                        allowFrom: existingAccount.allowFrom ?? ["*"],
-                        groups: existingAccount.groups ?? {
-                            "*": {
-                                enabled: true,
-                                groupPolicy: "mention",
-                                allowFrom: ["*"],
-                            },
-                        },
+                        // Существующие настройки не трогаем — повторная авторизация не
+                        // повод переписать чужие решения. Отсутствующие садятся закрытыми.
+                        allowFrom: existingAccount.allowFrom ?? (auth.selfId ? [auth.selfId] : []),
+                        readChats: existingAccount.readChats ?? [],
                     },
                 },
             },
@@ -244,12 +261,27 @@ function scanValue(raw, start) {
         kind: "scalar",
     };
 }
-function findObjectEnd(raw, objectStart) {
+/**
+ * Позиция СРАЗУ ЗА закрывающей скобкой объекта — как `end` у среза.
+ *
+ * Имя обманывало: `scanEnclosedValue` возвращает индекс после `}`, а вставка
+ * свойства обращалась с этим числом как с позицией самой скобки и клала
+ * свойство ЗА объектом. Итог — испорченный конфиг: аккаунт, добавленный к
+ * существующему `accounts`, оказывался соседом `accounts` внутри `clawgram`,
+ * а при отсутствующем `channels` вставка уезжала за корневую `}` и файл
+ * переставал быть JSON вовсе. Ловилось только на путях вставки, а обычная
+ * переавторизация идёт путём замены — поэтому и жило (находка A6-17).
+ */
+function findObjectEndExclusive(raw, objectStart) {
     return scanEnclosedValue(raw, objectStart, "{", "}");
 }
+/** Позиция самой закрывающей скобки — точка, ПЕРЕД которой вставляют. */
+function findObjectCloseBrace(raw, objectStart) {
+    return findObjectEndExclusive(raw, objectStart) - 1;
+}
 function listObjectProperties(raw, objectStart) {
     const properties = [];
-    const objectEnd = findObjectEnd(raw, objectStart);
+    const objectEnd = findObjectEndExclusive(raw, objectStart);
     let cursor = skipTrivia(raw, objectStart + 1);
     while (cursor < objectEnd) {
         if (raw[cursor] === "}") {
@@ -311,16 +343,16 @@ function replaceRange(raw, start, end, value) {
     return `${raw.slice(0, start)}${value}${raw.slice(end)}`;
 }
 function insertObjectProperty(raw, objectStart, key, value, format) {
-    const objectEnd = findObjectEnd(raw, objectStart);
+    const closeBrace = findObjectCloseBrace(raw, objectStart);
     const parentIndent = getLineIndent(raw, objectStart);
     const propertyIndent = `${parentIndent}${format.indentUnit}`;
     const propertyText = `${JSON.stringify(key)}: ${formatConfigValue(value, propertyIndent, format)}`;
     const properties = listObjectProperties(raw, objectStart);
     if (properties.length === 0) {
         const insertion = `${format.eol}${propertyIndent}${propertyText}${format.eol}${parentIndent}`;
-        return replaceRange(raw, objectEnd, objectEnd, insertion);
+        return replaceRange(raw, closeBrace, closeBrace, insertion);
     }
-    let insertAt = objectEnd;
+    let insertAt = closeBrace;
     while (insertAt > objectStart + 1 && /[ \t\r\n]/.test(raw[insertAt - 1])) {
         insertAt -= 1;
     }
@@ -333,23 +365,74 @@ function replaceObjectPropertyValue(raw, property, value, format) {
     const formattedValue = formatConfigValue(value, propertyIndent, format);
     return replaceRange(raw, property.valueStart, property.valueEnd, formattedValue);
 }
+/**
+ * Спуск по пути объектов. Недостающие звенья создаются пустыми объектами.
+ *
+ * Возвращает и текст, и позицию начала найденного объекта: после вставки
+ * прежние смещения указывают не туда.
+ */
+function descend(raw, objectStart, path) {
+    let start = objectStart;
+    for (let i = 0; i < path.length; i += 1) {
+        const property = findObjectProperty(raw, start, path[i]);
+        // Недостающее звено не достраивается по одному: вставить пустой объект и
+        // тут же найти его снова — значит положиться на разбор свойств сразу
+        // после правки текста, а это самое хрупкое место здесь. Вместо этого
+        // вызывающий вставляет весь остаток пути одним литералом.
+        if (!property)
+            return { objectStart: start, missing: path.slice(i) };
+        const valueStart = skipTrivia(raw, property.valueStart);
+        if (raw[valueStart] !== "{") {
+            throw new Error(`clawgram: ${path[i]} в конфиге не объект — правка вручную безопаснее`);
+        }
+        start = valueStart;
+    }
+    return { objectStart: start, missing: [] };
+}
+/** Вложенный литерал `{a: {b: {c: value}}}` для недостающего остатка пути. */
+function nest(path, value) {
+    return path.reduceRight((inner, key) => ({ [key]: inner }), value);
+}
+/**
+ * Правится один аккаунт, а не весь блок `channels`.
+ *
+ * Раньше блок находился хирургически, а его значение целиком пересобиралось
+ * через `JSON.stringify`: пропадали все комментарии JSON5, висячие запятые и
+ * ручное форматирование — включая блоки ДРУГИХ каналов, к авторизации
+ * отношения не имеющих. Файл потому и JSON5, что в нём пишут пояснения; после
+ * каждой переавторизации они исчезали, а diff тонул в переформатировании,
+ * пряча ровно то изменение, ради которого всё делалось (находка A6-06).
+ *
+ * Чего это НЕ спасает: комментарии внутри самого правимого аккаунта. Его
+ * значение пересобирается — там меняются учётные данные, и разбирать его
+ * посвойственно значит полагаться на разбор комментариев в позициях, который
+ * здесь и так самое хрупкое место. Всё за пределами этого аккаунта остаётся
+ * как было.
+ */
 function buildUpdatedConfigText(raw, accountId, auth) {
     const parsed = json5_1.default.parse(raw);
-    if (!isPlainObject(parsed)) {
+    if (!(0, util_1.isPlainObject)(parsed)) {
         throw new Error("OpenClaw config root must be an object.");
     }
-    const updatedConfig = applyAuthToConfig(parsed, accountId, auth);
-    const updatedChannels = isPlainObject(updatedConfig.channels) ? updatedConfig.channels : {};
     const format = detectTextFormat(raw);
     const rootStart = skipTrivia(raw, 0);
     if (raw[rootStart] !== "{") {
         throw new Error("OpenClaw config file is not a JSON object.");
     }
-    const channelsProperty = findObjectProperty(raw, rootStart, "channels");
-    if (!channelsProperty) {
-        return insertObjectProperty(raw, rootStart, "channels", updatedChannels, format);
+    // Что должно оказаться в аккаунте — считает та же функция, что и раньше:
+    // правила про SecretRef и закрытый посев живут в одном месте.
+    const updatedConfig = applyAuthToConfig(parsed, accountId, auth);
+    const account = updatedConfig?.channels?.[constants_1.CHANNEL_ID]?.accounts?.[accountId] ?? {};
+    const path = ["channels", constants_1.CHANNEL_ID, "accounts"];
+    const { objectStart, missing } = descend(raw, rootStart, path);
+    if (missing.length) {
+        // Раздела нет — вставляем недостающий остаток вместе с аккаунтом.
+        return insertObjectProperty(raw, objectStart, missing[0], nest(missing.slice(1), { [accountId]: account }), format);
     }
-    return replaceObjectPropertyValue(raw, channelsProperty, updatedChannels, format);
+    const existing = findObjectProperty(raw, objectStart, accountId);
+    return existing
+        ? replaceObjectPropertyValue(raw, existing, account, format)
+        : insertObjectProperty(raw, objectStart, accountId, account, format);
 }
 /**
  * The config this writes holds `apiHash` and `sessionString` in plaintext, so
@@ -391,11 +474,34 @@ async function createConfigBackup(configPath) {
     await node_fs_1.promises.chmod(backupPath, mode);
     return backupPath;
 }
+/**
+ * Which credentials stayed as secret-store references, so the caller can say
+ * so. Silence here would be the worst outcome: the operator would believe the
+ * freshly issued credential is in the config and find out at the next start.
+ */
+function secretRefFieldsFor(raw, accountId) {
+    let parsed;
+    try {
+        parsed = json5_1.default.parse(raw);
+    }
+    catch {
+        return [];
+    }
+    if (!(0, util_1.isPlainObject)(parsed))
+        return [];
+    const channels = (0, util_1.isPlainObject)(parsed.channels) ? parsed.channels : {};
+    const channel = (0, util_1.isPlainObject)(channels[constants_1.CHANNEL_ID]) ? channels[constants_1.CHANNEL_ID] : {};
+    const accounts = (0, util_1.isPlainObject)(channel.accounts) ? channel.accounts : {};
+    const account = (0, util_1.isPlainObject)(accounts[accountId]) ? accounts[accountId] : {};
+    return ["apiHash", "sessionString"].filter((field) => (0, secret_refs_1.asSecretRef)(account[field]));
+}
 async function updateConfigFileDirectly(configPath, accountId, auth) {
     const raw = await node_fs_1.promises.readFile(configPath, "utf8");
+    const keptRefs = secretRefFieldsFor(raw, accountId);
     const nextRaw = buildUpdatedConfigText(raw, accountId, auth);
     if (nextRaw === raw) {
-        return;
+        return keptRefs;
     }
     await writeConfigAtomically(configPath, nextRaw);
+    return keptRefs;
 }

package/dist/util.js

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * Small readers reimplemented once per module.
+ *
+ * `readString`, `readNumber` and `isPlainObject` each existed in two or three
+ * files with identical bodies. Identical is the good case: `toStringId` had
+ * drifted, and one path accepted an id the other rejected (finding A12-05).
+ * Nothing here is clever; the point is that there is one of each.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readString = readString;
+exports.readNumber = readNumber;
+exports.isPlainObject = isPlainObject;
+/** A non-empty trimmed string, or nothing. */
+function readString(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed === "" ? undefined : trimmed;
+}
+/** A finite number, from a number or from its decimal spelling. */
+function readNumber(value) {
+    if (typeof value === "number") {
+        return Number.isFinite(value) ? value : undefined;
+    }
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    const parsed = Number(String(value));
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+/** An object that is not an array and not null — a config or params bag. */
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}