chatccc 0.2.202 → 0.2.204

package/README.md

@@ -133,7 +133,7 @@ Write-Host ''
 chatccc
 ```
 
-如果一切顺利，浏览器会自动打开 `http://127.0.0.1:18080` 的 Web 配置页面。按页面提示填入飞书 App ID / App Secret，点击"保存并启动"即可。
+如果一切顺利，系统默认浏览器会自动打开 `http://localhost:18080/` 的 Web 配置页面。按页面提示填入飞书 App ID / App Secret，点击"保存并启动"即可。
 
 > **只想装 ChatCCC 本体？** 如果你已经有 Node.js，直接 `npm install -g chatccc && chatccc` 即可，不需要跑上面的完整脚本。
 
@@ -151,7 +151,7 @@ chatccc
 
 旧版本留在仓库或包目录下的 `config.json`、`logs/`、`state/` 会在首次启动时自动迁移到用户目录。
 
-首次启动时，如果还没有有效配置，ChatCCC 会自动打开本地 Web 配置向导（默认 `http://127.0.0.1:18080`）。
+每次直接运行 `chatccc` 时，无论是否已经完成配置，ChatCCC 默认都会用系统默认浏览器打开本地 Web UI（默认 `http://localhost:18080/`，修改 `config.port` 后跟随实际端口）。可在首次配置向导或管理页的 **Web UI** 设置中关闭；关闭后从下一次直接启动起生效。由 `/restart`、`/update` 或 Web UI 发起的内部重启始终不会重复打开浏览器。Linux 服务器没有 `DISPLAY`/`WAYLAND_DISPLAY` 时会跳过打开，并在终端输出 SSH 隧道访问提示。主页顶部的 **Agent Team** 入口会跳转到独立的 `/agent-team` 页面。
 
 #### 从源码运行
 
@@ -260,11 +260,14 @@ Codex 的默认模型和推理强度可继续由 `~/.codex/config.toml` 管理
     "appId": "cli_xxxxxxxxxxxx",
     "appSecret": "xxxxxxxxxxxxxxxxxxxxxxxxxx"
   },
-  "platforms": {
-    "feishu": { "enabled": true, "platformType": "feishu" },
-    "ilink": { "enabled": true, "reuseTokenOnStart": true }
-  },
-  "chromeDevtools": {
+  "platforms": {
+    "feishu": { "enabled": true, "platformType": "feishu" },
+    "ilink": { "enabled": true, "reuseTokenOnStart": true }
+  },
+  "webUi": {
+    "openOnStart": true
+  },
+  "chromeDevtools": {
     "enabled": false,
     "port": 15166,
     "chromePath": ""
@@ -305,9 +308,10 @@ Codex 的默认模型和推理强度可继续由 `~/.codex/config.toml` 管理
 | `feishu.appId` / `feishu.appSecret` | 飞书应用凭证 |
 | `platforms.feishu.enabled` | 是否启用飞书 |
 | `platforms.feishu.platformType` | 飞书平台类型，默认 `feishu` |
-| `platforms.ilink.enabled` | 是否启用微信 iLink |
-| `platforms.ilink.reuseTokenOnStart` | 启动时是否复用已有微信登录 token |
-| `chromeDevtools.enabled` | 是否启用常驻 Chrome CDP；默认 false |
+| `platforms.ilink.enabled` | 是否启用微信 iLink |
+| `platforms.ilink.reuseTokenOnStart` | 启动时是否复用已有微信登录 token |
+| `webUi.openOnStart` | 直接启动时是否打开系统默认浏览器；默认 true，内部重启始终跳过 |
+| `chromeDevtools.enabled` | 是否启用常驻 Chrome CDP；默认 false |
 | `chromeDevtools.port` | Chrome CDP 端口；默认 15166 |
 | `chromeDevtools.chromePath` | Chrome 可执行文件路径；留空时自动探测 |
 | `port` | 本地 Web 配置面板和中继服务端口 |
@@ -352,10 +356,12 @@ Codex 的默认模型和推理强度可继续由 `~/.codex/config.toml` 管理
 | `/plan <内容>` | 只读计划模式：仅允许读文件和 stop-stuck-loop 请求，不执行任何写操作 |
 | `/ask <内容>` | 只读问答模式：与 /plan 相同，仅允许读文件和 stop-stuck-loop 请求 |
 | `/restart` | 重启机器人进程 |
-| `/update` | 更新 npm 全局包并重启（仅限 `npm install -g chatccc` 安装的全局进程） |
-| `/deleteg` | 解散当前飞书会话群；Agent 会话记录保留 |
-
-> **模型切换**：`/model` 查看当前会话 Agent 的可选模型清单，`/model <名称>` 模糊匹配切换，`/model clear` 恢复默认。可选模型来自当前 Agent 的配置：Claude 使用 `claude.model` / `claude.subagentModel`，Cursor 使用 `cursor.model`，Codex 使用 `codex.model`。
+| `/update` | 更新 npm 全局包并重启（仅限 `npm install -g chatccc` 安装的全局进程；同一飞书事件跨重启去重） |
+| `/deleteg` | 解散当前飞书会话群；Agent 会话记录保留 |
+
+`/update` 会在执行 npm 更新前把飞书消息或按钮事件 ID 原子写入 `~/.chatccc/state/update-command-guard.json`。同一 ID 跨重启重投时会静默忽略；用户主动发送的新 `/update` 因事件 ID 不同，仍可立即执行。该保护仅作用于 `/update`，普通消息与 `/restart` 的处理不变。
+
+> **模型切换**：`/model` 查看当前会话 Agent 的可选模型清单，`/model <名称>` 模糊匹配切换，`/model clear` 恢复默认。可选模型来自当前 Agent 的配置：Claude 使用 `claude.model` / `claude.subagentModel`，Cursor 使用 `cursor.model`，Codex 使用 `codex.model`。
 
 ---
 

package/config.sample.json

@@ -3,11 +3,14 @@
     "appId": "",
     "appSecret": ""
   },
-  "platforms": {
-    "feishu": { "enabled": true, "platformType": "feishu" },
-    "ilink": { "enabled": true, "reuseTokenOnStart": true }
-  },
-  "chromeDevtools": {
+  "platforms": {
+    "feishu": { "enabled": true, "platformType": "feishu" },
+    "ilink": { "enabled": true, "reuseTokenOnStart": true }
+  },
+  "webUi": {
+    "openOnStart": true
+  },
+  "chromeDevtools": {
     "enabled": false,
     "port": 15166,
     "chromePath": ""

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chatccc",
-  "version": "0.2.202",
+  "version": "0.2.204",
   "description": "Feishu bot bridge for Claude Code",
   "license": "Apache-2.0",
   "type": "module",

package/src/__tests__/config-reload.test.ts

@@ -38,10 +38,11 @@ import {
 //      原地切换复用同一 server，重新读端口只会引入混乱）
 // ---------------------------------------------------------------------------
 
-const baseAppConfig: AppConfig = {
-  feishu: { appId: "INITIAL_APP", appSecret: "INITIAL_SECRET" },
-  platforms: { feishu: { enabled: true }, ilink: { enabled: true } },
-  chromeDevtools: { enabled: false, port: 15166, chromePath: "" },
+const baseAppConfig: AppConfig = {
+  feishu: { appId: "INITIAL_APP", appSecret: "INITIAL_SECRET" },
+  platforms: { feishu: { enabled: true }, ilink: { enabled: true } },
+  webUi: { openOnStart: true },
+  chromeDevtools: { enabled: false, port: 15166, chromePath: "" },
   port: 18080,
   gitTimeoutSeconds: 180,
   allowInterrupt: false,
@@ -216,7 +217,7 @@ describe("applyLoadedConfig — config 对象引用契约", () => {
     expect(config.codex.path).toBe("/refresh/codex");
   });
 
-  it("刷新 chromeDevtools 配置但保持 config 引用", () => {
+  it("刷新 chromeDevtools 配置但保持 config 引用", () => {
     const refBefore = config;
 
     applyLoadedConfig({
@@ -226,7 +227,19 @@ describe("applyLoadedConfig — config 对象引用契约", () => {
 
     expect(config).toBe(refBefore);
     expect(config.chromeDevtools).toEqual({ enabled: true, port: 15166, chromePath: "C:/Chrome/chrome.exe" });
-  });
+  });
+
+  it("刷新 webUi 启动开关但保持 config 引用", () => {
+    const refBefore = config;
+
+    applyLoadedConfig({
+      ...structuredClone(baseAppConfig),
+      webUi: { openOnStart: false },
+    });
+
+    expect(config).toBe(refBefore);
+    expect(config.webUi).toEqual({ openOnStart: false });
+  });
 
   it("空 feishu 凭证也能正确刷入（向导回滚到空的反向场景）", () => {
     applyLoadedConfig({

package/src/__tests__/config-sample.test.ts

@@ -59,7 +59,16 @@ describe("config.sample.json", () => {
     expect(sample.chromeDevtools?.enabled).toBe(false);
     expect(sample.chromeDevtools?.port).toBe(15166);
     expect(sample.chromeDevtools?.chromePath).toBe("");
-  });
+  });
+
+  it("opens the Web UI on direct startup by default", () => {
+    const configSamplePath = join(process.cwd(), "config.sample.json");
+    const sample = JSON.parse(readFileSync(configSamplePath, "utf8")) as {
+      webUi?: { openOnStart?: unknown };
+    };
+
+    expect(sample.webUi?.openOnStart).toBe(true);
+  });
 
   it("keeps raw stream logs disabled by default for every agent", () => {
     const configSamplePath = join(process.cwd(), "config.sample.json");

package/src/__tests__/startup-lifecycle.test.ts

@@ -0,0 +1,98 @@
+import { describe, expect, it, vi } from "vitest";
+
+import {
+  INTERNAL_RESTART_ENV_VAR,
+  buildWebUiUrl,
+  createInternalRestartEnv,
+  openWebUiInDefaultBrowser,
+  shouldAutoOpenWebUi,
+} from "../startup-lifecycle.ts";
+
+describe("ChatCCC startup lifecycle", () => {
+  it("opens the Web UI by default for a direct start", () => {
+    expect(shouldAutoOpenWebUi({ env: {} })).toBe(true);
+    expect(shouldAutoOpenWebUi({ env: {}, openOnStart: true })).toBe(true);
+  });
+
+  it("respects the persisted openOnStart preference", () => {
+    expect(shouldAutoOpenWebUi({ env: {}, openOnStart: false })).toBe(false);
+  });
+
+  it("never opens the Web UI for an internal restart", () => {
+    expect(shouldAutoOpenWebUi({
+      env: { [INTERNAL_RESTART_ENV_VAR]: "1" },
+      openOnStart: true,
+    })).toBe(false);
+  });
+
+  it("marks internal restart children without losing the inherited environment", () => {
+    expect(createInternalRestartEnv({ PATH: "test-path", CUSTOM: "value" })).toEqual({
+      PATH: "test-path",
+      CUSTOM: "value",
+      [INTERNAL_RESTART_ENV_VAR]: "1",
+    });
+  });
+
+  it("uses localhost and the configured port for the Web UI URL", () => {
+    expect(buildWebUiUrl(18080)).toBe("http://localhost:18080/");
+    expect(buildWebUiUrl(18081)).toBe("http://localhost:18081/");
+  });
+
+  it("opens the configured URL in the Windows default browser", () => {
+    const child = {
+      on: vi.fn().mockReturnThis(),
+      unref: vi.fn(),
+    };
+    const spawnImpl = vi.fn(() => child as never);
+
+    expect(openWebUiInDefaultBrowser(18081, {
+      platform: "win32",
+      spawnImpl,
+    })).toBe(true);
+    expect(spawnImpl).toHaveBeenCalledWith(
+      "cmd.exe",
+      ["/c", "start", "", "http://localhost:18081/"],
+      {
+        detached: true,
+        stdio: "ignore",
+        windowsHide: true,
+      },
+    );
+    expect(child.on).toHaveBeenCalledWith("error", expect.any(Function));
+    expect(child.unref).toHaveBeenCalledOnce();
+  });
+
+  it("opens the configured URL with xdg-open on a Linux desktop", () => {
+    const child = {
+      on: vi.fn().mockReturnThis(),
+      unref: vi.fn(),
+    };
+    const spawnImpl = vi.fn(() => child as never);
+
+    expect(openWebUiInDefaultBrowser(18080, {
+      platform: "linux",
+      env: { DISPLAY: ":0" },
+      spawnImpl,
+    })).toBe(true);
+    expect(spawnImpl).toHaveBeenCalledWith(
+      "xdg-open",
+      ["http://localhost:18080/"],
+      { detached: true, stdio: "ignore" },
+    );
+  });
+
+  it("skips xdg-open and prints an SSH tunnel hint on headless Linux", () => {
+    const spawnImpl = vi.fn();
+    const onInfo = vi.fn();
+
+    expect(openWebUiInDefaultBrowser(18080, {
+      platform: "linux",
+      env: {},
+      spawnImpl,
+      onInfo,
+    })).toBe(false);
+    expect(spawnImpl).not.toHaveBeenCalled();
+    expect(onInfo).toHaveBeenCalledWith(expect.stringContaining("ssh -L 18080:127.0.0.1:18080"));
+    expect(onInfo).toHaveBeenCalledWith(expect.stringContaining("http://localhost:18080/"));
+  });
+});

package/src/__tests__/update-command-guard.test.ts

@@ -0,0 +1,144 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import {
+  acquireUpdateCommandGuard,
+  buildUpdateCommandId,
+  extractFeishuEventId,
+} from "../update-command-guard.ts";
+
+describe("Feishu update command IDs", () => {
+  it("extracts and namespaces a card callback event_id", () => {
+    const eventId = extractFeishuEventId({
+      schema: "2.0",
+      header: { event_id: "evt_update_001" },
+      event: { action: { value: { action: "update" } } },
+    });
+
+    expect(buildUpdateCommandId("card", eventId)).toBe("card:evt_update_001");
+    expect(buildUpdateCommandId("message", "om_update_001")).toBe("message:om_update_001");
+  });
+});
+
+describe("acquireUpdateCommandGuard", () => {
+  let tempDir: string;
+  let guardFile: string;
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), "chatccc-update-guard-"));
+    guardFile = join(tempDir, "state", "update-command-guard.json");
+  });
+
+  afterEach(async () => {
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  it("persists an accepted update ID before returning", async () => {
+    const result = acquireUpdateCommandGuard({
+      filePath: guardFile,
+      commandId: "message:om_update_001",
+      now: 1_000,
+    });
+
+    expect(result).toEqual({ allowed: true, reason: "accepted" });
+    const saved = JSON.parse(await readFile(guardFile, "utf8"));
+    expect(saved).toEqual({
+      version: 1,
+      processed: [{ id: "message:om_update_001", recordedAt: 1_000 }],
+    });
+  });
+
+  it("rejects the same ID after a simulated process restart", () => {
+    expect(acquireUpdateCommandGuard({
+      filePath: guardFile,
+      commandId: "message:om_update_001",
+      now: 1_000,
+    }).allowed).toBe(true);
+
+    // 第二次调用不共享任何内存状态，只通过落盘文件模拟新进程重启后的判断。
+    expect(acquireUpdateCommandGuard({
+      filePath: guardFile,
+      commandId: "message:om_update_001",
+      now: 9_999_999,
+    })).toEqual({ allowed: false, reason: "duplicate_id" });
+  });
+
+  it("accepts different IDs immediately without a cooldown", () => {
+    expect(acquireUpdateCommandGuard({
+      filePath: guardFile,
+      commandId: "message:om_update_001",
+      now: 1_000,
+    }).allowed).toBe(true);
+
+    expect(acquireUpdateCommandGuard({
+      filePath: guardFile,
+      commandId: "message:om_update_002",
+      now: 1_001,
+    })).toEqual({ allowed: true, reason: "accepted" });
+  });
+
+  it("repairs a corrupt state file and warns without creating an update loop", async () => {
+    await mkdir(join(tempDir, "state"), { recursive: true });
+    await writeFile(guardFile, "not-json", "utf8");
+    const warn = vi.fn();
+
+    expect(acquireUpdateCommandGuard({
+      filePath: guardFile,
+      commandId: "message:om_update_001",
+      now: 1_000,
+      warn,
+    })).toEqual({ allowed: true, reason: "accepted" });
+    expect(warn).toHaveBeenCalledOnce();
+
+    // 损坏文件已被有效状态覆盖，因此重启后的重复投递仍会被拦截。
+    expect(acquireUpdateCommandGuard({
+      filePath: guardFile,
+      commandId: "message:om_update_001",
+      now: 2_000,
+      warn,
+    })).toEqual({ allowed: false, reason: "duplicate_id" });
+  });
+
+  it("fails closed when the accepted ID cannot be persisted", async () => {
+    const blocker = join(tempDir, "not-a-directory");
+    await writeFile(blocker, "block", "utf8");
+    const warn = vi.fn();
+
+    expect(acquireUpdateCommandGuard({
+      filePath: join(blocker, "update-command-guard.json"),
+      commandId: "message:om_update_001",
+      now: 1_000,
+      warn,
+    })).toEqual({ allowed: false, reason: "state_write_failed" });
+    expect(warn).toHaveBeenCalledOnce();
+  });
+
+  it("allows sources without a stable ID without writing a misleading record", async () => {
+    expect(acquireUpdateCommandGuard({
+      filePath: guardFile,
+      commandId: undefined,
+      now: 1_000,
+    })).toEqual({ allowed: true, reason: "missing_id" });
+    await expect(readFile(guardFile, "utf8")).rejects.toMatchObject({ code: "ENOENT" });
+  });
+
+  it("keeps only the newest configured number of update IDs", async () => {
+    for (let i = 0; i < 4; i++) {
+      expect(acquireUpdateCommandGuard({
+        filePath: guardFile,
+        commandId: `message:om_update_${i}`,
+        now: i,
+        maxEntries: 3,
+      }).allowed).toBe(true);
+    }
+
+    const saved = JSON.parse(await readFile(guardFile, "utf8"));
+    expect(saved.processed.map((entry: { id: string }) => entry.id)).toEqual([
+      "message:om_update_1",
+      "message:om_update_2",
+      "message:om_update_3",
+    ]);
+  });
+});

package/src/__tests__/web-ui.test.ts

@@ -1,11 +1,44 @@
+import { createServer } from "node:http";
+import type { AddressInfo } from "node:net";
 import { describe, it, expect } from "vitest";
 import {
+  AGENT_TEAM_PAGE_HTML,
   PAGE_HTML,
   chooseStartPath,
+  createUiRouter,
   getRestartRequiredReasons,
   unflattenConfig,
 } from "../web-ui.ts";
 
+describe("Agent Team page", () => {
+  it("adds a prominent global entry to the ChatCCC page", () => {
+    expect(PAGE_HTML).toContain('href="/agent-team"');
+    expect(PAGE_HTML).toContain('class="agent-team-entry"');
+    expect(PAGE_HTML).toContain("Agent Team");
+    expect(PAGE_HTML).toContain("linear-gradient");
+  });
+
+  it("contains only the Agent Team title as page content", () => {
+    expect(AGENT_TEAM_PAGE_HTML).toContain("<title>Agent Team</title>");
+    expect(AGENT_TEAM_PAGE_HTML).toContain("<h1>Agent Team</h1>");
+    expect(AGENT_TEAM_PAGE_HTML).not.toContain("dashboard-view");
+    expect(AGENT_TEAM_PAGE_HTML).not.toContain("wizard-view");
+  });
+
+  it("serves the Agent Team page from its own route", async () => {
+    const server = createServer(createUiRouter());
+    await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
+    const port = (server.address() as AddressInfo).port;
+    try {
+      const response = await fetch(`http://127.0.0.1:${port}/agent-team`);
+      expect(response.status).toBe(200);
+      expect(await response.text()).toBe(AGENT_TEAM_PAGE_HTML);
+    } finally {
+      await new Promise<void>((resolve, reject) => server.close((err) => err ? reject(err) : resolve()));
+    }
+  });
+});
+
 describe("unflattenConfig", () => {
   it("maps Claude subagent model into claude.subagentModel", () => {
     expect(
@@ -66,6 +99,18 @@ describe("unflattenConfig", () => {
       },
     });
   });
+
+  it("maps the Web UI startup preference into webUi config", () => {
+    expect(
+      unflattenConfig({
+        CHATCCC_WEB_UI_OPEN_ON_START: false,
+      }),
+    ).toEqual({
+      webUi: {
+        openOnStart: false,
+      },
+    });
+  });
 });
 
 describe("getRestartRequiredReasons", () => {
@@ -75,6 +120,7 @@ describe("getRestartRequiredReasons", () => {
       feishu: { enabled: true, platformType: "feishu" },
       ilink: { enabled: true, reuseTokenOnStart: true },
     },
+    webUi: { openOnStart: true },
     chromeDevtools: { enabled: false, port: 15166, chromePath: "" },
     port: 18080,
     claude: {
@@ -142,6 +188,12 @@ describe("getRestartRequiredReasons", () => {
 });
 
 describe("dashboard edit modal", () => {
+  it("keeps the embedded dashboard script syntactically valid", () => {
+    const script = PAGE_HTML.match(/<script>([\s\S]*)<\/script>/)?.[1];
+    expect(script).toBeTruthy();
+    expect(() => new Function(script ?? "")).not.toThrow();
+  });
+
   it("shows the edit modal and overlay when a section edit button is clicked", () => {
     expect(PAGE_HTML).toContain("function editSection(section)");
     expect(PAGE_HTML).toContain("document.getElementById('edit-modal').classList.remove('hidden');");
@@ -158,6 +210,13 @@ describe("dashboard edit modal", () => {
     expect(PAGE_HTML).toContain("生效范围：保存后下一条消息或下个新会话生效");
     expect(PAGE_HTML).toContain("生效范围：飞书开关、App ID、App Secret 或平台类型变更需要重启 ChatCCC");
   });
+
+  it("shows the Web UI startup switch in both the wizard and dashboard", () => {
+    expect(PAGE_HTML).toContain('id="field-CHATCCC_WEB_UI_OPEN_ON_START"');
+    expect(PAGE_HTML).toContain('id="cfg-WEB_UI_OPEN_ON_START"');
+    expect(PAGE_HTML).toContain("editSection('webUi')");
+    expect(PAGE_HTML).toContain("下次直接启动生效；内部重启始终不打开");
+  });
 });
 
 // ---------------------------------------------------------------------------

package/src/config.ts

@@ -150,10 +150,11 @@ export interface RawStreamLogsConfig {
   ccc: RawStreamAgentLogConfig;
 }
 
-export interface AppConfig {
-  feishu: FeishuConfig;
-  platforms: PlatformsConfig;
-  chromeDevtools: ChromeDevtoolsConfig;
+export interface AppConfig {
+  feishu: FeishuConfig;
+  platforms: PlatformsConfig;
+  webUi: { openOnStart: boolean };
+  chromeDevtools: ChromeDevtoolsConfig;
   port: number;
   gitTimeoutSeconds: number;
   /** 若为 false，AI 生成过程中用户发送消息不会打断，须先点「停止」再发送新消息 */
@@ -418,9 +419,10 @@ function normalizeRawStreamAgentLogConfig(raw: unknown): RawStreamAgentLogConfig
 
 function loadConfig(): AppConfig {
   const defaults: AppConfig = {
-    feishu: { appId: "", appSecret: "" },
-    platforms: { feishu: { enabled: true }, ilink: { enabled: true } },
-    chromeDevtools: { enabled: false, port: 15166, chromePath: "" },
+    feishu: { appId: "", appSecret: "" },
+    platforms: { feishu: { enabled: true }, ilink: { enabled: true } },
+    webUi: { openOnStart: true },
+    chromeDevtools: { enabled: false, port: 15166, chromePath: "" },
     port: 18080,
     gitTimeoutSeconds: 180,
     allowInterrupt: false,
@@ -495,6 +497,7 @@ function loadConfig(): AppConfig {
     };
     codex?: { enabled?: unknown; defaultAgent?: unknown; path?: unknown; command?: unknown; model?: unknown; alternativeModel?: unknown; effort?: unknown };
     ccc?: { DEEPSEEK_API_KEY?: unknown; DEEPSEEK_BASE_URL?: unknown; model?: unknown };
+    webUi?: { openOnStart?: unknown };
     chromeDevtools?: { enabled?: unknown; port?: unknown; chromePath?: unknown };
     rawStreamLogs?: unknown;
   };
@@ -510,6 +513,7 @@ function loadConfig(): AppConfig {
   const cursorRaw = (parsed.cursor ?? {}) as NonNullable<typeof parsed.cursor>;
   const codexRaw = (parsed.codex ?? {}) as NonNullable<typeof parsed.codex>;
   const cccRaw = (parsed.ccc ?? {}) as NonNullable<typeof parsed.ccc>;
+  const webUiRaw = (parsed.webUi ?? {}) as NonNullable<typeof parsed.webUi>;
   const chromeDevtoolsRaw = (parsed.chromeDevtools ?? {}) as NonNullable<typeof parsed.chromeDevtools>;
   const rawStreamLogsRaw = typeof parsed.rawStreamLogs === "object" && parsed.rawStreamLogs !== null
     ? parsed.rawStreamLogs as unknown as Record<string, unknown>
@@ -577,7 +581,7 @@ function loadConfig(): AppConfig {
       appId: feishu.appId ?? "",
       appSecret: feishu.appSecret ?? "",
     },
-    platforms: {
+    platforms: {
       feishu: {
         enabled: typeof (parsed.platforms as unknown as Record<string, unknown> | undefined)?.feishu === "object"
           ? Boolean(((parsed.platforms as unknown as Record<string, unknown>).feishu as Record<string, unknown>).enabled ?? true)
@@ -595,9 +599,13 @@ function loadConfig(): AppConfig {
         reuseTokenOnStart: typeof (parsed.platforms as unknown as Record<string, unknown> | undefined)?.ilink === "object"
           ? Boolean(((parsed.platforms as unknown as Record<string, unknown>).ilink as Record<string, unknown>).reuseTokenOnStart ?? true)
           : true,
-      },
-    },
-    chromeDevtools: {
+      },
+    },
+    webUi: {
+      // 兼容升级前没有 webUi 字段的 config.json：缺省仍按“自动打开”处理。
+      openOnStart: typeof webUiRaw.openOnStart === "boolean" ? webUiRaw.openOnStart : true,
+    },
+    chromeDevtools: {
       enabled: typeof chromeDevtoolsRaw.enabled === "boolean" ? chromeDevtoolsRaw.enabled : false,
       port: Number.isInteger(chromeDevtoolsPort) && chromeDevtoolsPort >= 1 && chromeDevtoolsPort <= 65535
         ? chromeDevtoolsPort