@clinebot/core 0.0.34 → 0.0.36

package/src/auth/bounded-ttl-cache.test.ts

@@ -1,38 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { BoundedTtlCache } from "./bounded-ttl-cache";
-
-describe("BoundedTtlCache", () => {
-	it("returns undefined after TTL", () => {
-		const cache = new BoundedTtlCache(1_000, 10);
-		cache.set("a", "one", 0);
-		expect(cache.get("a", 500)).toBe("one");
-		expect(cache.get("a", 1_500)).toBeUndefined();
-	});
-
-	it("evicts oldest entries when over max size", () => {
-		const cache = new BoundedTtlCache(60_000, 2);
-		cache.set("a", "1", 0);
-		cache.set("b", "2", 0);
-		cache.set("c", "3", 0);
-		expect(cache.get("a", 0)).toBeUndefined();
-		expect(cache.get("b", 0)).toBe("2");
-		expect(cache.get("c", 0)).toBe("3");
-	});
-
-	it("refreshes recency on get so hot keys survive eviction", () => {
-		const cache = new BoundedTtlCache(60_000, 2);
-		cache.set("a", "1", 0);
-		cache.set("b", "2", 0);
-		expect(cache.get("a", 0)).toBe("1");
-		cache.set("c", "3", 0);
-		expect(cache.get("a", 0)).toBe("1");
-		expect(cache.get("b", 0)).toBeUndefined();
-	});
-
-	it("supports per-entry TTL override", () => {
-		const cache = new BoundedTtlCache(60_000, 2);
-		cache.set("short", "v", 0, 1_000);
-		expect(cache.get("short", 500)).toBe("v");
-		expect(cache.get("short", 1_500)).toBeUndefined();
-	});
-});

package/src/auth/client.test.ts

@@ -1,69 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { createOAuthClientCallbacks } from "./client";
-
-describe("auth/client createOAuthClientCallbacks", () => {
-	it("emits instructions and URL and forwards prompts", async () => {
-		const onOutput = vi.fn();
-		const onPrompt = vi.fn().mockResolvedValue("value");
-		const callbacks = createOAuthClientCallbacks({ onOutput, onPrompt });
-
-		callbacks.onAuth({
-			url: "https://example.com/auth",
-			instructions: "Open your browser",
-		});
-		const answer = await callbacks.onPrompt({ message: "Enter code" });
-
-		expect(answer).toBe("value");
-		expect(onPrompt).toHaveBeenCalledWith({ message: "Enter code" });
-		expect(onOutput).toHaveBeenNthCalledWith(1, "Open your browser");
-		expect(onOutput).toHaveBeenNthCalledWith(2, "https://example.com/auth");
-	});
-
-	it("tries opening URL and reports opener errors", async () => {
-		const openUrl = vi.fn().mockRejectedValue(new Error("failed"));
-		const onOpenUrlError = vi.fn();
-		const callbacks = createOAuthClientCallbacks({
-			onPrompt: vi.fn().mockResolvedValue(""),
-			openUrl,
-			onOpenUrlError,
-		});
-
-		callbacks.onAuth({ url: "https://example.com/auth" });
-		await Promise.resolve();
-
-		expect(openUrl).toHaveBeenCalledWith("https://example.com/auth");
-		expect(onOpenUrlError).toHaveBeenCalledTimes(1);
-		expect(onOpenUrlError.mock.calls[0]?.[0]).toMatchObject({
-			url: "https://example.com/auth",
-		});
-	});
-
-	it("forwards onServerListening to the returned callbacks", () => {
-		const onServerListening = vi.fn();
-		const callbacks = createOAuthClientCallbacks({
-			onPrompt: vi.fn().mockResolvedValue(""),
-			onServerListening,
-		});
-
-		expect(callbacks.onServerListening).toBe(onServerListening);
-	});
-
-	it("forwards onServerClose to the returned callbacks", () => {
-		const onServerClose = vi.fn();
-		const callbacks = createOAuthClientCallbacks({
-			onPrompt: vi.fn().mockResolvedValue(""),
-			onServerClose,
-		});
-
-		expect(callbacks.onServerClose).toBe(onServerClose);
-	});
-
-	it("leaves onServerListening and onServerClose undefined when not provided", () => {
-		const callbacks = createOAuthClientCallbacks({
-			onPrompt: vi.fn().mockResolvedValue(""),
-		});
-
-		expect(callbacks.onServerListening).toBeUndefined();
-		expect(callbacks.onServerClose).toBeUndefined();
-	});
-});

package/src/auth/cline.test.ts

@@ -1,267 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-import type { ClineOAuthCredentials } from "./cline";
-import { getValidClineCredentials, loginClineOAuth } from "./cline";
-
-const PROVIDER_OPTIONS = {
-	apiBaseUrl: "https://auth.example.com",
-};
-const ORIGINAL_FETCH = globalThis.fetch;
-
-function createCredentials(
-	overrides: Partial<ClineOAuthCredentials> = {},
-): ClineOAuthCredentials {
-	return {
-		access: "access-old",
-		refresh: "refresh-old",
-		expires: 0,
-		accountId: "acct-1",
-		email: "user@example.com",
-		metadata: { provider: "google" },
-		...overrides,
-	};
-}
-
-describe("auth/cline getValidClineCredentials", () => {
-	afterEach(() => {
-		vi.restoreAllMocks();
-		globalThis.fetch = ORIGINAL_FETCH;
-	});
-
-	it("returns existing credentials when not expired", async () => {
-		const nowSpy = vi.spyOn(Date, "now").mockReturnValue(10_000);
-		const current = createCredentials({ expires: 400_000 });
-		const fetchMock = vi.fn();
-		globalThis.fetch = fetchMock as unknown as typeof fetch;
-
-		const result = await getValidClineCredentials(current, PROVIDER_OPTIONS);
-		expect(result).toBe(current);
-		expect(fetchMock).not.toHaveBeenCalled();
-		nowSpy.mockRestore();
-	});
-
-	it("refreshes expired credentials", async () => {
-		const nowSpy = vi.spyOn(Date, "now").mockReturnValue(100_000);
-		const current = createCredentials({ expires: 101_000 });
-		const fetchMock = vi.fn(
-			async () =>
-				new Response(
-					JSON.stringify({
-						success: true,
-						data: {
-							accessToken: "access-new",
-							refreshToken: "refresh-new",
-							tokenType: "Bearer",
-							expiresAt: "2030-01-01T00:00:00.000Z",
-							userInfo: {
-								subject: "sub-1",
-								email: "new@example.com",
-								name: "New User",
-								clineUserId: "acct-2",
-								accounts: [],
-							},
-						},
-					}),
-					{ status: 200, headers: { "Content-Type": "application/json" } },
-				),
-		);
-		globalThis.fetch = fetchMock as unknown as typeof fetch;
-
-		const result = await getValidClineCredentials(current, PROVIDER_OPTIONS);
-		expect(result).toMatchObject({
-			access: "access-new",
-			refresh: "refresh-new",
-			accountId: "acct-2",
-			email: "new@example.com",
-		});
-		nowSpy.mockRestore();
-	});
-
-	it("returns null when refresh fails with invalid_grant", async () => {
-		const nowSpy = vi.spyOn(Date, "now").mockReturnValue(100_000);
-		const current = createCredentials({ expires: 101_000 });
-		globalThis.fetch = vi.fn(
-			async () =>
-				new Response(
-					JSON.stringify({
-						error: "invalid_grant",
-						error_description: "refresh expired",
-					}),
-					{
-						status: 401,
-						headers: { "Content-Type": "application/json" },
-					},
-				),
-		) as unknown as typeof fetch;
-
-		const result = await getValidClineCredentials(current, PROVIDER_OPTIONS);
-		expect(result).toBeNull();
-		nowSpy.mockRestore();
-	});
-
-	it("keeps current credentials on transient refresh error while token remains valid", async () => {
-		const nowSpy = vi.spyOn(Date, "now").mockReturnValue(100_000);
-		const current = createCredentials({ expires: 150_000 });
-		globalThis.fetch = vi.fn(
-			async () =>
-				new Response(
-					JSON.stringify({
-						error: "server_error",
-						error_description: "temporary issue",
-					}),
-					{
-						status: 500,
-						headers: { "Content-Type": "application/json" },
-					},
-				),
-		) as unknown as typeof fetch;
-
-		const result = await getValidClineCredentials(current, PROVIDER_OPTIONS, {
-			refreshBufferMs: 60_000,
-			retryableTokenGraceMs: 30_000,
-		});
-		expect(result).toBe(current);
-		nowSpy.mockRestore();
-	});
-});
-
-describe("auth/cline loginClineOAuth", () => {
-	afterEach(() => {
-		vi.restoreAllMocks();
-		globalThis.fetch = ORIGINAL_FETCH;
-	});
-
-	it("completes WorkOS device auth and registers tokens", async () => {
-		const fetchMock = vi
-			.fn()
-			.mockResolvedValueOnce(
-				new Response(
-					JSON.stringify({
-						device_code: "dev-code-1",
-						user_code: "ABCD-EFGH",
-						verification_uri: "https://example.com/device",
-						verification_uri_complete:
-							"https://example.com/device?user_code=ABCD-EFGH",
-						expires_in: 300,
-						interval: 1,
-					}),
-					{ status: 200, headers: { "Content-Type": "application/json" } },
-				),
-			)
-			.mockResolvedValueOnce(
-				new Response(
-					JSON.stringify({
-						access_token: "workos-access",
-						refresh_token: "workos-refresh",
-						token_type: "Bearer",
-						expires_in: 3600,
-					}),
-					{ status: 200, headers: { "Content-Type": "application/json" } },
-				),
-			)
-			.mockResolvedValueOnce(
-				new Response(
-					JSON.stringify({
-						success: true,
-						data: {
-							accessToken: "cline-access",
-							refreshToken: "cline-refresh",
-							tokenType: "Bearer",
-							expiresAt: "2030-01-01T00:00:00.000Z",
-							userInfo: {
-								subject: "sub-1",
-								email: "user@example.com",
-								name: "User",
-								clineUserId: "acct-1",
-								accounts: ["acct-1"],
-							},
-						},
-					}),
-					{ status: 200, headers: { "Content-Type": "application/json" } },
-				),
-			);
-		globalThis.fetch = fetchMock as unknown as typeof fetch;
-
-		const onAuth = vi.fn();
-		const credentials = await loginClineOAuth({
-			apiBaseUrl: "https://api.cline.bot",
-			useWorkOSDeviceAuth: true,
-			callbacks: {
-				onAuth,
-				onPrompt: async () => "",
-			},
-		});
-
-		expect(onAuth).toHaveBeenCalledTimes(1);
-		expect(onAuth.mock.calls[0]?.[0]).toMatchObject({
-			url: "https://example.com/device?user_code=ABCD-EFGH",
-		});
-		expect(credentials).toMatchObject({
-			access: "cline-access",
-			refresh: "cline-refresh",
-			accountId: "acct-1",
-			email: "user@example.com",
-		});
-		expect(fetchMock).toHaveBeenCalledTimes(3);
-		const registerCallBody = JSON.parse(
-			String(fetchMock.mock.calls[2]?.[1]?.body ?? "{}"),
-		);
-		const deviceAuthBody = String(fetchMock.mock.calls[0]?.[1]?.body ?? "");
-		const deviceAuthParams = new URLSearchParams(deviceAuthBody);
-		expect(deviceAuthParams.get("client_id")).toMatch(/client_.*/);
-		expect(registerCallBody).toMatchObject({
-			accessToken: "workos-access",
-			refreshToken: "workos-refresh",
-		});
-	});
-
-	it("uses legacy callback OAuth flow by default", async () => {
-		const fetchMock = vi.fn(async (_url: string, init?: RequestInit) => {
-			const body =
-				typeof init?.body === "string"
-					? (JSON.parse(init.body) as Record<string, unknown>)
-					: {};
-			if (body.grant_type === "authorization_code") {
-				return new Response(
-					JSON.stringify({
-						success: true,
-						data: {
-							accessToken: "legacy-access",
-							refreshToken: "legacy-refresh",
-							tokenType: "Bearer",
-							expiresAt: "2030-01-01T00:00:00.000Z",
-							userInfo: {
-								subject: "sub-legacy",
-								email: "legacy@example.com",
-								name: "Legacy User",
-								clineUserId: "acct-legacy",
-								accounts: ["acct-legacy"],
-							},
-						},
-					}),
-					{ status: 200, headers: { "Content-Type": "application/json" } },
-				);
-			}
-			return new Response("not-found", { status: 404 });
-		});
-		globalThis.fetch = fetchMock as unknown as typeof fetch;
-
-		const credentials = await loginClineOAuth({
-			apiBaseUrl: "https://api.cline.bot",
-			callbackPorts: [48801],
-			callbacks: {
-				onAuth: () => {},
-				onPrompt: async () => "http://127.0.0.1:48801/auth?code=legacy-code",
-				onManualCodeInput: async () =>
-					"http://127.0.0.1:48801/auth?code=legacy-code",
-			},
-		});
-
-		expect(credentials).toMatchObject({
-			access: "legacy-access",
-			refresh: "legacy-refresh",
-			accountId: "acct-legacy",
-			email: "legacy@example.com",
-		});
-		expect(fetchMock).toHaveBeenCalledTimes(1);
-	});
-});

package/src/auth/codex.test.ts

@@ -1,170 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-import {
-	getValidOpenAICodexCredentials,
-	normalizeOpenAICodexCredentials,
-	refreshOpenAICodexToken,
-} from "./codex";
-import type { OAuthCredentials } from "./types";
-
-function toBase64Url(value: string): string {
-	return Buffer.from(value, "utf8").toString("base64url");
-}
-
-function createJwt(payload: Record<string, unknown>): string {
-	return `${toBase64Url(JSON.stringify({ alg: "none", typ: "JWT" }))}.${toBase64Url(JSON.stringify(payload))}.sig`;
-}
-
-function createCredentials(
-	overrides: Partial<OAuthCredentials> = {},
-): OAuthCredentials {
-	return {
-		access: "access-old",
-		refresh: "refresh-old",
-		expires: 0,
-		accountId: "acct-old",
-		email: "old@example.com",
-		metadata: { provider: "openai-codex" },
-		...overrides,
-	};
-}
-
-describe("auth/codex token lifecycle", () => {
-	afterEach(() => {
-		vi.unstubAllGlobals();
-		vi.restoreAllMocks();
-	});
-
-	it("returns current credentials when not expired", async () => {
-		const nowSpy = vi.spyOn(Date, "now").mockReturnValue(10_000);
-		const current = createCredentials({ expires: 400_000 });
-		const fetchMock = vi.fn();
-		vi.stubGlobal("fetch", fetchMock);
-
-		const result = await getValidOpenAICodexCredentials(current);
-		expect(result).toBe(current);
-		expect(fetchMock).not.toHaveBeenCalled();
-		nowSpy.mockRestore();
-	});
-
-	it("refreshes expired credentials and preserves provider metadata", async () => {
-		const nowSpy = vi.spyOn(Date, "now").mockReturnValue(100_000);
-		const idToken = createJwt({
-			"https://api.openai.com/auth": { chatgpt_account_id: "acct-new" },
-			email: "new@example.com",
-		});
-		const accessToken = createJwt({
-			"https://api.openai.com/auth": { chatgpt_account_id: "acct-new" },
-		});
-		vi.stubGlobal(
-			"fetch",
-			vi.fn(
-				async () =>
-					new Response(
-						JSON.stringify({
-							access_token: accessToken,
-							refresh_token: "refresh-new",
-							expires_in: 3600,
-							email: "new@example.com",
-							id_token: idToken,
-						}),
-						{ status: 200, headers: { "Content-Type": "application/json" } },
-					),
-			),
-		);
-
-		const current = createCredentials({ expires: 110_000 });
-		const result = await getValidOpenAICodexCredentials(current);
-		expect(result).toMatchObject({
-			access: accessToken,
-			refresh: "refresh-new",
-			accountId: "acct-new",
-			email: "new@example.com",
-			metadata: { provider: "openai-codex" },
-		});
-		nowSpy.mockRestore();
-	});
-
-	it("returns null on invalid_grant refresh errors", async () => {
-		const nowSpy = vi.spyOn(Date, "now").mockReturnValue(100_000);
-		vi.stubGlobal(
-			"fetch",
-			vi.fn(
-				async () =>
-					new Response(
-						JSON.stringify({
-							error: "invalid_grant",
-							error_description: "token revoked",
-						}),
-						{
-							status: 400,
-							headers: { "Content-Type": "application/json" },
-						},
-					),
-			),
-		);
-
-		const result = await getValidOpenAICodexCredentials(
-			createCredentials({ expires: 120_000 }),
-		);
-		expect(result).toBeNull();
-		nowSpy.mockRestore();
-	});
-
-	it("keeps current credentials on non-invalid transient refresh failures when still valid", async () => {
-		const nowSpy = vi.spyOn(Date, "now").mockReturnValue(100_000);
-		vi.stubGlobal(
-			"fetch",
-			vi.fn(
-				async () =>
-					new Response(
-						JSON.stringify({
-							error: "server_error",
-							error_description: "try again",
-						}),
-						{
-							status: 500,
-							headers: { "Content-Type": "application/json" },
-						},
-					),
-			),
-		);
-
-		const current = createCredentials({ expires: 150_000 });
-		const result = await getValidOpenAICodexCredentials(current, {
-			refreshBufferMs: 60_000,
-			retryableTokenGraceMs: 30_000,
-		});
-		expect(result).toBe(current);
-		nowSpy.mockRestore();
-	});
-
-	it("normalizes credentials by deriving accountId from access token", () => {
-		const accessToken = createJwt({
-			"https://api.openai.com/auth": { chatgpt_account_id: "acct-derived" },
-		});
-		const normalized = normalizeOpenAICodexCredentials({
-			access: accessToken,
-			refresh: "refresh",
-			expires: 1,
-		});
-		expect(normalized.accountId).toBe("acct-derived");
-		expect(normalized.metadata).toMatchObject({ provider: "openai-codex" });
-	});
-
-	it("refreshOpenAICodexToken throws when response is structurally invalid", async () => {
-		vi.stubGlobal(
-			"fetch",
-			vi.fn(
-				async () =>
-					new Response(JSON.stringify({ access_token: "only-access" }), {
-						status: 200,
-						headers: { "Content-Type": "application/json" },
-					}),
-			),
-		);
-
-		await expect(refreshOpenAICodexToken("refresh")).rejects.toThrow(
-			"Failed to refresh OpenAI Codex token",
-		);
-	});
-});