chatccc 0.2.184 → 0.2.185

package/src/__tests__/chatgpt-subscription.test.ts

@@ -0,0 +1,135 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import { config } from "../config.ts";
+import { getChatGptSubscriptionStatus } from "../chatgpt-subscription.ts";
+
+describe("ChatGPT subscription lookup", () => {
+  beforeEach(() => {
+    config.chromeDevtools = { enabled: true, port: 15166, chromePath: "" };
+  });
+
+  it("returns disabled without probing the port when Chrome CDP is off", async () => {
+    config.chromeDevtools = { enabled: false, port: 15166, chromePath: "" };
+    const probeChromeCdpImpl = vi.fn();
+    const fetchImpl = vi.fn() as unknown as typeof fetch;
+
+    await expect(getChatGptSubscriptionStatus({ probeChromeCdpImpl, fetchImpl })).resolves.toMatchObject({
+      ok: false,
+      code: "chrome_cdp_disabled",
+      chromeCdp: { enabled: false, port: 15166, status: "skipped" },
+    });
+    expect(probeChromeCdpImpl).not.toHaveBeenCalled();
+    expect(fetchImpl).not.toHaveBeenCalled();
+  });
+
+  it("returns occupied when the configured port is not a healthy Chrome CDP endpoint", async () => {
+    await expect(getChatGptSubscriptionStatus({
+      probeChromeCdpImpl: vi.fn(async () => "occupied" as const),
+    })).resolves.toMatchObject({
+      ok: false,
+      code: "chrome_cdp_occupied",
+      reason: expect.stringContaining("not a healthy Chrome CDP endpoint"),
+    });
+  });
+
+  it("returns page missing when CDP has no ChatGPT page and cannot create one", async () => {
+    const fetchImpl = vi.fn(async (url: string | URL | Request) => {
+      const text = String(url);
+      if (text.endsWith("/json/list")) return new Response(JSON.stringify([]), { status: 200 });
+      if (text.includes("/json/new?")) return new Response("nope", { status: 500 });
+      throw new Error(`unexpected fetch: ${text}`);
+    }) as unknown as typeof fetch;
+
+    await expect(getChatGptSubscriptionStatus({
+      fetchImpl,
+      probeChromeCdpImpl: vi.fn(async () => "healthy" as const),
+    })).resolves.toMatchObject({
+      ok: false,
+      code: "chatgpt_page_missing",
+    });
+  });
+
+  it("closes only the temporary ChatGPT page created for this lookup", async () => {
+    const closed: string[] = [];
+    const fetchImpl = vi.fn(async (url: string | URL | Request) => {
+      const text = String(url);
+      if (text.endsWith("/json/list")) return new Response(JSON.stringify([]), { status: 200 });
+      if (text.includes("/json/new?")) {
+        return new Response(JSON.stringify({
+          id: "temp-page",
+          type: "page",
+          url: "https://chatgpt.com/",
+          webSocketDebuggerUrl: "ws://cdp/temp-page",
+        }), { status: 200 });
+      }
+      if (text.endsWith("/json/close/temp-page")) {
+        closed.push("temp-page");
+        return new Response("Target is closing", { status: 200 });
+      }
+      throw new Error(`unexpected fetch: ${text}`);
+    }) as unknown as typeof fetch;
+
+    await expect(getChatGptSubscriptionStatus({
+      fetchImpl,
+      probeChromeCdpImpl: vi.fn(async () => "healthy" as const),
+      evaluateInPage: vi.fn(async () => ({
+        sessionOk: true,
+        hasAccessToken: true,
+        maskedEmail: "gg***@gmail.com",
+        sessionExpires: "2026-09-20T09:30:07.340Z",
+        account: {
+          status: 200,
+          ok: true,
+          entitlement: {
+            has_active_subscription: true,
+            subscription_plan: "chatgptprolite",
+            expires_at: "2026-07-12T10:20:11+00:00",
+          },
+          last_active_subscription: {
+            will_renew: false,
+            purchase_origin_platform: "chatgpt_web",
+          },
+        },
+      })),
+      now: () => new Date("2026-06-22T00:00:00+08:00"),
+    })).resolves.toMatchObject({
+      ok: true,
+      code: "ok",
+      subscription: {
+        plan: "chatgptprolite",
+        expiresAt: "2026-07-12T10:20:11+00:00",
+        willRenew: false,
+        remainingDays: 21,
+      },
+    });
+    expect(closed).toEqual(["temp-page"]);
+  });
+
+  it("does not close an existing ChatGPT page", async () => {
+    const fetchImpl = vi.fn(async (url: string | URL | Request) => {
+      const text = String(url);
+      if (text.endsWith("/json/list")) {
+        return new Response(JSON.stringify([{
+          id: "existing-page",
+          type: "page",
+          url: "https://chatgpt.com/",
+          webSocketDebuggerUrl: "ws://cdp/existing-page",
+        }]), { status: 200 });
+      }
+      if (text.includes("/json/close/")) throw new Error("should not close existing page");
+      throw new Error(`unexpected fetch: ${text}`);
+    }) as unknown as typeof fetch;
+
+    await expect(getChatGptSubscriptionStatus({
+      fetchImpl,
+      probeChromeCdpImpl: vi.fn(async () => "healthy" as const),
+      evaluateInPage: vi.fn(async () => ({
+        sessionOk: true,
+        hasAccessToken: false,
+      })),
+    })).resolves.toMatchObject({
+      ok: false,
+      code: "chatgpt_session_missing",
+    });
+  });
+});

package/src/__tests__/chrome-devtools-guard.test.ts

@@ -0,0 +1,125 @@
+import { describe, expect, it, vi } from "vitest";
+import { spawn } from "node:child_process";
+
+import {
+  ensureChromeCdpRunning,
+  isChromeCdpHealthy,
+  probeChromeCdp,
+  resolveChromeExecutable,
+  resolveChromeUserDataDir,
+} from "../chrome-devtools-guard.ts";
+
+describe("Chrome CDP guard", () => {
+  it("treats /json/version with Browser as healthy", async () => {
+    const fetchImpl = vi.fn(async () =>
+      new Response(JSON.stringify({ Browser: "Chrome/144.0.0.0" }), { status: 200 }),
+    ) as unknown as typeof fetch;
+
+    await expect(isChromeCdpHealthy(15166, { fetchImpl })).resolves.toBe(true);
+  });
+
+  it("does not spawn Chrome when the CDP endpoint is already healthy", async () => {
+    const fetchImpl = vi.fn(async () =>
+      new Response(JSON.stringify({ webSocketDebuggerUrl: "ws://127.0.0.1:15166/devtools/browser/1" }), { status: 200 }),
+    ) as unknown as typeof fetch;
+    const spawnImpl = vi.fn() as unknown as typeof spawn;
+
+    await expect(
+      ensureChromeCdpRunning(
+        { enabled: true, port: 15166, chromePath: "C:/Chrome/chrome.exe" },
+        { fetchImpl, spawnImpl },
+      ),
+    ).resolves.toEqual({ ok: true, started: false, port: 15166 });
+    expect(spawnImpl).not.toHaveBeenCalled();
+  });
+
+  it("spawns Chrome with a dedicated profile when the endpoint is unhealthy", async () => {
+    const fetchImpl = vi.fn()
+      .mockRejectedValueOnce(new Error("ECONNREFUSED"))
+      .mockResolvedValue(new Response(JSON.stringify({ Browser: "Chrome/144.0.0.0" }), { status: 200 })) as unknown as typeof fetch;
+    const unref = vi.fn();
+    const spawnImpl = vi.fn(() => ({ unref })) as unknown as typeof spawn;
+    const mkdirSyncImpl = vi.fn();
+
+    await expect(
+      ensureChromeCdpRunning(
+        { enabled: true, port: 15166, chromePath: "C:/Chrome/chrome.exe" },
+        {
+          fetchImpl,
+          spawnImpl,
+          mkdirSyncImpl: mkdirSyncImpl as never,
+          existsSyncImpl: vi.fn(() => true),
+          env: { LOCALAPPDATA: "C:/Users/me/AppData/Local" },
+        },
+      ),
+    ).resolves.toEqual({ ok: true, started: true, port: 15166 });
+
+    expect(mkdirSyncImpl).toHaveBeenCalledWith("C:\\Users\\me\\AppData\\Local\\chatccc\\chrome-cdp-15166", { recursive: true });
+    expect(spawnImpl).toHaveBeenCalledWith(
+      "C:/Chrome/chrome.exe",
+      expect.arrayContaining([
+        "--remote-debugging-address=127.0.0.1",
+        "--remote-debugging-port=15166",
+        "--user-data-dir=C:\\Users\\me\\AppData\\Local\\chatccc\\chrome-cdp-15166",
+        "--new-window",
+        "about:blank",
+      ]),
+      expect.objectContaining({ detached: true, stdio: "ignore", windowsHide: true }),
+    );
+    expect(unref).toHaveBeenCalled();
+  });
+
+  it("does not spawn Chrome when the port is occupied by a non-CDP service", async () => {
+    const fetchImpl = vi.fn(async () => new Response("not found", { status: 404 })) as unknown as typeof fetch;
+    const spawnImpl = vi.fn() as unknown as typeof spawn;
+
+    await expect(probeChromeCdp(15166, { fetchImpl })).resolves.toBe("occupied");
+    await expect(
+      ensureChromeCdpRunning(
+        { enabled: true, port: 15166, chromePath: "C:/Chrome/chrome.exe" },
+        { fetchImpl, spawnImpl },
+      ),
+    ).resolves.toMatchObject({
+      ok: false,
+      started: false,
+      port: 15166,
+      error: expect.stringContaining("not a healthy Chrome CDP endpoint"),
+    });
+    expect(spawnImpl).not.toHaveBeenCalled();
+  });
+
+  it("reports a clear error when Chrome cannot be found", async () => {
+    const fetchImpl = vi.fn(async () => { throw new Error("ECONNREFUSED"); }) as unknown as typeof fetch;
+
+    await expect(
+      ensureChromeCdpRunning(
+        { enabled: true, port: 15166, chromePath: "" },
+        {
+          fetchImpl,
+          existsSyncImpl: vi.fn(() => false),
+          platform: "win32",
+          env: {},
+        },
+      ),
+    ).resolves.toMatchObject({
+      ok: false,
+      started: false,
+      port: 15166,
+      error: expect.stringContaining("Cannot find chrome executable"),
+    });
+  });
+
+  it("resolves explicit and default Chrome paths", () => {
+    expect(resolveChromeExecutable("C:/Chrome/chrome.exe", { existsSyncImpl: vi.fn(() => true) })).toBe("C:/Chrome/chrome.exe");
+    expect(resolveChromeExecutable("", {
+      existsSyncImpl: vi.fn((p: unknown) => String(p).endsWith("Google\\Chrome\\Application\\chrome.exe")),
+      platform: "win32",
+      env: { ProgramFiles: "C:/Program Files" },
+    })).toBe("C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe");
+  });
+
+  it("uses LocalAppData for the Chrome CDP user data directory", () => {
+    expect(resolveChromeUserDataDir(15166, { LOCALAPPDATA: "C:/Users/me/AppData/Local" }))
+      .toBe("C:\\Users\\me\\AppData\\Local\\chatccc\\chrome-cdp-15166");
+  });
+});

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

@@ -40,6 +40,7 @@ import {
 const baseAppConfig: AppConfig = {
   feishu: { appId: "INITIAL_APP", appSecret: "INITIAL_SECRET" },
   platforms: { feishu: { enabled: true }, ilink: { enabled: true } },
+  chromeDevtools: { enabled: false, port: 15166, chromePath: "" },
   port: 18080,
   gitTimeoutSeconds: 180,
   allowInterrupt: false,
@@ -195,6 +196,18 @@ describe("applyLoadedConfig — config 对象引用契约", () => {
     expect(config.codex.path).toBe("/refresh/codex");
   });
 
+  it("刷新 chromeDevtools 配置但保持 config 引用", () => {
+    const refBefore = config;
+
+    applyLoadedConfig({
+      ...structuredClone(baseAppConfig),
+      chromeDevtools: { enabled: true, port: 15166, chromePath: "C:/Chrome/chrome.exe" },
+    });
+
+    expect(config).toBe(refBefore);
+    expect(config.chromeDevtools).toEqual({ enabled: true, port: 15166, chromePath: "C:/Chrome/chrome.exe" });
+  });
+
   it("空 feishu 凭证也能正确刷入（向导回滚到空的反向场景）", () => {
     applyLoadedConfig({
       ...structuredClone(baseAppConfig),

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

@@ -27,4 +27,15 @@ describe("config.sample.json", () => {
     expect(sample.claude?.model).toBe("");
     expect(sample.claude?.subagentModel).toBe("");
   });
+
+  it("keeps Chrome CDP guard disabled by default with port 15166", () => {
+    const configSamplePath = join(process.cwd(), "config.sample.json");
+    const sample = JSON.parse(readFileSync(configSamplePath, "utf8")) as {
+      chromeDevtools?: { enabled?: unknown; port?: unknown; chromePath?: unknown };
+    };
+
+    expect(sample.chromeDevtools?.enabled).toBe(false);
+    expect(sample.chromeDevtools?.port).toBe(15166);
+    expect(sample.chromeDevtools?.chromePath).toBe("");
+  });
 });

package/src/__tests__/orchestrator.test.ts

@@ -9,6 +9,7 @@ import type { SessionInfo, ToolAdapter } from "../adapters/adapter-interface.ts"
 const mockStreamStates = new Map<string, { status: "running" | "done" | "stopped"; finalReply: string }>();
 const mockGetCodexUsageSummary = vi.hoisted(() => vi.fn());
 const mockGetCursorUsageSummary = vi.hoisted(() => vi.fn());
+const mockGetChatGptSubscriptionStatus = vi.hoisted(() => vi.fn());
 
 vi.mock("../im-skills.ts", () => ({
   buildImSkillsPrompt: async () => "",
@@ -64,9 +65,13 @@ vi.mock("../cursor-usage.ts", () => ({
   getCursorUsageSummary: mockGetCursorUsageSummary,
 }));
 
+vi.mock("../chatgpt-subscription.ts", () => ({
+  getChatGptSubscriptionStatus: mockGetChatGptSubscriptionStatus,
+}));
+
 import { handleCommand } from "../orchestrator.ts";
-import {
-  _clearAdapterCacheForTest,
+import {
+  _clearAdapterCacheForTest,
   _resetSessionRegistryFileForTest,
   _resetSessionToolsFileForTest,
   _setAdapterForToolForTest,
@@ -74,10 +79,10 @@ import {
   _setSessionToolsFileForTest,
   loadSessionRegistryForBinding,
   recordSessionRegistry,
-  resetState,
-} from "../session.ts";
-import { activePrompts, resetBindingState } from "../session-chat-binding.ts";
-import { ABD_APPEND_PROMPT } from "../shared-prefix.ts";
+  resetState,
+} from "../session.ts";
+import { activePrompts, resetBindingState } from "../session-chat-binding.ts";
+import { ABD_APPEND_PROMPT } from "../shared-prefix.ts";
 
 function mockPlatform(kind: "wechat" | "feishu" = "wechat"): PlatformAdapter {
   return {
@@ -129,12 +134,13 @@ describe("handleCommand WeChat processing ack", () => {
     mockStreamStates.clear();
     mockGetCodexUsageSummary.mockReset();
     mockGetCursorUsageSummary.mockReset();
-    mockGetCodexUsageSummary.mockResolvedValue({
-      fiveHour: { usedPercent: 0, remainingPercent: 100, resetAtEpochSeconds: null, resetAfterSeconds: null },
-      weekly: { usedPercent: 0, remainingPercent: 100, resetAtEpochSeconds: null, resetAfterSeconds: null },
-      rateLimitResetCreditsAvailable: null,
-      rateLimitResetCredits: null,
-    });
+    mockGetChatGptSubscriptionStatus.mockReset();
+    mockGetCodexUsageSummary.mockResolvedValue({
+      fiveHour: { usedPercent: 0, remainingPercent: 100, resetAtEpochSeconds: null, resetAfterSeconds: null },
+      weekly: { usedPercent: 0, remainingPercent: 100, resetAtEpochSeconds: null, resetAfterSeconds: null },
+      rateLimitResetCreditsAvailable: null,
+      rateLimitResetCredits: null,
+    });
     mockGetCursorUsageSummary.mockResolvedValue({
       billingCycleStart: "1779357999000",
       billingCycleEnd: "1782036399000",
@@ -160,6 +166,12 @@ describe("handleCommand WeChat processing ack", () => {
       displayMessage: "You've hit your usage limit",
       autoBucketModels: ["default"],
     });
+    mockGetChatGptSubscriptionStatus.mockResolvedValue({
+      ok: false,
+      code: "chrome_cdp_disabled",
+      reason: "Chrome CDP guard is disabled in ChatCCC config.",
+      chromeCdp: { enabled: false, port: 15166, status: "skipped" },
+    });
     _setAdapterForToolForTest("claude", mockAdapter());
   });
 
@@ -200,8 +212,8 @@ describe("handleCommand WeChat processing ack", () => {
     expect(platform.sendCard).not.toHaveBeenCalled();
   });
 
-  it("sends the WeChat processing ack after the busy check for normal prompts", async () => {
-    const platform = mockPlatform();
+  it("sends the WeChat processing ack after the busy check for normal prompts", async () => {
+    const platform = mockPlatform();
     await recordSessionRegistry({
       chatId: "wx-chat",
       sessionId: "sid-wechat",
@@ -211,44 +223,44 @@ describe("handleCommand WeChat processing ack", () => {
     });
 
     await handleCommand(platform, "继续说明", "wx-chat", "wx-user", Date.now(), "p2p");
-
-    expect(platform.sendText).toHaveBeenCalledWith("wx-chat", "生成中...");
-  });
-
-  it("treats /abd as a shared prompt prefix in an existing session", async () => {
-    const platform = mockPlatform();
-    const prompt = vi.fn(async function* (_sessionId: string, userText: string) {
-      yield {
-        type: "assistant" as const,
-        blocks: [{ type: "text" as const, text: "done" }],
-      };
-    });
-    _setAdapterForToolForTest("claude", {
-      displayName: "Claude",
-      sessionDescPrefix: "Claude Session:",
-      createSession: vi.fn(async () => ({ sessionId: "sid-wechat" })),
-      prompt,
-      getSessionInfo: async (sessionId: string): Promise<SessionInfo> => ({
-        sessionId,
-        cwd: "F:\\repo",
-      }),
-      closeSession: async () => {},
-    });
-    await recordSessionRegistry({
-      chatId: "wx-chat",
-      sessionId: "sid-wechat",
-      tool: "claude",
-      chatName: "ready-session",
-      running: false,
-    });
-
-    await handleCommand(platform, "/abd帮我分析", "wx-chat", "wx-user", Date.now(), "p2p");
-
-    expect(platform.sendText).toHaveBeenCalledWith("wx-chat", "生成中...");
-    const userText = prompt.mock.calls[0][1];
-    expect(userText).toContain(`[User message]\n帮我分析\n\n---\n${ABD_APPEND_PROMPT}\n[/User message]`);
-    expect(userText).not.toContain("/abd");
-  });
+
+    expect(platform.sendText).toHaveBeenCalledWith("wx-chat", "生成中...");
+  });
+
+  it("treats /abd as a shared prompt prefix in an existing session", async () => {
+    const platform = mockPlatform();
+    const prompt = vi.fn(async function* (_sessionId: string, userText: string) {
+      yield {
+        type: "assistant" as const,
+        blocks: [{ type: "text" as const, text: "done" }],
+      };
+    });
+    _setAdapterForToolForTest("claude", {
+      displayName: "Claude",
+      sessionDescPrefix: "Claude Session:",
+      createSession: vi.fn(async () => ({ sessionId: "sid-wechat" })),
+      prompt,
+      getSessionInfo: async (sessionId: string): Promise<SessionInfo> => ({
+        sessionId,
+        cwd: "F:\\repo",
+      }),
+      closeSession: async () => {},
+    });
+    await recordSessionRegistry({
+      chatId: "wx-chat",
+      sessionId: "sid-wechat",
+      tool: "claude",
+      chatName: "ready-session",
+      running: false,
+    });
+
+    await handleCommand(platform, "/abd帮我分析", "wx-chat", "wx-user", Date.now(), "p2p");
+
+    expect(platform.sendText).toHaveBeenCalledWith("wx-chat", "生成中...");
+    const userText = prompt.mock.calls[0][1];
+    expect(userText).toContain(`[User message]\n帮我分析\n\n---\n${ABD_APPEND_PROMPT}\n[/User message]`);
+    expect(userText).not.toContain("/abd");
+  });
 
   it("does not send the stopped success text until the running prompt really exits", async () => {
     const platform = mockPlatform();
@@ -270,7 +282,7 @@ describe("handleCommand WeChat processing ack", () => {
     expect(platform.sendText).not.toHaveBeenCalledWith("wx-chat", "会话已停止。");
   });
 
-  it("cleans stale Feishu p2p binding, creates a group, and sends the private message as first prompt", async () => {
+  it("cleans stale Feishu p2p binding, creates a group, and sends the private message as first prompt", async () => {
     const platform = mockPlatform("feishu");
     const prompt = vi.fn(async function* (_sessionId: string, userText: string) {
       yield {
@@ -315,40 +327,40 @@ describe("handleCommand WeChat processing ack", () => {
 
     const registry = await loadSessionRegistryForBinding();
     expect(registry["feishu-p2p"]).toBeUndefined();
-    expect(registry["feishu-group"]?.sessionId).toBe("sid-feishu-new");
-  });
-
-  it("auto-creates a Feishu group for /abd private messages and sends the transformed prompt", async () => {
-    const platform = mockPlatform("feishu");
-    const prompt = vi.fn(async function* (_sessionId: string, userText: string) {
-      yield {
-        type: "assistant" as const,
-        blocks: [{ type: "text" as const, text: "done" }],
-      };
-    });
-    _setAdapterForToolForTest("claude", {
-      displayName: "Claude",
-      sessionDescPrefix: "Claude Session:",
-      createSession: vi.fn(async () => ({ sessionId: "sid-feishu-abd" })),
-      prompt,
-      getSessionInfo: async (sessionId: string): Promise<SessionInfo> => ({
-        sessionId,
-        cwd: "F:\\repo",
-      }),
-      closeSession: async () => {},
-    });
-
-    await handleCommand(platform, "/abd帮我看一下日志", "feishu-p2p", "ou-user", Date.now(), "p2p");
-
-    expect(platform.createGroup).toHaveBeenCalledWith(expect.stringContaining("帮我看一下日志"), ["ou-user"]);
-    expect(platform.createGroup).not.toHaveBeenCalledWith(expect.stringContaining("---"), expect.anything());
-    const updateCall = vi.mocked(platform.updateChatInfo).mock.calls[0];
-    expect(updateCall[1]).not.toContain("---");
-    expect(updateCall[1]).not.toContain(ABD_APPEND_PROMPT);
-    const userText = prompt.mock.calls[0][1];
-    expect(userText).toContain(`[User message]\n帮我看一下日志\n\n---\n${ABD_APPEND_PROMPT}\n[/User message]`);
-    expect(userText).not.toContain("/abd");
-  });
+    expect(registry["feishu-group"]?.sessionId).toBe("sid-feishu-new");
+  });
+
+  it("auto-creates a Feishu group for /abd private messages and sends the transformed prompt", async () => {
+    const platform = mockPlatform("feishu");
+    const prompt = vi.fn(async function* (_sessionId: string, userText: string) {
+      yield {
+        type: "assistant" as const,
+        blocks: [{ type: "text" as const, text: "done" }],
+      };
+    });
+    _setAdapterForToolForTest("claude", {
+      displayName: "Claude",
+      sessionDescPrefix: "Claude Session:",
+      createSession: vi.fn(async () => ({ sessionId: "sid-feishu-abd" })),
+      prompt,
+      getSessionInfo: async (sessionId: string): Promise<SessionInfo> => ({
+        sessionId,
+        cwd: "F:\\repo",
+      }),
+      closeSession: async () => {},
+    });
+
+    await handleCommand(platform, "/abd帮我看一下日志", "feishu-p2p", "ou-user", Date.now(), "p2p");
+
+    expect(platform.createGroup).toHaveBeenCalledWith(expect.stringContaining("帮我看一下日志"), ["ou-user"]);
+    expect(platform.createGroup).not.toHaveBeenCalledWith(expect.stringContaining("---"), expect.anything());
+    const updateCall = vi.mocked(platform.updateChatInfo).mock.calls[0];
+    expect(updateCall[1]).not.toContain("---");
+    expect(updateCall[1]).not.toContain(ABD_APPEND_PROMPT);
+    const userText = prompt.mock.calls[0][1];
+    expect(userText).toContain(`[User message]\n帮我看一下日志\n\n---\n${ABD_APPEND_PROMPT}\n[/User message]`);
+    expect(userText).not.toContain("/abd");
+  });
 
   it("cleans stale Feishu p2p binding but keeps valid commands from auto-creating a group", async () => {
     const platform = mockPlatform("feishu");
@@ -370,35 +382,68 @@ describe("handleCommand WeChat processing ack", () => {
 
   it("handles /usage without creating a new Feishu group", async () => {
     const platform = mockPlatform("feishu");
-    mockGetCodexUsageSummary.mockResolvedValue({
-      fiveHour: { usedPercent: 37, remainingPercent: 63, resetAtEpochSeconds: 1781528212, resetAfterSeconds: 10349 },
-      weekly: { usedPercent: 12, remainingPercent: 88, resetAtEpochSeconds: 1781842926, resetAfterSeconds: 325063 },
-      rateLimitResetCreditsAvailable: 2,
-      rateLimitResetCredits: [
-        { grantedAt: "2026-06-12T04:01:47.770016Z", expiresAt: "2026-07-12T04:01:47.770016Z" },
-        { grantedAt: "2026-06-18T00:44:23.904386Z", expiresAt: "2026-07-18T00:44:23.904386Z" },
-      ],
-    });
-
-    await handleCommand(platform, "/usage", "feishu-p2p", "ou-user", Date.now(), "p2p");
-
-    expect(platform.createGroup).not.toHaveBeenCalled();
-    expect(platform.sendCard).not.toHaveBeenCalled();
-    expect(platform.sendRawCard).toHaveBeenCalledTimes(1);
-    const card = JSON.parse(vi.mocked(platform.sendRawCard).mock.calls[0][1]);
-    expect(card.header.title.content).toBe("Codex Usage");
-    expect(card.elements[0].text.content).toContain("2026-07-12");
-    expect(card.elements[0].text.content).toContain("2026-07-18");
-    expect(card.elements[0].text.content).toContain("**主动重置:** 剩余 2 次");
-    expect(card.elements[0].text.content).toContain("**5h:** 已用 37%，剩余 63%，重置:");
-    expect(card.elements[0].text.content).toContain("约 2小时52分钟后");
-    expect(card.elements[0].text.content).toContain("[███████░░░░░░░░░░░░░]");
-    expect(card.elements[0].text.content).toContain("**周:** 已用 12%，剩余 88%，重置:");
-    expect(card.elements[0].text.content).toContain("约 3天18小时17分钟后");
-    expect(card.elements[0].text.content).toContain("[██░░░░░░░░░░░░░░░░░░]");
-    expect(card.elements[2].actions[0].text.content).toBe("发起重置");
-    expect(card.elements[2].actions[0].value).toEqual({ action: "codex_reset_request", availableCount: 2 });
-  });
+    mockGetCodexUsageSummary.mockResolvedValue({
+      fiveHour: { usedPercent: 37, remainingPercent: 63, resetAtEpochSeconds: 1781528212, resetAfterSeconds: 10349 },
+      weekly: { usedPercent: 12, remainingPercent: 88, resetAtEpochSeconds: 1781842926, resetAfterSeconds: 325063 },
+      rateLimitResetCreditsAvailable: 2,
+      rateLimitResetCredits: [
+        { grantedAt: "2026-06-12T04:01:47.770016Z", expiresAt: "2026-07-12T04:01:47.770016Z" },
+        { grantedAt: "2026-06-18T00:44:23.904386Z", expiresAt: "2026-07-18T00:44:23.904386Z" },
+      ],
+    });
+
+    await handleCommand(platform, "/usage", "feishu-p2p", "ou-user", Date.now(), "p2p");
+
+    expect(platform.createGroup).not.toHaveBeenCalled();
+    expect(platform.sendCard).not.toHaveBeenCalled();
+    expect(platform.sendRawCard).toHaveBeenCalledTimes(1);
+    const card = JSON.parse(vi.mocked(platform.sendRawCard).mock.calls[0][1]);
+    expect(card.header.title.content).toBe("Codex Usage");
+    expect(card.elements[0].text.content).toContain("2026-07-12");
+    expect(card.elements[0].text.content).toContain("2026-07-18");
+    expect(card.elements[0].text.content).toContain("**主动重置:** 剩余 2 次");
+    expect(card.elements[0].text.content).not.toContain("ChatGPT 订阅");
+    expect(card.elements[0].text.content).toContain("**5h:** 已用 37%，剩余 63%，重置:");
+    expect(card.elements[0].text.content).toContain("约 2小时52分钟后");
+    expect(card.elements[0].text.content).toContain("[███████░░░░░░░░░░░░░]");
+    expect(card.elements[0].text.content).toContain("**周:** 已用 12%，剩余 88%，重置:");
+    expect(card.elements[0].text.content).toContain("约 3天18小时17分钟后");
+    expect(card.elements[0].text.content).toContain("[██░░░░░░░░░░░░░░░░░░]");
+    expect(card.elements[2].actions[0].text.content).toBe("发起重置");
+    expect(card.elements[2].actions[0].value).toEqual({ action: "codex_reset_request", availableCount: 2 });
+  });
+
+  it("adds ChatGPT subscription expiry to Codex /usage when CDP lookup succeeds", async () => {
+    const platform = mockPlatform("feishu");
+    mockGetCodexUsageSummary.mockResolvedValue({
+      fiveHour: { usedPercent: 37, remainingPercent: 63, resetAtEpochSeconds: 1781528212, resetAfterSeconds: 10349 },
+      weekly: { usedPercent: 12, remainingPercent: 88, resetAtEpochSeconds: 1781842926, resetAfterSeconds: 325063 },
+      rateLimitResetCreditsAvailable: 0,
+      rateLimitResetCredits: [],
+    });
+    mockGetChatGptSubscriptionStatus.mockResolvedValue({
+      ok: true,
+      code: "ok",
+      chromeCdp: { enabled: true, port: 15166, status: "healthy" },
+      chatgpt: { sessionOk: true, maskedEmail: "gg***@gmail.com", sessionExpiresAt: "2026-09-20T09:30:07.340Z" },
+      subscription: {
+        active: true,
+        plan: "chatgptprolite",
+        expiresAt: "2026-07-12T10:20:11+00:00",
+        willRenew: false,
+        purchaseOriginPlatform: "chatgpt_web",
+        remainingDays: 20,
+      },
+    });
+
+    await handleCommand(platform, "/usage", "feishu-p2p", "ou-user", Date.now(), "p2p");
+
+    const card = JSON.parse(vi.mocked(platform.sendRawCard).mock.calls[0][1]);
+    expect(card.elements[0].text.content).toContain("**ChatGPT 订阅:**");
+    expect(card.elements[0].text.content).toContain("- 套餐: chatgptprolite");
+    expect(card.elements[0].text.content).toContain("剩余 20 天");
+    expect(card.elements[0].text.content).toContain("- 自动续费: 否");
+  });
 
   it("handles /usage as Cursor usage in Cursor chats", async () => {
     const platform = mockPlatform("feishu");
@@ -438,7 +483,7 @@ describe("handleCommand WeChat processing ack", () => {
     expect(codexPlatform.sendCard).toHaveBeenCalledWith(
       "feishu-group",
       "Codex Session Ready",
-      expect.stringContaining("发送 **/usage** 查看 Codex 5h/周用量，以及查询/使用主动重置卡。"),
+      expect.stringContaining("发送 **/usage** 查看 Codex 5h/周用量，以及查询/使用主动重置卡。"),
       "green",
     );