clawgram 2.21.1 → 2.23.0

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);
+}