chatccc 0.2.252 → 0.2.254

package/src/__tests__/ccc-adapter.test.ts

@@ -1,194 +0,0 @@
-import { mkdtemp } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-const streamTextMock = vi.fn();
-const generateTextMock = vi.fn();
-
-vi.mock("@ai-sdk/openai-compatible", () => ({
-  createOpenAICompatible: vi.fn(() => (modelId: string) => ({ modelId })),
-}));
-
-vi.mock("@ai-sdk/anthropic", () => ({
-  createAnthropic: vi.fn(() => (modelId: string) => ({ modelId })),
-}));
-
-vi.mock("ai", () => ({
-  streamText: streamTextMock,
-  generateText: generateTextMock,
-  isLoopFinished: vi.fn(() => ({ loopFinished: true })),
-  stepCountIs: vi.fn((count: number) => ({ count })),
-  jsonSchema: vi.fn((schema: unknown) => schema),
-  tool: vi.fn((definition: unknown) => definition),
-}));
-
-async function* textStream(...chunks: string[]): AsyncIterable<string> {
-  for (const chunk of chunks) yield chunk;
-}
-
-async function* fullStream(...parts: unknown[]): AsyncIterable<unknown> {
-  for (const part of parts) yield part;
-}
-
-afterEach(() => {
-  streamTextMock.mockReset();
-  generateTextMock.mockReset();
-});
-
-describe("createCccAdapter", () => {
-  it("disables response-stall detection when DeepCCC streaming is disabled", async () => {
-    const { config: deepCccConfig } = await import("../../deepccc-agent/src/config.ts");
-    const previousStreaming = deepCccConfig.streaming;
-    deepCccConfig.streaming = false;
-
-    try {
-      const { createCccAdapter } = await import("../adapters/ccc-adapter.ts");
-      const adapter = createCccAdapter({ apiKey: "sk-test" });
-
-      expect(adapter.responseStallDetectionEnabled).toBe(false);
-    } finally {
-      deepCccConfig.streaming = previousStreaming;
-    }
-  });
-
-  it("creates a persisted ccc session and exposes model/cwd metadata", async () => {
-    const { createCccAdapter } = await import("../adapters/ccc-adapter.ts");
-    const contextDir = await mkdtemp(join(tmpdir(), "chatccc-ccc-adapter-meta-"));
-    const adapter = createCccAdapter({
-      apiKey: "sk-test",
-      provider: "openai",
-      contextDir,
-      model: "deepseek-v4-pro",
-    });
-
-    const created = await adapter.createSession("F:\\repo");
-    const info = await adapter.getSessionInfo(created.sessionId);
-
-    expect(created.sessionId).toMatch(/^session-\d{8}-\d{6}-[a-f0-9]{6}$/);
-    expect(info).toEqual(expect.objectContaining({
-      sessionId: created.sessionId,
-      cwd: "F:\\repo",
-      model: "deepseek-v4-pro",
-    }));
-  });
-
-  it("maps ChatSession text chunks to unified assistant text blocks", async () => {
-    const { createCccAdapter } = await import("../adapters/ccc-adapter.ts");
-    const contextDir = await mkdtemp(join(tmpdir(), "chatccc-ccc-adapter-stream-"));
-    const adapter = createCccAdapter({
-      apiKey: "sk-test",
-      provider: "openai",
-      contextDir,
-      model: "deepseek-v4-flash",
-    });
-    const { sessionId } = await adapter.createSession("F:\\repo");
-    streamTextMock.mockReturnValueOnce({ textStream: textStream("hello", " world") });
-
-    const messages = [];
-    for await (const message of adapter.prompt(sessionId, "hi", "F:\\repo")) {
-      messages.push(message);
-    }
-
-    expect(messages).toEqual([
-      { type: "assistant", blocks: [{ type: "agent_status", status: "responding" }] },
-      { type: "assistant", blocks: [{ type: "text", text: "hello" }] },
-      { type: "assistant", blocks: [{ type: "text", text: " world" }] },
-      { type: "assistant", blocks: [], isFinalResponse: true },
-    ]);
-    expect(streamTextMock).toHaveBeenCalledWith(expect.objectContaining({
-      model: { modelId: "deepseek-v4-flash" },
-    }));
-  });
-
-  it("maps ChatSession tool events to unified tool blocks", async () => {
-    const { createCccAdapter } = await import("../adapters/ccc-adapter.ts");
-    const contextDir = await mkdtemp(join(tmpdir(), "chatccc-ccc-adapter-tools-"));
-    const adapter = createCccAdapter({
-      apiKey: "sk-test",
-      provider: "openai",
-      contextDir,
-      model: "deepseek-v4-flash",
-    });
-    const { sessionId } = await adapter.createSession("F:\\repo");
-    streamTextMock.mockReturnValueOnce({
-      fullStream: fullStream(
-        { type: "tool-call", toolCallId: "call-1", toolName: "read_file", input: { path: "README.md" } },
-        { type: "tool-result", toolCallId: "call-1", toolName: "read_file", output: { content: "hello" } },
-      ),
-    });
-
-    const messages = [];
-    for await (const message of adapter.prompt(sessionId, "read", "F:\\repo")) {
-      messages.push(message);
-    }
-
-    expect(messages).toEqual([
-      { type: "assistant", blocks: [{ type: "agent_status", status: "responding" }] },
-      {
-        type: "assistant",
-        blocks: [{ type: "tool_use", id: "call-1", name: "read_file", input: { path: "README.md" } }],
-      },
-      {
-        type: "assistant",
-        blocks: [{ type: "tool_result", tool_use_id: "call-1", content: { content: "hello" }, is_error: false }],
-      },
-      { type: "assistant", blocks: [], isFinalResponse: true },
-    ]);
-  });
-
-  it("maps DeepCCC compaction and generation phases to unified activity blocks", async () => {
-    const { createCccAdapter } = await import("../adapters/ccc-adapter.ts");
-    const contextDir = await mkdtemp(join(tmpdir(), "chatccc-ccc-adapter-status-"));
-    const adapter = createCccAdapter({
-      apiKey: "sk-test",
-      provider: "openai",
-      contextDir,
-      compactAtTokens: 1,
-      keepRecentMessages: 1,
-    });
-    const { sessionId } = await adapter.createSession("F:\\repo");
-    streamTextMock.mockReturnValueOnce({ textStream: textStream("old") });
-    for await (const _message of adapter.prompt(sessionId, "old question", "F:\\repo")) {
-      // drain
-    }
-
-    generateTextMock.mockResolvedValueOnce({ text: "summary" });
-    streamTextMock.mockReturnValueOnce({ textStream: textStream("new") });
-    const messages = [];
-    for await (const message of adapter.prompt(sessionId, "new question", "F:\\repo")) {
-      messages.push(message);
-    }
-
-    expect(messages[0]).toEqual({
-      type: "assistant",
-      blocks: [{ type: "agent_status", status: "compacting" }],
-    });
-    expect(messages).toContainEqual({
-      type: "assistant",
-      blocks: [{ type: "agent_status", status: "responding" }],
-    });
-  });
-
-  it("passes effort into ChatSession so streamText receives reasoningEffort", async () => {
-    const { createCccAdapter } = await import("../adapters/ccc-adapter.ts");
-    const contextDir = await mkdtemp(join(tmpdir(), "chatccc-ccc-adapter-effort-"));
-    const adapter = createCccAdapter({
-      apiKey: "sk-test",
-      provider: "openai",
-      contextDir,
-      effort: "xhigh",
-    });
-    const { sessionId } = await adapter.createSession("F:\\repo");
-    streamTextMock.mockReturnValueOnce({ textStream: textStream("ok") });
-
-    for await (const _message of adapter.prompt(sessionId, "hi", "F:\\repo")) {
-      // drain
-    }
-
-    expect(streamTextMock).toHaveBeenLastCalledWith(expect.objectContaining({
-      providerOptions: { deepseek: { reasoningEffort: "xhigh" } },
-    }));
-  });
-});

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

@@ -1,89 +0,0 @@
-import { Readable } from "node:stream";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-const mockGetChatGptSubscriptionStatus = vi.hoisted(() => vi.fn());
-
-vi.mock("../chatgpt-subscription.ts", () => ({
-  getChatGptSubscriptionStatus: mockGetChatGptSubscriptionStatus,
-}));
-
-import {
-  CHATGPT_SUBSCRIPTION_PATH,
-  handleChatGptSubscriptionRequest,
-} from "../chatgpt-subscription-rpc.ts";
-
-function request(path = CHATGPT_SUBSCRIPTION_PATH, method = "POST"): Readable & {
-  url?: string;
-  method?: string;
-  headers: Record<string, string>;
-} {
-  const req = Readable.from([]) as Readable & {
-    url?: string;
-    method?: string;
-    headers: Record<string, string>;
-  };
-  req.url = path;
-  req.method = method;
-  req.headers = {};
-  return req;
-}
-
-function response() {
-  const res = {
-    statusCode: 0,
-    headers: {} as Record<string, string>,
-    body: "",
-    writeHead(status: number, headers: Record<string, string>) {
-      this.statusCode = status;
-      this.headers = headers;
-      return this;
-    },
-    end(chunk?: string) {
-      this.body += chunk ?? "";
-      return this;
-    },
-  };
-  return res;
-}
-
-describe("ChatGPT subscription RPC", () => {
-  beforeEach(() => {
-    mockGetChatGptSubscriptionStatus.mockReset();
-    mockGetChatGptSubscriptionStatus.mockResolvedValue({
-      ok: false,
-      code: "chrome_cdp_disabled",
-      reason: "Chrome CDP guard is disabled in ChatCCC config.",
-      chromeCdp: { enabled: false, port: 15166, status: "skipped" },
-    });
-  });
-
-  it("returns the structured subscription lookup JSON", async () => {
-    const req = request();
-    const res = response();
-
-    await expect(handleChatGptSubscriptionRequest(req as never, res as never)).resolves.toBe(true);
-
-    expect(res.statusCode).toBe(200);
-    expect(JSON.parse(res.body)).toEqual({
-      ok: false,
-      code: "chrome_cdp_disabled",
-      reason: "Chrome CDP guard is disabled in ChatCCC config.",
-      chromeCdp: { enabled: false, port: 15166, status: "skipped" },
-    });
-  });
-
-  it("does not handle other paths", async () => {
-    const res = response();
-
-    await expect(handleChatGptSubscriptionRequest(request("/api/other") as never, res as never)).resolves.toBe(false);
-    expect(res.body).toBe("");
-  });
-
-  it("rejects non-POST methods", async () => {
-    const res = response();
-
-    await expect(handleChatGptSubscriptionRequest(request(CHATGPT_SUBSCRIPTION_PATH, "GET") as never, res as never)).resolves.toBe(true);
-    expect(res.statusCode).toBe(405);
-    expect(JSON.parse(res.body)).toMatchObject({ ok: false, code: "method_not_allowed" });
-  });
-});

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

@@ -1,135 +0,0 @@
-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

@@ -1,165 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { spawn } from "node:child_process";
-
-import {
-  ensureChromeCdpRunning,
-  ensureChatcccPageOpen,
-  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");
-  });
-
-  it("opens the configured ChatCCC page when no localhost or loopback page is present", async () => {
-    const fetchImpl = vi.fn(async (input: string | URL | Request, init?: RequestInit) => {
-      const url = String(input);
-      if (url === "http://127.0.0.1:15166/json/list") {
-        return new Response(JSON.stringify([
-          { id: "chatgpt", type: "page", url: "https://chatgpt.com/", webSocketDebuggerUrl: "ws://page" },
-        ]), { status: 200 });
-      }
-      if (url === "http://127.0.0.1:15166/json/new?http%3A%2F%2Flocalhost%3A18081%2F") {
-        expect(init?.method).toBe("PUT");
-        return new Response(JSON.stringify({ id: "chatccc" }), { status: 200 });
-      }
-      throw new Error(`unexpected fetch ${url}`);
-    }) as unknown as typeof fetch;
-
-    await expect(ensureChatcccPageOpen(15166, 18081, { fetchImpl })).resolves.toEqual({
-      ok: true,
-      opened: true,
-    });
-  });
-
-  it("does not open another ChatCCC page when localhost or 127.0.0.1 is already present", async () => {
-    const fetchImpl = vi.fn(async (input: string | URL | Request) => {
-      const url = String(input);
-      if (url === "http://127.0.0.1:15166/json/list") {
-        return new Response(JSON.stringify([
-          { id: "chatccc", type: "page", url: "http://127.0.0.1:18080/", webSocketDebuggerUrl: "ws://page" },
-        ]), { status: 200 });
-      }
-      throw new Error(`unexpected fetch ${url}`);
-    }) as unknown as typeof fetch;
-
-    await expect(ensureChatcccPageOpen(15166, 18080, { fetchImpl })).resolves.toEqual({
-      ok: true,
-      opened: false,
-    });
-    expect(fetchImpl).toHaveBeenCalledTimes(1);
-  });
-});