chatccc 0.2.198 → 0.2.199

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

@@ -98,10 +98,10 @@ function createHangingMockCursorProcess(args: {
     pid: undefined,
   });
 
-  setTimeout(() => {
+  queueMicrotask(() => {
     if (args.stdout) stdout.write(args.stdout);
     if (args.stderr) stderr.write(args.stderr);
-  }, 0);
+  });
 
   return child;
 }
@@ -744,6 +744,33 @@ describe("Cursor adapter process failures", () => {
     expect(message).not.toContain("登录态已失效");
   });
 
+  it("formats empty stdout action-required stderr with the actionable Cursor error", () => {
+    const message = formatCursorAgentEmptyOutputMessage({
+      exitCode: 1,
+      stdoutLength: 0,
+      stderr: "ActionRequiredError: You have an unpaid invoice Your team has an unpaid invoice. Please contact your team administrator to pay your invoice and continue using Cursor.\n",
+    });
+
+    expect(message).toContain("底层命令异常退出");
+    expect(message).toContain("[Cursor stderr] exit=1");
+    expect(message).toContain("ActionRequiredError");
+    expect(message).toContain("unpaid invoice");
+    expect(message).toContain("team administrator");
+  });
+
+  it("redacts obvious secrets from visible Cursor stderr", () => {
+    const message = formatCursorAgentEmptyOutputMessage({
+      exitCode: 1,
+      stdoutLength: 0,
+      stderr: "Error: failed with token=secret-token-value and Bearer abcdefghijklmnop\n",
+    });
+
+    expect(message).toContain("token=<redacted>");
+    expect(message).toContain("Bearer <redacted>");
+    expect(message).not.toContain("secret-token-value");
+    expect(message).not.toContain("abcdefghijklmnop");
+  });
+
   it("does not format a message when stdout is non-empty", () => {
     expect(
       formatCursorAgentEmptyOutputMessage({
@@ -786,14 +813,49 @@ describe("Cursor adapter process failures", () => {
     );
   });
 
+  it("prompt surfaces action-required stderr before failing the stream", async () => {
+    const store = createInMemoryMetaStore({ sid: { cwd: "F:/repo" } });
+    const spawnImpl = (() =>
+      createMockCursorProcess({
+        exitCode: 1,
+        stderr: "ActionRequiredError: You have an unpaid invoice Your team has an unpaid invoice. Please contact your team administrator to pay your invoice and continue using Cursor.\n",
+      })) as CursorSpawnForTest;
+    const adapter = createCursorAdapter({ metaStore: store, spawn: spawnImpl });
+    const iterator = adapter.prompt(
+      "sid",
+      "[User message]\nhello\n[/User message]",
+      "F:/repo",
+    )[Symbol.asyncIterator]();
+
+    const first = await iterator.next();
+    expect(first.done).toBe(false);
+    expect(first.value.blocks).toHaveLength(1);
+    expect(first.value.blocks[0]).toMatchObject({ type: "text_final" });
+    expect(first.value.blocks[0]).toHaveProperty(
+      "text",
+      expect.stringContaining("ActionRequiredError"),
+    );
+    expect(first.value.blocks[0]).toHaveProperty(
+      "text",
+      expect.stringContaining("unpaid invoice"),
+    );
+
+    await expect(iterator.next()).rejects.toThrow(
+      /Cursor Agent exited without stream-json output/,
+    );
+  });
+
   it("prompt fails when Cursor emits bad JSON and then leaves stdout idle", async () => {
-    vi.useFakeTimers();
     const store = createInMemoryMetaStore({ sid: { cwd: "F:/repo" } });
     const spawnImpl = (() =>
       createHangingMockCursorProcess({
         stdout: "{\"type\":\"tool_call\",\"subtype\":\"started\"\n",
       })) as CursorSpawnForTest;
-    const adapter = createCursorAdapter({ metaStore: store, spawn: spawnImpl });
+    const adapter = createCursorAdapter({
+      metaStore: store,
+      spawn: spawnImpl,
+      badJsonIdleTimeoutMs: 10,
+    });
 
     const pending = (async () => {
       for await (const _event of adapter.prompt(
@@ -805,9 +867,6 @@ describe("Cursor adapter process failures", () => {
       }
     })().catch((error: unknown) => error);
 
-    await vi.advanceTimersByTimeAsync(0);
-    await vi.advanceTimersByTimeAsync(120_000);
-
     const error = await pending;
     expect(error).toBeInstanceOf(BadJsonIdleTimeoutError);
   });

package/src/__tests__/feishu-avatar.test.ts

@@ -1,4 +1,4 @@
-import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
@@ -68,7 +68,7 @@ function mockAvatarFetch(uploadedNames: string[], usageResponse: Response): void
   }));
 }
 
-function mockAvatarUploadOnlyFetch(uploadedNames: string[]): ReturnType<typeof vi.fn> {
+function mockAvatarUploadOnlyFetch(uploadedNames: string[]): ReturnType<typeof vi.fn> {
   const fetchMock = vi.fn(async (url: string | URL | Request, init?: RequestInit) => {
     const urlText = String(url);
     if (urlText === "https://open.feishu.test/im/v1/images") {
@@ -83,44 +83,44 @@ function mockAvatarUploadOnlyFetch(uploadedNames: string[]): ReturnType<typeof v
     throw new Error(`unexpected fetch: ${urlText}`);
   });
   vi.stubGlobal("fetch", fetchMock);
-  return fetchMock;
-}
-
-describe("Plain avatar fallback", () => {
-  afterEach(() => {
-    vi.unstubAllGlobals();
-    vi.doUnmock("node:os");
-    vi.doUnmock("../config.ts");
-    vi.doUnmock("../cursor-usage.ts");
-    vi.restoreAllMocks();
-    getCursorUsageSummaryMock.mockReset();
-    mockConfig.cursor.avatarBatteryMode = "apiPercent";
-    mockConfig.cursor.onDemandMonthlyBudget = 1000;
-  });
-
-  it("uses a status-only avatar for unknown tools instead of falling back to Claude", async () => {
-    const homeDir = await mkdtemp(join(tmpdir(), "chatccc-avatar-home-"));
-    const userDataDir = await mkdtemp(join(tmpdir(), "chatccc-avatar-data-"));
-    const uploadedNames: string[] = [];
-    mockAvatarUploadOnlyFetch(uploadedNames);
-
-    try {
-      const { setChatAvatar } = await loadFeishuApiWithHome(homeDir, userDataDir);
-      await setChatAvatar("tenant-token", "chat_1", "ccc", "new");
-
-      expect(uploadedNames).toEqual(["avatar_plain_new.jpg"]);
-      const cacheRaw = await readFile(join(userDataDir, "state", "avatar-image-keys.json"), "utf-8");
-      const cache = JSON.parse(cacheRaw) as Record<string, string>;
-      expect(cache["plain:new"]).toBe("img_test");
-      expect(cache["claude:new"]).toBeUndefined();
-    } finally {
-      await rm(homeDir, { recursive: true, force: true });
-      await rm(userDataDir, { recursive: true, force: true });
-    }
-  });
-});
-
-describe("Codex avatar usage battery", () => {
+  return fetchMock;
+}
+
+describe("Plain avatar fallback", () => {
+  afterEach(() => {
+    vi.unstubAllGlobals();
+    vi.doUnmock("node:os");
+    vi.doUnmock("../config.ts");
+    vi.doUnmock("../cursor-usage.ts");
+    vi.restoreAllMocks();
+    getCursorUsageSummaryMock.mockReset();
+    mockConfig.cursor.avatarBatteryMode = "apiPercent";
+    mockConfig.cursor.onDemandMonthlyBudget = 1000;
+  });
+
+  it("uses a status-only avatar for unknown tools instead of falling back to Claude", async () => {
+    const homeDir = await mkdtemp(join(tmpdir(), "chatccc-avatar-home-"));
+    const userDataDir = await mkdtemp(join(tmpdir(), "chatccc-avatar-data-"));
+    const uploadedNames: string[] = [];
+    mockAvatarUploadOnlyFetch(uploadedNames);
+
+    try {
+      const { setChatAvatar } = await loadFeishuApiWithHome(homeDir, userDataDir);
+      await setChatAvatar("tenant-token", "chat_1", "ccc", "new");
+
+      expect(uploadedNames).toEqual(["avatar_plain_new.jpg"]);
+      const cacheRaw = await readFile(join(userDataDir, "state", "avatar-image-keys.json"), "utf-8");
+      const cache = JSON.parse(cacheRaw) as Record<string, string>;
+      expect(cache["plain:new"]).toBe("img_test");
+      expect(cache["claude:new"]).toBeUndefined();
+    } finally {
+      await rm(homeDir, { recursive: true, force: true });
+      await rm(userDataDir, { recursive: true, force: true });
+    }
+  });
+});
+
+describe("Codex avatar usage battery", () => {
   afterEach(() => {
     vi.unstubAllGlobals();
     vi.doUnmock("node:os");

package/src/__tests__/jsonl-stream.test.ts

@@ -1,79 +1,79 @@
-import { PassThrough } from "node:stream";
-
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-import {
-  BadJsonIdleTimeoutError,
-  readJsonLinesWithBadJsonIdleWatchdog,
-} from "../adapters/jsonl-stream.ts";
-
-function createReader(input: PassThrough, idleTimeoutMs = 100): AsyncIterator<unknown> {
-  return readJsonLinesWithBadJsonIdleWatchdog({
-    input,
-    tool: "test-agent",
-    tag: "sid-test",
-    idleTimeoutMs,
-    parse: (line) => JSON.parse(line) as unknown,
-  })[Symbol.asyncIterator]();
-}
-
-afterEach(() => {
-  vi.useRealTimers();
-});
-
-describe("readJsonLinesWithBadJsonIdleWatchdog", () => {
-  it("throws when a JSON-like bad line remains the last stdout past the idle timeout", async () => {
-    vi.useFakeTimers();
-    const input = new PassThrough();
-    const iterator = createReader(input);
-
-    const pending = iterator.next().catch((error: unknown) => error);
-    input.write("{\"type\":\"tool_call\",\"subtype\":\"started\"\n");
-
-    await vi.advanceTimersByTimeAsync(100);
-
-    const error = await pending;
-    expect(error).toBeInstanceOf(BadJsonIdleTimeoutError);
-    expect(error).toMatchObject({
-      code: "BAD_JSON_IDLE_TIMEOUT",
-      tool: "test-agent",
-      tag: "sid-test",
-    });
-  });
-
-  it("does not throw when a valid JSON line arrives after the bad line before timeout", async () => {
-    vi.useFakeTimers();
-    const input = new PassThrough();
-    const iterator = createReader(input);
-
-    const pending = iterator.next();
-    input.write("{\"type\":\"tool_call\"\n");
-    await vi.advanceTimersByTimeAsync(50);
-    input.write("{\"type\":\"ok\"}\n");
-
-    await expect(pending).resolves.toEqual({
-      done: false,
-      value: { type: "ok" },
-    });
-
-    const done = iterator.next();
-    input.end();
-    await expect(done).resolves.toEqual({ done: true, value: undefined });
-  });
-
-  it("ignores non-JSON banner lines for the bad JSON idle watchdog", async () => {
-    vi.useFakeTimers();
-    const input = new PassThrough();
-    const iterator = createReader(input);
-
-    const pending = iterator.next();
-    input.write("Reading prompt from stdin...\n");
-    await vi.advanceTimersByTimeAsync(200);
-    input.write("{\"type\":\"ok\"}\n");
-
-    await expect(pending).resolves.toEqual({
-      done: false,
-      value: { type: "ok" },
-    });
-  });
-});
+import { PassThrough } from "node:stream";
+
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import {
+  BadJsonIdleTimeoutError,
+  readJsonLinesWithBadJsonIdleWatchdog,
+} from "../adapters/jsonl-stream.ts";
+
+function createReader(input: PassThrough, idleTimeoutMs = 100): AsyncIterator<unknown> {
+  return readJsonLinesWithBadJsonIdleWatchdog({
+    input,
+    tool: "test-agent",
+    tag: "sid-test",
+    idleTimeoutMs,
+    parse: (line) => JSON.parse(line) as unknown,
+  })[Symbol.asyncIterator]();
+}
+
+afterEach(() => {
+  vi.useRealTimers();
+});
+
+describe("readJsonLinesWithBadJsonIdleWatchdog", () => {
+  it("throws when a JSON-like bad line remains the last stdout past the idle timeout", async () => {
+    vi.useFakeTimers();
+    const input = new PassThrough();
+    const iterator = createReader(input);
+
+    const pending = iterator.next().catch((error: unknown) => error);
+    input.write("{\"type\":\"tool_call\",\"subtype\":\"started\"\n");
+
+    await vi.advanceTimersByTimeAsync(100);
+
+    const error = await pending;
+    expect(error).toBeInstanceOf(BadJsonIdleTimeoutError);
+    expect(error).toMatchObject({
+      code: "BAD_JSON_IDLE_TIMEOUT",
+      tool: "test-agent",
+      tag: "sid-test",
+    });
+  });
+
+  it("does not throw when a valid JSON line arrives after the bad line before timeout", async () => {
+    vi.useFakeTimers();
+    const input = new PassThrough();
+    const iterator = createReader(input);
+
+    const pending = iterator.next();
+    input.write("{\"type\":\"tool_call\"\n");
+    await vi.advanceTimersByTimeAsync(50);
+    input.write("{\"type\":\"ok\"}\n");
+
+    await expect(pending).resolves.toEqual({
+      done: false,
+      value: { type: "ok" },
+    });
+
+    const done = iterator.next();
+    input.end();
+    await expect(done).resolves.toEqual({ done: true, value: undefined });
+  });
+
+  it("ignores non-JSON banner lines for the bad JSON idle watchdog", async () => {
+    vi.useFakeTimers();
+    const input = new PassThrough();
+    const iterator = createReader(input);
+
+    const pending = iterator.next();
+    input.write("Reading prompt from stdin...\n");
+    await vi.advanceTimersByTimeAsync(200);
+    input.write("{\"type\":\"ok\"}\n");
+
+    await expect(pending).resolves.toEqual({
+      done: false,
+      value: { type: "ok" },
+    });
+  });
+});