@aspalagin/openclaw-max 0.7.2 → 0.8.0

package/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: MAX
-description: Канал-плагин для подключения OpenClaw к мессенджеру MAX (max.ru). Поддерживает отправку и получение текстовых сообщений, медиа, inline-кнопки (callback/link/message/clipboard/open_app), pin/unpin, форматирование в MAX-диалекте markdown. Работает в режимах long polling и webhook. Используй когда нужно отправить сообщение через мессенджер MAX или обработать входящие сообщения из MAX.
+description: Канал-плагин для подключения OpenClaw к мессенджеру MAX (max.ru). Отправка и получение текста, медиа, голосовых, пересланных сообщений, inline-кнопки (callback/link/message/clipboard/open_app), pin/unpin, markdown в диалекте MAX. Работает через webhook или long polling. Используй, когда нужно отправить сообщение через MAX или обработать входящие сообщения из MAX.
 ---
 
 # MAX — плагин для OpenClaw
@@ -9,39 +9,32 @@ description: Канал-плагин для подключения OpenClaw к
 
 ## Что делает
 
-- **Текстовые сообщения** — отправка и получение; исходящий markdown конвертируется в MAX-диалект (`++подчёркивание++`)
-- **Медиа** — фото, видео, аудио (включая m4a/heic с iPhone), файлы, стикеры, контакты, геолокация
-- **Inline-кнопки** — callback, link, message (suggested replies), clipboard, open_app, request_contact, request_geo_location
-- **Pin/unpin** — закрепление сообщений в чатах
-- **Long polling** — с персистентным marker (рестарты без потери/дублей событий)
-- **Webhook** — HTTPS c обязательным secret (X-Max-Bot-Api-Secret), мгновенный ACK, последовательная обработка
-- **Команды бота** — регистрация через PATCH /me/commands из `channels.max.commands`
-- **Мультиаккаунт**, DM-security (pairing/allowlist/open), пер-групповые политики
+- **Текст** — отправка и получение; исходящий markdown переводится в диалект MAX (`++подчёркивание++`). Если MAX отверг разметку, сообщение уходит обычным текстом.
+- **Медиа** — фото, видео, аудио, файлы, стикеры, контакты, геолокация; несколько вложений — альбомами до 12.
+- **Голосовые** — входящие распознаёт ядро (`tools.media.audio`) или берётся транскрипт MAX; голосовой ответ уходит аудиовложением MAX.
+- **Пересылки и цитаты** — агент видит пересланные сообщения и цитату сообщения, на которое ответили.
+- **Inline-кнопки** — callback, link, message (подсказки ответа), clipboard, open_app, request_contact, request_geo_location; меню `/think`, `/fast` и других команд кнопками.
+- **Pin/unpin** — закрепление в группах и каналах.
+- **Webhook** (рекомендуется MAX для боевой работы) и **long polling**; события webhook переживают рестарт gateway.
+- **Команды бота** — регистрация через `PATCH /me/commands` из `channels.max.commands`.
+- **Несколько аккаунтов**, политики доступа для личных сообщений (pairing/allowlist/open/disabled) и групп.
 
-TLS-сертификат Минцифры для platform-api2.max.ru встроен в плагин — дополнительная настройка не нужна.
+TLS-сертификат Минцифры для `platform-api2.max.ru` встроен в плагин и используется только для его соединений — отдельная настройка не нужна.
 
 ## Установка
 
-Через ClawHub (рекомендуется):
+Через ClawHub:
 
 ```bash
 openclaw plugins install clawhub:@aspalagin/openclaw-max
 ```
 
-Через npm:
+Через npm (имя с областью; пакет `openclaw-max` без области — другой проект):
 
 ```bash
 openclaw plugins install npm:@aspalagin/openclaw-max
 ```
 
-Вручную из исходников (для разработки):
-
-```bash
-cd ~/.openclaw/extensions
-git clone https://github.com/aspalagin/openclaw-max openclaw-max
-cd openclaw-max && npm install && npm run build
-```
-
 ## Настройка
 
 В `~/.openclaw/openclaw.json`:
@@ -51,8 +44,8 @@ cd openclaw-max && npm install && npm run build
   "channels": {
     "max": {
       "enabled": true,
-      "botToken": "ТОКЕН_БОТА",          // или env MAX_BOT_TOKEN
-      "dmPolicy": "pairing",              // pairing | allowlist | open | disabled
+      "tokenFile": "/home/you/.openclaw/secrets/max-bot-token", // абсолютный путь, обычный файл; или botToken (строка или SecretRef), или env MAX_BOT_TOKEN
+      "dmPolicy": "pairing",                            // pairing | allowlist | open | disabled
       "allowFrom": ["12345678"],
       "commands": [
         { "name": "status", "description": "Статус ассистента" }
@@ -62,22 +55,19 @@ cd openclaw-max && npm install && npm run build
 }
 ```
 
-Webhook-режим: добавить `"transport": "webhook"`, `"webhookUrl": "https://ваш-домен/max/webhook"`
-(только HTTPS:443, доверенный сертификат) и `"webhookSecretFile"` (без него secret
-генерируется и хранится в state-файле). Роут поднимается на HTTP-сервере gateway,
-подписку создаёт плагин; порядок включения и откат — README, раздел «Webhook».
+Webhook: `"webhookUrl": "https://bot.example.com/max/webhook"` (только HTTPS на порту 443 с доверенным сертификатом) и `"webhookSecretFile"`; без секрета плагин сгенерирует его сам и сохранит в каталоге состояния. Роут поднимается на HTTP-сервере gateway, подписку создаёт плагин. Подробности и порядок включения — README, раздел «Транспорты: webhook и long polling».
 
-## Примеры использования
+## Примеры
 
 ### Отправка сообщения
 
 ```bash
-openclaw message send --channel max --target "144660345" --message "Привет из OpenClaw!"
+openclaw message send --channel max --target "user:12345678" --message "Привет из OpenClaw!"
 ```
 
-Цели: числовой chat_id, `user:<id>` (адресация в личку; голое число, для которого MAX ответил `dialog.not.found`, повторяется как user_id), `@username` и ссылки max.ru не поддерживаются: MAX Bot API не резолвит их (`chat.not.found`), плагин сразу отвечает понятной ошибкой — для чатов и каналов используйте числовой chat_id.
+Цели: `user:<id>` — личный диалог с пользователем; числовой `chat_id` — группа или канал (например, `-70000000000001`). `@username` и ссылки max.ru не поддерживаются: MAX Bot API их не разрешает, плагин сразу отвечает понятной ошибкой.
 
-### Кнопки (из message-tool агента)
+### Кнопки
 
 ```
 message(action="send", target="CHAT_ID", message="Выберите:",
@@ -85,6 +75,28 @@ message(action="send", target="CHAT_ID", message="Выберите:",
                   {"text":"Подробнее","type":"message"}]])
 ```
 
+### Файлы, голосовые, тихая отправка
+
+```
+message(action="sendAttachment", target="CHAT_ID", path="report.pdf", caption="Отчёт")
+message(action="sendAttachment", target="CHAT_ID", buffer="data:text/plain;base64,SGVsbG8=", filename="hello.txt")
+message(action="send", target="CHAT_ID", path="reply.ogg", asVoice=true)
+message(action="send", target="CHAT_ID", message="Без уведомления", silent=true)
+```
+
+- `asVoice=true` с аудиофайлом (`mp3`, `m4a`, `wav`, `ogg`, `opus`) отправляет аудиосообщение MAX, а не файл. Если MAX отказал в аудио, те же байты уходят файлом.
+- `buffer` — содержимое в base64 или data URL, с `filename` и `contentType`; лимит размера — `mediaMaxMb` (по умолчанию 20 МБ). Если заданы и путь, и `buffer`, отправляется файл по пути.
+- `silent=true` — без push-уведомления. В каналы MAX сообщения всегда уходят с уведомлением.
+- Несколько вложений: `attachments=[{"path": …}, {"buffer": …, "filename": …}]` — фото и видео альбомами до 12, аудио и файлы по одному; в ответе `messageIds`, неудачные — в `mediaErrors`.
+
+### Ограничение локальных файлов
+
+Отправить можно только файлы из каталогов, которые OpenClaw разрешает агенту: его рабочий каталог и media-каталоги gateway. Путь вне них отклоняется ошибкой `Local media path is not under an allowed directory`; выход через `..` и символические ссылки тоже закрыт. Нужен файл извне — сначала скопировать его в рабочий каталог. Если у агента чтение с хоста, путь может быть любым, но ядро пропускает только проверенные по содержимому типы (изображения, аудио, видео, PDF, документы Office, архивы, текст `.txt`/`.md`/`.csv`/`.json`/`.yaml`); отказ — `Host-local media sends only allow …`.
+
+### В каких чатах работают действия
+
+`send`, `sendAttachment`, `sticker`, `edit`, `delete`, `pin`, `unpin` выполняются в текущем чате, по запросу владельца или в чатах, которые допускает политика доступа канала (`channels.max.actionScope`, по умолчанию `admitted`; `current` — только текущий чат; `off` — без проверки). Отказ — ошибка инструмента до любого изменения в MAX: сообщить о нём, не пытаться повторить в другом чате.
+
 ### Pin
 
 ```
@@ -92,16 +104,12 @@ message(action="pin", target="CHAT_ID", messageId="MID")
 message(action="unpin", target="CHAT_ID")
 ```
 
-В диалогах (личка, `user:<id>`) MAX не поддерживает закреп: плагин не вызывает API и возвращает `pinned: false` с причиной.
-
-### Несколько вложений
-
-`message(action="send", target=…, message="Подпись", attachments=[{"path": …}, {"path": …}])` отправляет все вложения: фото/видео альбомами до 12, файлы и аудио по одному; в ответе `messageIds`.
+В личных диалогах MAX не поддерживает закрепление: плагин не вызывает API и возвращает `pinned: false` с причиной.
 
 ## Требования
 
-- OpenClaw 2026.x (plugin SDK)
-- Node.js >= 20
+- OpenClaw ≥ 2026.9.6
+- Node.js ≥ 22
 
 ## Поддержка
 

package/dist/secret-contract-api.js

@@ -0,0 +1,6 @@
+/**
+ * MAX channel secret contract — the artifact the gateway loads before the
+ * plugin runtime (`dist/secret-contract-api.js`) to resolve SecretRef options
+ * and to list them for `openclaw secrets`. See src/secret-contract.ts.
+ */
+export { collectRuntimeConfigAssignments, maxChannelSecrets as channelSecrets, secretTargetRegistryEntries, } from './src/secret-contract.js';

package/dist/src/access-policy.js

@@ -0,0 +1,123 @@
+/**
+ * Chat admission rules shared by the inbound gate and message-tool action
+ * scoping: the DM policy with allowFrom and the pairing store, the group
+ * policy with its allowlist, the group sender allowlist.
+ */
+import { isSenderIdAllowed, resolveGroupAllowFromSources } from 'openclaw/plugin-sdk/allow-from';
+import { DEFAULT_ACCOUNT_ID } from 'openclaw/plugin-sdk/core';
+import { maxAccountConfigPath } from './accounts.js';
+import { getMaxRuntime } from './runtime.js';
+/** Effective group policy: account, then channels.defaults, then allowlist. */
+export function resolveMaxGroupPolicy(account, config) {
+    return account.config.groupPolicy ?? config.channels?.defaults?.groupPolicy ?? 'allowlist';
+}
+/** Whether a group chat passes the group policy (disabled / allowlist with "*" / open) and is enabled. */
+export function admitMaxGroupChat(account, config, chatId) {
+    const groupPolicy = resolveMaxGroupPolicy(account, config);
+    if (groupPolicy === 'disabled')
+        return { admitted: false, reason: 'groupPolicy=disabled' };
+    if (groupPolicy === 'allowlist') {
+        const groups = account.config.groups ?? {};
+        if (!(String(chatId) in groups) && !('*' in groups)) {
+            return { admitted: false, reason: 'chat is not in the groups allowlist' };
+        }
+    }
+    // groups.<id>.enabled=false (else the "*" entry's) turns the group off under any policy.
+    const groupCfg = account.config.groups?.[String(chatId)] ?? account.config.groups?.['*'];
+    if (groupCfg?.enabled === false)
+        return { admitted: false, reason: 'group enabled=false' };
+    return { admitted: true };
+}
+/**
+ * Sender allowlist of a group: its own groups.<id>.allowFrom (else the "*"
+ * entry's), else the account's groupAllowFrom — the first non-empty one, as
+ * core resolves group sender lists. `max:` prefixes are stripped.
+ */
+export function resolveMaxGroupSenderAllowFrom(account, chatId) {
+    const groupCfg = account.config.groups?.[String(chatId)] ?? account.config.groups?.['*'];
+    const groupAllowFrom = Array.isArray(groupCfg?.allowFrom)
+        ? groupCfg.allowFrom
+        : undefined;
+    return resolveGroupAllowFromSources({
+        groupAllowFrom,
+        allowFrom: account.config.groupAllowFrom,
+    }).map((entry) => entry.replace(/^max:/i, ''));
+}
+/**
+ * Whether a sender may trigger the bot in a group the group policy admits:
+ * anyone when no sender list is set (unlike core's WhatsApp/Telegram, no
+ * fallback to the DM allowFrom — MAX never applied it to groups), "*" for
+ * anyone, else only the listed user ids. DM pairing approvals don't count.
+ */
+export function admitMaxGroupSender(account, chatId, senderId) {
+    const entries = resolveMaxGroupSenderAllowFrom(account, chatId);
+    const allow = {
+        entries,
+        hasWildcard: entries.includes('*'),
+        hasEntries: entries.length > 0,
+    };
+    if (isSenderIdAllowed(allow, senderId != null ? String(senderId) : undefined, true)) {
+        return { admitted: true };
+    }
+    return { admitted: false, reason: 'sender is not in the group allowFrom/groupAllowFrom' };
+}
+/** Group policy, then the group's sender allowlist. */
+export function admitMaxGroupMessage(account, config, chatId, senderId) {
+    const chat = admitMaxGroupChat(account, config, chatId);
+    return chat.admitted ? admitMaxGroupSender(account, chatId, senderId) : chat;
+}
+/** allowFrom from the config plus the approved pairing store, as strings. */
+export async function readMaxDmAllowFrom(account) {
+    const configAllowFrom = (account.config.allowFrom ?? []).map(String);
+    const storeAllowFrom = await getMaxRuntime()
+        .channel.pairing.readAllowFromStore({ channel: 'max', accountId: account.accountId })
+        .catch(() => []);
+    return [...configAllowFrom, ...storeAllowFrom];
+}
+/** Whether a DM peer passes the DM policy (disabled / open / allowFrom + pairing store). */
+export async function admitMaxDmUser(account, userId) {
+    const dmPolicy = account.config.dmPolicy ?? 'pairing';
+    if (dmPolicy === 'disabled')
+        return { admitted: false, reason: 'dmPolicy=disabled' };
+    if (dmPolicy === 'open')
+        return { admitted: true };
+    const allowFrom = await readMaxDmAllowFrom(account);
+    if (allowFrom.includes('*') || (userId != null && allowFrom.includes(String(userId)))) {
+        return { admitted: true };
+    }
+    return {
+        admitted: false,
+        reason: `user is not in allowFrom or the pairing store (dmPolicy=${dmPolicy})`,
+    };
+}
+/**
+ * Start-up warning for a named account that sets no DM or group policy of its
+ * own and inherits an open one (channels.max, or channels.defaults for
+ * groups): the second bot is then open too. Names the account, the policy
+ * and where to set its own; no secrets or user ids. undefined when nothing
+ * open is inherited.
+ */
+export function describeMaxInheritedOpenAccess(cfg, account) {
+    if (!cfg || account.accountId === DEFAULT_ACCOUNT_ID)
+        return undefined;
+    const channel = cfg.channels?.max;
+    const accounts = channel?.accounts;
+    const own = accounts?.[account.accountId] ?? {};
+    const inherited = [];
+    const fix = [];
+    if (!Object.hasOwn(own, 'dmPolicy') && account.config.dmPolicy === 'open') {
+        inherited.push('dmPolicy="open" from channels.max (anyone can message this bot)');
+        fix.push('dmPolicy (e.g. "pairing")');
+    }
+    if (!Object.hasOwn(own, 'groupPolicy') && resolveMaxGroupPolicy(account, cfg) === 'open') {
+        const from = channel?.groupPolicy === 'open' ? 'channels.max' : 'channels.defaults';
+        inherited.push(`groupPolicy="open" from ${from} (any group can add and ping this bot)`);
+        fix.push('groupPolicy (e.g. "allowlist" with groups)');
+    }
+    if (inherited.length === 0)
+        return undefined;
+    const path = maxAccountConfigPath(account.accountId);
+    return (`MAX account "${account.accountId}" has no access policy of its own and inherits ` +
+        `${inherited.join(' and ')}; set ${fix.map((key) => `${path}.${key}`).join(' / ')} ` +
+        'to give this bot its own access rules.');
+}

package/dist/src/accounts.js

@@ -2,7 +2,30 @@
  * MAX account resolution — reads config and produces a resolved account object.
  */
 import { lstatSync, readFileSync } from 'node:fs';
+import { mergeAccountConfig } from 'openclaw/plugin-sdk/account-core';
 import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from 'openclaw/plugin-sdk/core';
+import { resolveSecretInputString } from 'openclaw/plugin-sdk/secret-input';
+import { canResolveEnvSecretRefInReadOnlyPath } from 'openclaw/plugin-sdk/secret-ref-readonly';
+import { bindMaxNetwork, MaxNetworkConfigError, resolveMaxNetwork, } from './network.js';
+/**
+ * Channel-level keys a named account never inherits: they belong to one bot
+ * (token, token file, display name) or to one webhook subscription (transport,
+ * URL, secret, secret file, HTTP path — a shared path would route two bots to
+ * one handler). Top-level-only keys (commands, defaultAccount) are not account
+ * settings at all.
+ */
+export const MAX_ACCOUNT_OWN_KEYS = [
+    'botToken',
+    'tokenFile',
+    'name',
+    'transport',
+    'webhookUrl',
+    'webhookSecret',
+    'webhookSecretFile',
+    'webhookPath',
+    'commands',
+    'defaultAccount',
+];
 /**
  * Get the MAX channel section from config.
  */
@@ -27,6 +50,42 @@ function readTokenFile(tokenFile) {
         return '';
     }
 }
+/** Thrown at account start for an option whose SecretRef did not resolve. */
+export class MaxSecretConfigError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'MaxSecretConfigError';
+    }
+}
+/**
+ * A secret-capable option: a plain string, or a SecretRef the gateway has
+ * already replaced by its value in the runtime snapshot. A ref still present
+ * is unresolved — except an env ref the read-only SDK check allows (CLI and
+ * status paths without a gateway snapshot, as core channels do).
+ */
+function readSecretOption(cfg, value, path) {
+    const resolved = resolveSecretInputString({
+        value,
+        path,
+        defaults: cfg.secrets?.defaults,
+        mode: 'inspect',
+    });
+    if (resolved.status === 'available')
+        return { value: resolved.value };
+    if (resolved.status === 'missing')
+        return {};
+    const { ref } = resolved;
+    if (ref.source === 'env' &&
+        canResolveEnvSecretRefInReadOnlyPath({ cfg, provider: ref.provider, id: ref.id })) {
+        const fromEnv = process.env[ref.id]?.trim();
+        if (fromEnv)
+            return { value: fromEnv };
+    }
+    return {
+        error: `MAX ${path} is a SecretRef (${ref.source}:${ref.provider}:${ref.id}) that did not ` +
+            'resolve; check the secret and secrets.providers (openclaw secrets audit)',
+    };
+}
 /**
  * List all MAX account IDs from config.
  */
@@ -61,10 +120,58 @@ export function listMaxAccountIds(cfg) {
 export function resolveDefaultMaxAccountId(_cfg) {
     return DEFAULT_ACCOUNT_ID;
 }
+/** Config path of an account's own settings, for error messages. */
+export function maxAccountConfigPath(accountId) {
+    return accountId === DEFAULT_ACCOUNT_ID ? 'channels.max' : `channels.max.accounts.${accountId}`;
+}
+/**
+ * The account's validated network settings (API base URL, proxy). Throws
+ * MaxNetworkConfigError with the config path; never echoes proxy credentials.
+ */
+export function resolveMaxAccountNetwork(account) {
+    const proxyError = account.secretErrors?.httpProxy;
+    if (proxyError)
+        throw new MaxNetworkConfigError(proxyError);
+    return resolveMaxNetwork(account.config, maxAccountConfigPath(account.accountId));
+}
+function resolveAccountNetwork(accountId, config, proxyError) {
+    // An unresolved proxy ref must not mean "connect directly".
+    if (proxyError)
+        return { error: new MaxNetworkConfigError(proxyError) };
+    try {
+        return resolveMaxNetwork(config, maxAccountConfigPath(accountId));
+    }
+    catch (err) {
+        if (err instanceof MaxNetworkConfigError)
+            return { error: err };
+        throw err;
+    }
+}
+/** A token was found, or botToken is a SecretRef that did not resolve. */
+export function isMaxAccountConfigured(account) {
+    return Boolean(account.token?.trim()) || account.tokenStatus === 'configured_unavailable';
+}
 /**
  * Resolve a single MAX account from config.
  */
 export function resolveMaxAccount(params) {
+    const account = readMaxAccount(params);
+    // Every MaxApi built for this token (any send/action/lifecycle path) uses
+    // the account's API base URL and proxy — or fails with their config error.
+    bindMaxNetwork(account.token, resolveAccountNetwork(account.accountId, account.config, account.secretErrors?.httpProxy));
+    return account;
+}
+/** Why an account has no token: the options to set or the unreadable token file (no path of the file itself). */
+function missingTokenReason(accountId, tokenFile) {
+    const path = maxAccountConfigPath(accountId);
+    if (tokenFile?.trim())
+        return `${path}.tokenFile is missing, empty or not a regular file`;
+    return accountId === DEFAULT_ACCOUNT_ID
+        ? `no bot token: set ${path}.botToken, ${path}.tokenFile or MAX_BOT_TOKEN`
+        : `no bot token: set ${path}.botToken or ${path}.tokenFile`;
+}
+/** Account resolution without side effects (resolveMaxAccount also binds its network). */
+export function readMaxAccount(params) {
     const { cfg, accountId: rawId } = params;
     const accountId = rawId ? normalizeAccountId(rawId) : DEFAULT_ACCOUNT_ID;
     const section = getMaxSection(cfg) ?? {};
@@ -72,6 +179,7 @@ export function resolveMaxAccount(params) {
     let accountConfig;
     let token = '';
     let tokenSource = 'none';
+    const secretErrors = {};
     if (accountId === DEFAULT_ACCOUNT_ID) {
         // Default account: top-level config
         accountConfig = {
@@ -89,60 +197,99 @@ export function resolveMaxAccount(params) {
             webhookSecret: section.webhookSecret,
             webhookSecretFile: section.webhookSecretFile,
             webhookPath: section.webhookPath,
+            webhookQueue: section.webhookQueue,
+            maxEventAgeMinutes: section.maxEventAgeMinutes,
+            logMessagePreview: section.logMessagePreview,
             mediaMaxMb: section.mediaMaxMb,
             streamMode: section.streamMode,
             markSeen: section.markSeen,
+            actionScope: section.actionScope,
+            notify: section.notify,
+            disableLinkPreview: section.disableLinkPreview,
+            mediaMaxCount: section.mediaMaxCount,
+            apiBaseUrl: section.apiBaseUrl,
+            httpProxy: section.httpProxy,
+            streaming: section.streaming,
+            mentionPatterns: section.mentionPatterns,
+            actions: section.actions,
         };
-        if (accountConfig.botToken?.trim()) {
-            token = accountConfig.botToken.trim();
+        const botToken = readSecretOption(cfg, section.botToken, 'channels.max.botToken');
+        if (botToken.value) {
+            token = botToken.value;
+            tokenSource = 'config';
+        }
+        else if (botToken.error) {
             tokenSource = 'config';
+            secretErrors.botToken = botToken.error;
         }
         else if (accountConfig.tokenFile?.trim()) {
             token = readTokenFile(accountConfig.tokenFile);
             tokenSource = token ? 'file' : 'none';
         }
-        if (!token && process.env.MAX_BOT_TOKEN?.trim()) {
+        if (!token && !botToken.error && process.env.MAX_BOT_TOKEN?.trim()) {
             token = process.env.MAX_BOT_TOKEN.trim();
             tokenSource = 'env';
         }
     }
     else {
-        // Named account
+        // Named account: the account's own values over the channel-level ones
+        // (SDK mergeAccountConfig, as core channels do), minus the per-bot keys.
+        // A channel switched off switches off every account.
         const raw = accounts?.[accountId] ?? {};
         accountConfig = {
-            enabled: raw.enabled !== false,
-            botToken: raw.botToken,
-            tokenFile: raw.tokenFile,
-            name: raw.name,
-            dmPolicy: raw.dmPolicy,
-            allowFrom: raw.allowFrom,
-            groups: raw.groups,
-            groupPolicy: raw.groupPolicy,
-            groupAllowFrom: raw.groupAllowFrom,
-            transport: raw.transport,
-            webhookUrl: raw.webhookUrl,
-            webhookSecret: raw.webhookSecret,
-            webhookSecretFile: raw.webhookSecretFile,
-            webhookPath: raw.webhookPath,
-            mediaMaxMb: raw.mediaMaxMb,
-            streamMode: raw.streamMode,
-            markSeen: raw.markSeen,
+            ...mergeAccountConfig({
+                channelConfig: section,
+                accountConfig: raw,
+                omitKeys: [...MAX_ACCOUNT_OWN_KEYS],
+            }),
+            enabled: section.enabled !== false && raw.enabled !== false,
         };
-        if (accountConfig.botToken?.trim()) {
-            token = accountConfig.botToken.trim();
+        const botToken = readSecretOption(cfg, raw.botToken, `${maxAccountConfigPath(accountId)}.botToken`);
+        if (botToken.value) {
+            token = botToken.value;
             tokenSource = 'config';
         }
+        else if (botToken.error) {
+            tokenSource = 'config';
+            secretErrors.botToken = botToken.error;
+        }
         else if (accountConfig.tokenFile?.trim()) {
             token = readTokenFile(accountConfig.tokenFile);
             tokenSource = token ? 'file' : 'none';
         }
     }
+    // From here on a SecretRef option holds its value, or is absent.
+    const setResolved = (key, value) => {
+        if (!(key in accountConfig))
+            return;
+        if (value === undefined)
+            delete accountConfig[key];
+        else
+            accountConfig[key] = value;
+    };
+    setResolved('botToken', tokenSource === 'config' && token ? token : undefined);
+    // The webhook secret is per-bot; a named account's proxy may be inherited.
+    const webhookSecret = readSecretOption(cfg, accountConfig.webhookSecret, `${maxAccountConfigPath(accountId)}.webhookSecret`);
+    setResolved('webhookSecret', webhookSecret.value);
+    if (webhookSecret.error)
+        secretErrors.webhookSecret = webhookSecret.error;
+    const ownProxy = accountId === DEFAULT_ACCOUNT_ID || Object.hasOwn(accounts?.[accountId] ?? {}, 'httpProxy');
+    const httpProxy = readSecretOption(cfg, accountConfig.httpProxy, `${ownProxy ? maxAccountConfigPath(accountId) : 'channels.max'}.httpProxy`);
+    // "" still turns an inherited proxy off.
+    setResolved('httpProxy', httpProxy.value ?? (accountConfig.httpProxy === '' ? '' : undefined));
+    if (httpProxy.error)
+        secretErrors.httpProxy = httpProxy.error;
     return {
         accountId,
         name: accountConfig.name,
         enabled: accountConfig.enabled ?? true,
         token,
         tokenSource,
+        tokenStatus: token ? 'available' : secretErrors.botToken ? 'configured_unavailable' : 'missing',
+        ...(Object.keys(secretErrors).length > 0 ? { secretErrors } : {}),
+        ...(token || secretErrors.botToken
+            ? {}
+            : { stateReason: missingTokenReason(accountId, accountConfig.tokenFile) }),
         config: accountConfig,
     };
 }