chatccc 0.2.183 → 0.2.185

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",
     );
 

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

@@ -33,6 +33,22 @@ describe("unflattenConfig", () => {
       },
     });
   });
+
+  it("maps Chrome CDP guard fields into chromeDevtools config", () => {
+    expect(
+      unflattenConfig({
+        CHATCCC_CHROME_DEVTOOLS_ENABLED: true,
+        CHATCCC_CHROME_DEVTOOLS_PORT: "15166",
+        CHATCCC_CHROME_DEVTOOLS_PATH: "C:/Program Files/Google/Chrome/Application/chrome.exe",
+      }),
+    ).toEqual({
+      chromeDevtools: {
+        enabled: true,
+        port: 15166,
+        chromePath: "C:/Program Files/Google/Chrome/Application/chrome.exe",
+      },
+    });
+  });
 });
 
 describe("dashboard edit modal", () => {

package/src/agent-delegate-task-rpc.ts

@@ -0,0 +1,153 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { resolve } from "node:path";
+
+import { resolveDefaultAgentTool } from "./config.ts";
+import { readUtf8JsonBody } from "./agent-rpc-body.ts";
+import { delegateAgentTask } from "./agent-delegate-task.ts";
+import type { PlatformAdapter } from "./platform-adapter.ts";
+import { applySharedPrefix } from "./shared-prefix.ts";
+
+export const AGENT_DELEGATE_TASK_PATH = "/api/agent/delegate-task";
+
+const MAX_REQUEST_BYTES = 128 * 1024;
+const VALID_TOOLS = new Set(["claude", "cursor", "codex"]);
+
+interface AgentDelegateTaskPayload {
+  tool?: unknown;
+  cwd?: unknown;
+  prompt?: unknown;
+  text?: unknown;
+  message?: unknown;
+  open_id?: unknown;
+  open_ids?: unknown;
+  openIds?: unknown;
+  chat_name?: unknown;
+}
+
+function jsonReply(res: ServerResponse, status: number, data: unknown): void {
+  res.writeHead(status, { "Content-Type": "application/json; charset=utf-8" });
+  res.end(JSON.stringify(data));
+}
+
+function stringValue(value: unknown): string {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function normalizeOpenIds(payload: AgentDelegateTaskPayload): string[] {
+  const explicitOpenId = stringValue(payload.open_id);
+  if (explicitOpenId) return [explicitOpenId];
+
+  const rawOpenIds = Array.isArray(payload.open_ids) ? payload.open_ids : payload.openIds;
+  if (!Array.isArray(rawOpenIds)) return [];
+  return rawOpenIds
+    .filter((item): item is string => typeof item === "string")
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
+function promptFromPayload(payload: AgentDelegateTaskPayload): string {
+  return stringValue(payload.prompt) || stringValue(payload.text) || stringValue(payload.message);
+}
+
+function validateTool(rawTool: unknown): string {
+  const tool = stringValue(rawTool).toLowerCase() || resolveDefaultAgentTool();
+  if (!VALID_TOOLS.has(tool)) throw new Error(`unsupported tool: ${tool}`);
+  return tool;
+}
+
+function validateCwd(rawCwd: unknown): string {
+  const cwd = stringValue(rawCwd);
+  if (!cwd) throw new Error("cwd must be a non-empty string");
+  return resolve(cwd);
+}
+
+export async function handleAgentDelegateTaskRequest(
+  req: IncomingMessage,
+  res: ServerResponse,
+  platform: PlatformAdapter,
+): Promise<boolean> {
+  const url = new URL(req.url ?? "/", "http://127.0.0.1");
+  if (url.pathname !== AGENT_DELEGATE_TASK_PATH) return false;
+
+  if (req.method !== "POST") {
+    jsonReply(res, 405, { ok: false, error: "Method not allowed" });
+    return true;
+  }
+
+  if (platform.kind !== "feishu") {
+    jsonReply(res, 409, { ok: false, error: "This endpoint currently only supports Feishu." });
+    return true;
+  }
+
+  let payload: AgentDelegateTaskPayload;
+  try {
+    payload = await readUtf8JsonBody(req, MAX_REQUEST_BYTES);
+  } catch (err) {
+    jsonReply(res, 400, { ok: false, error: (err as Error).message || "Invalid JSON" });
+    return true;
+  }
+
+  let tool: string;
+  let cwd: string;
+  let promptText: string;
+  let promptNamePrefix: string;
+  let openIds: string[];
+  try {
+    tool = validateTool(payload.tool);
+    cwd = validateCwd(payload.cwd);
+    const rawPrompt = promptFromPayload(payload);
+    if (!rawPrompt) throw new Error("prompt must be a non-empty string");
+    const sharedPrefix = applySharedPrefix(rawPrompt);
+    promptText = sharedPrefix.text;
+    promptNamePrefix = sharedPrefix.body || rawPrompt;
+    openIds = normalizeOpenIds(payload);
+    if (openIds.length === 0) throw new Error("open_id or openIds must include at least one user");
+  } catch (err) {
+    jsonReply(res, 400, { ok: false, error: (err as Error).message });
+    return true;
+  }
+
+  try {
+    const result = await delegateAgentTask({
+      platform,
+      tool,
+      cwd,
+      promptText,
+      openIds,
+      chatNamePrefix: stringValue(payload.chat_name) || promptNamePrefix.slice(0, 10),
+    });
+    jsonReply(res, 200, {
+      ok: true,
+      chat_id: result.chatId,
+      session_id: result.sessionId,
+      tool: result.tool,
+      cwd: result.cwd,
+    });
+  } catch (err) {
+    jsonReply(res, 500, { ok: false, error: (err as Error).message });
+  }
+  return true;
+}
+
+export function buildAgentDelegateTaskCapabilityPrompt(input: { url: string; cwd?: string }): string {
+  const lines = [
+    "[ChatCCC local capability: delegate task]",
+    "You can create a separate Feishu ChatCCC agent session and assign its first task by calling this local endpoint.",
+    "",
+    `POST ${input.url}`,
+    "Content-Type: application/json; charset=utf-8",
+    "",
+    'Body: {"tool":"codex|claude|cursor","cwd":"absolute working directory","open_id":"Feishu open_id to invite","prompt":"first task text"}',
+    "",
+    "Rules:",
+    "- Use this only when the user asks you to start a separate delegated conversation/session.",
+    "- Pass cwd explicitly as an absolute local path.",
+    "- Pass tool explicitly when the user specified a target agent.",
+    "- Use open_id for one user or open_ids/openIds for multiple users.",
+    "- The prompt is sent through the normal ChatCCC prompt path, so project prompt injection and IM skills still apply.",
+    "- Request body must be UTF-8 encoded JSON bytes. Do not call Feishu Open Platform directly.",
+    "[/ChatCCC local capability: delegate task]",
+  ];
+  if (input.cwd) lines.splice(2, 0, `Current working directory: ${input.cwd}`);
+  return lines.join("\n");
+}

package/src/agent-delegate-task.ts

@@ -0,0 +1,81 @@
+import { resolve } from "node:path";
+
+import { sessionPrefixForTool, toolDisplayName, ts } from "./config.ts";
+import { setDefaultCwd } from "./config.ts";
+import type { PlatformAdapter } from "./platform-adapter.ts";
+import { initClaudeSession, recordSessionRegistry, resumeAndPrompt, saveSessionTool } from "./session.ts";
+import { bindChatToSession } from "./session-chat-binding.ts";
+import { sessionChatName } from "./session-name.ts";
+
+export interface DelegateAgentTaskInput {
+  platform: PlatformAdapter;
+  tool: string;
+  cwd: string;
+  promptText: string;
+  openIds: string[];
+  chatNamePrefix?: string;
+  msgTimestamp?: number;
+  traceId?: string;
+}
+
+export interface DelegateAgentTaskResult {
+  chatId: string;
+  sessionId: string;
+  tool: string;
+  cwd: string;
+}
+
+export async function delegateAgentTask(input: DelegateAgentTaskInput): Promise<DelegateAgentTaskResult> {
+  const cwd = resolve(input.cwd);
+  const toolLabel = toolDisplayName(input.tool);
+  const init = await initClaudeSession(input.tool, cwd);
+  const sessionId = init.sessionId;
+  const chatNamePrefix = input.chatNamePrefix?.trim() || input.promptText.slice(0, 10) || "新会话";
+  const chatName = sessionChatName(chatNamePrefix, cwd);
+
+  let chatId: string;
+  try {
+    chatId = await input.platform.createGroup(chatName, input.openIds);
+    await input.platform.updateChatInfo(chatId, chatName, `${sessionPrefixForTool(input.tool)} ${sessionId}`);
+    await setDefaultCwd(cwd, chatId);
+    bindChatToSession(sessionId, chatId);
+    await recordSessionRegistry({
+      chatId,
+      sessionId,
+      tool: input.tool,
+      chatName,
+      turnCount: 0,
+      startTime: Date.now(),
+      running: false,
+    });
+    await saveSessionTool(sessionId, input.tool, chatName);
+  } catch (err) {
+    console.error(`[${ts()}] [AGENT-DELEGATE-TASK] create group failed: ${(err as Error).message}`);
+    throw err;
+  }
+
+  await input.platform.sendCard(
+    chatId,
+    `${toolLabel} Session Ready`,
+    `已创建 **${toolLabel}** 会话群。\n\n` +
+      `**Session ID:** ${sessionId}\n` +
+      `**工作目录:** \`${cwd}\`\n\n` +
+      `下面会自动把任务作为第一句话发送给 ${toolLabel}。`,
+    "green",
+  ).catch(() => {});
+  input.platform.setChatAvatar(chatId, input.tool, "new").catch(() => {});
+
+  await resumeAndPrompt(
+    sessionId,
+    input.promptText,
+    input.platform,
+    chatId,
+    input.msgTimestamp ?? Date.now(),
+    input.tool,
+    input.traceId,
+  );
+
+  console.log(`[${ts()}] [AGENT-DELEGATE-TASK] created ${toolLabel} session=${sessionId} chat=${chatId} cwd=${cwd}`);
+  return { chatId, sessionId, tool: input.tool, cwd };
+}
+

package/src/chatgpt-subscription-rpc.ts

@@ -0,0 +1,27 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+
+import { getChatGptSubscriptionStatus } from "./chatgpt-subscription.ts";
+
+export const CHATGPT_SUBSCRIPTION_PATH = "/api/chatgpt/subscription";
+
+function jsonReply(res: ServerResponse, code: number, data: unknown): void {
+  res.writeHead(code, { "Content-Type": "application/json; charset=utf-8" });
+  res.end(JSON.stringify(data));
+}
+
+export async function handleChatGptSubscriptionRequest(
+  req: IncomingMessage,
+  res: ServerResponse,
+): Promise<boolean> {
+  const method = req.method ?? "GET";
+  const url = new URL(req.url ?? "/", "http://127.0.0.1");
+  if (url.pathname !== CHATGPT_SUBSCRIPTION_PATH) return false;
+
+  if (method !== "GET") {
+    jsonReply(res, 405, { ok: false, code: "method_not_allowed", reason: "Use GET." });
+    return true;
+  }
+
+  jsonReply(res, 200, await getChatGptSubscriptionStatus());
+  return true;
+}