pikiclaw 0.2.65 → 0.2.66

package/dist/bot-weixin.js

@@ -0,0 +1,268 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { Bot, buildPrompt, fmtUptime, normalizeAgent, parseAllowedChatIds, } from './bot.js';
+import { BOT_SHUTDOWN_FORCE_EXIT_MS, buildSessionTaskId } from './bot-orchestration.js';
+import { shutdownAllDrivers } from './agent-driver.js';
+import { registerProcessRuntime } from './process-control.js';
+import { WeixinChannel } from './channel-weixin.js';
+import { getActiveUserConfig } from './user-config.js';
+const SHUTDOWN_EXIT_CODE = {
+    SIGINT: 130,
+    SIGTERM: 143,
+};
+function describeError(error) {
+    return error instanceof Error ? error.message : String(error ?? 'unknown error');
+}
+export class WeixinBot extends Bot {
+    botToken;
+    accountId;
+    baseUrl;
+    channel;
+    nextTaskId = 1;
+    shutdownInFlight = false;
+    shutdownExitCode = null;
+    shutdownForceExitTimer = null;
+    signalHandlers = {};
+    processRuntimeCleanup = null;
+    constructor() {
+        super();
+        const config = getActiveUserConfig();
+        if (process.env.WEIXIN_ALLOWED_USER_IDS) {
+            for (const id of parseAllowedChatIds(process.env.WEIXIN_ALLOWED_USER_IDS))
+                this.allowedChatIds.add(id);
+        }
+        this.baseUrl = String(config.weixinBaseUrl || process.env.WEIXIN_BASE_URL || '').trim();
+        this.botToken = String(config.weixinBotToken || process.env.WEIXIN_BOT_TOKEN || '').trim();
+        this.accountId = String(config.weixinAccountId || process.env.WEIXIN_ACCOUNT_ID || '').trim();
+        if (!this.baseUrl || !this.botToken || !this.accountId) {
+            throw new Error('Missing Weixin credentials. Configure via dashboard QR login first.');
+        }
+    }
+    onManagedConfigChange(config, opts = {}) {
+        const nextBaseUrl = String(config.weixinBaseUrl || process.env.WEIXIN_BASE_URL || '').trim();
+        const nextBotToken = String(config.weixinBotToken || process.env.WEIXIN_BOT_TOKEN || '').trim();
+        const nextAccountId = String(config.weixinAccountId || process.env.WEIXIN_ACCOUNT_ID || '').trim();
+        if (nextBaseUrl && nextBaseUrl !== this.baseUrl) {
+            this.baseUrl = nextBaseUrl;
+            if (!opts.initial)
+                this.log('weixin baseUrl reloaded from setting.json');
+        }
+        if (nextBotToken && nextBotToken !== this.botToken) {
+            this.botToken = nextBotToken;
+            if (!opts.initial)
+                this.log('weixin botToken reloaded from setting.json');
+        }
+        if (nextAccountId && nextAccountId !== this.accountId) {
+            this.accountId = nextAccountId;
+            if (!opts.initial)
+                this.log('weixin accountId reloaded from setting.json');
+        }
+    }
+    installSignalHandlers() {
+        this.removeSignalHandlers();
+        const onSigint = () => this.beginShutdown('SIGINT');
+        const onSigterm = () => this.beginShutdown('SIGTERM');
+        this.signalHandlers = { SIGINT: onSigint, SIGTERM: onSigterm };
+        process.once('SIGINT', onSigint);
+        process.once('SIGTERM', onSigterm);
+    }
+    removeSignalHandlers() {
+        for (const signal of Object.keys(this.signalHandlers)) {
+            const handler = this.signalHandlers[signal];
+            if (handler)
+                process.off(signal, handler);
+        }
+        this.signalHandlers = {};
+    }
+    clearShutdownForceExitTimer() {
+        if (!this.shutdownForceExitTimer)
+            return;
+        clearTimeout(this.shutdownForceExitTimer);
+        this.shutdownForceExitTimer = null;
+    }
+    cleanupRuntimeForExit() {
+        try {
+            this.channel.disconnect();
+        }
+        catch { }
+        this.stopKeepAlive();
+        shutdownAllDrivers();
+    }
+    beginShutdown(signal) {
+        if (this.shutdownInFlight)
+            return;
+        this.shutdownInFlight = true;
+        this.shutdownExitCode = SHUTDOWN_EXIT_CODE[signal];
+        this.log(`${signal}, shutting down...`);
+        this.cleanupRuntimeForExit();
+        this.clearShutdownForceExitTimer();
+        this.shutdownForceExitTimer = setTimeout(() => {
+            this.log(`shutdown still pending after ${Math.floor(BOT_SHUTDOWN_FORCE_EXIT_MS / 1000)}s, forcing exit`);
+            process.exit(this.shutdownExitCode ?? 1);
+        }, BOT_SHUTDOWN_FORCE_EXIT_MS);
+        this.shutdownForceExitTimer.unref?.();
+    }
+    resolveSession(chatId, title, files) {
+        return this.ensureSessionForChat(chatId, title, files);
+    }
+    buildStatusText(chatId) {
+        const status = this.getStatusData(chatId);
+        return [
+            `Agent: ${status.agent}`,
+            `Model: ${status.model || '-'}`,
+            `Session: ${status.sessionId || 'new'}`,
+            `Tasks: ${status.activeTasksCount}`,
+            `Workdir: ${status.workdir}`,
+            `Uptime: ${fmtUptime(status.uptime)}`,
+        ].join('\n');
+    }
+    async handleCommand(text, ctx) {
+        const [rawCommand, ...rest] = text.trim().slice(1).split(/\s+/);
+        const command = rawCommand?.toLowerCase() || '';
+        const args = rest.join(' ').trim();
+        switch (command) {
+            case 'help':
+                await ctx.reply([
+                    '/help',
+                    '/new',
+                    '/status',
+                    '/agent codex|claude|gemini',
+                ].join('\n'));
+                return true;
+            case 'new':
+                this.resetConversationForChat(ctx.chatId);
+                await ctx.reply('Started a new session.');
+                return true;
+            case 'status':
+                await ctx.reply(this.buildStatusText(ctx.chatId));
+                return true;
+            case 'agent':
+                if (!args) {
+                    await ctx.reply('Usage: /agent codex|claude|gemini');
+                    return true;
+                }
+                try {
+                    const agent = normalizeAgent(args);
+                    this.switchAgentForChat(ctx.chatId, agent);
+                    await ctx.reply(`Agent switched to ${agent}.`);
+                }
+                catch {
+                    await ctx.reply('Usage: /agent codex|claude|gemini');
+                }
+                return true;
+            default:
+                return false;
+        }
+    }
+    createMcpSendFile(chatId) {
+        return async (filePath) => {
+            try {
+                await this.channel.send(chatId, `Artifact ready: ${path.basename(filePath)}\n${filePath}`);
+                return { ok: true };
+            }
+            catch (error) {
+                return { ok: false, error: describeError(error) };
+            }
+        };
+    }
+    async sendResult(chatId, result) {
+        const text = result.ok
+            ? (result.message.trim() || 'Task finished.')
+            : ['Task failed.', result.error || result.message || 'Unknown error.'].filter(Boolean).join('\n');
+        await this.channel.send(chatId, text);
+    }
+    async handleMessage(msg, ctx) {
+        const text = msg.text.trim();
+        if (text.startsWith('/') && await this.handleCommand(text, ctx))
+            return;
+        if (!text && !msg.files.length) {
+            await ctx.reply('This Weixin channel currently supports text input only.');
+            return;
+        }
+        const session = this.resolveSession(ctx.chatId, text, msg.files);
+        const prompt = buildPrompt(text, msg.files);
+        const taskId = buildSessionTaskId(session, this.nextTaskId++);
+        this.beginTask({
+            taskId,
+            chatId: ctx.chatId,
+            agent: session.agent,
+            sessionKey: session.key,
+            prompt,
+            startedAt: Date.now(),
+            sourceMessageId: ctx.messageId,
+        });
+        void this.queueSessionTask(session, async () => {
+            const abortController = new AbortController();
+            const task = this.markTaskRunning(taskId, () => abortController.abort());
+            if (task?.cancelled) {
+                this.finishTask(taskId);
+                return;
+            }
+            let typingTimer = null;
+            try {
+                await ctx.sendTyping().catch(() => { });
+                typingTimer = setInterval(() => {
+                    void ctx.sendTyping().catch(() => { });
+                }, 4_000);
+                typingTimer.unref?.();
+                const result = await this.runStream(prompt, session, msg.files, () => { }, undefined, this.createMcpSendFile(ctx.chatId), abortController.signal);
+                await this.sendResult(ctx.chatId, result);
+            }
+            catch (error) {
+                await ctx.reply(`Error: ${describeError(error)}`);
+            }
+            finally {
+                if (typingTimer)
+                    clearInterval(typingTimer);
+                this.finishTask(taskId);
+                this.syncSelectedChats(session);
+            }
+        }).catch(error => {
+            this.finishTask(taskId);
+            this.log(`weixin queue execution failed: ${describeError(error)}`);
+        });
+    }
+    async run() {
+        const tmpDir = path.join(os.tmpdir(), 'pikiclaw');
+        fs.mkdirSync(tmpDir, { recursive: true });
+        this.channel = new WeixinChannel({
+            token: this.botToken,
+            accountId: this.accountId,
+            baseUrl: this.baseUrl,
+            allowedChatIds: this.allowedChatIds.size ? new Set([...this.allowedChatIds].map(value => String(value))) : undefined,
+        });
+        this.processRuntimeCleanup?.();
+        this.processRuntimeCleanup = registerProcessRuntime({
+            label: 'weixin',
+            getActiveTaskCount: () => this.activeTasks.size,
+            prepareForRestart: () => this.cleanupRuntimeForExit(),
+        });
+        this.installSignalHandlers();
+        try {
+            const bot = await this.channel.connect();
+            this.connected = true;
+            this.log(`bot: ${bot.displayName} (id=${bot.id})`);
+            for (const agent of this.fetchAgents().agents) {
+                this.log(`agent ${agent.agent}: ${agent.path || 'NOT FOUND'}`);
+            }
+            this.log(`config: agent=${this.defaultAgent} workdir=${this.workdir} timeout=${this.runTimeout}s`);
+            this.channel.onMessage((msg, ctx) => this.handleMessage(msg, ctx));
+            this.channel.onError(error => this.log(`error: ${describeError(error)}`));
+            this.startKeepAlive();
+            this.log('✓ Weixin connected, long-polling started — ready to receive messages');
+            await this.channel.listen();
+            this.stopKeepAlive();
+            this.log('stopped');
+        }
+        finally {
+            this.stopKeepAlive();
+            this.clearShutdownForceExitTimer();
+            this.removeSignalHandlers();
+            this.processRuntimeCleanup?.();
+            this.processRuntimeCleanup = null;
+            if (this.shutdownInFlight)
+                process.exit(this.shutdownExitCode ?? 1);
+        }
+    }
+}

package/dist/bot.js

@@ -1004,6 +1004,7 @@ export class Bot {
         const totalMem = os.totalmem(), freeMem = os.freemem();
         const memory = getHostMemoryUsageData(totalMem, freeMem);
         const cpuUsage = getHostCpuUsageData();
+        const [loadOne, loadFive, loadFifteen] = os.loadavg();
         let disk = null;
         const battery = getHostBatteryData();
         try {
@@ -1022,6 +1023,7 @@ export class Bot {
             hostName: getHostDisplayName(),
             cpuModel: cpus[0]?.model || 'unknown', cpuCount: cpus.length,
             cpuUsage,
+            loadAverage: { one: loadOne, five: loadFive, fifteen: loadFifteen },
             totalMem, freeMem, memoryUsed: memory.usedBytes, memoryAvailable: memory.availableBytes, memoryPercent: memory.percent, memorySource: memory.source,
             disk, battery, topProcs,
             selfPid: process.pid, selfRss: mem.rss, selfHeap: mem.heapUsed,

package/dist/channel-weixin.js

@@ -0,0 +1,189 @@
+import { Channel, DEFAULT_CHANNEL_CAPABILITIES, splitText, sleep, } from './channel-base.js';
+import { WEIXIN_LIMITS } from './constants.js';
+import { extractWeixinTextBody, markdownToWeixinPlainText, normalizeWeixinBaseUrl, WeixinMessageType, weixinGetConfig, weixinGetUpdates, weixinSendTextMessage, weixinSendTyping, } from './weixin-api.js';
+const WEIXIN_MAX_MESSAGE_LENGTH = WEIXIN_LIMITS.maxMessageLength;
+const WEIXIN_MAX_RETRY_DELAY_MS = WEIXIN_LIMITS.maxRetryDelay;
+function describeError(error) {
+    return error instanceof Error ? error.message : String(error ?? 'unknown error');
+}
+function isAbortError(error) {
+    return error instanceof Error && error.name === 'AbortError';
+}
+export class WeixinChannel extends Channel {
+    capabilities = {
+        ...DEFAULT_CHANNEL_CAPABILITIES,
+        typingIndicators: true,
+    };
+    knownChats = new Set();
+    token;
+    accountId;
+    baseUrl;
+    pollTimeout;
+    allowedChatIds;
+    messageHandlers = new Set();
+    errorHandlers = new Set();
+    chatMeta = new Map();
+    stopping = false;
+    updateBuf = '';
+    constructor(opts) {
+        super();
+        this.token = opts.token;
+        this.accountId = opts.accountId;
+        this.baseUrl = normalizeWeixinBaseUrl(opts.baseUrl);
+        this.pollTimeout = opts.pollTimeout ?? WEIXIN_LIMITS.longPollTimeout;
+        this.allowedChatIds = opts.allowedChatIds;
+    }
+    onMessage(handler) {
+        this.messageHandlers.add(handler);
+        return this;
+    }
+    onError(handler) {
+        this.errorHandlers.add(handler);
+        return this;
+    }
+    async connect() {
+        const shortId = this.accountId.length > 18 ? `${this.accountId.slice(0, 8)}...${this.accountId.slice(-6)}` : this.accountId;
+        this.bot = {
+            id: this.accountId,
+            username: `weixin_${shortId}`,
+            displayName: `Weixin ${shortId}`,
+        };
+        return this.bot;
+    }
+    async listen() {
+        this.stopping = false;
+        let retryDelayMs = 1_000;
+        while (!this.stopping) {
+            try {
+                const response = await weixinGetUpdates({
+                    baseUrl: this.baseUrl,
+                    token: this.token,
+                    getUpdatesBuf: this.updateBuf,
+                    timeoutMs: this.pollTimeout,
+                });
+                retryDelayMs = 1_000;
+                if (response.get_updates_buf !== undefined)
+                    this.updateBuf = response.get_updates_buf || '';
+                if ((response.ret ?? 0) !== 0 || (response.errcode ?? 0) !== 0) {
+                    throw new Error(`Weixin getupdates failed: ${response.errmsg || response.errcode || response.ret}`);
+                }
+                for (const message of response.msgs || []) {
+                    await this.dispatchInboundMessage(message);
+                }
+            }
+            catch (error) {
+                if (this.stopping || isAbortError(error))
+                    break;
+                this.emitError(new Error(`Weixin polling failed: ${describeError(error)}`));
+                await sleep(retryDelayMs);
+                retryDelayMs = Math.min(retryDelayMs * 2, WEIXIN_MAX_RETRY_DELAY_MS);
+            }
+        }
+    }
+    disconnect() {
+        this.stopping = true;
+    }
+    async send(chatId, text, _opts) {
+        const meta = this.chatMeta.get(String(chatId));
+        if (!meta?.contextToken)
+            throw new Error('Weixin context token is missing for this chat.');
+        const plain = markdownToWeixinPlainText(text) || String(text || '').trim();
+        const chunks = splitText(plain, WEIXIN_MAX_MESSAGE_LENGTH).map(chunk => chunk.trim()).filter(Boolean);
+        let lastMessageId = null;
+        for (const chunk of chunks) {
+            await weixinSendTextMessage({
+                baseUrl: this.baseUrl,
+                token: this.token,
+                toUserId: meta.userId,
+                text: chunk,
+                contextToken: meta.contextToken,
+            });
+            lastMessageId = `wx:${Date.now().toString(36)}:${Math.random().toString(36).slice(2, 8)}`;
+        }
+        return lastMessageId;
+    }
+    async editMessage(_chatId, _msgId, _text, _opts) { }
+    async deleteMessage(_chatId, _msgId) { }
+    async sendTyping(chatId, _opts) {
+        const meta = this.chatMeta.get(String(chatId));
+        if (!meta?.contextToken || !meta.userId)
+            return;
+        let typingTicket = meta.typingTicket;
+        if (!typingTicket) {
+            const config = await weixinGetConfig({
+                baseUrl: this.baseUrl,
+                token: this.token,
+                userId: meta.userId,
+                contextToken: meta.contextToken,
+            });
+            typingTicket = String(config.typing_ticket || '').trim();
+            if (!typingTicket)
+                return;
+            meta.typingTicket = typingTicket;
+            this.chatMeta.set(String(chatId), meta);
+        }
+        await weixinSendTyping({
+            baseUrl: this.baseUrl,
+            token: this.token,
+            userId: meta.userId,
+            typingTicket,
+        });
+    }
+    composeChatId(userId) {
+        return `${this.accountId}:${userId}`;
+    }
+    isAllowed(chatId, userId) {
+        if (!this.allowedChatIds?.size)
+            return true;
+        return this.allowedChatIds.has(chatId) || this.allowedChatIds.has(userId);
+    }
+    async dispatchInboundMessage(message) {
+        if ((message.message_type ?? WeixinMessageType.USER) !== WeixinMessageType.USER)
+            return;
+        const userId = String(message.from_user_id || '').trim();
+        if (!userId)
+            return;
+        const chatId = this.composeChatId(userId);
+        if (!this.isAllowed(chatId, userId))
+            return;
+        const existing = this.chatMeta.get(chatId);
+        const contextToken = String(message.context_token || existing?.contextToken || '').trim();
+        const meta = {
+            userId,
+            contextToken,
+            typingTicket: existing?.contextToken === contextToken ? existing?.typingTicket : undefined,
+        };
+        this.chatMeta.set(chatId, meta);
+        this.knownChats.add(chatId);
+        const ctx = {
+            chatId,
+            messageId: String(message.message_id || message.seq || Date.now()),
+            from: { userId },
+            reply: (text, opts) => this.send(chatId, text, opts),
+            editReply: (msgId, text, opts) => this.editMessage(chatId, msgId, text, opts),
+            sendTyping: () => this.sendTyping(chatId),
+            channel: this,
+            raw: message,
+        };
+        const payload = {
+            text: extractWeixinTextBody(message),
+            files: [],
+        };
+        for (const handler of this.messageHandlers) {
+            try {
+                await handler(payload, ctx);
+            }
+            catch (error) {
+                this.emitError(error instanceof Error ? error : new Error(describeError(error)));
+            }
+        }
+    }
+    emitError(error) {
+        for (const handler of this.errorHandlers) {
+            try {
+                handler(error);
+            }
+            catch { }
+        }
+    }
+}

package/dist/cli-channels.js

@@ -3,7 +3,12 @@ export function hasConfiguredChannelToken(config, channel, tokenOverride) {
         case 'telegram':
             return !!(config.telegramBotToken || tokenOverride);
         case 'feishu':
-            return !!(config.feishuAppId || tokenOverride);
+            return !!((config.feishuAppId && config.feishuAppSecret) || tokenOverride);
+        case 'weixin':
+            return !!(config.channels?.includes('weixin')
+                && config.weixinBaseUrl
+                && config.weixinBotToken
+                && config.weixinAccountId);
         case 'whatsapp':
             return !!tokenOverride;
     }
@@ -13,9 +18,12 @@ export function resolveConfiguredChannels(opts) {
     if (rawChannels) {
         return rawChannels.split(',').map(channel => channel.trim().toLowerCase()).filter(Boolean);
     }
-    if (opts.config.channels?.length)
-        return opts.config.channels;
+    if (opts.config.channels?.length) {
+        return opts.config.channels.filter(channel => hasConfiguredChannelToken(opts.config, channel, opts.tokenOverride));
+    }
     const detected = [];
+    if (hasConfiguredChannelToken(opts.config, 'weixin', opts.tokenOverride))
+        detected.push('weixin');
     if (hasConfiguredChannelToken(opts.config, 'feishu', opts.tokenOverride))
         detected.push('feishu');
     if (hasConfiguredChannelToken(opts.config, 'telegram', opts.tokenOverride))

package/dist/cli.js

@@ -212,8 +212,8 @@ Run a bot that forwards IM messages to a local AI coding agent
 (Claude Code or Codex CLI), streams responses in real-time, and manages
 sessions, models, and workdirs.
 
-Channels are auto-detected from configured tokens. If both Feishu and
-Telegram tokens are present, both channels launch simultaneously.
+Channels are auto-detected from configured credentials. If multiple
+validated channels are enabled, they launch simultaneously.
 
 Usage:
   npx pikiclaw                              # auto-detect from config/env
@@ -248,6 +248,11 @@ Environment variables (Telegram):
   TELEGRAM_BOT_TOKEN         Telegram bot token (from @BotFather)
   TELEGRAM_ALLOWED_CHAT_IDS  Comma-separated allowed Telegram chat IDs
 
+Environment variables (Weixin):
+  WEIXIN_BASE_URL            Weixin API base URL (default: https://ilinkai.weixin.qq.com)
+  WEIXIN_BOT_TOKEN           Weixin bot token (normally configured from dashboard QR login)
+  WEIXIN_ACCOUNT_ID          Weixin bot account ID
+
 Environment variables (per agent):
   CLAUDE_MODEL               Claude model name
   CLAUDE_PERMISSION_MODE     Permission mode (default: bypassPermissions)
@@ -277,6 +282,7 @@ Environment variables (Feishu):
   FEISHU_ALLOWED_CHAT_IDS    Comma-separated allowed Feishu chat IDs
 
 Notes:
+  - weixin setup is QR-based in the dashboard and currently supports text-only replies.
   - whatsapp is planned but not implemented yet.
   - --safe-mode delegates to the agent's own permission model; it does not add
     a pikiclaw-specific approval workflow.
@@ -530,6 +536,14 @@ async function launchChannels(channels, dashboard) {
                 await bot.run();
                 break;
             }
+            case 'weixin': {
+                const { WeixinBot } = await import('./bot-weixin.js');
+                const bot = new WeixinBot();
+                if (dashboard)
+                    dashboard.attachBot(bot);
+                await bot.run();
+                break;
+            }
             case 'whatsapp':
                 process.stderr.write('WhatsApp channel is not yet implemented. Coming soon.\n');
                 break;

package/dist/config-validation.js

@@ -1,7 +1,9 @@
 import * as lark from '@larksuiteoapi/node-sdk';
 import { validateTelegramToken } from './setup-wizard.js';
 import { VALIDATION_TIMEOUTS } from './constants.js';
+import { normalizeWeixinBaseUrl, weixinGetUpdates } from './weixin-api.js';
 const DEFAULT_FEISHU_VALIDATION_TIMEOUT_MS = VALIDATION_TIMEOUTS.feishuDefault;
+const DEFAULT_WEIXIN_VALIDATION_TIMEOUT_MS = VALIDATION_TIMEOUTS.weixinDefault;
 function feishuValidationLog(appId, message) {
     const ts = new Date().toISOString().slice(11, 19);
     process.stdout.write(`[feishu-validate ${ts}] app=${appId} ${message}\n`);
@@ -250,12 +252,68 @@ export async function validateFeishuConfig(appId, appSecret, options = {}) {
         };
     }
 }
+export async function validateWeixinConfig(baseUrl, botToken, accountId, options = {}) {
+    const normalizedBaseUrl = normalizeWeixinBaseUrl(baseUrl);
+    const trimmedToken = String(botToken || '').trim();
+    const trimmedAccountId = String(accountId || '').trim();
+    const timeoutMs = Number.isFinite(options.timeoutMs) && Number(options.timeoutMs) > 0
+        ? Math.round(Number(options.timeoutMs))
+        : DEFAULT_WEIXIN_VALIDATION_TIMEOUT_MS;
+    if (!trimmedToken && !trimmedAccountId && !String(baseUrl || '').trim()) {
+        return {
+            state: missingChannelState('weixin', 'Weixin is not configured.'),
+            account: null,
+            normalizedBaseUrl,
+        };
+    }
+    if (!trimmedToken || !trimmedAccountId) {
+        return {
+            state: invalidChannelState('weixin', 'Weixin requires Base URL, Bot Token, and Account ID.'),
+            account: null,
+            normalizedBaseUrl,
+        };
+    }
+    try {
+        const response = await weixinGetUpdates({
+            baseUrl: normalizedBaseUrl,
+            token: trimmedToken,
+            getUpdatesBuf: '',
+            timeoutMs,
+        });
+        if ((response.ret ?? 0) !== 0 || (response.errcode ?? 0) !== 0) {
+            const detail = String(response.errmsg || response.errcode || 'credentials rejected').trim();
+            return {
+                state: invalidChannelState('weixin', `Weixin rejected these credentials: ${detail}`),
+                account: null,
+                normalizedBaseUrl,
+            };
+        }
+        return {
+            state: readyChannelState('weixin', `Weixin account ${trimmedAccountId} verified.`),
+            account: {
+                accountId: trimmedAccountId,
+                baseUrl: normalizedBaseUrl,
+            },
+            normalizedBaseUrl,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error ?? 'unknown error');
+        return {
+            state: errorChannelState('weixin', `Failed to reach Weixin: ${message}`),
+            account: null,
+            normalizedBaseUrl,
+        };
+    }
+}
 export async function collectChannelSetupStates(config) {
-    const [telegram, feishu] = await Promise.all([
+    const [telegram, feishu, weixin] = await Promise.all([
         validateTelegramConfig(config.telegramBotToken, config.telegramAllowedChatIds),
         validateFeishuConfig(config.feishuAppId, config.feishuAppSecret),
+        validateWeixinConfig(config.weixinBaseUrl, config.weixinBotToken, config.weixinAccountId),
     ]);
     return [
+        weixin.state,
         telegram.state,
         feishu.state,
     ];

package/dist/constants.js

@@ -170,6 +170,18 @@ export const FEISHU_LIMITS = {
 /** Feishu bot rendering limit for card payloads. */
 export const FEISHU_BOT_CARD_MAX = 25_000;
 // ---------------------------------------------------------------------------
+// Channels — Weixin
+// ---------------------------------------------------------------------------
+/** Weixin channel transport constants. */
+export const WEIXIN_LIMITS = {
+    /** Conservative text split budget for plain-text replies. */
+    maxMessageLength: 1200,
+    /** Long-poll timeout for getupdates. */
+    longPollTimeout: 35_000,
+    /** Maximum back-off delay for polling retries. */
+    maxRetryDelay: 60_000,
+};
+// ---------------------------------------------------------------------------
 // Config validation
 // ---------------------------------------------------------------------------
 /** Timeouts for channel credential validation flows. */
@@ -180,6 +192,10 @@ export const VALIDATION_TIMEOUTS = {
     feishuBotInfo: 5_000,
     /** Timeout for Telegram token validation (setup wizard). */
     telegramToken: 8_000,
+    /** Default timeout for Weixin credential validation. */
+    weixinDefault: 8_000,
+    /** Long-poll timeout for dashboard QR login wait calls. */
+    weixinQrPoll: 35_000,
 };
 // ---------------------------------------------------------------------------
 // Agent auto-update