@vacbo/opencode-anthropic-fix 0.0.44 → 0.1.1

package/src/__tests__/helpers/plugin-fetch-harness.ts

@@ -0,0 +1,401 @@
+/**
+ * Plugin Fetch Harness — Reusable test scaffolding for AnthropicAuthPlugin.
+ *
+ * Provides a clean abstraction for bootstrapping the plugin with mocked
+ * dependencies, making it easy to write integration tests that exercise
+ * the fetch interceptor, account management, and request transformation.
+ *
+ * @example
+ * ```ts
+ * const harness = await createFetchHarness({
+ *   accounts: [{ refreshToken: "test-1", email: "test@example.com" }],
+ *   mockResponses: { "https://api.anthropic.com/v1/messages": { ok: true, json: async () => ({}) } }
+ * });
+ *
+ * await harness.fetch("https://api.anthropic.com/v1/messages", { method: "POST" });
+ * expect(harness.mockFetch).toHaveBeenCalledTimes(1);
+ *
+ * await harness.tearDown();
+ * ```
+ */
+
+import { vi, type Mock } from "vitest";
+import type { AnthropicAuthConfig } from "../../config.js";
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+/** Map of URL patterns to mock Response objects */
+export type MockResponseMap = Record<string, Partial<Response> | (() => Partial<Response>)>;
+
+/** Account data structure for harness initialization */
+export interface HarnessAccount {
+  refreshToken?: string;
+  access?: string;
+  expires?: number;
+  email?: string;
+  enabled?: boolean;
+}
+
+/** Options for creating a fetch harness */
+export interface HarnessOptions {
+  /** Account overrides to initialize the harness with (default: single test account) */
+  accounts?: HarnessAccount[];
+  /** Plugin configuration overrides (default: test-friendly defaults) */
+  config?: Partial<AnthropicAuthConfig>;
+  /** Mock responses for specific URLs (default: empty) */
+  mockResponses?: MockResponseMap;
+  /** Initial account index to set as active (default: 0) */
+  initialAccount?: number;
+}
+
+/** The fetch harness instance returned by createFetchHarness */
+export interface FetchHarness {
+  /** The fetch interceptor function returned by plugin.auth.loader */
+  fetch: (input: string | Request | URL, init?: RequestInit) => Promise<Response>;
+  /** The mocked global fetch (vi.fn()) — use for assertions */
+  mockFetch: Mock;
+  /** Cleanup function to restore global state */
+  tearDown: () => void;
+  /** Helper to wait for an assertion to pass (polling) */
+  waitFor: (assertion: () => void, timeoutMs?: number) => Promise<void>;
+  /** Get the headers from a specific mock fetch call */
+  getFetchHeaders: (callIndex: number) => Headers | undefined;
+  /** Get the URL from a specific mock fetch call */
+  getFetchUrl: (callIndex: number) => string | Request | undefined;
+}
+
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+
+/** Default test account factory */
+function makeStoredAccount(index: number, overrides: HarnessAccount = {}) {
+  const addedAt = Date.now();
+  return {
+    id: `test-${addedAt}-${index}`,
+    index,
+    refreshToken: overrides.refreshToken ?? `refresh-${index + 1}`,
+    access: overrides.access ?? `access-${index + 1}`,
+    expires: overrides.expires ?? Date.now() + 3600_000,
+    token_updated_at: addedAt,
+    addedAt,
+    lastUsed: 0,
+    enabled: overrides.enabled ?? true,
+    rateLimitResetTimes: {},
+    consecutiveFailures: 0,
+    lastFailureTime: null,
+    email: overrides.email,
+    stats: {
+      requests: 0,
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheReadTokens: 0,
+      cacheWriteTokens: 0,
+      lastReset: addedAt,
+    },
+    source: "oauth" as const,
+  };
+}
+
+/** Default mock client factory */
+function makeMockClient() {
+  return {
+    auth: {
+      set: vi.fn().mockResolvedValue(undefined),
+    },
+    session: {
+      prompt: vi.fn().mockResolvedValue(undefined),
+    },
+    tui: {
+      showToast: vi.fn().mockResolvedValue(undefined),
+    },
+  };
+}
+
+/** Default mock provider factory */
+function makeMockProvider() {
+  return {
+    models: {
+      "claude-sonnet": {
+        id: "claude-sonnet",
+        cost: { input: 3, output: 15, cache: { read: 0.3, write: 3.75 } },
+        limit: { context: 200_000, output: 8192 },
+      },
+      "claude-opus-4-6": {
+        id: "claude-opus-4-6",
+        cost: { input: 15, output: 75, cache: { read: 1.5, write: 18.75 } },
+        limit: { context: 200_000, output: 32_000 },
+      },
+    },
+  };
+}
+
+/** Default test configuration */
+const DEFAULT_TEST_CONFIG: AnthropicAuthConfig = {
+  account_selection_strategy: "sticky",
+  failure_ttl_seconds: 3600,
+  debug: false,
+  signature_emulation: {
+    enabled: true,
+    fetch_claude_code_version_on_startup: false,
+    prompt_compaction: "minimal",
+  },
+  override_model_limits: {
+    enabled: false,
+    context: 1_000_000,
+    output: 0,
+  },
+  custom_betas: [],
+  health_score: {
+    initial: 70,
+    success_reward: 1,
+    rate_limit_penalty: -10,
+    failure_penalty: -20,
+    recovery_rate_per_hour: 2,
+    min_usable: 50,
+    max_score: 100,
+  },
+  token_bucket: {
+    max_tokens: 50,
+    regeneration_rate_per_minute: 6,
+    initial_tokens: 50,
+  },
+  toasts: {
+    quiet: true,
+    debounce_seconds: 30,
+  },
+  headers: {},
+  idle_refresh: {
+    enabled: false,
+    window_minutes: 60,
+    min_interval_minutes: 30,
+  },
+  cc_credential_reuse: {
+    enabled: false,
+    auto_detect: false,
+    prefer_over_oauth: false,
+  },
+};
+
+// ---------------------------------------------------------------------------
+// Module mock state
+// ---------------------------------------------------------------------------
+
+let mockAccountsData: {
+  version: number;
+  accounts: ReturnType<typeof makeStoredAccount>[];
+  activeIndex: number;
+} | null = null;
+
+/**
+ * Set the mock accounts data that will be returned by loadAccounts.
+ * Call this before createFetchHarness to pre-seed accounts.
+ */
+export function setMockAccounts(accounts: ReturnType<typeof makeStoredAccount>[], activeIndex = 0): void {
+  mockAccountsData = { version: 1, accounts, activeIndex };
+}
+
+/**
+ * Clear the mock accounts data.
+ */
+export function clearMockAccounts(): void {
+  mockAccountsData = null;
+}
+
+// ---------------------------------------------------------------------------
+// Main harness factory
+// ---------------------------------------------------------------------------
+
+/**
+ * Creates a fetch harness for testing the AnthropicAuthPlugin.
+ *
+ * This function bootstraps the plugin with mocked dependencies and returns
+ * a harness object containing the fetch interceptor and utilities for
+ * assertions and cleanup.
+ *
+ * IMPORTANT: This function must be called AFTER vi.mock() declarations
+ * at the top of your test file. The mocks are hoisted by Vitest.
+ *
+ * @param opts - Configuration options for the harness
+ * @returns A FetchHarness instance ready for testing
+ */
+export async function createFetchHarness(opts: HarnessOptions = {}): Promise<FetchHarness> {
+  const { accounts = [{}], config = {}, mockResponses = {}, initialAccount = 0 } = opts;
+
+  // Merge config with defaults
+  const mergedConfig: AnthropicAuthConfig = {
+    ...DEFAULT_TEST_CONFIG,
+    ...config,
+    signature_emulation: {
+      ...DEFAULT_TEST_CONFIG.signature_emulation,
+      ...config.signature_emulation,
+    },
+    health_score: { ...DEFAULT_TEST_CONFIG.health_score, ...config.health_score },
+    token_bucket: { ...DEFAULT_TEST_CONFIG.token_bucket, ...config.token_bucket },
+    toasts: { ...DEFAULT_TEST_CONFIG.toasts, ...config.toasts },
+    override_model_limits: {
+      ...DEFAULT_TEST_CONFIG.override_model_limits,
+      ...config.override_model_limits,
+    },
+    idle_refresh: { ...DEFAULT_TEST_CONFIG.idle_refresh, ...config.idle_refresh },
+    cc_credential_reuse: { ...DEFAULT_TEST_CONFIG.cc_credential_reuse, ...config.cc_credential_reuse },
+  };
+
+  // Create mock client
+  const client = makeMockClient();
+
+  // Store original fetch and create mock
+  const originalFetch = globalThis.fetch;
+  const mockFetch = vi.fn();
+
+  // Set up mock response handler
+  mockFetch.mockImplementation((input: string | Request | URL) => {
+    let url: string;
+    if (typeof input === "string") {
+      url = input;
+    } else if (input instanceof URL) {
+      url = input.toString();
+    } else {
+      url = input.url;
+    }
+
+    // Check for matching mock response
+    for (const [pattern, response] of Object.entries(mockResponses)) {
+      if (url && url.includes(pattern)) {
+        const responseObj = typeof response === "function" ? response() : response;
+        if (responseObj instanceof Response) {
+          return Promise.resolve(responseObj);
+        }
+
+        if (typeof responseObj.json === "function") {
+          return responseObj.json().then(
+            (jsonBody) =>
+              new Response(JSON.stringify(jsonBody), {
+                status: responseObj.status ?? 200,
+                statusText: responseObj.statusText ?? "OK",
+                headers:
+                  responseObj.headers instanceof Headers
+                    ? responseObj.headers
+                    : new Headers(responseObj.headers ?? { "content-type": "application/json" }),
+              }),
+          );
+        }
+
+        if (typeof responseObj.text === "function") {
+          return responseObj.text().then(
+            (textBody) =>
+              new Response(textBody, {
+                status: responseObj.status ?? 200,
+                statusText: responseObj.statusText ?? "OK",
+                headers:
+                  responseObj.headers instanceof Headers
+                    ? responseObj.headers
+                    : new Headers(responseObj.headers ?? undefined),
+              }),
+          );
+        }
+
+        return Promise.resolve(
+          new Response(undefined, {
+            status: responseObj.status ?? 200,
+            statusText: responseObj.statusText ?? "OK",
+            headers:
+              responseObj.headers instanceof Headers
+                ? responseObj.headers
+                : new Headers(responseObj.headers ?? undefined),
+          }),
+        );
+      }
+    }
+
+    // Default: return empty successful response
+    return Promise.resolve(new Response("{}", { status: 200, headers: { "content-type": "application/json" } }));
+  });
+
+  // Install mock
+  globalThis.fetch = mockFetch as unknown as typeof globalThis.fetch;
+
+  // Build accounts data
+  const managedAccounts = accounts.map((overrides, index) => makeStoredAccount(index, overrides));
+
+  // Pre-seed mock accounts
+  mockAccountsData = { version: 1, accounts: managedAccounts, activeIndex: initialAccount };
+
+  // Dynamically import modules to get mocked versions
+  const { AnthropicAuthPlugin } = await import("../../index.js");
+  const { loadConfig, loadConfigFresh } = await import("../../config.js");
+  const { loadAccounts } = await import("../../storage.js");
+
+  // Override config mock to return our merged config
+  vi.mocked(loadConfig).mockReturnValue(mergedConfig);
+  vi.mocked(loadConfigFresh).mockReturnValue(mergedConfig);
+  vi.mocked(loadAccounts).mockResolvedValue(mockAccountsData);
+
+  // Initialize plugin
+  const plugin = await AnthropicAuthPlugin({ client });
+
+  // Create mock auth getter
+  const getAuth = vi.fn().mockResolvedValue({
+    type: "oauth",
+    refresh: managedAccounts[initialAccount]?.refreshToken ?? "refresh-1",
+    access: managedAccounts[initialAccount]?.access ?? "access-1",
+    expires: Date.now() + 3600_000,
+  });
+
+  // Initialize the plugin's auth loader
+  const provider = makeMockProvider();
+  const result = await plugin.auth.loader(getAuth, provider);
+
+  // Helper: wait for assertion
+  async function waitFor(assertion: () => void, timeoutMs = 500): Promise<void> {
+    const started = Date.now();
+    while (true) {
+      try {
+        assertion();
+        return;
+      } catch (err) {
+        if (Date.now() - started >= timeoutMs) throw err;
+        await new Promise((resolve) => setTimeout(resolve, 10));
+      }
+    }
+  }
+
+  // Helper: get fetch headers
+  function getFetchHeaders(callIndex: number): Headers | undefined {
+    const [input, init] = mockFetch.mock.calls[callIndex] ?? [];
+    if (init?.headers) {
+      return init.headers instanceof Headers ? init.headers : new Headers(init.headers);
+    }
+    if (input instanceof Request) {
+      return input.headers;
+    }
+    return undefined;
+  }
+
+  // Helper: get fetch URL
+  function getFetchUrl(callIndex: number): string | Request | undefined {
+    const [input] = mockFetch.mock.calls[callIndex] ?? [];
+    return input;
+  }
+
+  // Cleanup function
+  function tearDown(): void {
+    globalThis.fetch = originalFetch;
+    clearMockAccounts();
+  }
+
+  if (!result.fetch) {
+    throw new Error("Plugin did not return a fetch function");
+  }
+
+  return {
+    fetch: result.fetch,
+    mockFetch,
+    tearDown,
+    waitFor,
+    getFetchHeaders,
+    getFetchUrl,
+  };
+}

package/src/__tests__/helpers/sse.smoke.test.ts

@@ -0,0 +1,243 @@
+import { describe, it, expect } from "vitest";
+import {
+  encodeSSEEvent,
+  encodeSSEStream,
+  chunkUtf8AtOffsets,
+  makeSSEResponse,
+  makeTruncatedSSEResponse,
+  makeMalformedSSEResponse,
+  messageStartEvent,
+  contentBlockStartEvent,
+  contentBlockDeltaEvent,
+  contentBlockStopEvent,
+  messageDeltaEvent,
+  messageStopEvent,
+  errorEvent,
+} from "./sse";
+
+describe("sse helpers", () => {
+  describe("encodeSSEEvent", () => {
+    it("formats a basic event with data", () => {
+      const event = { data: "hello world" };
+      const encoded = encodeSSEEvent(event);
+      expect(encoded).toBe("data: hello world\n\n");
+    });
+
+    it("includes event type when provided", () => {
+      const event = { event: "message", data: "hello" };
+      const encoded = encodeSSEEvent(event);
+      expect(encoded).toBe("event: message\ndata: hello\n\n");
+    });
+
+    it("splits multiline data into multiple data lines", () => {
+      const event = { data: "line1\nline2\nline3" };
+      const encoded = encodeSSEEvent(event);
+      expect(encoded).toBe("data: line1\ndata: line2\ndata: line3\n\n");
+    });
+
+    it("includes id when provided", () => {
+      const event = { data: "hello", id: "123" };
+      const encoded = encodeSSEEvent(event);
+      expect(encoded).toBe("data: hello\nid: 123\n\n");
+    });
+
+    it("includes retry when provided", () => {
+      const event = { data: "hello", retry: 5000 };
+      const encoded = encodeSSEEvent(event);
+      expect(encoded).toBe("data: hello\nretry: 5000\n\n");
+    });
+
+    it("includes all fields when provided", () => {
+      const event = { event: "message", data: "hello", id: "123", retry: 5000 };
+      const encoded = encodeSSEEvent(event);
+      expect(encoded).toBe("event: message\ndata: hello\nid: 123\nretry: 5000\n\n");
+    });
+  });
+
+  describe("encodeSSEStream", () => {
+    it("joins multiple events", () => {
+      const events = [{ data: "event1" }, { data: "event2" }];
+      const encoded = encodeSSEStream(events);
+      expect(encoded).toBe("data: event1\n\ndata: event2\n\n");
+    });
+
+    it("returns empty string for empty events array", () => {
+      const encoded = encodeSSEStream([]);
+      expect(encoded).toBe("");
+    });
+  });
+
+  describe("chunkUtf8AtOffsets", () => {
+    it("splits ASCII text at byte offsets", () => {
+      const chunks = chunkUtf8AtOffsets("hello world", [5, 8]);
+      const decoder = new TextDecoder();
+      expect(chunks.map((c) => decoder.decode(c))).toEqual(["hello", " wo", "rld"]);
+    });
+
+    it("handles multi-byte UTF-8 characters safely", () => {
+      const chunks = chunkUtf8AtOffsets("café", [1, 2, 3]);
+      const decoder = new TextDecoder();
+      const decoded = chunks.map((c) => decoder.decode(c));
+      expect(decoded).toEqual(["c", "a", "f", "é"]);
+    });
+
+    it("handles emoji (4-byte UTF-8)", () => {
+      const chunks = chunkUtf8AtOffsets("hello 🎉 world", [5, 6]);
+      const decoder = new TextDecoder();
+      const decoded = chunks.map((c) => decoder.decode(c));
+      expect(decoded).toEqual(["hello", " ", "🎉 world"]);
+    });
+
+    it("deduplicates and sorts offsets", () => {
+      const chunks = chunkUtf8AtOffsets("hello", [3, 1, 3, 2]);
+      const decoder = new TextDecoder();
+      expect(chunks.map((c) => decoder.decode(c))).toEqual(["h", "e", "l", "lo"]);
+    });
+
+    it("ignores offsets beyond string length", () => {
+      const chunks = chunkUtf8AtOffsets("hi", [1, 5, 10]);
+      const decoder = new TextDecoder();
+      expect(chunks.map((c) => decoder.decode(c))).toEqual(["h", "i"]);
+    });
+
+    it("ignores offsets at or before current position", () => {
+      const chunks = chunkUtf8AtOffsets("hello", [0, 0, 1]);
+      const decoder = new TextDecoder();
+      expect(chunks.map((c) => decoder.decode(c))).toEqual(["h", "ello"]);
+    });
+  });
+
+  describe("makeSSEResponse", () => {
+    it("creates response with text/event-stream content-type", () => {
+      const response = makeSSEResponse("data: hello\n\n");
+      expect(response.headers.get("content-type")).toBe("text/event-stream");
+      expect(response.status).toBe(200);
+    });
+
+    it("accepts custom status code", () => {
+      const response = makeSSEResponse("data: hello\n\n", { status: 201 });
+      expect(response.status).toBe(201);
+    });
+
+    it("accepts ReadableStream body", async () => {
+      const encoder = new TextEncoder();
+      const stream = new ReadableStream<Uint8Array>({
+        start(controller) {
+          controller.enqueue(encoder.encode("data: hello\n\n"));
+          controller.close();
+        },
+      });
+      const response = makeSSEResponse(stream);
+      const text = await response.text();
+      expect(text).toBe("data: hello\n\n");
+    });
+  });
+
+  describe("makeTruncatedSSEResponse", () => {
+    it("emits only specified number of events", async () => {
+      const events = [{ data: "event1" }, { data: "event2" }, { data: "event3" }];
+      const response = makeTruncatedSSEResponse(events, 2);
+      const text = await response.text();
+      expect(text).toContain("data: event1");
+      expect(text).toContain("data: event2");
+      expect(text).not.toContain("data: event3");
+    });
+
+    it("has text/event-stream content-type", () => {
+      const events = [{ data: "event1" }];
+      const response = makeTruncatedSSEResponse(events, 1);
+      expect(response.headers.get("content-type")).toBe("text/event-stream");
+    });
+  });
+
+  describe("makeMalformedSSEResponse", () => {
+    it("emits malformed content directly", async () => {
+      const response = makeMalformedSSEResponse("not valid sse");
+      const text = await response.text();
+      expect(text).toBe("not valid sse");
+    });
+
+    it("has text/event-stream content-type", () => {
+      const response = makeMalformedSSEResponse("malformed");
+      expect(response.headers.get("content-type")).toBe("text/event-stream");
+    });
+  });
+
+  describe("typed event factories", () => {
+    describe("messageStartEvent", () => {
+      it("creates a message_start event", () => {
+        const event = messageStartEvent();
+        const parsed = JSON.parse(event.data);
+        expect(parsed.type).toBe("message_start");
+        expect(parsed.message.role).toBe("assistant");
+      });
+
+      it("accepts overrides", () => {
+        const event = messageStartEvent({ message: { id: "custom_id" } as any });
+        const parsed = JSON.parse(event.data);
+        expect(parsed.message.id).toBe("custom_id");
+      });
+    });
+
+    describe("contentBlockStartEvent", () => {
+      it("creates a content_block_start event", () => {
+        const event = contentBlockStartEvent(0);
+        const parsed = JSON.parse(event.data);
+        expect(parsed.type).toBe("content_block_start");
+        expect(parsed.index).toBe(0);
+      });
+
+      it("accepts overrides", () => {
+        const event = contentBlockStartEvent(1, { content_block: { type: "tool_use", name: "read_file" } });
+        const parsed = JSON.parse(event.data);
+        expect(parsed.index).toBe(1);
+        expect(parsed.content_block.type).toBe("tool_use");
+      });
+    });
+
+    describe("contentBlockDeltaEvent", () => {
+      it("creates a content_block_delta event", () => {
+        const event = contentBlockDeltaEvent(0, "hello");
+        const parsed = JSON.parse(event.data);
+        expect(parsed.type).toBe("content_block_delta");
+        expect(parsed.delta.text).toBe("hello");
+      });
+    });
+
+    describe("contentBlockStopEvent", () => {
+      it("creates a content_block_stop event", () => {
+        const event = contentBlockStopEvent(0);
+        const parsed = JSON.parse(event.data);
+        expect(parsed.type).toBe("content_block_stop");
+        expect(parsed.index).toBe(0);
+      });
+    });
+
+    describe("messageDeltaEvent", () => {
+      it("creates a message_delta event", () => {
+        const event = messageDeltaEvent();
+        const parsed = JSON.parse(event.data);
+        expect(parsed.type).toBe("message_delta");
+        expect(parsed.delta.stop_reason).toBe("end_turn");
+      });
+    });
+
+    describe("messageStopEvent", () => {
+      it("creates a message_stop event", () => {
+        const event = messageStopEvent();
+        const parsed = JSON.parse(event.data);
+        expect(parsed.type).toBe("message_stop");
+      });
+    });
+
+    describe("errorEvent", () => {
+      it("creates an error event", () => {
+        const event = errorEvent("rate_limit_error", "Rate limit exceeded");
+        const parsed = JSON.parse(event.data);
+        expect(parsed.type).toBe("error");
+        expect(parsed.error.type).toBe("rate_limit_error");
+        expect(parsed.error.message).toBe("Rate limit exceeded");
+      });
+    });
+  });
+});