@clinebot/core 0.0.35 → 0.0.36

package/src/account/featurebase-token.test.ts

@@ -1,175 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { ClineAccountService } from "./cline-account-service";
-import {
-	type ClineAccountOperations,
-	executeRpcClineAccountAction,
-	RpcClineAccountService,
-} from "./rpc";
-
-describe("ClineAccountService.fetchFeaturebaseToken", () => {
-	it("returns featurebaseJwt on success", async () => {
-		const fetchImpl = vi.fn(async (input: unknown, init?: RequestInit) => {
-			expect(String(input)).toBe(
-				"https://api.cline.bot/api/v1/users/me/featurebase-token",
-			);
-			expect(init?.headers).toMatchObject({
-				Authorization: "Bearer workos:token-123",
-			});
-			return new Response(
-				JSON.stringify({
-					success: true,
-					data: { featurebaseJwt: "eyJhbGciOiJIUzI1NiJ9.test.sig" },
-				}),
-				{ status: 200, headers: { "Content-Type": "application/json" } },
-			);
-		});
-
-		const service = new ClineAccountService({
-			apiBaseUrl: "https://api.cline.bot",
-			getAuthToken: async () => "workos:token-123",
-			fetchImpl: fetchImpl as unknown as typeof fetch,
-		});
-
-		const result = await service.fetchFeaturebaseToken();
-		expect(result).toEqual({
-			featurebaseJwt: "eyJhbGciOiJIUzI1NiJ9.test.sig",
-		});
-		expect(fetchImpl).toHaveBeenCalledTimes(1);
-	});
-
-	it("returns undefined on network/request error", async () => {
-		const fetchImpl = vi.fn(async () => {
-			throw new Error("Network error");
-		});
-
-		const service = new ClineAccountService({
-			apiBaseUrl: "https://api.cline.bot",
-			getAuthToken: async () => "workos:token-123",
-			fetchImpl: fetchImpl as unknown as typeof fetch,
-		});
-
-		const result = await service.fetchFeaturebaseToken();
-		expect(result).toBeUndefined();
-	});
-
-	it("returns undefined when auth token is missing", async () => {
-		const fetchImpl = vi.fn();
-
-		const service = new ClineAccountService({
-			apiBaseUrl: "https://api.cline.bot",
-			getAuthToken: async () => undefined,
-			fetchImpl: fetchImpl as unknown as typeof fetch,
-		});
-
-		const result = await service.fetchFeaturebaseToken();
-		expect(result).toBeUndefined();
-		expect(fetchImpl).not.toHaveBeenCalled();
-	});
-
-	it("returns undefined on HTTP error response", async () => {
-		const fetchImpl = vi.fn(async () => {
-			return new Response(JSON.stringify({ error: "Unauthorized" }), {
-				status: 401,
-				headers: { "Content-Type": "application/json" },
-			});
-		});
-
-		const service = new ClineAccountService({
-			apiBaseUrl: "https://api.cline.bot",
-			getAuthToken: async () => "workos:token-123",
-			fetchImpl: fetchImpl as unknown as typeof fetch,
-		});
-
-		const result = await service.fetchFeaturebaseToken();
-		expect(result).toBeUndefined();
-	});
-});
-
-describe("executeRpcClineAccountAction - fetchFeaturebaseToken", () => {
-	it("dispatches fetchFeaturebaseToken", async () => {
-		const service: ClineAccountOperations = {
-			fetchMe: vi.fn(async () => ({
-				id: "u1",
-				email: "user1@example.com",
-				displayName: "User 1",
-				photoUrl: "",
-				createdAt: "2025-01-01T00:00:00Z",
-				updatedAt: "2025-01-01T00:00:00Z",
-				organizations: [],
-			})),
-			fetchBalance: vi.fn(async () => ({ balance: 1, userId: "u1" })),
-			fetchUsageTransactions: vi.fn(async () => []),
-			fetchPaymentTransactions: vi.fn(async () => []),
-			fetchUserOrganizations: vi.fn(async () => []),
-			fetchOrganizationBalance: vi.fn(async () => ({
-				balance: 1,
-				organizationId: "org-1",
-			})),
-			fetchOrganizationUsageTransactions: vi.fn(async () => []),
-			switchAccount: vi.fn(async () => {}),
-			fetchFeaturebaseToken: vi.fn(async () => ({
-				featurebaseJwt: "mock-jwt-token",
-			})),
-		};
-
-		const result = await executeRpcClineAccountAction(
-			{ action: "clineAccount", operation: "fetchFeaturebaseToken" },
-			service,
-		);
-		expect(service.fetchFeaturebaseToken).toHaveBeenCalledTimes(1);
-		expect(result).toEqual({ featurebaseJwt: "mock-jwt-token" });
-	});
-
-	it("returns undefined when fetchFeaturebaseToken is not implemented", async () => {
-		const service: ClineAccountOperations = {
-			fetchMe: vi.fn(async () => ({
-				id: "u1",
-				email: "user1@example.com",
-				displayName: "User 1",
-				photoUrl: "",
-				createdAt: "2025-01-01T00:00:00Z",
-				updatedAt: "2025-01-01T00:00:00Z",
-				organizations: [],
-			})),
-			fetchBalance: vi.fn(async () => ({ balance: 1, userId: "u1" })),
-			fetchUsageTransactions: vi.fn(async () => []),
-			fetchPaymentTransactions: vi.fn(async () => []),
-			fetchUserOrganizations: vi.fn(async () => []),
-			fetchOrganizationBalance: vi.fn(async () => ({
-				balance: 1,
-				organizationId: "org-1",
-			})),
-			fetchOrganizationUsageTransactions: vi.fn(async () => []),
-			switchAccount: vi.fn(async () => {}),
-		};
-
-		const result = await executeRpcClineAccountAction(
-			{ action: "clineAccount", operation: "fetchFeaturebaseToken" },
-			service,
-		);
-		expect(result).toBeUndefined();
-	});
-});
-
-describe("RpcClineAccountService.fetchFeaturebaseToken", () => {
-	it("sends provider action payload and parses response", async () => {
-		const runProviderAction = vi.fn(async (request: unknown) => {
-			const parsed = request as {
-				action: string;
-				operation: string;
-			};
-			expect(parsed).toEqual({
-				action: "clineAccount",
-				operation: "fetchFeaturebaseToken",
-			});
-			return {
-				result: { featurebaseJwt: "rpc-jwt-token" },
-			};
-		});
-		const service = new RpcClineAccountService({ runProviderAction });
-
-		const result = await service.fetchFeaturebaseToken();
-		expect(runProviderAction).toHaveBeenCalledTimes(1);
-		expect(result).toEqual({ featurebaseJwt: "rpc-jwt-token" });
-	});
-});

package/src/account/rpc.test.ts

@@ -1,63 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import {
-	type ClineAccountOperations,
-	executeRpcClineAccountAction,
-	RpcClineAccountService,
-} from "./rpc";
-
-describe("executeRpcClineAccountAction", () => {
-	it("dispatches fetchMe", async () => {
-		const service: ClineAccountOperations = {
-			fetchMe: vi.fn(async () => ({
-				id: "u1",
-				email: "user1@example.com",
-				displayName: "User 1",
-				photoUrl: "",
-				createdAt: "2025-01-01T00:00:00Z",
-				updatedAt: "2025-01-01T00:00:00Z",
-				organizations: [],
-			})),
-			fetchBalance: vi.fn(async () => ({ balance: 1, userId: "u1" })),
-			fetchUsageTransactions: vi.fn(async () => []),
-			fetchPaymentTransactions: vi.fn(async () => []),
-			fetchUserOrganizations: vi.fn(async () => []),
-			fetchOrganizationBalance: vi.fn(async () => ({
-				balance: 1,
-				organizationId: "org-1",
-			})),
-			fetchOrganizationUsageTransactions: vi.fn(async () => []),
-			switchAccount: vi.fn(async () => {}),
-			fetchFeaturebaseToken: vi.fn(async () => undefined),
-		};
-
-		const result = await executeRpcClineAccountAction(
-			{ action: "clineAccount", operation: "fetchMe" },
-			service,
-		);
-		expect(service.fetchMe).toHaveBeenCalledTimes(1);
-		expect(result).toMatchObject({ id: "u1" });
-	});
-});
-
-describe("RpcClineAccountService", () => {
-	it("sends provider action payload and parses response", async () => {
-		const runProviderAction = vi.fn(async (request: unknown) => {
-			const parsed = request as {
-				action: string;
-				operation: string;
-			};
-			expect(parsed).toEqual({
-				action: "clineAccount",
-				operation: "fetchMe",
-			});
-			return {
-				result: { id: "u2", email: "u2@example.com" },
-			};
-		});
-		const service = new RpcClineAccountService({ runProviderAction });
-
-		const me = await service.fetchMe();
-		expect(runProviderAction).toHaveBeenCalledTimes(1);
-		expect(me).toEqual({ id: "u2", email: "u2@example.com" });
-	});
-});

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);
-	});
-});