@clinebot/core 0.0.22 → 0.0.24

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

@@ -0,0 +1,175 @@
+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/index.ts

@@ -0,0 +1,23 @@
+export {
+	ClineAccountService,
+	type ClineAccountServiceOptions,
+} from "./cline-account-service";
+export {
+	type ClineAccountOperations,
+	executeRpcClineAccountAction,
+	isRpcClineAccountActionRequest,
+	RpcClineAccountService,
+	type RpcProviderActionExecutor,
+} from "./rpc";
+export type {
+	ClineAccountBalance,
+	ClineAccountOrganization,
+	ClineAccountOrganizationBalance,
+	ClineAccountOrganizationUsageTransaction,
+	ClineAccountPaymentTransaction,
+	ClineAccountUsageTransaction,
+	ClineAccountUser,
+	ClineOrganization,
+	FeaturebaseTokenResponse,
+	UserRemoteConfigResponse,
+} from "./types";

package/src/account/rpc.test.ts

@@ -0,0 +1,63 @@
+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/account/rpc.ts

@@ -0,0 +1,185 @@
+import type {
+	RpcClineAccountActionRequest,
+	RpcProviderActionRequest,
+} from "@clinebot/shared";
+import type {
+	ClineAccountBalance,
+	ClineAccountOrganization,
+	ClineAccountOrganizationBalance,
+	ClineAccountOrganizationUsageTransaction,
+	ClineAccountPaymentTransaction,
+	ClineAccountUsageTransaction,
+	ClineAccountUser,
+	FeaturebaseTokenResponse,
+} from "./types";
+
+export interface ClineAccountOperations {
+	fetchMe(): Promise<ClineAccountUser>;
+	fetchBalance(userId?: string): Promise<ClineAccountBalance>;
+	fetchUsageTransactions(
+		userId?: string,
+	): Promise<ClineAccountUsageTransaction[]>;
+	fetchPaymentTransactions(
+		userId?: string,
+	): Promise<ClineAccountPaymentTransaction[]>;
+	fetchUserOrganizations(): Promise<ClineAccountOrganization[]>;
+	fetchOrganizationBalance(
+		organizationId: string,
+	): Promise<ClineAccountOrganizationBalance>;
+	fetchOrganizationUsageTransactions(input: {
+		organizationId: string;
+		memberId?: string;
+	}): Promise<ClineAccountOrganizationUsageTransaction[]>;
+	switchAccount(organizationId?: string | null): Promise<void>;
+	fetchFeaturebaseToken?(): Promise<FeaturebaseTokenResponse | undefined>;
+}
+
+export function isRpcClineAccountActionRequest(
+	request: RpcProviderActionRequest,
+): request is RpcClineAccountActionRequest {
+	return request.action === "clineAccount";
+}
+
+export async function executeRpcClineAccountAction(
+	request: RpcClineAccountActionRequest,
+	service: ClineAccountOperations,
+): Promise<unknown> {
+	switch (request.operation) {
+		case "fetchMe":
+			return service.fetchMe();
+		case "fetchBalance":
+			return service.fetchBalance(request.userId);
+		case "fetchUsageTransactions":
+			return service.fetchUsageTransactions(request.userId);
+		case "fetchPaymentTransactions":
+			return service.fetchPaymentTransactions(request.userId);
+		case "fetchUserOrganizations":
+			return service.fetchUserOrganizations();
+		case "fetchOrganizationBalance":
+			return service.fetchOrganizationBalance(request.organizationId);
+		case "fetchOrganizationUsageTransactions":
+			return service.fetchOrganizationUsageTransactions({
+				organizationId: request.organizationId,
+				memberId: request.memberId,
+			});
+		case "switchAccount":
+			await service.switchAccount(request.organizationId);
+			return { updated: true };
+		case "fetchFeaturebaseToken":
+			return service.fetchFeaturebaseToken?.();
+		default: {
+			const exhaustive: never = request;
+			throw new Error(
+				`Unsupported Cline account operation: ${String(exhaustive)}`,
+			);
+		}
+	}
+}
+
+export interface RpcProviderActionExecutor {
+	runProviderAction(request: RpcProviderActionRequest): Promise<{
+		result: unknown;
+	}>;
+}
+
+export class RpcClineAccountService implements ClineAccountOperations {
+	private readonly executor: RpcProviderActionExecutor;
+
+	constructor(executor: RpcProviderActionExecutor) {
+		this.executor = executor;
+	}
+
+	public async fetchMe(): Promise<ClineAccountUser> {
+		return this.request<ClineAccountUser>({
+			action: "clineAccount",
+			operation: "fetchMe",
+		});
+	}
+
+	public async fetchBalance(userId?: string): Promise<ClineAccountBalance> {
+		return this.request<ClineAccountBalance>({
+			action: "clineAccount",
+			operation: "fetchBalance",
+			...(userId?.trim() ? { userId: userId.trim() } : {}),
+		});
+	}
+
+	public async fetchUsageTransactions(
+		userId?: string,
+	): Promise<ClineAccountUsageTransaction[]> {
+		return this.request<ClineAccountUsageTransaction[]>({
+			action: "clineAccount",
+			operation: "fetchUsageTransactions",
+			...(userId?.trim() ? { userId: userId.trim() } : {}),
+		});
+	}
+
+	public async fetchPaymentTransactions(
+		userId?: string,
+	): Promise<ClineAccountPaymentTransaction[]> {
+		return this.request<ClineAccountPaymentTransaction[]>({
+			action: "clineAccount",
+			operation: "fetchPaymentTransactions",
+			...(userId?.trim() ? { userId: userId.trim() } : {}),
+		});
+	}
+
+	public async fetchUserOrganizations(): Promise<ClineAccountOrganization[]> {
+		return this.request<ClineAccountOrganization[]>({
+			action: "clineAccount",
+			operation: "fetchUserOrganizations",
+		});
+	}
+
+	public async fetchOrganizationBalance(
+		organizationId: string,
+	): Promise<ClineAccountOrganizationBalance> {
+		const orgId = organizationId.trim();
+		if (!orgId) {
+			throw new Error("organizationId is required");
+		}
+		return this.request<ClineAccountOrganizationBalance>({
+			action: "clineAccount",
+			operation: "fetchOrganizationBalance",
+			organizationId: orgId,
+		});
+	}
+
+	public async fetchOrganizationUsageTransactions(input: {
+		organizationId: string;
+		memberId?: string;
+	}): Promise<ClineAccountOrganizationUsageTransaction[]> {
+		const orgId = input.organizationId.trim();
+		if (!orgId) {
+			throw new Error("organizationId is required");
+		}
+		return this.request<ClineAccountOrganizationUsageTransaction[]>({
+			action: "clineAccount",
+			operation: "fetchOrganizationUsageTransactions",
+			organizationId: orgId,
+			...(input.memberId?.trim() ? { memberId: input.memberId.trim() } : {}),
+		});
+	}
+
+	public async switchAccount(organizationId?: string | null): Promise<void> {
+		await this.request<{ updated: boolean }>({
+			action: "clineAccount",
+			operation: "switchAccount",
+			organizationId: organizationId?.trim() || null,
+		});
+	}
+
+	public async fetchFeaturebaseToken(): Promise<
+		FeaturebaseTokenResponse | undefined
+	> {
+		return this.request<FeaturebaseTokenResponse | undefined>({
+			action: "clineAccount",
+			operation: "fetchFeaturebaseToken",
+		});
+	}
+
+	private async request<T>(request: RpcClineAccountActionRequest): Promise<T> {
+		const response = await this.executor.runProviderAction(request);
+		return response.result as T;
+	}
+}

package/src/account/types.ts

@@ -0,0 +1,102 @@
+export interface ClineAccountOrganization {
+	active: boolean;
+	memberId: string;
+	name: string;
+	organizationId: string;
+	roles: Array<"admin" | "member" | "owner">;
+}
+
+export interface ClineAccountUser {
+	id: string;
+	email: string;
+	displayName: string;
+	photoUrl: string;
+	createdAt: string;
+	updatedAt: string;
+	organizations: ClineAccountOrganization[];
+}
+
+export interface UserRemoteConfigResponse {
+	organizationId: string;
+	value: string;
+	enabled: boolean;
+}
+
+export interface ClineAccountBalance {
+	balance: number;
+	userId: string;
+}
+
+export interface ClineAccountUsageTransaction {
+	aiInferenceProviderName: string;
+	aiModelName: string;
+	aiModelTypeName: string;
+	completionTokens: number;
+	costUsd: number;
+	createdAt: string;
+	creditsUsed: number;
+	generationId: string;
+	id: string;
+	metadata: {
+		additionalProp1: string;
+		additionalProp2: string;
+		additionalProp3: string;
+	};
+	operation?: string;
+	organizationId: string;
+	promptTokens: number;
+	totalTokens: number;
+	userId: string;
+}
+
+export interface ClineAccountPaymentTransaction {
+	paidAt: string;
+	creatorId: string;
+	amountCents: number;
+	credits: number;
+}
+
+export interface ClineOrganization {
+	createdAt: string;
+	defaultRemoteConfig?: string;
+	deletedAt?: string;
+	externalOrganizationId?: string;
+	id: string;
+	memberCount?: number;
+	name: string;
+	remoteConfigEnabled: boolean;
+	updatedAt: string;
+}
+
+export interface ClineAccountOrganizationBalance {
+	balance: number;
+	organizationId: string;
+}
+
+export interface FeaturebaseTokenResponse {
+	featurebaseJwt: string;
+}
+
+export interface ClineAccountOrganizationUsageTransaction {
+	aiInferenceProviderName: string;
+	aiModelName: string;
+	aiModelTypeName: string;
+	completionTokens: number;
+	costUsd: number;
+	createdAt: string;
+	creditsUsed: number;
+	generationId: string;
+	id: string;
+	memberDisplayName: string;
+	memberEmail: string;
+	metadata: {
+		additionalProp1: string;
+		additionalProp2: string;
+		additionalProp3: string;
+	};
+	operation?: string;
+	organizationId: string;
+	promptTokens: number;
+	totalTokens: number;
+	userId: string;
+}