@clinebot/core 0.0.0

package/dist/team/projections.d.ts

@@ -0,0 +1,8 @@
+import type { TeamEvent, TeamRuntimeState } from "@clinebot/agents";
+import type { TeamProgressLifecycleEvent, TeamProgressSummary } from "@clinebot/shared";
+export declare function buildTeamProgressSummary(teamName: string, state: TeamRuntimeState): TeamProgressSummary;
+export declare function toTeamProgressLifecycleEvent(input: {
+    teamName: string;
+    sessionId: string;
+    event: TeamEvent;
+}): TeamProgressLifecycleEvent;

package/dist/types/common.d.ts

@@ -0,0 +1,10 @@
+export declare const SESSION_STATUSES: readonly ["running", "completed", "failed", "cancelled"];
+export type SessionStatus = (typeof SESSION_STATUSES)[number];
+export declare enum SessionSource {
+    CLI = "cli",
+    CLI_SUBAGENT = "cli-subagent",
+    CORE = "core",
+    CORE_SUBAGENT = "core-subagent",
+    DESKTOP = "desktop",
+    DESKTOP_CHAT = "desktop-chat"
+}

package/dist/types/config.d.ts

@@ -0,0 +1,37 @@
+import type { AgentConfig, AgentHooks, HookErrorMode, TeamEvent, Tool } from "@clinebot/agents";
+import type { providers as LlmsProviders } from "@clinebot/llms";
+import type { AgentMode, BasicLogger, SessionExecutionConfig, SessionPromptConfig, SessionWorkspaceConfig } from "@clinebot/shared";
+export type CoreAgentMode = AgentMode;
+export interface CoreModelConfig {
+    providerId: string;
+    modelId: string;
+    apiKey?: string;
+    baseUrl?: string;
+    headers?: Record<string, string>;
+    providerConfig?: LlmsProviders.ProviderConfig;
+    knownModels?: Record<string, LlmsProviders.ModelInfo>;
+    /**
+     * Request model-side thinking/reasoning when supported.
+     */
+    thinking?: boolean;
+}
+export interface CoreRuntimeFeatures {
+    enableTools: boolean;
+    enableSpawnAgent: boolean;
+    enableAgentTeams: boolean;
+}
+export interface CoreSessionConfig extends CoreModelConfig, CoreRuntimeFeatures, Omit<SessionWorkspaceConfig, "workspaceRoot">, Omit<SessionPromptConfig, "systemPrompt">, Omit<SessionExecutionConfig, "enableTools" | "teamName" | "missionLogIntervalSteps" | "missionLogIntervalMs"> {
+    sessionId?: string;
+    workspaceRoot?: string;
+    systemPrompt: string;
+    teamName?: string;
+    missionLogIntervalSteps?: number;
+    missionLogIntervalMs?: number;
+    hooks?: AgentHooks;
+    hookErrorMode?: HookErrorMode;
+    logger?: BasicLogger;
+    extraTools?: Tool[];
+    pluginPaths?: string[];
+    extensions?: AgentConfig["extensions"];
+    onTeamEvent?: (event: TeamEvent) => void;
+}

package/dist/types/events.d.ts

@@ -0,0 +1,54 @@
+export interface SessionChunkEvent {
+    sessionId: string;
+    stream: "stdout" | "stderr" | "agent";
+    chunk: string;
+    ts: number;
+}
+export interface SessionEndedEvent {
+    sessionId: string;
+    reason: string;
+    ts: number;
+}
+export interface SessionToolEvent {
+    sessionId: string;
+    hookEventName: "tool_call" | "tool_result" | "agent_end" | "session_shutdown";
+    agentId?: string;
+    conversationId?: string;
+    parentAgentId?: string;
+    iteration?: number;
+    toolName?: string;
+    inputTokens?: number;
+    outputTokens?: number;
+    ts?: string;
+}
+export interface SessionTeamProgressEvent {
+    sessionId: string;
+    teamName: string;
+    lifecycle: import("@clinebot/shared").TeamProgressLifecycleEvent;
+    summary: import("@clinebot/shared").TeamProgressSummary;
+}
+export type CoreSessionEvent = {
+    type: "chunk";
+    payload: SessionChunkEvent;
+} | {
+    type: "agent_event";
+    payload: {
+        sessionId: string;
+        event: import("@clinebot/agents").AgentEvent;
+    };
+} | {
+    type: "team_progress";
+    payload: SessionTeamProgressEvent;
+} | {
+    type: "ended";
+    payload: SessionEndedEvent;
+} | {
+    type: "hook";
+    payload: SessionToolEvent;
+} | {
+    type: "status";
+    payload: {
+        sessionId: string;
+        status: string;
+    };
+};

package/dist/types/provider-settings.d.ts

@@ -0,0 +1,20 @@
+import { providers } from "@clinebot/llms";
+import { z } from "zod";
+export type ProviderConfig = providers.ProviderConfig;
+export type ProviderSettings = providers.ProviderSettings;
+export declare const ProviderSettingsSchema: z.ZodType<ProviderSettings>;
+export declare const toProviderConfig: typeof providers.toProviderConfig;
+export type ProviderTokenSource = "manual" | "oauth" | "migration";
+export interface StoredProviderSettingsEntry {
+    settings: ProviderSettings;
+    updatedAt: string;
+    tokenSource: ProviderTokenSource;
+}
+export interface StoredProviderSettings {
+    version: 1;
+    lastUsedProvider?: string;
+    providers: Record<string, StoredProviderSettingsEntry>;
+}
+export declare const StoredProviderSettingsEntrySchema: z.ZodType<StoredProviderSettingsEntry>;
+export declare const StoredProviderSettingsSchema: z.ZodType<StoredProviderSettings>;
+export declare function emptyStoredProviderSettings(): StoredProviderSettings;

package/dist/types/sessions.d.ts

@@ -0,0 +1,9 @@
+import type { SessionLineage, SessionRuntimeRecordShape } from "@clinebot/shared";
+import type { SessionSource, SessionStatus } from "./common";
+export interface SessionRef extends SessionLineage {
+    sessionId: string;
+}
+export interface SessionRecord extends SessionRef, Omit<SessionRuntimeRecordShape, "source" | "status"> {
+    source: SessionSource;
+    status: SessionStatus;
+}

package/dist/types/storage.d.ts

@@ -0,0 +1,37 @@
+import type { TeamEvent, TeamRuntimeState, TeamTeammateSpec } from "@clinebot/agents";
+import type { SessionStatus } from "./common";
+import type { SessionRecord } from "./sessions";
+export interface SessionStore {
+    init(): Promise<void> | void;
+    create(record: SessionRecord): Promise<void> | void;
+    updateStatus(sessionId: string, status: SessionStatus, exitCode?: number | null): Promise<void> | void;
+    update(record: Partial<SessionRecord> & {
+        sessionId: string;
+    }): Promise<void> | void;
+    get(sessionId: string): Promise<SessionRecord | undefined> | SessionRecord | undefined;
+    list(limit?: number): Promise<SessionRecord[]> | SessionRecord[];
+    delete(sessionId: string, cascade?: boolean): Promise<boolean> | boolean;
+}
+export interface TeamStore {
+    listTeamNames(): Promise<string[]> | string[];
+    readState(teamName: string): Promise<TeamRuntimeState | undefined> | TeamRuntimeState | undefined;
+    readHistory(teamName: string, limit?: number): Promise<unknown[]> | unknown[];
+    loadRuntime(teamName: string): Promise<{
+        state?: TeamRuntimeState;
+        teammates: TeamTeammateSpec[];
+        interruptedRunIds: string[];
+    }> | {
+        state?: TeamRuntimeState;
+        teammates: TeamTeammateSpec[];
+        interruptedRunIds: string[];
+    };
+    handleTeamEvent(teamName: string, event: TeamEvent): Promise<void> | void;
+    persistRuntime(teamName: string, state: TeamRuntimeState, teammates: TeamTeammateSpec[]): Promise<void> | void;
+    markInProgressRunsInterrupted(teamName: string, reason: string): Promise<string[]> | string[];
+}
+export interface ArtifactStore {
+    appendTranscript(sessionId: string, text: string): Promise<void> | void;
+    appendHook(sessionId: string, payload: unknown): Promise<void> | void;
+    writeMessages(sessionId: string, messages: unknown[]): Promise<void> | void;
+    readTranscript(sessionId: string, maxChars?: number): Promise<string> | string;
+}

package/dist/types/workspace.d.ts

@@ -0,0 +1,7 @@
+export interface WorkspaceInfo {
+    rootPath: string;
+    hint?: string;
+    associatedRemoteUrls?: string[];
+    latestGitCommitHash?: string;
+    latestGitBranchName?: string;
+}

package/dist/types.d.ts

@@ -0,0 +1,26 @@
+import type { providers as LlmsProviders } from "@clinebot/llms";
+import type { CoreSessionEvent } from "./types/events";
+export type { AgentConfigWatcher, AgentConfigWatcherEvent, AgentYamlConfig, BuildAgentConfigOverridesOptions, CreateAgentConfigWatcherOptions, CreateInstructionWatcherOptions, CreateRulesConfigDefinitionOptions, CreateSkillsConfigDefinitionOptions, CreateUserInstructionConfigWatcherOptions, CreateWorkflowsConfigDefinitionOptions, LoadAgentPluginFromPathOptions, ParseMarkdownFrontmatterResult, ParseYamlFrontmatterResult, ResolveAgentPluginPathsOptions, RuleConfig, SkillConfig, UnifiedConfigDefinition, UnifiedConfigFileCandidate, UnifiedConfigFileContext, UnifiedConfigRecord, UnifiedConfigWatcherEvent, UnifiedConfigWatcherOptions, UserInstructionConfig, UserInstructionConfigType, UserInstructionConfigWatcher, UserInstructionConfigWatcherEvent, WorkflowConfig, } from "./agents";
+export { createAgentConfigDefinition, createAgentConfigWatcher, createRulesConfigDefinition, createSkillsConfigDefinition, createUserInstructionConfigWatcher, createWorkflowsConfigDefinition, discoverPluginModulePaths, loadAgentPluginFromPath, loadAgentPluginsFromPaths, parseAgentConfigFromYaml, parsePartialAgentConfigFromYaml, parseRuleConfigFromMarkdown, parseSkillConfigFromMarkdown, parseWorkflowConfigFromMarkdown, RULES_CONFIG_DIRECTORY_NAME, resolveAgentPluginPaths, resolveAgentTools, resolveAndLoadAgentPlugins, resolveDocumentsRulesDirectoryPath, resolveDocumentsWorkflowsDirectoryPath, resolvePluginConfigSearchPaths, resolveRulesConfigSearchPaths, resolveSkillsConfigSearchPaths, resolveWorkflowsConfigSearchPaths, SKILLS_CONFIG_DIRECTORY_NAME, toPartialAgentConfig, UnifiedConfigFileWatcher, WORKFLOWS_CONFIG_DIRECTORY_NAME, } from "./agents";
+export type { ChatMessage, ChatSessionConfig, ChatSessionStatus, ChatSummary, ChatViewState, } from "./chat/chat-schema";
+export type { SandboxCallOptions, SubprocessSandboxOptions, } from "./runtime/sandbox/subprocess-sandbox";
+export { SubprocessSandbox } from "./runtime/sandbox/subprocess-sandbox";
+export type { BuiltRuntime as RuntimeEnvironment, RuntimeBuilder, RuntimeBuilderInput, SessionRuntime, } from "./runtime/session-runtime";
+export type { CreateSessionHostOptions, SessionHost, } from "./session/session-host";
+export type { SendSessionInput, SessionManager, StartSessionInput, StartSessionResult, } from "./session/session-manager";
+export type { SessionManifest } from "./session/session-manifest";
+export type { CreateRootSessionWithArtifactsInput, RootSessionArtifacts, } from "./session/session-service";
+export type { WorkspaceManager, WorkspaceManagerEvent, } from "./session/workspace-manager";
+export type { WorkspaceManifest } from "./session/workspace-manifest";
+export type { SessionSource, SessionStatus } from "./types/common";
+export type { CoreAgentMode, CoreModelConfig, CoreRuntimeFeatures, CoreSessionConfig, } from "./types/config";
+export type { CoreSessionEvent, SessionChunkEvent, SessionEndedEvent, SessionTeamProgressEvent, SessionToolEvent, } from "./types/events";
+export type { SessionRecord, SessionRef } from "./types/sessions";
+export type { ArtifactStore, SessionStore, TeamStore } from "./types/storage";
+export type { WorkspaceInfo } from "./types/workspace";
+export interface StoredMessages {
+    version: 1;
+    updatedAt: string;
+    messages: LlmsProviders.MessageWithMetadata[];
+}
+export type SessionEvent = CoreSessionEvent;

package/package.json

@@ -0,0 +1,63 @@
+{
+	"name": "@clinebot/core",
+	"version": "0.0.0",
+	"main": "dist/index.js",
+	"dependencies": {
+		"@clinebot/agents": "workspace:*",
+		"@clinebot/llms": "workspace:*",
+		"@clinebot/rpc": "workspace:*",
+		"@clinebot/shared": "workspace:*",
+		"nanoid": "^5.1.6",
+		"simple-git": "^3.32.3",
+		"yaml": "^2.8.2",
+		"zod": "^4.3.6"
+	},
+	"exports": {
+		".": {
+			"development": "./src/index.ts",
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
+		},
+		"./node": {
+			"development": "./src/index.ts",
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
+		},
+		"./browser": {
+			"development": "./src/index.ts",
+			"types": "./dist/index.browser.d.ts",
+			"import": "./dist/index.browser.js"
+		},
+		"./server": {
+			"development": "./src/server/index.ts",
+			"types": "./dist/server/index.d.ts",
+			"import": "./dist/server/index.js"
+		},
+		"./server/node": {
+			"development": "./src/server/index.ts",
+			"types": "./dist/server/index.d.ts",
+			"import": "./dist/server/index.js"
+		},
+		"./server/browser": {
+			"development": "./src/server/index.ts",
+			"types": "./dist/server.browser.d.ts",
+			"import": "./dist/server.browser.js"
+		}
+	},
+	"description": "State-aware orchestration for Cline Agent runtimes",
+	"files": [
+		"dist",
+		"src"
+	],
+	"scripts": {
+		"build": "bun run ./build.ts && bun tsc -p tsconfig.build.json",
+		"clean": "rm -rf dist node_modules",
+		"typecheck": "bun tsc -p tsconfig.dev.json --noEmit",
+		"test": "bun run test:unit && bun run test:e2e",
+		"test:unit": "vitest run --config vitest.config.ts",
+		"test:e2e": "vitest run --config vitest.e2e.config.ts",
+		"test:watch": "vitest --config vitest.config.ts"
+	},
+	"type": "module",
+	"types": "dist/index.d.ts"
+}

package/src/account/cline-account-service.test.ts

@@ -0,0 +1,101 @@
+import { describe, expect, it, vi } from "vitest";
+import { ClineAccountService } from "./cline-account-service";
+
+describe("ClineAccountService", () => {
+	it("fetches current user balance and sends auth header", async () => {
+		const fetchImpl = vi.fn(async (input: unknown, init?: RequestInit) => {
+			expect(String(input)).toBe(
+				"https://api.cline.bot/api/v1/users/user-1/balance",
+			);
+			expect(init?.headers).toMatchObject({
+				Authorization: "Bearer workos:token-123",
+			});
+			return new Response(
+				JSON.stringify({
+					success: true,
+					data: { balance: 5, userId: "user-1" },
+				}),
+				{ status: 200, headers: { "Content-Type": "application/json" } },
+			);
+		});
+
+		const service = new ClineAccountService({
+			apiBaseUrl: "https://api.cline.bot",
+			getAuthToken: async () => "workos:token-123",
+			getCurrentUserId: () => "user-1",
+			fetchImpl: fetchImpl as unknown as typeof fetch,
+		});
+
+		const balance = await service.fetchBalance();
+		expect(balance).toEqual({ balance: 5, userId: "user-1" });
+	});
+
+	it("resolves organization member id from /users/me when not provided", async () => {
+		const fetchImpl = vi
+			.fn()
+			.mockResolvedValueOnce(
+				new Response(
+					JSON.stringify({
+						success: true,
+						data: {
+							id: "u-1",
+							email: "u@example.com",
+							displayName: "User",
+							photoUrl: "",
+							createdAt: "2025-01-01T00:00:00Z",
+							updatedAt: "2025-01-01T00:00:00Z",
+							organizations: [
+								{
+									active: true,
+									memberId: "member-9",
+									name: "Org",
+									organizationId: "org-1",
+									roles: ["member"],
+								},
+							],
+						},
+					}),
+					{ status: 200 },
+				),
+			)
+			.mockResolvedValueOnce(
+				new Response(
+					JSON.stringify({ success: true, data: { items: [{ id: "tx-1" }] } }),
+					{ status: 200 },
+				),
+			);
+
+		const service = new ClineAccountService({
+			apiBaseUrl: "https://api.cline.bot",
+			getAuthToken: async () => "workos:token-123",
+			fetchImpl: fetchImpl as unknown as typeof fetch,
+		});
+
+		const transactions = await service.fetchOrganizationUsageTransactions({
+			organizationId: "org-1",
+		});
+
+		expect(fetchImpl).toHaveBeenCalledTimes(2);
+		expect(String(fetchImpl.mock.calls[1][0])).toBe(
+			"https://api.cline.bot/api/v1/organizations/org-1/members/member-9/usages",
+		);
+		expect(transactions).toEqual([{ id: "tx-1" }]);
+	});
+
+	it("switchAccount sends null org id for personal account", async () => {
+		const fetchImpl = vi.fn(async (_input: unknown, init?: RequestInit) => {
+			expect(init?.method).toBe("PUT");
+			expect(init?.body).toBe(JSON.stringify({ organizationId: null }));
+			return new Response(null, { status: 204 });
+		});
+
+		const service = new ClineAccountService({
+			apiBaseUrl: "https://api.cline.bot",
+			getAuthToken: async () => "workos:token-123",
+			fetchImpl: fetchImpl as unknown as typeof fetch,
+		});
+
+		await service.switchAccount(undefined);
+		expect(fetchImpl).toHaveBeenCalledTimes(1);
+	});
+});

package/src/account/cline-account-service.ts

@@ -0,0 +1,267 @@
+import type {
+	ClineAccountBalance,
+	ClineAccountOrganization,
+	ClineAccountOrganizationBalance,
+	ClineAccountOrganizationUsageTransaction,
+	ClineAccountPaymentTransaction,
+	ClineAccountUsageTransaction,
+	ClineAccountUser,
+} from "./types";
+
+const DEFAULT_TIMEOUT_MS = 30_000;
+
+interface ClineApiEnvelope<T> {
+	success?: boolean;
+	error?: string;
+	data?: T;
+}
+
+export interface ClineAccountServiceOptions {
+	apiBaseUrl: string;
+	getAuthToken: () => Promise<string | undefined | null>;
+	getCurrentUserId?: () =>
+		| Promise<string | undefined | null>
+		| string
+		| undefined
+		| null;
+	getOrganizationMemberId?: (
+		organizationId: string,
+	) => Promise<string | undefined | null> | string | undefined | null;
+	getHeaders?: () =>
+		| Promise<Record<string, string> | undefined>
+		| Record<string, string>
+		| undefined;
+	requestTimeoutMs?: number;
+	fetchImpl?: typeof fetch;
+}
+
+export class ClineAccountService {
+	private readonly apiBaseUrl: string;
+	private readonly getAuthTokenFn: ClineAccountServiceOptions["getAuthToken"];
+	private readonly getCurrentUserIdFn: ClineAccountServiceOptions["getCurrentUserId"];
+	private readonly getOrganizationMemberIdFn: ClineAccountServiceOptions["getOrganizationMemberId"];
+	private readonly getHeadersFn: ClineAccountServiceOptions["getHeaders"];
+	private readonly requestTimeoutMs: number;
+	private readonly fetchImpl: typeof fetch;
+
+	constructor(options: ClineAccountServiceOptions) {
+		const apiBaseUrl = options.apiBaseUrl.trim();
+		if (!apiBaseUrl) {
+			throw new Error("apiBaseUrl is required");
+		}
+
+		this.apiBaseUrl = apiBaseUrl;
+		this.getAuthTokenFn = options.getAuthToken;
+		this.getCurrentUserIdFn = options.getCurrentUserId;
+		this.getOrganizationMemberIdFn = options.getOrganizationMemberId;
+		this.getHeadersFn = options.getHeaders;
+		this.requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_TIMEOUT_MS;
+		this.fetchImpl = options.fetchImpl ?? fetch;
+	}
+
+	public async fetchMe(): Promise<ClineAccountUser> {
+		return this.request<ClineAccountUser>("/api/v1/users/me");
+	}
+
+	public async fetchBalance(userId?: string): Promise<ClineAccountBalance> {
+		const resolvedUserId = await this.resolveUserId(userId);
+		return this.request<ClineAccountBalance>(
+			`/api/v1/users/${encodeURIComponent(resolvedUserId)}/balance`,
+		);
+	}
+
+	public async fetchUsageTransactions(
+		userId?: string,
+	): Promise<ClineAccountUsageTransaction[]> {
+		const resolvedUserId = await this.resolveUserId(userId);
+		const response = await this.request<{
+			items: ClineAccountUsageTransaction[];
+		}>(`/api/v1/users/${encodeURIComponent(resolvedUserId)}/usages`);
+		return response.items ?? [];
+	}
+
+	public async fetchPaymentTransactions(
+		userId?: string,
+	): Promise<ClineAccountPaymentTransaction[]> {
+		const resolvedUserId = await this.resolveUserId(userId);
+		const response = await this.request<{
+			paymentTransactions: ClineAccountPaymentTransaction[];
+		}>(`/api/v1/users/${encodeURIComponent(resolvedUserId)}/payments`);
+		return response.paymentTransactions ?? [];
+	}
+
+	public async fetchUserOrganizations(): Promise<ClineAccountOrganization[]> {
+		const me = await this.fetchMe();
+		return me.organizations ?? [];
+	}
+
+	public async fetchOrganizationBalance(
+		organizationId: string,
+	): Promise<ClineAccountOrganizationBalance> {
+		const orgId = organizationId.trim();
+		if (!orgId) {
+			throw new Error("organizationId is required");
+		}
+		return this.request<ClineAccountOrganizationBalance>(
+			`/api/v1/organizations/${encodeURIComponent(orgId)}/balance`,
+		);
+	}
+
+	public async fetchOrganizationUsageTransactions(input: {
+		organizationId: string;
+		memberId?: string;
+	}): Promise<ClineAccountOrganizationUsageTransaction[]> {
+		const organizationId = input.organizationId.trim();
+		if (!organizationId) {
+			throw new Error("organizationId is required");
+		}
+
+		const memberId = await this.resolveOrganizationMemberId(
+			organizationId,
+			input.memberId,
+		);
+		const response = await this.request<{
+			items: ClineAccountOrganizationUsageTransaction[];
+		}>(
+			`/api/v1/organizations/${encodeURIComponent(organizationId)}/members/${encodeURIComponent(memberId)}/usages`,
+		);
+		return response.items ?? [];
+	}
+
+	public async switchAccount(organizationId?: string | null): Promise<void> {
+		await this.request<void>("/api/v1/users/active-account", {
+			method: "PUT",
+			body: {
+				organizationId: organizationId?.trim() || null,
+			},
+			expectNoContent: true,
+		});
+	}
+
+	private async resolveUserId(userId?: string): Promise<string> {
+		const explicit = userId?.trim();
+		if (explicit) {
+			return explicit;
+		}
+
+		const fromProvider = this.getCurrentUserIdFn
+			? await this.getCurrentUserIdFn()
+			: undefined;
+		const provided = fromProvider?.trim();
+		if (provided) {
+			return provided;
+		}
+
+		const me = await this.fetchMe();
+		if (!me.id?.trim()) {
+			throw new Error("Unable to resolve current user id");
+		}
+		return me.id;
+	}
+
+	private async resolveOrganizationMemberId(
+		organizationId: string,
+		memberId?: string,
+	): Promise<string> {
+		const explicit = memberId?.trim();
+		if (explicit) {
+			return explicit;
+		}
+
+		const fromProvider = this.getOrganizationMemberIdFn
+			? await this.getOrganizationMemberIdFn(organizationId)
+			: undefined;
+		const provided = fromProvider?.trim();
+		if (provided) {
+			return provided;
+		}
+
+		const organizations = await this.fetchUserOrganizations();
+		const resolved = organizations.find(
+			(org) => org.organizationId === organizationId,
+		)?.memberId;
+		if (!resolved?.trim()) {
+			throw new Error(
+				`Unable to resolve memberId for organization ${organizationId}`,
+			);
+		}
+		return resolved;
+	}
+
+	private async request<T>(
+		endpoint: string,
+		input?: {
+			method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+			body?: unknown;
+			expectNoContent?: boolean;
+		},
+	): Promise<T> {
+		const token = (await this.getAuthTokenFn())?.trim();
+		if (!token) {
+			throw new Error("No Cline account auth token found");
+		}
+
+		const extraHeaders = this.getHeadersFn ? await this.getHeadersFn() : {};
+		const controller = new AbortController();
+		const timeout = setTimeout(() => controller.abort(), this.requestTimeoutMs);
+
+		try {
+			const response = await this.fetchImpl(
+				new URL(endpoint, this.apiBaseUrl),
+				{
+					method: input?.method ?? "GET",
+					headers: {
+						Authorization: `Bearer ${token}`,
+						"Content-Type": "application/json",
+						...(extraHeaders ?? {}),
+					},
+					body:
+						input?.body !== undefined ? JSON.stringify(input.body) : undefined,
+					signal: controller.signal,
+				},
+			);
+
+			if (response.status === 204 || input?.expectNoContent) {
+				if (!response.ok) {
+					throw new Error(
+						`Cline account request failed with status ${response.status}`,
+					);
+				}
+				return undefined as T;
+			}
+
+			const text = await response.text();
+			let parsed: unknown;
+			if (text.trim()) {
+				parsed = JSON.parse(text);
+			}
+
+			if (!response.ok) {
+				const message =
+					typeof parsed === "object" && parsed !== null && "error" in parsed
+						? String((parsed as { error: unknown }).error)
+						: `Cline account request failed with status ${response.status}`;
+				throw new Error(message);
+			}
+
+			if (typeof parsed === "object" && parsed !== null) {
+				const envelope = parsed as ClineApiEnvelope<T>;
+				if (typeof envelope.success === "boolean") {
+					if (!envelope.success) {
+						throw new Error(envelope.error || "Cline account request failed");
+					}
+					if (envelope.data !== undefined) {
+						return envelope.data;
+					}
+				}
+			}
+
+			if (parsed === undefined || parsed === null) {
+				throw new Error("Cline account response payload was empty");
+			}
+			return parsed as T;
+		} finally {
+			clearTimeout(timeout);
+		}
+	}
+}

package/src/account/index.ts

@@ -0,0 +1,20 @@
+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,
+} from "./types";