@aspalagin/openclaw-max 0.7.2

package/src/callbacks.ts

@@ -0,0 +1,140 @@
+/**
+ * Button presses (message_callback): presentation approvals and ask_user
+ * answers go to the gateway runtimes; other payloads re-enter the inbound
+ * pipeline as a synthesized message.
+ */
+
+import { resolveApprovalOverGateway } from 'openclaw/plugin-sdk/approval-gateway-runtime';
+import { questionGatewayRuntime } from 'openclaw/plugin-sdk/question-gateway-runtime';
+
+import type { ResolvedMaxAccount } from './accounts.js';
+import type { MaxCallback, MaxMessage } from './api.js';
+import { processIncomingMessage } from './inbound.js';
+import type { MaxMonitorOptions } from './monitor-types.js';
+import { decodeMaxPresentationCallback, type MaxPresentationCallback } from './presentation.js';
+
+/**
+ * Synthesize a regular message from a button press. The keyboard's message is
+ * a sibling of `callback` in the update; its recipient is the real chat
+ * (dialog chat_id ≠ user_id). Only when that message is gone (null) do we fall
+ * back to addressing the pressing user.
+ * callback_id is not a valid MAX message id, so replies to callback-originated
+ * commands must not use it as replyToMessageId.
+ * @internal - Exported for testing only
+ */
+export function buildCallbackMessage(
+  callback: MaxCallback,
+  message: MaxMessage | null,
+  text: string = callback.payload ?? '',
+): MaxMessage & { __maxCallback: true } {
+  return {
+    __maxCallback: true,
+    sender: callback.user,
+    recipient: message ? message.recipient : { chat_id: callback.user.user_id },
+    timestamp: callback.timestamp,
+    body: {
+      mid: callback.callback_id,
+      text,
+    },
+  };
+}
+
+export async function processCallback(
+  callback: MaxCallback,
+  message: MaxMessage | null,
+  userLocale: string | null | undefined,
+  opts: MaxMonitorOptions,
+): Promise<void> {
+  const payload = callback.payload ?? '';
+  if (!payload.trim()) return;
+
+  // Presentation buttons carry private envelopes (see presentation.ts).
+  // Command buttons carry the command text itself and take the default path;
+  // plain channelData.max.buttons payloads keep arriving as message text.
+  const presentationCallback = decodeMaxPresentationCallback(payload);
+  if (presentationCallback?.kind === 'approval' || presentationCallback?.kind === 'question') {
+    await resolveMaxRuntimeControlCallback(presentationCallback, callback, opts);
+    return;
+  }
+  // Opaque callback data goes to the agent labelled, never as a slash command.
+  const text =
+    presentationCallback?.kind === 'callback'
+      ? `callback_data: ${presentationCallback.value}`
+      : payload;
+
+  await processIncomingMessage(buildCallbackMessage(callback, message, text), userLocale, opts);
+}
+
+/**
+ * Approvals and ask_user answers are operator actions: only senders listed
+ * explicitly in the account's allowFrom may press them (a wildcard is enough
+ * for questions, never for approvals).
+ */
+function isMaxRuntimeControlSender(
+  account: ResolvedMaxAccount,
+  senderId: string,
+  kind: 'approval' | 'question',
+): boolean {
+  const allowFrom = (account.config.allowFrom ?? []).map((entry) =>
+    String(entry).trim().replace(/^max:/i, ''),
+  );
+  if (allowFrom.includes(senderId)) return true;
+  return kind === 'question' && allowFrom.includes('*');
+}
+
+async function resolveMaxRuntimeControlCallback(
+  action: Extract<MaxPresentationCallback, { kind: 'approval' | 'question' }>,
+  callback: MaxCallback,
+  opts: MaxMonitorOptions,
+): Promise<void> {
+  const { account, config, log } = opts;
+  const senderId = String(callback.user.user_id);
+  let notification: string;
+
+  if (!isMaxRuntimeControlSender(account, senderId, action.kind)) {
+    log?.warn(
+      `[${account.accountId}] MAX ${action.kind} button pressed by unauthorized sender ${senderId}`,
+    );
+    notification = 'You are not allowed to answer this.';
+  } else {
+    try {
+      if (action.kind === 'approval') {
+        const result = await resolveApprovalOverGateway({
+          cfg: config,
+          approvalId: action.approvalId,
+          approvalKind: action.approvalKind,
+          decision: action.decision,
+          channel: 'max',
+          accountId: account.accountId,
+          senderId,
+        });
+        notification = result.applied
+          ? `Decision recorded: ${action.decision}.`
+          : 'This approval was already resolved.';
+      } else {
+        const result = await questionGatewayRuntime.resolveOption({
+          cfg: config,
+          questionId: action.questionId,
+          optionValue: action.optionValue,
+          senderId,
+          authorize: () => isMaxRuntimeControlSender(account, senderId, 'question'),
+        });
+        notification =
+          result.status === 'answered'
+            ? 'Answer recorded.'
+            : result.status === 'denied'
+              ? 'You are not allowed to answer this.'
+              : 'This question is no longer open.';
+      }
+    } catch (err) {
+      log?.error(`[${account.accountId}] MAX ${action.kind} callback failed: ${String(err)}`);
+      notification = 'Could not apply this action.';
+    }
+  }
+
+  try {
+    await opts.api.answerCallback(callback.callback_id, { notification });
+  } catch (err) {
+    log?.debug?.(`[${account.accountId}] MAX callback answer failed: ${String(err)}`);
+  }
+}

package/src/channel-agent-prompt.ts

@@ -0,0 +1,47 @@
+/**
+ * Agent prompt hints of the MAX channel: stickers, location, contact, pin,
+ * button types and presentation for the message tool.
+ */
+
+import type { ChannelPlugin } from 'openclaw/plugin-sdk/channel-core';
+
+import type { ResolvedMaxAccount } from './accounts.js';
+
+type MaxChannelPlugin = ChannelPlugin<ResolvedMaxAccount>;
+
+/** message tool hints for MAX-specific actions. */
+export const maxAgentPromptAdapter: NonNullable<MaxChannelPlugin['agentPrompt']> = {
+  messageToolHints: () => {
+    // Compact sticker emoji map: top 50 emojis → sticker codes
+    // Codes are hex IDs derived from listmax.ru external_id: parseInt(extId).toString(16)
+    const emojiMap =
+      '😂:109550b5 😊:109971b5 😍:10931eb5 🥰:10931eb5 😢:109330b5 😭:109330b5 😡:10941fb5 😱:109302b5 🤔:109308b5 👍:109368b5 👎:109323b5 ❤️:10931eb5 🔥:b4867ebb 💪:c1254bbb 🎉:10933cb5 😘:10931eb5 🤗:109b94b5 😎:10931db5 🙄:c14211bb 😴:10936eb5 😤:10941fb5 🤮:6b8bb 🤯:109302b5 😳:109302b5 🥳:10933cb5 💀:b4863ebb 🙈:b4850cbb 😏:11e4c60bb 😅:109550b5 🤣:109550b5 😋:109d2db5 😜:455b5 🤷:10d5cf5bb 😫:10936eb5 😩:10997db5 🥺:109356b5 😌:14aae3bb 😒:109323b5 🤪:455b5 😇:11e4dedbb 🙏:50cb5 💔:10997db5 👀:b48534bb ✨:11e43b2bb 😈:10941fb5 🤝:109368b5 🤦:502b5 😬:5dab4b5 🤩:5dabfb5 😶:2ae2b5';
+
+    // Also try to load full sticker-emoji-map.json for extended catalog
+    let extendedHint = '';
+    try {
+      const fs = require('fs');
+      const path = require('path');
+      const candidates = [
+        path.join(__dirname, '..', 'sticker-emoji-map.json'),
+        path.join(process.cwd(), 'projects', 'openclaw-max', 'sticker-emoji-map.json'),
+      ];
+      for (const p of candidates) {
+        if (fs.existsSync(p)) {
+          extendedHint = ' Full emoji→sticker map available at: ' + p;
+          break;
+        }
+      }
+    } catch {}
+
+    return [
+      '- MAX stickers: use `message(action="sticker", target="CHAT_ID", stickerId="CODE")`. Pick a sticker code matching the mood from the emoji map below. Each entry is emoji:hexCode.',
+      `- Sticker emoji map: ${emojiMap}${extendedHint}`,
+      '- MAX location: use `message(action="sendAttachment", target="CHAT_ID", type="location", latitude="55.75", longitude="37.62")` to send a native map pin.',
+      '- MAX contact: use `message(action="sendAttachment", target="CHAT_ID", type="contact", contactName="Name", vcfPhone="+70001234567")` to send a native contact card.',
+      '- MAX pin: use `message(action="pin", target="CHAT_ID", messageId="MID")` to pin a message; `message(action="unpin", target="CHAT_ID")` to unpin.',
+      '- MAX buttons support types: callback (default), link, message (sends the button text as a user message — great for suggested replies), clipboard (copies payload), open_app (webApp = public name of the bot wired to the mini app), request_contact, request_geo_location. Pass via buttons=[[{"text":"...","type":"message"}]].',
+      '- MAX rich messages: prefer `presentation` (title/tone, text, context, divider, table/chart as monospace text, buttons and select as an inline keyboard); `pin=true` pins the sent message.',
+    ];
+  },
+};

package/src/channel-config.ts

@@ -0,0 +1,138 @@
+/**
+ * Account config and CLI setup adapters of the MAX channel: account listing
+ * and resolution, enable/delete, allowFrom formatting, `openclaw channels add`.
+ */
+
+import type { ChannelPlugin } from 'openclaw/plugin-sdk/channel-core';
+import {
+  applyAccountNameToChannelSection,
+  DEFAULT_ACCOUNT_ID,
+  deleteAccountFromConfigSection,
+  migrateBaseNameToDefaultAccount,
+  normalizeAccountId,
+  setAccountEnabledInConfigSection,
+} from 'openclaw/plugin-sdk/core';
+
+import { listMaxAccountIds, type ResolvedMaxAccount, resolveMaxAccount } from './accounts.js';
+
+type MaxChannelPlugin = ChannelPlugin<ResolvedMaxAccount>;
+
+/** Accounts under channels.max (top level = default account, plus channels.max.accounts). */
+export const maxConfigAdapter: NonNullable<MaxChannelPlugin['config']> = {
+  listAccountIds: (cfg) => listMaxAccountIds(cfg),
+  resolveAccount: (cfg, accountId) => resolveMaxAccount({ cfg, accountId }),
+  defaultAccountId: () => DEFAULT_ACCOUNT_ID,
+
+  setAccountEnabled: ({ cfg, accountId, enabled }) =>
+    setAccountEnabledInConfigSection({
+      cfg,
+      sectionKey: 'max',
+      accountId,
+      enabled,
+      allowTopLevel: true,
+    }),
+
+  deleteAccount: ({ cfg, accountId }) =>
+    deleteAccountFromConfigSection({
+      cfg,
+      sectionKey: 'max',
+      accountId,
+      clearBaseFields: ['botToken', 'tokenFile', 'name'],
+    }),
+
+  isConfigured: (account) => Boolean(account.token?.trim()),
+
+  describeAccount: (account) => ({
+    accountId: account.accountId,
+    name: account.name,
+    enabled: account.enabled,
+    configured: Boolean(account.token?.trim()),
+    tokenSource: account.tokenSource,
+  }),
+
+  resolveAllowFrom: ({ cfg, accountId }) =>
+    (resolveMaxAccount({ cfg, accountId }).config.allowFrom ?? []).map(String),
+
+  formatAllowFrom: ({ allowFrom }) =>
+    allowFrom
+      .map((entry) => String(entry).trim())
+      .filter(Boolean)
+      .map((entry) => entry.replace(/^max:/i, '')),
+};
+
+/** Non-interactive setup: token / token file / MAX_BOT_TOKEN for the default account. */
+export const maxSetupAdapter: NonNullable<MaxChannelPlugin['setup']> = {
+  resolveAccountId: ({ accountId }) => normalizeAccountId(accountId),
+
+  applyAccountName: ({ cfg, accountId, name }) =>
+    applyAccountNameToChannelSection({
+      cfg,
+      channelKey: 'max',
+      accountId,
+      name,
+    }),
+
+  validateInput: ({ accountId, input }) => {
+    if (input.useEnv && accountId !== DEFAULT_ACCOUNT_ID) {
+      return 'MAX_BOT_TOKEN can only be used for the default account.';
+    }
+    if (!input.useEnv && !input.token && !input.tokenFile) {
+      return 'MAX requires --token or --token-file (or --use-env with MAX_BOT_TOKEN).';
+    }
+    return null;
+  },
+
+  applyAccountConfig: ({ cfg, accountId, input }) => {
+    const namedConfig = applyAccountNameToChannelSection({
+      cfg,
+      channelKey: 'max',
+      accountId,
+      name: input.name,
+    });
+    const next =
+      accountId !== DEFAULT_ACCOUNT_ID
+        ? migrateBaseNameToDefaultAccount({
+            cfg: namedConfig,
+            channelKey: 'max',
+          })
+        : namedConfig;
+
+    if (accountId === DEFAULT_ACCOUNT_ID) {
+      return {
+        ...next,
+        channels: {
+          ...next.channels,
+          max: {
+            ...((next.channels as Record<string, unknown>)?.max as Record<string, unknown>),
+            enabled: true,
+            ...(input.useEnv ? {} : input.token ? { botToken: input.token } : {}),
+          },
+        },
+      };
+    }
+
+    const maxSection =
+      ((next.channels as Record<string, unknown>)?.max as Record<string, unknown>) ?? {};
+    return {
+      ...next,
+      channels: {
+        ...next.channels,
+        max: {
+          ...maxSection,
+          enabled: true,
+          accounts: {
+            ...(maxSection.accounts as Record<string, unknown>),
+            [accountId]: {
+              ...((maxSection.accounts as Record<string, unknown>)?.[accountId] as Record<
+                string,
+                unknown
+              >),
+              enabled: true,
+              ...(input.token ? { botToken: input.token } : {}),
+            },
+          },
+        },
+      },
+    };
+  },
+};

package/src/channel-directory.ts

@@ -0,0 +1,90 @@
+/**
+ * Directory and addressing of the MAX channel: self, peers from allowFrom,
+ * groups from the passive chat registry, numeric target normalization.
+ */
+
+import type { ChannelPlugin } from 'openclaw/plugin-sdk/channel-core';
+
+import { type ResolvedMaxAccount, resolveMaxAccount } from './accounts.js';
+import { MaxApi } from './api.js';
+import { loadMaxAccountState } from './state.js';
+
+type MaxChannelPlugin = ChannelPlugin<ResolvedMaxAccount>;
+
+/** `user:<id>` addresses a user (DM); a bare number is a chat id. */
+const MAX_TARGET_PATTERN = /^(?:user:\d+|-?\d+)$/;
+
+function stripMaxPrefix(raw: string): string {
+  const trimmed = raw.trim();
+  return trimmed.startsWith('max:') ? trimmed.slice(4) : trimmed;
+}
+
+/**
+ * Targets are numeric chat ids or `user:<id>`, with an optional max: prefix.
+ * The `user:` prefix must survive normalization: dropping it turns a user id
+ * into a chat_id and MAX answers dialog.not.found.
+ */
+export const maxMessagingAdapter: NonNullable<MaxChannelPlugin['messaging']> = {
+  normalizeTarget: (raw) => {
+    const normalized = stripMaxPrefix(raw);
+    return MAX_TARGET_PATTERN.test(normalized) ? normalized : undefined;
+  },
+  targetResolver: {
+    looksLikeId: (raw) => MAX_TARGET_PATTERN.test(stripMaxPrefix(raw)),
+    hint: '<chatId|user:userId>',
+  },
+};
+
+/** MAX has no member/chat listing for bots: peers come from allowFrom, groups from the chat registry. */
+export const maxDirectoryAdapter: NonNullable<MaxChannelPlugin['directory']> = {
+  self: async ({ cfg, accountId }) => {
+    const account = resolveMaxAccount({ cfg, accountId });
+    if (!account.token) return null;
+    try {
+      const api = new MaxApi({ token: account.token, timeoutMs: 3000 });
+      const me = await api.getMe();
+      return {
+        kind: 'user' as const,
+        id: String(me.user_id),
+        name: me.first_name || undefined,
+        handle: me.username || undefined,
+      };
+    } catch {
+      return null;
+    }
+  },
+  listPeers: async ({ cfg, accountId }) => {
+    const account = resolveMaxAccount({ cfg, accountId });
+    // MAX doesn't expose a full user list API. Return peers from allowFrom config.
+    const allowFrom = account.config.allowFrom ?? [];
+    return allowFrom.map((id: string | number) => ({
+      kind: 'user' as const,
+      id: String(id),
+      name: undefined,
+    }));
+  },
+  listGroups: async ({ cfg, accountId }) => {
+    const account = resolveMaxAccount({ cfg, accountId });
+    if (!account.token) return [];
+
+    const groups = new Map<string, { kind: 'channel' | 'group'; id: string; name?: string }>();
+
+    // Реестр чатов пополняется событиями bot_added, chat_title_changed и сообщениями групп.
+    try {
+      const state = await loadMaxAccountState(account.accountId);
+      for (const entry of Object.values(state.chats ?? {})) {
+        if (entry.removedAt) continue;
+        if (entry.type !== 'chat' && entry.type !== 'channel') continue;
+        groups.set(String(entry.chatId), {
+          kind: entry.type === 'channel' ? 'channel' : 'group',
+          id: String(entry.chatId),
+          name: entry.title || undefined,
+        });
+      }
+    } catch {
+      // При недоступности реестра вернуть пустой список.
+    }
+
+    return [...groups.values()];
+  },
+};

package/src/channel-lifecycle.ts

@@ -0,0 +1,256 @@
+/**
+ * Account lifecycle of the MAX channel: gateway start (probe, bot commands,
+ * monitor) and logout, status snapshots, probes and group audits (health).
+ */
+
+import type { ChannelPlugin } from 'openclaw/plugin-sdk/channel-core';
+import type { OpenClawConfig } from 'openclaw/plugin-sdk/core';
+import { DEFAULT_ACCOUNT_ID } from 'openclaw/plugin-sdk/core';
+
+import type { ResolvedMaxAccount } from './accounts.js';
+import { MaxApi } from './api.js';
+import { startMaxPolling } from './monitor.js';
+import { writeMaxConfig } from './runtime.js';
+
+type MaxChannelPlugin = ChannelPlugin<ResolvedMaxAccount>;
+
+/** Runtime snapshots, GET /me probe and a membership audit of configured groups. */
+export const maxStatusAdapter: NonNullable<MaxChannelPlugin['status']> = {
+  defaultRuntime: {
+    accountId: DEFAULT_ACCOUNT_ID,
+    running: false,
+    lastStartAt: null,
+    lastStopAt: null,
+    lastError: null,
+  },
+
+  buildChannelSummary: ({ snapshot }) => ({
+    configured: snapshot.configured ?? false,
+    tokenSource: snapshot.tokenSource ?? 'none',
+    running: snapshot.running ?? false,
+    // lifecycle/connected must mirror the gateway runtime store: the health cache
+    // compares them with the live runtime and treats a missing value as stale.
+    ...(snapshot.lifecycle !== undefined ? { lifecycle: snapshot.lifecycle } : {}),
+    ...(typeof snapshot.connected === 'boolean' ? { connected: snapshot.connected } : {}),
+    lastStartAt: snapshot.lastStartAt ?? null,
+    lastStopAt: snapshot.lastStopAt ?? null,
+    lastError: snapshot.lastError ?? null,
+    probe: snapshot.probe,
+  }),
+
+  probeAccount: async ({ account, timeoutMs }) => {
+    if (!account.token) return { ok: false, error: 'no token' };
+    const api = new MaxApi({ token: account.token, timeoutMs });
+    try {
+      const me = await api.getMe();
+      return { ok: true, bot: me };
+    } catch (err) {
+      return { ok: false, error: String(err) };
+    }
+  },
+
+  buildAccountSnapshot: ({ account, runtime, probe }) => ({
+    accountId: account.accountId,
+    name: account.name,
+    enabled: account.enabled,
+    configured: Boolean(account.token?.trim()),
+    tokenSource: account.tokenSource,
+    running: runtime?.running ?? false,
+    ...(runtime?.lifecycle !== undefined ? { lifecycle: runtime.lifecycle } : {}),
+    ...(typeof runtime?.connected === 'boolean' ? { connected: runtime.connected } : {}),
+    lastStartAt: runtime?.lastStartAt ?? null,
+    lastStopAt: runtime?.lastStopAt ?? null,
+    lastError: runtime?.lastError ?? null,
+    probe,
+    lastInboundAt: runtime?.lastInboundAt ?? null,
+    lastOutboundAt: runtime?.lastOutboundAt ?? null,
+  }),
+
+  auditAccount: async ({ account, timeoutMs }) => {
+    if (!account.token) {
+      return {
+        ok: false,
+        checkedGroups: 0,
+        unresolvedGroups: 0,
+        groups: [],
+        elapsedMs: 0,
+      };
+    }
+
+    const start = Date.now();
+    const groups = account.config.groups ?? {};
+    const groupIds = Object.keys(groups).filter((id) => id !== '*');
+
+    if (groupIds.length === 0) {
+      return {
+        ok: true,
+        checkedGroups: 0,
+        unresolvedGroups: 0,
+        groups: [],
+        elapsedMs: Date.now() - start,
+      };
+    }
+
+    const api = new MaxApi({ token: account.token, timeoutMs });
+    const results: Array<{
+      id: string;
+      ok: boolean;
+      title?: string;
+      error?: string;
+    }> = [];
+    let unresolvedCount = 0;
+
+    for (const groupId of groupIds) {
+      try {
+        const chat = await api.getChat(Number(groupId));
+        const isMember = chat.type === 'chat' || chat.type === 'channel';
+        if (!isMember) {
+          unresolvedCount++;
+          results.push({
+            id: groupId,
+            ok: false,
+            error: 'Bot is not a member of this chat',
+          });
+        } else {
+          // Long polling delivers group updates only to admin bots — surface
+          // a missing-admin state, the classic "bot is silent in the group" cause.
+          let adminSuffix = '';
+          try {
+            const membership = await api.getMembership(Number(groupId));
+            if (membership && membership.is_admin !== true) {
+              adminSuffix = ' (⚠ bot is not admin — group updates are not delivered via polling)';
+            }
+          } catch {
+            // membership endpoint unavailable — skip the admin hint
+          }
+          results.push({
+            id: groupId,
+            ok: true,
+            title: `${chat.title ?? ''}${adminSuffix}` || undefined,
+          });
+        }
+      } catch (err) {
+        unresolvedCount++;
+        results.push({
+          id: groupId,
+          ok: false,
+          error: String(err),
+        });
+      }
+    }
+
+    return {
+      ok: unresolvedCount === 0,
+      checkedGroups: groupIds.length,
+      unresolvedGroups: unresolvedCount,
+      groups: results,
+      elapsedMs: Date.now() - start,
+    };
+  },
+
+  collectStatusIssues: (accounts) => {
+    const issues: Array<{
+      channel: string;
+      accountId: string;
+      kind: 'config' | 'permissions' | 'auth' | 'runtime' | 'intent';
+      message: string;
+      fix?: string;
+    }> = [];
+
+    for (const snapshot of accounts) {
+      if (!snapshot.configured) {
+        issues.push({
+          channel: 'max',
+          accountId: snapshot.accountId,
+          kind: 'config' as const,
+          message: 'MAX bot token not configured',
+          fix: 'Set channels.max.botToken or MAX_BOT_TOKEN env var',
+        });
+      }
+    }
+
+    return issues;
+  },
+};
+
+/** Starts one account: probe the bot, register commands, run the monitor until abort. */
+export const maxGatewayAdapter: NonNullable<MaxChannelPlugin['gateway']> = {
+  startAccount: async (ctx) => {
+    const account = ctx.account;
+    const token = account.token.trim();
+
+    let botLabel = '';
+    let botUserId: number | undefined;
+    let botUsername: string | undefined;
+    try {
+      const probeApi = new MaxApi({ token, timeoutMs: 3000 });
+      const me = await probeApi.getMe();
+      if (me.username) {
+        botLabel = ` (@${me.username})`;
+        botUsername = me.username;
+      }
+      botUserId = me.user_id;
+    } catch {
+      // probe failed, continue anyway
+    }
+
+    ctx.log?.info(`[${account.accountId}] Starting MAX provider${botLabel}`);
+
+    const api = new MaxApi({ token });
+
+    // Register bot commands if configured
+    const commands = ctx.cfg.channels?.max?.commands as
+      Array<{ name: string; description?: string }> | undefined;
+    if (commands?.length) {
+      try {
+        await api.setMyCommands(commands);
+        ctx.log?.info(`[${account.accountId}] Registered ${commands.length} bot commands`);
+      } catch (err) {
+        ctx.log?.error(`[${account.accountId}] Failed to register commands: ${String(err)}`);
+      }
+    }
+
+    return startMaxPolling({
+      api,
+      account,
+      config: ctx.cfg,
+      abortSignal: ctx.abortSignal,
+      botUserId,
+      botUsername,
+      log: ctx.log,
+      statusSink: (patch) => {
+        const current = ctx.getStatus();
+        ctx.setStatus({ ...current, ...patch });
+      },
+    });
+  },
+
+  logoutAccount: async ({ accountId, cfg }) => {
+    const nextCfg = { ...cfg } as OpenClawConfig;
+    const channels = { ...(nextCfg.channels as Record<string, unknown>) };
+    const maxSection = channels.max ? { ...(channels.max as Record<string, unknown>) } : undefined;
+    let cleared = false;
+
+    if (maxSection) {
+      if (accountId === DEFAULT_ACCOUNT_ID && maxSection.botToken) {
+        delete maxSection.botToken;
+        cleared = true;
+      }
+
+      const accounts = maxSection.accounts as Record<string, unknown> | undefined;
+      if (accounts && accountId in accounts) {
+        delete (accounts as Record<string, unknown>)[accountId];
+        cleared = true;
+      }
+
+      channels.max = maxSection;
+      nextCfg.channels = channels;
+
+      if (cleared) {
+        await writeMaxConfig(nextCfg);
+      }
+    }
+
+    return { cleared, loggedOut: cleared };
+  },
+};