chatccc 0.2.184 → 0.2.185

package/src/chatgpt-subscription.ts

@@ -0,0 +1,299 @@
+import WebSocket from "ws";
+
+import { config } from "./config.ts";
+import { probeChromeCdp, type ChromeCdpProbeStatus } from "./chrome-devtools-guard.ts";
+
+const CDP_HOST = "127.0.0.1";
+const DEFAULT_CDP_PORT = 15166;
+const CDP_TIMEOUT_MS = 10_000;
+const CHATGPT_URL = "https://chatgpt.com/";
+
+type FetchLike = typeof fetch;
+
+export type ChatGptSubscriptionCode =
+  | "ok"
+  | "chrome_cdp_disabled"
+  | "chrome_cdp_unreachable"
+  | "chrome_cdp_occupied"
+  | "chatgpt_page_missing"
+  | "chatgpt_session_missing"
+  | "chatgpt_subscription_failed";
+
+export interface ChatGptSubscriptionResult {
+  ok: boolean;
+  code: ChatGptSubscriptionCode;
+  reason?: string;
+  chromeCdp: {
+    enabled: boolean;
+    port: number;
+    status: ChromeCdpProbeStatus | "skipped";
+  };
+  chatgpt?: {
+    sessionOk: boolean;
+    maskedEmail?: string;
+    sessionExpiresAt?: string;
+  };
+  subscription?: {
+    active: boolean;
+    plan: string | null;
+    expiresAt: string | null;
+    willRenew: boolean | null;
+    purchaseOriginPlatform: string | null;
+    remainingDays: number | null;
+  };
+}
+
+interface ChromeCdpPage {
+  id: string;
+  type: string;
+  title?: string;
+  url: string;
+  webSocketDebuggerUrl?: string;
+}
+
+interface BrowserProbeValue {
+  sessionStatus?: number;
+  sessionOk?: boolean;
+  hasAccessToken?: boolean;
+  maskedEmail?: string;
+  sessionExpires?: string;
+  account?: {
+    status: number;
+    ok: boolean;
+    entitlement: {
+      has_active_subscription?: unknown;
+      subscription_plan?: unknown;
+      expires_at?: unknown;
+    } | null;
+    last_active_subscription: {
+      will_renew?: unknown;
+      purchase_origin_platform?: unknown;
+    } | null;
+    detail?: unknown;
+    bodyPrefix?: string;
+  };
+  error?: string;
+}
+
+export interface ChatGptSubscriptionDeps {
+  fetchImpl?: FetchLike;
+  probeChromeCdpImpl?: typeof probeChromeCdp;
+  evaluateInPage?: (webSocketDebuggerUrl: string, expression: string) => Promise<unknown>;
+  now?: () => Date;
+}
+
+function normalizePort(value: unknown): number {
+  const port = Number(value);
+  return Number.isInteger(port) && port >= 1 && port <= 65535 ? port : DEFAULT_CDP_PORT;
+}
+
+function cdpBaseUrl(port: number): string {
+  return `http://${CDP_HOST}:${port}`;
+}
+
+function maskEmail(value: unknown): string | undefined {
+  if (typeof value !== "string" || !value.includes("@")) return undefined;
+  const [name, domain] = value.split("@");
+  if (!name || !domain) return undefined;
+  return `${name.slice(0, 2)}***@${domain}`;
+}
+
+function calculateRemainingDays(expiresAt: string | null, now: Date): number | null {
+  if (!expiresAt) return null;
+  const expires = new Date(expiresAt).getTime();
+  if (!Number.isFinite(expires)) return null;
+  return Math.max(0, Math.ceil((expires - now.getTime()) / 86_400_000));
+}
+
+async function fetchJson<T>(url: string, fetchImpl: FetchLike, init?: RequestInit): Promise<T> {
+  const response = await fetchImpl(url, init);
+  if (!response.ok) throw new Error(`HTTP ${response.status}`);
+  return await response.json() as T;
+}
+
+async function listCdpPages(port: number, fetchImpl: FetchLike): Promise<ChromeCdpPage[]> {
+  const pages = await fetchJson<unknown>(`${cdpBaseUrl(port)}/json/list`, fetchImpl);
+  return Array.isArray(pages)
+    ? pages.flatMap((raw): ChromeCdpPage[] => {
+      if (!raw || typeof raw !== "object") return [];
+      const page = raw as Partial<ChromeCdpPage>;
+      if (typeof page.id !== "string" || typeof page.type !== "string" || typeof page.url !== "string") return [];
+      return [{
+        id: page.id,
+        type: page.type,
+        title: typeof page.title === "string" ? page.title : undefined,
+        url: page.url,
+        webSocketDebuggerUrl: typeof page.webSocketDebuggerUrl === "string" ? page.webSocketDebuggerUrl : undefined,
+      }];
+    })
+    : [];
+}
+
+async function createChatGptPage(port: number, fetchImpl: FetchLike): Promise<ChromeCdpPage | null> {
+  const url = `${cdpBaseUrl(port)}/json/new?${encodeURIComponent(CHATGPT_URL)}`;
+  const response = await fetchImpl(url, { method: "PUT" });
+  if (!response.ok) return null;
+  const page = await response.json() as Partial<ChromeCdpPage>;
+  if (typeof page.id !== "string" || typeof page.webSocketDebuggerUrl !== "string") return null;
+  return {
+    id: page.id,
+    type: typeof page.type === "string" ? page.type : "page",
+    title: typeof page.title === "string" ? page.title : undefined,
+    url: typeof page.url === "string" ? page.url : CHATGPT_URL,
+    webSocketDebuggerUrl: page.webSocketDebuggerUrl,
+  };
+}
+
+async function closeCdpPage(port: number, pageId: string, fetchImpl: FetchLike): Promise<void> {
+  try {
+    await fetchImpl(`${cdpBaseUrl(port)}/json/close/${encodeURIComponent(pageId)}`);
+  } catch {
+    // Closing a temporary tab is best effort and must not change the query result.
+  }
+}
+
+function subscriptionProbeExpression(): string {
+  return `(async()=>{try{const sResp=await fetch('/api/auth/session',{credentials:'include',headers:{Accept:'application/json'}});const sText=await sResp.text();let s=null;try{s=JSON.parse(sText)}catch{}const token=s&&typeof s.accessToken==='string'?s.accessToken:'';const email=s&&s.user&&typeof s.user.email==='string'?s.user.email:'';let account=null;if(token){const r=await fetch('/backend-api/accounts/check/v4-2023-04-27?timezone_offset_min=-480',{credentials:'include',headers:{Accept:'application/json',Authorization:'Bearer '+token}});const text=await r.text();let data=null;try{data=JSON.parse(text)}catch{}const accounts=data&&data.accounts&&typeof data.accounts==='object'?data.accounts:null;const keys=accounts?Object.keys(accounts):[];const acc=accounts&&(accounts.default||accounts[keys[0]]);const ent=acc&&acc.entitlement;const last=acc&&acc.last_active_subscription;account={status:r.status,ok:r.ok,entitlement:ent?{has_active_subscription:ent.has_active_subscription,subscription_plan:ent.subscription_plan,expires_at:ent.expires_at}:null,last_active_subscription:last?{will_renew:last.will_renew,purchase_origin_platform:last.purchase_origin_platform}:null,detail:data&&data.detail?data.detail:undefined,bodyPrefix:data?undefined:text.slice(0,120)};}return {sessionStatus:sResp.status,sessionOk:sResp.ok,hasAccessToken:!!token,maskedEmail:(${maskEmail.toString()})(email),sessionExpires:s&&s.expires,account};}catch(e){return {error:String(e&&e.message||e)}}})()`;
+}
+
+async function evaluateInPage(webSocketDebuggerUrl: string, expression: string): Promise<unknown> {
+  return await new Promise((resolve, reject) => {
+    const ws = new WebSocket(webSocketDebuggerUrl);
+    const id = 1;
+    const timer = setTimeout(() => {
+      ws.close();
+      reject(new Error("CDP Runtime.evaluate timed out"));
+    }, CDP_TIMEOUT_MS);
+
+    ws.on("open", () => {
+      ws.send(JSON.stringify({
+        id,
+        method: "Runtime.evaluate",
+        params: { expression, awaitPromise: true, returnByValue: true },
+      }));
+    });
+    ws.on("message", (data) => {
+      const msg = JSON.parse(String(data)) as {
+        id?: number;
+        error?: unknown;
+        result?: { result?: { value?: unknown } };
+      };
+      if (msg.id !== id) return;
+      clearTimeout(timer);
+      ws.close();
+      if (msg.error) {
+        reject(new Error(JSON.stringify(msg.error)));
+      } else {
+        resolve(msg.result?.result?.value);
+      }
+    });
+    ws.on("error", (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+  });
+}
+
+function failure(
+  code: Exclude<ChatGptSubscriptionCode, "ok">,
+  reason: string,
+  chromeCdp: ChatGptSubscriptionResult["chromeCdp"],
+  extra: Partial<ChatGptSubscriptionResult> = {},
+): ChatGptSubscriptionResult {
+  return { ok: false, code, reason, chromeCdp, ...extra };
+}
+
+export function isExpectedSubscriptionFailure(code: ChatGptSubscriptionCode): boolean {
+  return code !== "chatgpt_subscription_failed";
+}
+
+export async function getChatGptSubscriptionStatus(
+  deps: ChatGptSubscriptionDeps = {},
+): Promise<ChatGptSubscriptionResult> {
+  const cfg = config.chromeDevtools;
+  const port = normalizePort(cfg.port);
+  const baseChromeCdp = { enabled: cfg.enabled, port };
+  const fetchImpl = deps.fetchImpl ?? fetch;
+
+  if (!cfg.enabled) {
+    return failure("chrome_cdp_disabled", "Chrome CDP guard is disabled in ChatCCC config.", {
+      ...baseChromeCdp,
+      status: "skipped",
+    });
+  }
+
+  const probe = await (deps.probeChromeCdpImpl ?? probeChromeCdp)(port, { fetchImpl });
+  const chromeCdp = { ...baseChromeCdp, status: probe };
+  if (probe === "unreachable") {
+    return failure("chrome_cdp_unreachable", `Chrome CDP endpoint is unreachable on port ${port}.`, chromeCdp);
+  }
+  if (probe === "occupied") {
+    return failure("chrome_cdp_occupied", `Port ${port} is reachable but is not a healthy Chrome CDP endpoint.`, chromeCdp);
+  }
+
+  let temporaryPage: ChromeCdpPage | null = null;
+  try {
+    const existingPages = await listCdpPages(port, fetchImpl);
+    let page = existingPages.find((p) =>
+      p.type === "page" &&
+      p.webSocketDebuggerUrl &&
+      p.url.startsWith(CHATGPT_URL)
+    ) ?? null;
+    if (!page) {
+      temporaryPage = await createChatGptPage(port, fetchImpl);
+      page = temporaryPage;
+    }
+    if (!page?.webSocketDebuggerUrl) {
+      return failure("chatgpt_page_missing", "No usable chatgpt.com page is available from Chrome CDP.", chromeCdp);
+    }
+
+    const raw = await (deps.evaluateInPage ?? evaluateInPage)(page.webSocketDebuggerUrl, subscriptionProbeExpression()) as BrowserProbeValue;
+    if (!raw || typeof raw !== "object") {
+      return failure("chatgpt_subscription_failed", "Chrome CDP returned an empty subscription probe result.", chromeCdp);
+    }
+    if (raw.error) {
+      return failure("chatgpt_subscription_failed", raw.error, chromeCdp);
+    }
+
+    const chatgpt = {
+      sessionOk: raw.sessionOk === true,
+      maskedEmail: raw.maskedEmail || undefined,
+      sessionExpiresAt: typeof raw.sessionExpires === "string" ? raw.sessionExpires : undefined,
+    };
+    if (!raw.hasAccessToken) {
+      return failure("chatgpt_session_missing", "ChatGPT browser session has no access token.", chromeCdp, { chatgpt });
+    }
+    if (!raw.account?.ok || !raw.account.entitlement) {
+      return failure(
+        "chatgpt_subscription_failed",
+        `ChatGPT account check failed${raw.account?.status ? ` with HTTP ${raw.account.status}` : ""}.`,
+        chromeCdp,
+        { chatgpt },
+      );
+    }
+
+    const entitlement = raw.account.entitlement;
+    const last = raw.account.last_active_subscription;
+    const expiresAt = typeof entitlement.expires_at === "string" ? entitlement.expires_at : null;
+    return {
+      ok: true,
+      code: "ok",
+      chromeCdp,
+      chatgpt,
+      subscription: {
+        active: entitlement.has_active_subscription === true,
+        plan: typeof entitlement.subscription_plan === "string" ? entitlement.subscription_plan : null,
+        expiresAt,
+        willRenew: typeof last?.will_renew === "boolean" ? last.will_renew : null,
+        purchaseOriginPlatform: typeof last?.purchase_origin_platform === "string" ? last.purchase_origin_platform : null,
+        remainingDays: calculateRemainingDays(expiresAt, deps.now?.() ?? new Date()),
+      },
+    };
+  } catch (err) {
+    return failure("chatgpt_subscription_failed", (err as Error).message, chromeCdp);
+  } finally {
+    if (temporaryPage) {
+      await closeCdpPage(port, temporaryPage.id, fetchImpl);
+    }
+  }
+}

package/src/chrome-devtools-guard.ts

@@ -0,0 +1,242 @@
+import { spawn, type ChildProcess } from "node:child_process";
+import { existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+
+import { appendStartupTrace } from "./shared.ts";
+import { config, ts, USER_DATA_DIR, type ChromeDevtoolsConfig } from "./config.ts";
+
+const CDP_HOST = "127.0.0.1";
+const DEFAULT_CDP_PORT = 15166;
+const HEALTH_TIMEOUT_MS = 3000;
+const START_VERIFY_ATTEMPTS = 10;
+const START_VERIFY_DELAY_MS = 500;
+const GUARD_INTERVAL_MS = 60_000;
+
+type FetchLike = typeof fetch;
+
+export interface ChromeDevtoolsGuardDeps {
+  fetchImpl?: FetchLike;
+  spawnImpl?: typeof spawn;
+  existsSyncImpl?: typeof existsSync;
+  mkdirSyncImpl?: typeof mkdirSync;
+  platform?: NodeJS.Platform;
+  env?: NodeJS.ProcessEnv;
+  log?: (message: string) => void;
+}
+
+export interface ChromeCdpEnsureResult {
+  ok: boolean;
+  started: boolean;
+  port: number;
+  error?: string;
+}
+
+export type ChromeCdpProbeStatus = "healthy" | "occupied" | "unreachable";
+
+let guardTimer: ReturnType<typeof setInterval> | null = null;
+let ensureInFlight: Promise<ChromeCdpEnsureResult> | null = null;
+
+function normalizePort(value: unknown): number {
+  const port = Number(value);
+  return Number.isInteger(port) && port >= 1 && port <= 65535 ? port : DEFAULT_CDP_PORT;
+}
+
+function chromeCandidates(platform: NodeJS.Platform, env: NodeJS.ProcessEnv): string[] {
+  if (platform === "win32") {
+    return [
+      env.ProgramFiles ? join(env.ProgramFiles, "Google", "Chrome", "Application", "chrome.exe") : "",
+      env["ProgramFiles(x86)"] ? join(env["ProgramFiles(x86)"]!, "Google", "Chrome", "Application", "chrome.exe") : "",
+      env.LOCALAPPDATA ? join(env.LOCALAPPDATA, "Google", "Chrome", "Application", "chrome.exe") : "",
+    ].filter(Boolean);
+  }
+
+  if (platform === "darwin") {
+    return ["/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"];
+  }
+
+  return [
+    "/usr/bin/google-chrome",
+    "/usr/bin/google-chrome-stable",
+    "/usr/bin/chromium",
+    "/usr/bin/chromium-browser",
+  ];
+}
+
+export function resolveChromeExecutable(
+  chromePath: string | undefined,
+  deps: Pick<ChromeDevtoolsGuardDeps, "existsSyncImpl" | "platform" | "env"> = {},
+): string | null {
+  const exists = deps.existsSyncImpl ?? existsSync;
+  const explicit = chromePath?.trim();
+  if (explicit) return exists(explicit) ? explicit : null;
+
+  for (const candidate of chromeCandidates(deps.platform ?? process.platform, deps.env ?? process.env)) {
+    if (exists(candidate)) return candidate;
+  }
+  return null;
+}
+
+export function resolveChromeUserDataDir(port: number, env: NodeJS.ProcessEnv = process.env): string {
+  const root = env.LOCALAPPDATA ? join(env.LOCALAPPDATA, "chatccc") : join(USER_DATA_DIR, "chrome-cdp");
+  return join(root, `chrome-cdp-${port}`);
+}
+
+async function fetchWithTimeout(url: string, fetchImpl: FetchLike, timeoutMs: number): Promise<Response> {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetchImpl(url, { signal: controller.signal });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+export async function probeChromeCdp(
+  port: number,
+  deps: Pick<ChromeDevtoolsGuardDeps, "fetchImpl"> = {},
+): Promise<ChromeCdpProbeStatus> {
+  const normalizedPort = normalizePort(port);
+  try {
+    const response = await fetchWithTimeout(
+      `http://${CDP_HOST}:${normalizedPort}/json/version`,
+      deps.fetchImpl ?? fetch,
+      HEALTH_TIMEOUT_MS,
+    );
+    if (!response.ok) return "occupied";
+    const data = await response.json() as Record<string, unknown>;
+    return typeof data.Browser === "string" || typeof data.webSocketDebuggerUrl === "string"
+      ? "healthy"
+      : "occupied";
+  } catch {
+    return "unreachable";
+  }
+}
+
+export async function isChromeCdpHealthy(
+  port: number,
+  deps: Pick<ChromeDevtoolsGuardDeps, "fetchImpl"> = {},
+): Promise<boolean> {
+  return (await probeChromeCdp(port, deps)) === "healthy";
+}
+
+function startChromeForCdp(
+  cfg: ChromeDevtoolsConfig,
+  deps: ChromeDevtoolsGuardDeps = {},
+): { ok: true; child: ChildProcess } | { ok: false; error: string } {
+  const port = normalizePort(cfg.port);
+  const chromeExe = resolveChromeExecutable(cfg.chromePath, deps);
+  if (!chromeExe) {
+    return { ok: false, error: "Cannot find chrome executable. Configure chromeDevtools.chromePath." };
+  }
+
+  const userDataDir = resolveChromeUserDataDir(port, deps.env ?? process.env);
+  try {
+    (deps.mkdirSyncImpl ?? mkdirSync)(userDataDir, { recursive: true });
+  } catch (err) {
+    return { ok: false, error: `Cannot create Chrome user data dir: ${(err as Error).message}` };
+  }
+
+  const args = [
+    `--remote-debugging-address=${CDP_HOST}`,
+    `--remote-debugging-port=${port}`,
+    `--user-data-dir=${userDataDir}`,
+    "--no-first-run",
+    "--no-default-browser-check",
+    "--new-window",
+    "about:blank",
+  ];
+
+  try {
+    const child = (deps.spawnImpl ?? spawn)(chromeExe, args, {
+      detached: true,
+      stdio: "ignore",
+      windowsHide: true,
+    });
+    child.unref();
+    return { ok: true, child };
+  } catch (err) {
+    return { ok: false, error: `Failed to start Chrome: ${(err as Error).message}` };
+  }
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export async function ensureChromeCdpRunning(
+  cfg: ChromeDevtoolsConfig = config.chromeDevtools,
+  deps: ChromeDevtoolsGuardDeps = {},
+): Promise<ChromeCdpEnsureResult> {
+  const port = normalizePort(cfg.port);
+  if (!cfg.enabled) return { ok: true, started: false, port };
+
+  const probe = await probeChromeCdp(port, deps);
+  if (probe === "healthy") {
+    return { ok: true, started: false, port };
+  }
+  if (probe === "occupied") {
+    return {
+      ok: false,
+      started: false,
+      port,
+      error: `Port ${port} is reachable but is not a healthy Chrome CDP endpoint.`,
+    };
+  }
+
+  const started = startChromeForCdp({ ...cfg, port }, deps);
+  if (!started.ok) return { ok: false, started: false, port, error: started.error };
+
+  for (let i = 0; i < START_VERIFY_ATTEMPTS; i++) {
+    await sleep(START_VERIFY_DELAY_MS);
+    if (await isChromeCdpHealthy(port, deps)) {
+      return { ok: true, started: true, port };
+    }
+  }
+
+  return { ok: false, started: true, port, error: "Chrome started but CDP endpoint is not healthy yet." };
+}
+
+async function runGuardOnce(reason: string, deps: ChromeDevtoolsGuardDeps = {}): Promise<void> {
+  if (ensureInFlight) return;
+  const log = deps.log ?? ((message: string) => console.log(message));
+  ensureInFlight = ensureChromeCdpRunning(config.chromeDevtools, deps);
+  try {
+    const result = await ensureInFlight;
+    appendStartupTrace("chrome-devtools-guard: ensure result", {
+      reason,
+      enabled: config.chromeDevtools.enabled,
+      port: result.port,
+      ok: result.ok,
+      started: result.started,
+      error: result.error,
+    });
+    if (!config.chromeDevtools.enabled) return;
+    if (result.ok && result.started) {
+      log(`[${ts()}] [Chrome CDP] Started Chrome for http://${CDP_HOST}:${result.port}/json/version`);
+    } else if (!result.ok) {
+      log(`[${ts()}] [Chrome CDP] Guard failed: ${result.error}`);
+    }
+  } finally {
+    ensureInFlight = null;
+  }
+}
+
+export function startChromeDevtoolsGuard(deps: ChromeDevtoolsGuardDeps = {}): void {
+  stopChromeDevtoolsGuard();
+  if (!config.chromeDevtools.enabled) {
+    appendStartupTrace("chrome-devtools-guard: disabled");
+    return;
+  }
+
+  void runGuardOnce("startup", deps);
+  guardTimer = setInterval(() => {
+    void runGuardOnce("interval", deps);
+  }, GUARD_INTERVAL_MS);
+}
+
+export function stopChromeDevtoolsGuard(): void {
+  if (guardTimer) {
+    clearInterval(guardTimer);
+    guardTimer = null;
+  }
+}

package/src/config.ts

@@ -113,9 +113,19 @@ export interface PlatformsConfig {
   ilink: PlatformConfig;
 }
 
+export interface ChromeDevtoolsConfig {
+  /** 是否由 ChatCCC 守护一个常驻 Chrome CDP 实例 */
+  enabled: boolean;
+  /** Chrome remote debugging 端口，默认 15166 */
+  port: number;
+  /** Chrome 可执行文件路径；留空时按常见安装位置自动探测 */
+  chromePath: string;
+}
+
 export interface AppConfig {
   feishu: FeishuConfig;
   platforms: PlatformsConfig;
+  chromeDevtools: ChromeDevtoolsConfig;
   port: number;
   gitTimeoutSeconds: number;
   /** 若为 false，AI 生成过程中用户发送消息不会打断，须先点「停止」再发送新消息 */
@@ -342,6 +352,7 @@ function loadConfig(): AppConfig {
   const defaults: AppConfig = {
     feishu: { appId: "", appSecret: "" },
     platforms: { feishu: { enabled: true }, ilink: { enabled: true } },
+    chromeDevtools: { enabled: false, port: 15166, chromePath: "" },
     port: 18080,
     gitTimeoutSeconds: 180,
     allowInterrupt: false,
@@ -406,6 +417,7 @@ function loadConfig(): AppConfig {
       onDemandMonthlyBudget?: unknown;
     };
     codex?: { enabled?: unknown; defaultAgent?: unknown; path?: unknown; command?: unknown; model?: unknown; effort?: unknown };
+    chromeDevtools?: { enabled?: unknown; port?: unknown; chromePath?: unknown };
   };
   try {
     parsed = JSON.parse(raw);
@@ -418,6 +430,7 @@ function loadConfig(): AppConfig {
   const claude = parsed.claude ?? {} as Partial<ClaudeConfig>;
   const cursorRaw = (parsed.cursor ?? {}) as NonNullable<typeof parsed.cursor>;
   const codexRaw = (parsed.codex ?? {}) as NonNullable<typeof parsed.codex>;
+  const chromeDevtoolsRaw = (parsed.chromeDevtools ?? {}) as NonNullable<typeof parsed.chromeDevtools>;
 
   // 兼容旧字段 `command`：命中时打印一次性 warning 提示用户改名
   const onLegacyField = (label: string, value: string): void => {
@@ -461,6 +474,7 @@ function loadConfig(): AppConfig {
   const claudeEnabled = resolveEnabled(claude.enabled, claudeNonEmpty);
   const cursorEnabled = resolveEnabled(cursorRaw.enabled, cursorNonEmpty);
   const codexEnabled = resolveEnabled(codexRaw.enabled, codexNonEmpty);
+  const chromeDevtoolsPort = Number(chromeDevtoolsRaw.port);
   const explicitDefaultTool: AgentTool | null =
     typeof claude.defaultAgent === "boolean" && claude.defaultAgent && claudeEnabled ? "claude" :
     typeof cursorRaw.defaultAgent === "boolean" && cursorRaw.defaultAgent && cursorEnabled ? "cursor" :
@@ -498,6 +512,13 @@ function loadConfig(): AppConfig {
           : true,
       },
     },
+    chromeDevtools: {
+      enabled: typeof chromeDevtoolsRaw.enabled === "boolean" ? chromeDevtoolsRaw.enabled : false,
+      port: Number.isInteger(chromeDevtoolsPort) && chromeDevtoolsPort >= 1 && chromeDevtoolsPort <= 65535
+        ? chromeDevtoolsPort
+        : 15166,
+      chromePath: normalizeOptionalConfigField(chromeDevtoolsRaw.chromePath, { label: "chromeDevtools.chromePath" }),
+    },
     port: typeof parsed.port === "number" ? parsed.port : 18080,
     gitTimeoutSeconds: typeof parsed.gitTimeoutSeconds === "number" ? parsed.gitTimeoutSeconds : 180,
     allowInterrupt: typeof parsed.allowInterrupt === "boolean" ? parsed.allowInterrupt : false,

package/src/index.ts

@@ -82,6 +82,7 @@ import { handleAgentImageRequest } from "./agent-image-rpc.ts";
 import { handleAgentFileRequest } from "./agent-file-rpc.ts";
 import { handleAgentDelegateTaskRequest } from "./agent-delegate-task-rpc.ts";
 import { handleAgentStopStuckRequest } from "./agent-stop-stuck.ts";
+import { handleChatGptSubscriptionRequest } from "./chatgpt-subscription-rpc.ts";
 import { applyPrivacy } from "./privacy.ts";
 import {
   createCardKitCard,
@@ -98,6 +99,7 @@ import {
   setSessionPlatform,
   startUnifiedDisplayLoop,
 } from "./session.ts";
+import { startChromeDevtoolsGuard, stopChromeDevtoolsGuard } from "./chrome-devtools-guard.ts";
 import {
   rebuildSessionChatsFromRegistry,
   setQueueConsumer,
@@ -711,7 +713,8 @@ async function main(): Promise<void> {
       return (await handleAgentImageRequest(req, res))
         || (await handleAgentFileRequest(req, res))
         || (await handleAgentDelegateTaskRequest(req, res, feishuPlatform))
-        || (await handleAgentStopStuckRequest(req, res));
+        || (await handleAgentStopStuckRequest(req, res))
+        || (await handleChatGptSubscriptionRequest(req, res));
     });
 
     const simServer = createServer(createUiRouter());
@@ -765,6 +768,7 @@ async function main(): Promise<void> {
   setReloadConfigHook(() => {
     reloadConfigFromDisk();
     clearAdapterCache();
+    startChromeDevtoolsGuard();
     appendStartupTrace("reload-from-ui: config reloaded", {
       appIdMask: maskAppId(APP_ID),
     });
@@ -773,7 +777,8 @@ async function main(): Promise<void> {
     return (await handleAgentImageRequest(req, res))
       || (await handleAgentFileRequest(req, res))
       || (await handleAgentDelegateTaskRequest(req, res, feishuPlatform))
-      || (await handleAgentStopStuckRequest(req, res));
+      || (await handleAgentStopStuckRequest(req, res))
+      || (await handleChatGptSubscriptionRequest(req, res));
   });
 
   console.log(`[启动 2/7] 环境与凭证检查`);
@@ -793,6 +798,7 @@ async function main(): Promise<void> {
         onActivate: async (httpServer: Server) => {
           reloadConfigFromDisk();
           clearAdapterCache();
+          startChromeDevtoolsGuard();
           appendStartupTrace("setup-activate: reloaded config from disk", {
             appIdMaskAfterReload: maskAppId(APP_ID),
           });
@@ -817,6 +823,8 @@ async function main(): Promise<void> {
     appendStartupTrace("main: feishu disabled", {});
   }
 
+  startChromeDevtoolsGuard();
+
   // 启动 HTTP server（同时挂 UI router，供 dashboard / setup / agent image/file 使用）
   appendStartupTrace("main: before freeRelayListenPort", { CHATCCC_PORT });
   const killed = freeRelayListenPort(CHATCCC_PORT);
@@ -877,8 +885,8 @@ async function listenWithRetry(
  * 先写盘，再走这里。
  */
 function installShutdownHandlers(httpServer: Server): void {
-  process.on("SIGINT", () => { console.log("\nShutting down..."); wechatSignal.stopped = true; httpServer.close(); process.exit(0); });
-  process.on("SIGTERM", () => { wechatSignal.stopped = true; httpServer.close(); process.exit(0); });
+  process.on("SIGINT", () => { console.log("\nShutting down..."); wechatSignal.stopped = true; stopChromeDevtoolsGuard(); httpServer.close(); process.exit(0); });
+  process.on("SIGTERM", () => { wechatSignal.stopped = true; stopChromeDevtoolsGuard(); httpServer.close(); process.exit(0); });
 }
 
 main().catch((err: Error) => {