chatccc 0.2.252 → 0.2.254

package/dist/src/sim-platform.js

@@ -0,0 +1,142 @@
+/**
+ * sim-platform.ts — SimulatedPlatform: 零飞书依赖的本地模拟实现
+ *
+ * 所有飞书 API 调用都由本地 SimStore 替代：
+ * - 消息通过 SimStore 写入内存 + JSONL + 事件推送
+ * - 群聊/账户信息由 SimStore 统一管理
+ * - createGroupChat 生成 "sim_<uuid>" 格式的 chat_id
+ *
+ * 纯函数（extractSessionInfo / formatDelayNotice / reportPermissionResults）
+ * 直接从 feishu-api.ts re-export，不重新实现。
+ */
+import { join } from "node:path";
+import { extractSessionInfo as realExtractSessionInfo, extractSessionId as realExtractSessionId, formatDelayNotice as realFormatDelayNotice, reportPermissionResults as realReportPermissionResults, } from "./feishu-api.js";
+import { simStore } from "./sim-store.js";
+// ---------------------------------------------------------------------------
+// 持久化路径
+// ---------------------------------------------------------------------------
+import { homedir } from "node:os";
+const SIM_DIR = join(homedir(), ".chatccc", "sim");
+// ---------------------------------------------------------------------------
+// 工具函数
+// ---------------------------------------------------------------------------
+function ts() {
+    return new Date().toISOString().replace("T", " ").slice(0, 19);
+}
+// ---------------------------------------------------------------------------
+// SimulatedPlatform
+// ---------------------------------------------------------------------------
+export const SimulatedPlatform = {
+    // ---- 认证 ----
+    async getTenantAccessToken() {
+        return "sim_token";
+    },
+    // ---- 消息发送：委托给 simStore ----
+    async sendTextReply(_token, chatId, text) {
+        console.log(`[${ts()}] [SIM:SEND] text → ${chatId}: ${text.slice(0, 80)}`);
+        simStore.sendReply(chatId, "text", text);
+        return true;
+    },
+    async sendCardReply(_token, chatId, title, content, _template) {
+        console.log(`[${ts()}] [SIM:SEND] card → ${chatId}: [${title}]`);
+        const text = `**[${title}]**\n${content}`;
+        simStore.sendReply(chatId, "card", text);
+        return true;
+    },
+    async sendImageReply(_token, chatId, imagePath) {
+        console.log(`[${ts()}] [SIM:SEND] image → ${chatId}: ${imagePath}`);
+        simStore.sendReply(chatId, "image", imagePath);
+        return true;
+    },
+    async sendFileReply(_token, chatId, filePath) {
+        console.log(`[${ts()}] [SIM:SEND] file → ${chatId}: ${filePath}`);
+        simStore.sendReply(chatId, "file", filePath);
+        return true;
+    },
+    async sendRawCard(_token, chatId, cardJson) {
+        console.log(`[${ts()}] [SIM:SEND] raw_card → ${chatId}: ${cardJson.slice(0, 80)}...`);
+        simStore.sendReply(chatId, "raw_card", cardJson.slice(0, 500));
+        return true;
+    },
+    async sendPostMessage(_token, chatId, title, postContent) {
+        console.log(`[${ts()}] [SIM:SEND] post → ${chatId}: title="${title}" paragraphs=${postContent.length}`);
+        simStore.sendReply(chatId, "post", `[${title}] ${postContent.length} paragraphs`);
+        return true;
+    },
+    // ---- 消息管理 ----
+    async addReaction(_token, _messageId, _emojiType) {
+        // 模拟模式不需要表情回应
+    },
+    async recallMessage(_token, _messageId) {
+        return true;
+    },
+    async updateCardMessage(_token, _messageId, content) {
+        // 模拟模式：记录卡片更新到控制台（无 chatId，不写入消息历史）
+        console.log(`[${ts()}] [SIM:CARD] update: msgId=${_messageId} preview=${content.slice(0, 80)}`);
+        return true;
+    },
+    // ---- 群聊管理 ----
+    async createGroupChat(_token, name, userIds) {
+        const chat = simStore.createGroupChat(name, userIds);
+        console.log(`[${ts()}] [SIM:CHAT] created: ${chat.id} name="${name}" members=${userIds.length}`);
+        return chat.id;
+    },
+    async updateChatInfo(_token, chatId, name, description) {
+        simStore.updateChatInfo(chatId, name, description);
+        console.log(`[${ts()}] [SIM:CHAT] updated: ${chatId} name="${name}"`);
+    },
+    async getChatInfo(_token, chatId) {
+        const chat = simStore.getChat(chatId);
+        if (!chat)
+            throw new Error(`[99999] chat not found: ${chatId}`);
+        return { name: chat.name, description: chat.description };
+    },
+    async disbandChat(_token, chatId) {
+        simStore.disbandChat(chatId);
+        console.log(`[${ts()}] [SIM:CHAT] disbanded: ${chatId}`);
+    },
+    // ---- 头像 ----
+    async setChatAvatar(_token, _chatId, _tool, _status) {
+        // 模拟模式不需要头像
+    },
+    async getCodexUsageSummary() {
+        return {
+            fiveHour: { usedPercent: 0, remainingPercent: 100, resetAtEpochSeconds: null, resetAfterSeconds: null },
+            weekly: { usedPercent: 0, remainingPercent: 100, resetAtEpochSeconds: null, resetAfterSeconds: null },
+            rateLimitResetCreditsAvailable: null,
+            rateLimitResetCredits: null,
+        };
+    },
+    async consumeCodexRateLimitResetCredit(_redeemRequestId) {
+        return { code: "no_credit", windowsReset: 0 };
+    },
+    // ---- 图片下载 ----
+    async getOrDownloadImage(_token, _messageId, fileKey) {
+        return join(SIM_DIR, "images", fileKey);
+    },
+    // ---- 权限验证 ----
+    async verifyAllPermissions(_token) {
+        return [
+            { scope: "im:chat", description: "模拟", ok: true, detail: "模拟模式跳过" },
+            { scope: "im:message:send_as_bot", description: "模拟", ok: true, detail: "模拟模式跳过" },
+            { scope: "im:message:reaction", description: "模拟", ok: true, detail: "模拟模式跳过" },
+            { scope: "im:message", description: "模拟", ok: true, detail: "模拟模式跳过" },
+            { scope: "cardkit:card", description: "模拟", ok: true, detail: "模拟模式跳过" },
+        ];
+    },
+    // ---- 纯函数：直接从真实实现 re-export ----
+    extractSessionInfo: realExtractSessionInfo,
+    extractSessionId: realExtractSessionId,
+    formatDelayNotice: realFormatDelayNotice,
+    reportPermissionResults: realReportPermissionResults,
+    // ---- 其他 ----
+    async sendRestartCard(_token) {
+        // 模拟模式不需要重启通知
+    },
+    async getMergeForwardMessages(_token, _messageId) {
+        // 模拟模式没有真实 API，返回空数组让调用方降级到 preview
+        return [];
+    },
+};
+/** 模拟模式下的默认 chat_id（重新导出以保持向后兼容） */
+export { SIM_DEFAULT_CHAT_ID } from "./sim-store.js";

package/dist/src/sim-store.js

@@ -0,0 +1,231 @@
+/**
+ * sim-store.ts — 模拟飞书环境的状态管理核心
+ *
+ * SimStore 是一个单例的 EventEmitter，管理所有模拟状态：
+ * - 账户（bot + 多个用户）
+ * - 会话（群聊 + 私聊）
+ * - 消息历史（内存 + JSONL 持久化）
+ *
+ * 同时暴露 setMessageHandler / dispatchMessage，让 SimAgent 进程内触发
+ * handleCommand 而无需通过 HTTP。
+ */
+import { randomUUID } from "node:crypto";
+import { appendFile, mkdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { EventEmitter } from "node:events";
+// ---------------------------------------------------------------------------
+// 持久化路径
+// ---------------------------------------------------------------------------
+const SIM_DIR = join(homedir(), ".chatccc", "sim");
+const MESSAGES_FILE = join(SIM_DIR, "messages.jsonl");
+async function ensureDir() {
+    await mkdir(SIM_DIR, { recursive: true });
+}
+async function appendJsonl(line) {
+    await ensureDir();
+    await appendFile(MESSAGES_FILE, JSON.stringify(line) + "\n", "utf-8");
+}
+// ---------------------------------------------------------------------------
+// SimStore
+// ---------------------------------------------------------------------------
+export class SimStore extends EventEmitter {
+    accounts = new Map();
+    chats = new Map();
+    // ---- 初始化 ----
+    constructor() {
+        super();
+        this._initDefaults();
+    }
+    _initDefaults() {
+        // 注册 bot 账户
+        this.accounts.set("bot", { id: "bot", kind: "bot", name: "ChatCCC" });
+        // 注册默认用户
+        this.accounts.set("sim_user_001", { id: "sim_user_001", kind: "user", name: "Developer" });
+        // 创建默认群聊
+        const defaultChatId = "sim_default";
+        this.chats.set(defaultChatId, {
+            id: defaultChatId,
+            type: "group",
+            name: "默认模拟会话",
+            description: "",
+            memberIds: ["bot", "sim_user_001"],
+            messages: [],
+        });
+    }
+    // ---- 账户管理 ----
+    registerAccount(account) {
+        if (this.accounts.has(account.id)) {
+            throw new Error(`Account "${account.id}" already exists`);
+        }
+        this.accounts.set(account.id, account);
+    }
+    getAccount(id) {
+        return this.accounts.get(id);
+    }
+    // ---- 会话管理 ----
+    createGroupChat(name, memberIds) {
+        const chatId = `sim_${randomUUID().slice(0, 8)}`;
+        // bot 始终是成员
+        const allMembers = ["bot", ...memberIds.filter((id) => id !== "bot")];
+        const chat = {
+            id: chatId,
+            type: "group",
+            name,
+            description: "",
+            memberIds: allMembers,
+            messages: [],
+        };
+        this.chats.set(chatId, chat);
+        // 通知被拉入群的用户
+        for (const uid of memberIds) {
+            this.emit("member_added", { chatId, userId: uid });
+        }
+        this.emit("chat_created", { chat });
+        return chat;
+    }
+    createP2pChat(userId) {
+        // p2p 命名规则：p2p_<userId>_bot
+        const chatId = `p2p_${userId}_bot`;
+        const existing = this.chats.get(chatId);
+        if (existing)
+            return existing;
+        const user = this.accounts.get(userId);
+        const chat = {
+            id: chatId,
+            type: "p2p",
+            name: user ? `${user.name} 的私聊` : `私聊`,
+            description: "",
+            memberIds: ["bot", userId],
+            messages: [],
+        };
+        this.chats.set(chatId, chat);
+        this.emit("chat_created", { chat });
+        return chat;
+    }
+    getChat(chatId) {
+        return this.chats.get(chatId);
+    }
+    getChatsForUser(userId) {
+        return [...this.chats.values()].filter((c) => c.memberIds.includes(userId));
+    }
+    addMember(chatId, userId) {
+        const chat = this.chats.get(chatId);
+        if (!chat)
+            throw new Error(`Chat not found: ${chatId}`);
+        if (!chat.memberIds.includes(userId)) {
+            chat.memberIds.push(userId);
+            this.emit("member_added", { chatId, userId });
+        }
+    }
+    updateChatInfo(chatId, name, description) {
+        const chat = this.chats.get(chatId);
+        if (chat) {
+            chat.name = name;
+            chat.description = description;
+        }
+        else {
+            // 模拟模式下机器人可能尝试更新不存在的群（比如从旧状态恢复），兼容处理
+            this.chats.set(chatId, {
+                id: chatId,
+                type: "group",
+                name,
+                description,
+                memberIds: ["bot", "sim_user_001"],
+                messages: [],
+            });
+        }
+    }
+    disbandChat(chatId) {
+        this.chats.delete(chatId);
+    }
+    // ---- 消息管理 ----
+    /** 任何参与者发送消息 */
+    recordMessage(chatId, senderId, type, content) {
+        const chat = this.chats.get(chatId);
+        if (!chat)
+            throw new Error(`Chat not found: ${chatId}`);
+        const msg = {
+            id: randomUUID(),
+            chatId,
+            senderId,
+            type,
+            content,
+            timestamp: Date.now(),
+        };
+        chat.messages.push(msg);
+        // 写 JSONL
+        appendJsonl({
+            direction: senderId === "bot" ? "send" : "recv",
+            chat_id: chatId,
+            sender_id: senderId,
+            msg_type: type,
+            content,
+            timestamp: msg.timestamp,
+        }).catch(() => { });
+        // 通知所有订阅者
+        this.emit("message", { chatId, message: msg });
+        return msg;
+    }
+    /** bot 发送回复——即使 chat 不存在也记录（兼容未知 chat） */
+    sendReply(chatId, type, content) {
+        const msg = {
+            id: randomUUID(),
+            chatId,
+            senderId: "bot",
+            type,
+            content,
+            timestamp: Date.now(),
+        };
+        // 如果 chat 存在，追加到消息历史
+        const chat = this.chats.get(chatId);
+        if (chat) {
+            chat.messages.push(msg);
+        }
+        // 写 JSONL
+        appendJsonl({
+            direction: "send",
+            chat_id: chatId,
+            msg_type: type,
+            content,
+            timestamp: msg.timestamp,
+        }).catch(() => { });
+        // 通知订阅者
+        this.emit("message", { chatId, message: msg });
+        return msg;
+    }
+    /** 获取指定会话的消息 */
+    getMessages(chatId, requesterId) {
+        const chat = this.chats.get(chatId);
+        if (!chat)
+            return [];
+        // 只有成员能看消息
+        if (!chat.memberIds.includes(requesterId))
+            return [];
+        return chat.messages;
+    }
+    /** 重置所有状态（测试用） */
+    reset() {
+        this.accounts.clear();
+        this.chats.clear();
+        this.removeAllListeners();
+        this._initDefaults();
+    }
+}
+// ---------------------------------------------------------------------------
+// 单例 + 消息分发
+// ---------------------------------------------------------------------------
+export const simStore = new SimStore();
+export const SIM_DEFAULT_CHAT_ID = "sim_default";
+let _messageHandler = null;
+/** 注册 handleCommand 回调（由 index.ts 在模拟模式启动时调用） */
+export function setMessageHandler(handler) {
+    _messageHandler = handler;
+}
+/** 模拟用户发送消息 → 记录消息 + 触发 bot 处理 */
+export async function dispatchMessage(text, chatId, openId, chatType) {
+    if (!_messageHandler)
+        throw new Error("Message handler not registered — is simulate mode running?");
+    simStore.recordMessage(chatId, openId, "text", text);
+    await _messageHandler(text, chatId, openId, Date.now(), chatType);
+}

package/dist/src/simplify.js

@@ -0,0 +1,99 @@
+import { existsSync, readFileSync } from "node:fs";
+import { resolve as resolvePath } from "node:path";
+import { PROJECT_ROOT } from "./config.js";
+let config = null;
+let loaded = false;
+function loadConfig() {
+    const filePath = resolvePath(PROJECT_ROOT, "simplify.json");
+    if (!existsSync(filePath))
+        return {};
+    try {
+        const raw = readFileSync(filePath, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+            console.error("[SIMPLIFY] simplify.json 格式错误：应为对象");
+            return {};
+        }
+        return parsed;
+    }
+    catch (err) {
+        console.error(`[SIMPLIFY] 读取 simplify.json 失败: ${err.message}`);
+        return {};
+    }
+}
+function getConfig() {
+    if (!loaded) {
+        config = loadConfig();
+        loaded = true;
+    }
+    return config;
+}
+/** 热重载 */
+export function reloadSimplifyConfig() {
+    loaded = false;
+    config = null;
+}
+/**
+ * 对模板字符串中的 {field} 占位符做替换。
+ * fields 为可用字段映射，extra 是额外的上下文（如 tool_use_id 的 id）。
+ */
+function resolveTemplate(template, fields, extra) {
+    let result = template;
+    if (extra) {
+        for (const [k, v] of Object.entries(extra)) {
+            result = result.split(`{${k}}`).join(v);
+        }
+    }
+    for (const [k, v] of Object.entries(fields)) {
+        const strVal = typeof v === "string" ? v : JSON.stringify(v);
+        result = result.split(`{${k}}`).join(strVal);
+    }
+    return result;
+}
+/**
+ * 简化 tool_use 展示。
+ * 返回 null 表示无规则，调用方应回退到默认格式化。
+ */
+export function simplifyToolUse(name, input) {
+    const cfg = getConfig();
+    const rules = cfg.tool_use;
+    if (!rules)
+        return null;
+    const rule = rules[name];
+    if (!rule)
+        return null;
+    const fields = typeof input === "object" && input !== null
+        ? input
+        : {};
+    let result = resolveTemplate(rule.template, fields);
+    if (result.length > rule.maxLength) {
+        result = result.slice(0, rule.maxLength) + "...";
+    }
+    return result;
+}
+/**
+ * 简化 tool_result 展示。
+ * 返回 null 表示无规则，调用方应回退到默认格式化。
+ * toolCallInput 为对应的 tool_use 输入（可选），用于在 result 模板中引用输入字段。
+ */
+export function simplifyToolResult(name, toolUseId, isError, toolCallInput) {
+    const cfg = getConfig();
+    const rules = cfg.tool_result;
+    if (!rules)
+        return null;
+    const rule = rules[name];
+    if (!rule)
+        return null;
+    const id = toolUseId.slice(-6);
+    const extra = { id };
+    const fields = toolCallInput && typeof toolCallInput === "object"
+        ? toolCallInput
+        : {};
+    let result = resolveTemplate(rule.template, fields, extra);
+    if (isError)
+        result = "❌ " + result;
+    if (result.length > rule.maxLength) {
+        result = result.slice(0, rule.maxLength) + "...";
+    }
+    return result;
+}

package/dist/src/startup-lifecycle.js

@@ -0,0 +1,209 @@
+import { spawn } from "node:child_process";
+const DEFAULT_SERVICE_HEALTH_INTERVAL_MS = 10_000;
+/**
+ * 为 ChatCCC 这种常驻服务建立一个明确的进程生命周期锚点。
+ *
+ * 正常情况下，正在 listen 的 HTTP Server 自己就足以维持事件循环；额外的
+ * referenced timer 是最后一道保险，避免某个依赖升级或异常 close/unref 让进程在
+ * 没有信号、异常或退出码的情况下静默消失。定时检查同时会重新 ref Server，并在
+ * Server 确实停止监听时串行触发恢复，避免只把一个失去服务能力的僵尸进程留下来。
+ */
+export function createServiceLifecycleGuard(options = {}) {
+    const intervalMs = options.intervalMs ?? DEFAULT_SERVICE_HEALTH_INTERVAL_MS;
+    const setIntervalImpl = options.setIntervalImpl
+        ?? ((callback, delayMs) => setInterval(callback, delayMs));
+    const clearIntervalImpl = options.clearIntervalImpl
+        ?? ((timer) => clearInterval(timer));
+    const tracer = options.tracer ?? (() => { });
+    const getActiveResourcesInfo = options.getActiveResourcesInfo
+        ?? (() => process.getActiveResourcesInfo());
+    let timer = null;
+    let server = null;
+    let recoverServer;
+    let recoveryPromise = null;
+    let shuttingDown = false;
+    const trace = (message, extra) => {
+        try {
+            tracer(message, extra);
+        }
+        catch { /* 诊断路径不能反过来打断服务 */ }
+    };
+    const serverAddress = () => {
+        try {
+            return server?.address() ?? null;
+        }
+        catch {
+            return null;
+        }
+    };
+    const activeResources = () => {
+        try {
+            return getActiveResourcesInfo();
+        }
+        catch {
+            return [];
+        }
+    };
+    const diagnostics = (extra = {}) => ({
+        ...extra,
+        uptimeSeconds: Math.floor(process.uptime()),
+        activeResources: activeResources(),
+        serverAttached: server !== null,
+        serverListening: server?.listening ?? false,
+        serverAddress: serverAddress(),
+    });
+    const start = () => {
+        if (shuttingDown || timer)
+            return;
+        timer = setIntervalImpl(() => { void checkNow(); }, intervalMs);
+        // Node 的 Timeout 默认就是 ref 状态；显式 ref 让常驻服务契约不会依赖默认值。
+        try {
+            timer.ref?.();
+        }
+        catch { /* ignore */ }
+        trace("service-lifecycle: guard started", { intervalMs });
+    };
+    const checkNow = async () => {
+        if (shuttingDown || !server)
+            return;
+        if (server.listening) {
+            try {
+                server.ref();
+            }
+            catch (err) {
+                trace("service-lifecycle: HTTP server ref failed", diagnostics({
+                    error: err.message,
+                }));
+            }
+            return;
+        }
+        if (recoveryPromise)
+            return recoveryPromise;
+        trace("service-lifecycle: HTTP server inactive", diagnostics());
+        if (!recoverServer)
+            return;
+        recoveryPromise = Promise.resolve()
+            .then(() => recoverServer?.())
+            .then(() => {
+            if (server?.listening) {
+                try {
+                    server.ref();
+                }
+                catch { /* 下一轮健康检查会再次尝试 */ }
+                trace("service-lifecycle: HTTP server recovered", diagnostics());
+            }
+            else {
+                trace("service-lifecycle: HTTP recovery completed without listening", diagnostics());
+            }
+        })
+            .catch((err) => {
+            trace("service-lifecycle: HTTP server recovery failed", diagnostics({
+                error: err instanceof Error ? err.message : String(err),
+            }));
+        })
+            .finally(() => {
+            recoveryPromise = null;
+        });
+        return recoveryPromise;
+    };
+    const attachServer = (nextServer, nextRecoverServer) => {
+        server = nextServer;
+        recoverServer = nextRecoverServer;
+        if (server.listening) {
+            try {
+                server.ref();
+            }
+            catch { /* 下一轮健康检查会记录 */ }
+        }
+        trace("service-lifecycle: HTTP server attached", diagnostics());
+    };
+    const handleBeforeExit = (code) => {
+        if (shuttingDown)
+            return;
+        trace("service-lifecycle: unexpected beforeExit", diagnostics({ code }));
+        start();
+        void checkNow();
+    };
+    const beginShutdown = (reason) => {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        if (timer) {
+            try {
+                clearIntervalImpl(timer);
+            }
+            catch { /* process 即将退出 */ }
+            timer = null;
+        }
+        trace("service-lifecycle: shutdown requested", { reason });
+    };
+    return { start, attachServer, checkNow, handleBeforeExit, beginShutdown };
+}
+/**
+ * ChatCCC 自己拉起替代进程时使用的内部标记。
+ *
+ * 不能用“是否已有配置”判断是否打开控制台：首次配置和日常直接启动都应该
+ * 打开，而 `/restart`、`/update` 和 Web UI 重启都不应该打扰用户。环境变量
+ * 会自然穿过 cmd/bash/npx 这几层启动器，因此也适用于 Windows 与 Linux。
+ */
+export const INTERNAL_RESTART_ENV_VAR = "CHATCCC_INTERNAL_RESTART";
+export function createInternalRestartEnv(inherited = process.env) {
+    return {
+        ...inherited,
+        [INTERNAL_RESTART_ENV_VAR]: "1",
+    };
+}
+export function shouldAutoOpenWebUi(options = {}) {
+    const env = options.env ?? process.env;
+    return options.openOnStart !== false && env[INTERNAL_RESTART_ENV_VAR] !== "1";
+}
+/** Web UI 始终使用 localhost，并跟随实际配置端口。 */
+export function buildWebUiUrl(port) {
+    return `http://localhost:${port}/`;
+}
+/**
+ * 调用操作系统默认浏览器打开 Web UI，与 Chrome CDP 守护功能完全独立。
+ * 返回值仅表示打开请求是否成功发起；浏览器是否复用标签页由系统浏览器决定。
+ */
+export function openWebUiInDefaultBrowser(port, deps = {}) {
+    const url = buildWebUiUrl(port);
+    const platform = deps.platform ?? process.platform;
+    const env = deps.env ?? process.env;
+    const spawnImpl = deps.spawnImpl ?? spawn;
+    const onError = deps.onError ?? ((message) => console.error(message));
+    const onInfo = deps.onInfo ?? ((message) => console.log(message));
+    // Linux 服务器通常没有图形会话。此时调用 xdg-open 只会制造噪音；
+    // 直接给出可复制的 SSH 隧道命令，让用户从自己的电脑访问本地 Web UI。
+    if (platform === "linux" && !env.DISPLAY && !env.WAYLAND_DISPLAY) {
+        onInfo(`[WEB-UI] 未检测到 Linux 图形桌面，跳过自动打开浏览器。` +
+            `可在本机执行 ssh -L ${port}:127.0.0.1:${port} <user>@<server>，` +
+            `然后访问 ${url}`);
+        return false;
+    }
+    try {
+        let child;
+        if (platform === "win32") {
+            // `start` 会把第一个带引号的参数当窗口标题，空字符串是必要占位符。
+            child = spawnImpl("cmd.exe", ["/c", "start", "", url], {
+                detached: true,
+                stdio: "ignore",
+                windowsHide: true,
+            });
+        }
+        else if (platform === "darwin") {
+            child = spawnImpl("open", [url], { detached: true, stdio: "ignore" });
+        }
+        else {
+            child = spawnImpl("xdg-open", [url], { detached: true, stdio: "ignore" });
+        }
+        child.on("error", (err) => {
+            onError(`[WEB-UI] 自动打开浏览器失败: ${err.message}`);
+        });
+        child.unref();
+        return true;
+    }
+    catch (err) {
+        onError(`[WEB-UI] 自动打开浏览器失败: ${err.message}`);
+        return false;
+    }
+}