@wu529778790/open-im 1.11.8-beta.2 → 1.11.8-beta.21

package/dist/codex/cli-runner.js

@@ -6,8 +6,9 @@ import { existsSync, readFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { createInterface } from 'node:readline';
 import { createLogger } from '../logger.js';
-import { processEnvForNonClaudeCliChild } from '../config/file-io.js';
 import { killProcessTree, trackChild } from '../shared/process-kill.js';
+import { isSessionInvalidMessage } from '../shared/session-invalid-detector.js';
+import { createStderrBuffer, appendStderr, reconstructStderr, createFinalizeGate, isFinalizeReady, clearWallClockTimeout, buildBaseSpawnOptions, } from '../shared/cli-runner-base.js';
 const log = createLogger('CodexCli');
 const windowsCodexLaunchCache = new Map();
 const SUPPORTED_IMAGE_EXTENSIONS = new Set([
@@ -163,22 +164,18 @@ function resolveWindowsCodexLaunch(cliPath, args) {
 }
 export function runCodex(cliPath, prompt, sessionId, workDir, callbacks, options) {
     const args = buildCodexArgs(prompt, sessionId, workDir, options);
-    const env = processEnvForNonClaudeCliChild();
+    const extraEnv = {};
     if (options?.chatId)
-        env.CC_IM_CHAT_ID = options.chatId;
+        extraEnv.CC_IM_CHAT_ID = options.chatId;
     if (options?.hookPort)
-        env.CC_IM_HOOK_PORT = String(options.hookPort);
+        extraEnv.CC_IM_HOOK_PORT = String(options.hookPort);
     if (options?.proxy) {
-        env.HTTPS_PROXY = options.proxy;
-        env.HTTP_PROXY = options.proxy;
-        env.https_proxy = options.proxy;
-        env.http_proxy = options.proxy;
-        env.ALL_PROXY = options.proxy;
-        env.all_proxy = options.proxy;
-    }
-    if (process.platform === 'win32') {
-        env.LANG = env.LANG || 'C.UTF-8';
-        env.LC_ALL = env.LC_ALL || 'C.UTF-8';
+        extraEnv.HTTPS_PROXY = options.proxy;
+        extraEnv.HTTP_PROXY = options.proxy;
+        extraEnv.https_proxy = options.proxy;
+        extraEnv.http_proxy = options.proxy;
+        extraEnv.ALL_PROXY = options.proxy;
+        extraEnv.all_proxy = options.proxy;
     }
     const argsForLog = args.join(' ');
     log.info(`Spawning Codex CLI: path=${cliPath}, cwd=${workDir}, session=${sessionId ?? 'new'}, args=${argsForLog}`);
@@ -200,14 +197,7 @@ export function runCodex(cliPath, prompt, sessionId, workDir, callbacks, options
                 `chcp 65001>nul && ${formatWindowsCommandName(cliPath)} ${args.map(quoteForWindowsCmd).join(' ')}`,
             ]
             : args;
-    const child = spawn(spawnCmd, spawnArgs, {
-        cwd: workDir,
-        // Unix 上放入独立进程组，使 abort/关停能用 process.kill(-pid) 杀掉整棵子树（含 MCP/shell 孙进程）
-        detached: process.platform !== 'win32',
-        stdio: ['pipe', 'pipe', 'pipe'],
-        env,
-        windowsHide: process.platform === 'win32',
-    });
+    const child = spawn(spawnCmd, spawnArgs, buildBaseSpawnOptions(workDir, ['pipe', 'pipe', 'pipe'], extraEnv));
     trackChild(child);
     child.stdin?.write(prompt);
     child.stdin?.end();
@@ -217,27 +207,10 @@ export function runCodex(cliPath, prompt, sessionId, workDir, callbacks, options
     const toolStats = {};
     const startTime = Date.now();
     const rl = createInterface({ input: child.stdout });
-    const MAX_STDERR_HEAD = 4 * 1024;
-    const MAX_STDERR_TAIL = 6 * 1024;
-    let stderrHead = '';
-    let stderrTail = '';
-    let stderrTotal = 0;
-    let stderrHeadFull = false;
+    const stderrBuf = createStderrBuffer();
     child.stderr?.on('data', (chunk) => {
         const text = chunk.toString();
-        stderrTotal += text.length;
-        if (!stderrHeadFull) {
-            const room = MAX_STDERR_HEAD - stderrHead.length;
-            if (room > 0) {
-                stderrHead += text.slice(0, room);
-                if (stderrHead.length >= MAX_STDERR_HEAD)
-                    stderrHeadFull = true;
-            }
-        }
-        stderrTail += text;
-        if (stderrTail.length > MAX_STDERR_TAIL) {
-            stderrTail = stderrTail.slice(-MAX_STDERR_TAIL);
-        }
+        appendStderr(stderrBuf, text);
         log.debug(`[stderr] ${text.trimEnd()}`);
     });
     rl.on('line', (line) => {
@@ -329,38 +302,18 @@ export function runCodex(cliPath, prompt, sessionId, workDir, callbacks, options
         }
     });
     let exitCode = null;
-    let rlClosed = false;
-    let childClosed = false;
+    const gate = createFinalizeGate();
     let cliTimeoutHandle = null;
     const finalize = () => {
-        if (cliTimeoutHandle) {
-            clearTimeout(cliTimeoutHandle);
-            cliTimeoutHandle = null;
-        }
-        if (!rlClosed || !childClosed)
+        clearWallClockTimeout(cliTimeoutHandle);
+        cliTimeoutHandle = null;
+        if (!isFinalizeReady(gate))
             return;
         if (completed)
             return;
         if (exitCode !== null && exitCode !== 0) {
-            let errMsg = '';
-            if (stderrTotal > 0) {
-                if (!stderrHeadFull) {
-                    errMsg = stderrHead;
-                }
-                else if (stderrTotal <= MAX_STDERR_HEAD + MAX_STDERR_TAIL) {
-                    errMsg = stderrHead + stderrTail.slice(stderrTail.length - (stderrTotal - MAX_STDERR_HEAD));
-                }
-                else {
-                    errMsg =
-                        stderrHead +
-                            `\n\n... (omitted ${stderrTotal - MAX_STDERR_HEAD - MAX_STDERR_TAIL} bytes) ...\n\n` +
-                            stderrTail;
-                }
-            }
-            if (sessionId &&
-                (errMsg.includes('No session found') ||
-                    errMsg.includes('No conversation found') ||
-                    errMsg.includes('Unable to find session'))) {
+            const errMsg = reconstructStderr(stderrBuf);
+            if (sessionId && isSessionInvalidMessage(errMsg)) {
                 callbacks.onSessionInvalid?.();
             }
             callbacks.onError(errMsg || `Codex CLI exited with code ${exitCode}`);
@@ -379,11 +332,11 @@ export function runCodex(cliPath, prompt, sessionId, workDir, callbacks, options
     child.on('close', (code) => {
         log.info(`Codex CLI closed: exitCode=${code}, pid=${child.pid}`);
         exitCode = code;
-        childClosed = true;
+        gate.childClosed = true;
         finalize();
     });
     rl.on('close', () => {
-        rlClosed = true;
+        gate.rlClosed = true;
         finalize();
     });
     child.on('error', (err) => {
@@ -393,7 +346,7 @@ export function runCodex(cliPath, prompt, sessionId, workDir, callbacks, options
             completed = true;
             callbacks.onError(`Failed to start Codex CLI: ${err.message}`);
         }
-        childClosed = true;
+        gate.childClosed = true;
         finalize();
     });
     // 墙钟超时：防止 CLI 挂死（网络卡住、工具死循环等）永久占用用户队列槽
@@ -401,7 +354,6 @@ export function runCodex(cliPath, prompt, sessionId, workDir, callbacks, options
     cliTimeoutHandle = setTimeout(() => {
         if (completed)
             return;
-        log.warn(`Codex CLI 超过 ${cliTimeoutMs}ms，强制终止 (pid=${child.pid})`);
         completed = true;
         rl.close();
         killProcessTree(child);
@@ -413,10 +365,7 @@ export function runCodex(cliPath, prompt, sessionId, workDir, callbacks, options
             if (completed)
                 return;
             completed = true;
-            if (cliTimeoutHandle) {
-                clearTimeout(cliTimeoutHandle);
-                cliTimeoutHandle = null;
-            }
+            clearWallClockTimeout(cliTimeoutHandle);
             rl.close();
             killProcessTree(child);
         },

package/dist/commands/handler.d.ts

@@ -23,6 +23,7 @@ export declare class CommandHandler {
     dispatch(text: string, chatId: string, userId: string, platform: Platform, handleClaudeRequest: ClaudeRequestHandler, 
     /** 若提供，本条消息的斜杠命令回复走此 sender（须与 handleTextFlow 的 sendTextReply 一致，如带 msgId）。 */
     senderOverride?: MessageSender): Promise<boolean>;
+    private handleAutopilotStatus;
     private handleHelp;
     private handlePlugins;
     private handleSessions;

package/dist/commands/handler.js

@@ -1,5 +1,6 @@
 import { resolvePlatformAiCommand } from '../config.js';
 import { escapePathForMarkdown } from '../shared/utils.js';
+import { getAutopilotPendingStatus } from '../shared/ai-task.js';
 import { TERMINAL_ONLY_COMMANDS } from '../constants.js';
 import { createLogger } from '../logger.js';
 import { ClaudeSDKAdapter } from '../adapters/claude-sdk-adapter.js';
@@ -103,6 +104,8 @@ export class CommandHandler {
                 return this.handlePwd(chatId, userId);
             if (t === '/status')
                 return this.handleStatus(chatId, userId, platform);
+            if (t === '/autopilot')
+                return this.handleAutopilotStatus(chatId, userId);
             // 快捷命令 — 直接发送预设 prompt 给 AI
             if (t === '/git commit')
                 return this.handleQuickCommand(chatId, userId, 'git commit -m "AI generated commit"', platform);
@@ -133,6 +136,36 @@ export class CommandHandler {
         }
         return runBody();
     }
+    async handleAutopilotStatus(chatId, userId) {
+        const ap = this.deps.config.autopilot;
+        const lines = [
+            '🤖 限流自动恢复 (Autopilot)',
+            '',
+            `状态: ${ap.enabled ? '✅ 已启用' : '❌ 已禁用'}`,
+            `最大重试: ${ap.maxRetries} 次`,
+            `默认等待: ${ap.defaultIntervalHours} 小时`,
+            `短延迟: ${ap.shortRetrySeconds} 秒`,
+            `恢复提示: "${ap.autoResumePrompt}"`,
+        ];
+        const pending = getAutopilotPendingStatus(userId);
+        if (pending) {
+            const remaining = Math.max(pending.retryAt.getTime() - Date.now(), 0);
+            const hours = Math.floor(remaining / 3600000);
+            const minutes = Math.floor((remaining % 3600000) / 60000);
+            lines.push('');
+            lines.push('⏳ 当前等待中:');
+            lines.push(`  类型: ${pending.type}`);
+            lines.push(`  恢复时间: ${pending.retryAt.toLocaleTimeString('zh-CN', { hour: '2-digit', minute: '2-digit' })}`);
+            lines.push(`  剩余: ${hours > 0 ? `${hours}小时` : ''}${minutes}分钟`);
+            lines.push(`  重试次数: ${pending.retryCount}/${ap.maxRetries}`);
+        }
+        else {
+            lines.push('');
+            lines.push('当前无等待中的限流恢复任务。');
+        }
+        await this.replySender().sendTextReply(chatId, lines.join('\n'));
+        return true;
+    }
     async handleHelp(chatId) {
         const help = [
             '📋 可用命令:',
@@ -151,6 +184,7 @@ export class CommandHandler {
             '/status - 显示状态',
             '/cd <路径> - 切换工作目录',
             '/pwd - 当前工作目录',
+            '/autopilot - 查看限流自动恢复状态',
             '',
             '⚡ 快捷命令:',
             '/git commit - 提交代码',

package/dist/config/types.d.ts

@@ -26,6 +26,8 @@ export interface Config {
     codexCliPath: string;
     codebuddyCliPath: string;
     opencodeCliPath: string;
+    /** OpenCode SDK 使用的模型（格式: providerID/modelID，如 zhipuai-coding-plan/glm-5.1） */
+    opencodeModel?: string;
     /** Claude 访问 API 的代理（如 http://127.0.0.1:7890） */
     claudeProxy?: string;
     /** Codex 访问 chatgpt.com 的代理（如 http://127.0.0.1:7890） */
@@ -51,6 +53,17 @@ export interface Config {
         /** 可选 Bearer，与采集端一致 */
         token?: string;
     };
+    /**
+     * 限流自动恢复（Autopilot）。
+     * 当 AI 工具遇到限流错误时，自动等待并在恢复后重试。
+     */
+    autopilot: {
+        enabled: boolean;
+        maxRetries: number;
+        defaultIntervalHours: number;
+        shortRetrySeconds: number;
+        autoResumePrompt: string;
+    };
     platforms: {
         telegram?: {
             enabled: boolean;
@@ -174,6 +187,14 @@ export interface FileToolClaude {
     proxy?: string;
     /** Claude API 配置（优先级：环境变量 > tools.claude.env > ~/.claude/settings.json） */
     env?: Record<string, string>;
+    /** 限流自动恢复配置 */
+    autopilot?: {
+        enabled?: boolean;
+        maxRetries?: number;
+        defaultIntervalHours?: number;
+        shortRetrySeconds?: number;
+        autoResumePrompt?: string;
+    };
 }
 export interface FileToolCodex {
     cliPath?: string;
@@ -186,6 +207,8 @@ export interface FileToolCodeBuddy {
 }
 export interface FileToolOpenCode {
     cliPath?: string;
+    /** 模型（格式: providerID/modelID） */
+    model?: string;
 }
 export interface FileConfig {
     telegramBotToken?: string;

package/dist/config-web-auth.d.ts

@@ -0,0 +1,13 @@
+import type { IncomingMessage } from "node:http";
+export interface LoginTokenInfo {
+    expiresAt: number;
+}
+export declare function getWebConfigHost(): string;
+/** 设为 true 时，非本机绑定的 Web 配置服务跳过登录 Cookie 校验（仅适用于受信网络；生产建议配合 HTTPS 反向代理） */
+export declare function allowRemoteApiWithoutAuth(): boolean;
+export declare function consumeLoginToken(loginToken: string): LoginTokenInfo | undefined;
+export declare function createLoginToken(ttlMs: number): string;
+export declare function createSession(request: IncomingMessage, ttlMs: number): string;
+export declare function isSessionValid(request: IncomingMessage): boolean;
+export declare function buildSessionCookie(sessionId: string, ttlMs: number): string;
+export declare function generateLoginUrl(host: string, port: number, loginTtlMs: number): string;

package/dist/config-web-auth.js

@@ -0,0 +1,114 @@
+import { randomBytes } from "node:crypto";
+const pendingLogins = new Map();
+const activeSessions = new Map();
+export function getWebConfigHost() {
+    const envHost = process.env.OPEN_IM_WEB_HOST?.trim();
+    if (envHost)
+        return envHost;
+    return "127.0.0.1";
+}
+/** 设为 true 时，非本机绑定的 Web 配置服务跳过登录 Cookie 校验（仅适用于受信网络；生产建议配合 HTTPS 反向代理） */
+export function allowRemoteApiWithoutAuth() {
+    return process.env.OPEN_IM_ALLOW_REMOTE_API === "true";
+}
+function generateRandomToken(bytes = 32) {
+    return randomBytes(bytes).toString("base64url");
+}
+function cleanupExpiredAuth(now) {
+    for (const [token, info] of pendingLogins) {
+        if (info.expiresAt <= now)
+            pendingLogins.delete(token);
+    }
+    for (const [sessionId, info] of activeSessions) {
+        if (info.expiresAt <= now)
+            activeSessions.delete(sessionId);
+    }
+}
+export function consumeLoginToken(loginToken) {
+    const info = pendingLogins.get(loginToken);
+    if (!info)
+        return undefined;
+    pendingLogins.delete(loginToken);
+    const now = Date.now();
+    if (info.expiresAt <= now)
+        return undefined;
+    return info;
+}
+export function createLoginToken(ttlMs) {
+    const now = Date.now();
+    cleanupExpiredAuth(now);
+    const token = generateRandomToken(32);
+    pendingLogins.set(token, { expiresAt: now + ttlMs });
+    return token;
+}
+export function createSession(request, ttlMs) {
+    const now = Date.now();
+    cleanupExpiredAuth(now);
+    const sessionId = generateRandomToken(32);
+    const remoteAddr = request.socket.remoteAddress;
+    const userAgent = typeof request.headers["user-agent"] === "string" ? request.headers["user-agent"] : undefined;
+    activeSessions.set(sessionId, {
+        expiresAt: now + ttlMs,
+        remoteAddr,
+        userAgent,
+    });
+    return sessionId;
+}
+function parseCookies(request) {
+    const header = request.headers.cookie;
+    if (!header)
+        return {};
+    const cookies = {};
+    const parts = header.split(";");
+    for (const part of parts) {
+        const [rawKey, ...rest] = part.split("=");
+        const key = rawKey.trim();
+        if (!key)
+            continue;
+        const value = rest.join("=").trim();
+        cookies[key] = decodeURIComponent(value);
+    }
+    return cookies;
+}
+function getSessionIdFromRequest(request) {
+    const cookies = parseCookies(request);
+    const sessionId = cookies.openim_session;
+    return sessionId && typeof sessionId === "string" && sessionId.length > 0 ? sessionId : null;
+}
+export function isSessionValid(request) {
+    const sessionId = getSessionIdFromRequest(request);
+    if (!sessionId)
+        return false;
+    const info = activeSessions.get(sessionId);
+    if (!info)
+        return false;
+    const now = Date.now();
+    if (info.expiresAt <= now) {
+        activeSessions.delete(sessionId);
+        return false;
+    }
+    // Optional: tie session to basic client fingerprint (remote address)
+    const remoteAddr = request.socket.remoteAddress;
+    if (info.remoteAddr && remoteAddr && remoteAddr !== info.remoteAddr) {
+        return false;
+    }
+    return true;
+}
+export function buildSessionCookie(sessionId, ttlMs) {
+    const maxAgeSec = Math.floor(ttlMs / 1000);
+    const parts = [
+        `openim_session=${encodeURIComponent(sessionId)}`,
+        "Path=/",
+        "HttpOnly",
+        "SameSite=Lax",
+        `Max-Age=${maxAgeSec}`,
+    ];
+    // 不设置 Secure，方便本地 http 使用；如果放在 https 反代后，可以在代理层加 Secure
+    return parts.join("; ");
+}
+export function generateLoginUrl(host, port, loginTtlMs) {
+    const loginToken = createLoginToken(loginTtlMs);
+    const displayHost = host === "0.0.0.0" ? "127.0.0.1" : host;
+    const baseUrl = `http://${displayHost}:${port}`;
+    return `${baseUrl}/?login_token=${encodeURIComponent(loginToken)}`;
+}

package/dist/config-web-browser.d.ts

@@ -0,0 +1,4 @@
+export declare function openBrowser(url: string): void;
+export declare function getWebConfigPort(): number;
+export declare function getWebConfigUrl(): string;
+export declare function openWebConfigUrl(): void;

package/dist/config-web-browser.js

@@ -0,0 +1,48 @@
+import { spawn } from "node:child_process";
+import { WEB_CONFIG_PORT, getPublicWebDashboardUrl } from "./constants.js";
+import { createLogger } from "./logger.js";
+const log = createLogger("ConfigWeb");
+export function openBrowser(url) {
+    // 显式关闭自动打开浏览器（服务器环境推荐设置）
+    if (process.env.OPEN_IM_NO_BROWSER === "1") {
+        return;
+    }
+    // 在无 TTY 且无图形环境（常见于服务器）时直接跳过，避免无意义的 xdg-open 调用
+    if (!process.stdout.isTTY && !process.env.DISPLAY) {
+        log.info(`Skipping browser launch for URL ${url} (no TTY/DISPLAY detected).`);
+        return;
+    }
+    const safeSpawn = (command, args) => {
+        try {
+            const child = spawn(command, args, { detached: true, stdio: "ignore", windowsHide: process.platform === "win32" });
+            // 防止 ENOENT 之类的错误变成未捕获异常
+            child.on("error", (error) => {
+                log.warn(`Failed to launch browser command "${command}": ${error.code ?? error.message}`);
+            });
+            child.unref();
+        }
+        catch (error) {
+            log.warn(`Failed to spawn browser command "${command}": ${error instanceof Error ? error.message : String(error)}`);
+        }
+    };
+    if (process.platform === "win32") {
+        safeSpawn("cmd", ["/c", "start", "", url]);
+        return;
+    }
+    if (process.platform === "darwin") {
+        safeSpawn("open", [url]);
+        return;
+    }
+    // linux / 其他 UNIX 平台：优先尝试 xdg-open，失败时仅记录日志，不抛出
+    safeSpawn("xdg-open", [url]);
+}
+export function getWebConfigPort() {
+    const fromEnv = process.env.OPEN_IM_WEB_PORT ? parseInt(process.env.OPEN_IM_WEB_PORT, 10) : NaN;
+    return Number.isFinite(fromEnv) && fromEnv > 0 ? fromEnv : WEB_CONFIG_PORT;
+}
+export function getWebConfigUrl() {
+    return `http://127.0.0.1:${getWebConfigPort()}`;
+}
+export function openWebConfigUrl() {
+    openBrowser(getPublicWebDashboardUrl());
+}

package/dist/config-web-cors.d.ts

@@ -0,0 +1,5 @@
+import type { IncomingMessage, OutgoingHttpHeaders } from "node:http";
+export declare function splitCsv(value: string | undefined): string[];
+/** 有 Origin 时返回 CORS 响应头；无 Origin（如本地 file:// 或同源内置页）不返回，行为与原来一致 */
+export declare function corsHeadersFor(request: IncomingMessage): Record<string, string> | undefined;
+export declare function mergeCors(request: IncomingMessage, headers: OutgoingHttpHeaders): OutgoingHttpHeaders;

package/dist/config-web-cors.js

@@ -0,0 +1,48 @@
+import { URL } from "node:url";
+import { getPublicWebDashboardUrl } from "./constants.js";
+export function splitCsv(value) {
+    if (!value)
+        return [];
+    return value.split(",").map((item) => item.trim()).filter(Boolean);
+}
+/** 是否允许该浏览器 Origin（与 getPublicWebDashboardUrl() 同源时始终允许，便于反代 / 自定义 OPEN_IM_PUBLIC_WEB_URL） */
+function isCorsOriginAllowed(origin) {
+    const publicWeb = getPublicWebDashboardUrl();
+    try {
+        if (origin === new URL(publicWeb).origin)
+            return true;
+    }
+    catch {
+        if (origin === publicWeb)
+            return true;
+    }
+    const allowlist = splitCsv(process.env.OPEN_IM_CORS_ORIGINS);
+    if (allowlist.length === 0)
+        return true;
+    return allowlist.includes(origin);
+}
+/** 有 Origin 时返回 CORS 响应头；无 Origin（如本地 file:// 或同源内置页）不返回，行为与原来一致 */
+export function corsHeadersFor(request) {
+    const originRaw = request.headers.origin;
+    if (!originRaw || typeof originRaw !== "string")
+        return undefined;
+    if (!isCorsOriginAllowed(originRaw))
+        return undefined;
+    const requestedHeaders = request.headers["access-control-request-headers"];
+    const allowHeaders = typeof requestedHeaders === "string" && requestedHeaders.trim()
+        ? requestedHeaders
+        : "Content-Type, Authorization";
+    return {
+        "Access-Control-Allow-Origin": originRaw,
+        "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+        "Access-Control-Allow-Headers": allowHeaders,
+        "Access-Control-Allow-Credentials": "true",
+        "Access-Control-Max-Age": "86400",
+    };
+}
+export function mergeCors(request, headers) {
+    const cors = corsHeadersFor(request);
+    if (!cors)
+        return headers;
+    return { ...headers, ...cors };
+}

package/dist/config-web-health.d.ts

@@ -0,0 +1,7 @@
+import type { FileConfig } from "./config.js";
+export declare function getHealthPlatformSnapshot(file: FileConfig, env?: NodeJS.ProcessEnv): Record<string, {
+    configured: boolean;
+    enabled: boolean;
+    healthy: boolean;
+    message?: string;
+}>;

package/dist/config-web-health.js

@@ -0,0 +1,65 @@
+export function getHealthPlatformSnapshot(file, env = process.env) {
+    const fileTelegram = file.platforms?.telegram;
+    const fileFeishu = file.platforms?.feishu;
+    const fileQQ = file.platforms?.qq;
+    const fileWework = file.platforms?.wework;
+    const fileDingtalk = file.platforms?.dingtalk;
+    const fileWorkbuddy = file.platforms?.workbuddy;
+    const fileClawbot = file.platforms?.clawbot;
+    const telegramBotToken = env.TELEGRAM_BOT_TOKEN ?? fileTelegram?.botToken ?? file.telegramBotToken;
+    const feishuAppId = env.FEISHU_APP_ID ?? fileFeishu?.appId ?? file.feishuAppId;
+    const feishuAppSecret = env.FEISHU_APP_SECRET ?? fileFeishu?.appSecret ?? file.feishuAppSecret;
+    const qqAppId = env.QQ_BOT_APPID ?? env.QQ_APP_ID ?? fileQQ?.appId;
+    const qqSecret = env.QQ_BOT_SECRET ?? env.QQ_SECRET ?? fileQQ?.secret;
+    const weworkCorpId = env.WEWORK_CORP_ID ?? fileWework?.corpId;
+    const weworkSecret = env.WEWORK_SECRET ?? fileWework?.secret;
+    const dingtalkClientId = env.DINGTALK_CLIENT_ID ?? fileDingtalk?.clientId;
+    const dingtalkClientSecret = env.DINGTALK_CLIENT_SECRET ?? fileDingtalk?.clientSecret;
+    const workbuddyAccessToken = fileWorkbuddy?.accessToken;
+    const workbuddyRefreshToken = fileWorkbuddy?.refreshToken;
+    const workbuddyUserId = fileWorkbuddy?.userId;
+    return {
+        telegram: {
+            configured: !!telegramBotToken,
+            enabled: !!telegramBotToken && fileTelegram?.enabled !== false,
+            healthy: !!telegramBotToken,
+            message: telegramBotToken ? "Token configured" : "Token not configured",
+        },
+        feishu: {
+            configured: !!(feishuAppId && feishuAppSecret),
+            enabled: !!(feishuAppId && feishuAppSecret) && fileFeishu?.enabled !== false,
+            healthy: !!(feishuAppId && feishuAppSecret),
+            message: feishuAppId && feishuAppSecret ? "App ID and Secret configured" : "Missing credentials",
+        },
+        qq: {
+            configured: !!(qqAppId && qqSecret),
+            enabled: !!(qqAppId && qqSecret) && fileQQ?.enabled !== false,
+            healthy: !!(qqAppId && qqSecret),
+            message: qqAppId && qqSecret ? "App ID and Secret configured" : "Missing credentials",
+        },
+        wework: {
+            configured: !!(weworkCorpId && weworkSecret),
+            enabled: !!(weworkCorpId && weworkSecret) && fileWework?.enabled !== false,
+            healthy: !!(weworkCorpId && weworkSecret),
+            message: weworkCorpId && weworkSecret ? "Corp ID and Secret configured" : "Missing credentials",
+        },
+        dingtalk: {
+            configured: !!(dingtalkClientId && dingtalkClientSecret),
+            enabled: !!(dingtalkClientId && dingtalkClientSecret) && fileDingtalk?.enabled !== false,
+            healthy: !!(dingtalkClientId && dingtalkClientSecret),
+            message: dingtalkClientId && dingtalkClientSecret ? "Client ID and Secret configured" : "Missing credentials",
+        },
+        workbuddy: {
+            configured: !!(workbuddyAccessToken && workbuddyRefreshToken && workbuddyUserId),
+            enabled: !!(workbuddyAccessToken && workbuddyRefreshToken && workbuddyUserId) && fileWorkbuddy?.enabled !== false,
+            healthy: !!(workbuddyAccessToken && workbuddyRefreshToken && workbuddyUserId),
+            message: workbuddyAccessToken && workbuddyRefreshToken && workbuddyUserId ? "OAuth credentials configured" : "Missing credentials",
+        },
+        clawbot: {
+            configured: !!fileClawbot?.apiToken,
+            enabled: !!fileClawbot?.apiToken && fileClawbot?.enabled !== false,
+            healthy: !!fileClawbot?.apiToken,
+            message: fileClawbot?.apiToken ? "API Token configured" : "Missing API Token",
+        },
+    };
+}

package/dist/config-web-http.d.ts

@@ -0,0 +1,3 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+export declare function readJson<T>(request: IncomingMessage): Promise<T>;
+export declare function jsonResponse(response: ServerResponse, statusCode: number, body: unknown, request: IncomingMessage): void;

package/dist/config-web-http.js

@@ -0,0 +1,31 @@
+import { mergeCors } from "./config-web-cors.js";
+const MAX_REQUEST_BODY_BYTES = 1 * 1024 * 1024; // 1 MB
+export function readJson(request) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let totalBytes = 0;
+        request.on("data", (chunk) => {
+            totalBytes += chunk.length;
+            if (totalBytes > MAX_REQUEST_BODY_BYTES) {
+                reject(new Error("Request body too large (max 1 MB)"));
+                request.destroy();
+                return;
+            }
+            chunks.push(Buffer.from(chunk));
+        });
+        request.on("end", () => {
+            try {
+                const raw = Buffer.concat(chunks).toString("utf-8");
+                resolve((raw ? JSON.parse(raw) : {}));
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+        request.on("error", reject);
+    });
+}
+export function jsonResponse(response, statusCode, body, request) {
+    response.writeHead(statusCode, mergeCors(request, { "content-type": "application/json; charset=utf-8" }));
+    response.end(JSON.stringify(body));
+}