@clinebot/core 0.0.28 → 0.0.29

package/src/ClineCore.test.ts

@@ -0,0 +1,150 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type {
+	StartSessionInput,
+	StartSessionResult,
+} from "./session/session-manager";
+
+const { createSessionHostMock } = vi.hoisted(() => ({
+	createSessionHostMock: vi.fn(),
+}));
+
+vi.mock("./session/session-host", () => ({
+	createSessionHost: createSessionHostMock,
+}));
+
+import { ClineCore } from "./ClineCore";
+
+function createStartInput(): StartSessionInput {
+	return {
+		config: {
+			providerId: "anthropic",
+			modelId: "claude-sonnet-4-6",
+			apiKey: "test",
+			cwd: "/tmp/workspace",
+			workspaceRoot: "/tmp/workspace",
+			systemPrompt: "You are concise.",
+			enableTools: true,
+			enableSpawnAgent: false,
+			enableAgentTeams: false,
+		},
+		prompt: "hello",
+		interactive: false,
+	};
+}
+
+function createStartResult(sessionId: string): StartSessionResult {
+	return {
+		sessionId,
+		manifest: {} as StartSessionResult["manifest"],
+		manifestPath: `/tmp/${sessionId}.json`,
+		transcriptPath: `/tmp/${sessionId}.log`,
+		hookPath: `/tmp/${sessionId}.hooks.jsonl`,
+		messagesPath: `/tmp/${sessionId}.messages.json`,
+	};
+}
+
+describe("ClineCore", () => {
+	beforeEach(() => {
+		createSessionHostMock.mockReset();
+	});
+
+	it("applies start-session bootstraps before delegating to the host", async () => {
+		const listeners: Array<
+			(event: { type: string; payload: { sessionId: string } }) => void
+		> = [];
+		const host = {
+			start: vi.fn(async (input: StartSessionInput) => {
+				expect(input.config.systemPrompt).toBe("Bootstrapped prompt");
+				expect(input.config.extensions).toEqual([{ name: "enterprise" }]);
+				return createStartResult("session-1");
+			}),
+			send: vi.fn(),
+			getAccumulatedUsage: vi.fn(),
+			abort: vi.fn(),
+			stop: vi.fn(),
+			dispose: vi.fn(),
+			get: vi.fn(async () => undefined),
+			list: vi.fn(),
+			delete: vi.fn(),
+			readMessages: vi.fn(),
+			readTranscript: vi.fn(),
+			readHooks: vi.fn(),
+			subscribe: vi.fn((listener) => {
+				listeners.push(listener);
+				return () => {};
+			}),
+			updateSessionModel: vi.fn(),
+		};
+		createSessionHostMock.mockResolvedValue(host);
+
+		const dispose = vi.fn(async () => {});
+		const applyToStartSessionInput = vi.fn(
+			async (input: StartSessionInput) => ({
+				...input,
+				config: {
+					...input.config,
+					systemPrompt: "Bootstrapped prompt",
+					extensions: [
+						{ name: "enterprise" },
+					] as StartSessionInput["config"]["extensions"],
+				},
+			}),
+		);
+
+		const core = await ClineCore.create({
+			prepare: async () => ({
+				applyToStartSessionInput,
+				dispose,
+			}),
+		});
+
+		await core.start(createStartInput());
+
+		expect(applyToStartSessionInput).toHaveBeenCalledTimes(1);
+		expect(host.start).toHaveBeenCalledTimes(1);
+		expect(dispose).toHaveBeenCalledTimes(1);
+		expect(listeners).toHaveLength(1);
+	});
+
+	it("disposes active session bootstraps when the session ends", async () => {
+		let listener:
+			| ((event: { type: string; payload: { sessionId: string } }) => void)
+			| undefined;
+		const host = {
+			start: vi.fn(async () => createStartResult("session-2")),
+			send: vi.fn(),
+			getAccumulatedUsage: vi.fn(),
+			abort: vi.fn(),
+			stop: vi.fn(),
+			dispose: vi.fn(),
+			get: vi.fn(async () => ({ sessionId: "session-2" })),
+			list: vi.fn(),
+			delete: vi.fn(),
+			readMessages: vi.fn(),
+			readTranscript: vi.fn(),
+			readHooks: vi.fn(),
+			subscribe: vi.fn((nextListener) => {
+				listener = nextListener;
+				return () => {};
+			}),
+			updateSessionModel: vi.fn(),
+		};
+		createSessionHostMock.mockResolvedValue(host);
+
+		const dispose = vi.fn(async () => {});
+		const core = await ClineCore.create({
+			prepare: async () => ({
+				applyToStartSessionInput: (input) => input,
+				dispose,
+			}),
+		});
+
+		await core.start(createStartInput());
+		expect(dispose).not.toHaveBeenCalled();
+
+		listener?.({ type: "ended", payload: { sessionId: "session-2" } });
+		await Promise.resolve();
+
+		expect(dispose).toHaveBeenCalledTimes(1);
+	});
+});

package/src/ClineCore.ts

@@ -1,14 +1,16 @@
 import type {
 	AgentConfig,
+	ITelemetryService,
 	ToolApprovalRequest,
 	ToolApprovalResult,
-} from "@clinebot/agents";
-import type { ITelemetryService } from "@clinebot/shared";
+} from "@clinebot/shared";
+import type { TeamToolsFactory } from "./runtime/session-runtime";
 import {
 	createSessionHost,
 	type SessionBackend,
 	type SessionHost,
 } from "./session/session-host";
+import type { StartSessionInput } from "./session/session-manager";
 import type { ToolExecutors } from "./tools";
 
 /** Advanced options for connecting to or spawning the Cline RPC server. */
@@ -87,6 +89,34 @@ export interface ClineCoreOptions {
 	 * @internal
 	 */
 	sessionService?: SessionBackend;
+	/**
+	 * Factory that creates team management tools for the multi-agent team system.
+	 * When provided, team tools are registered whenever `enableAgentTeams` is `true`
+	 * on a session config.
+	 *
+	 * Consumers that depend on `@clinebot/enterprise` can pass
+	 * `bootstrapAgentTeams` here directly.
+	 */
+	teamToolsFactory?: TeamToolsFactory;
+	/**
+	 * Optional hook invoked before each session starts.
+	 * Use this to prepare workspace-scoped runtime state and then return an
+	 * adapter that mutates the `StartSessionInput` generically before core
+	 * builds the runtime.
+	 */
+	prepare?: (
+		input: StartSessionInput,
+	) =>
+		| Promise<StartSessionBootstrap | undefined>
+		| StartSessionBootstrap
+		| undefined;
+}
+
+export interface StartSessionBootstrap {
+	applyToStartSessionInput(
+		input: StartSessionInput,
+	): Promise<StartSessionInput> | StartSessionInput;
+	dispose?(): Promise<void> | void;
 }
 
 /**
@@ -103,27 +133,103 @@ export interface ClineCoreOptions {
 export class ClineCore implements SessionHost {
 	readonly clientName: string | undefined;
 	private readonly host: SessionHost;
+	private readonly prepare: ClineCoreOptions["prepare"] | undefined;
+	private readonly teamToolsFactory: TeamToolsFactory | undefined;
+	private readonly activeSessionBootstraps = new Map<
+		string,
+		StartSessionBootstrap
+	>();
+	private readonly unsubscribeBootstrapCleanup: () => void;
 
-	private constructor(host: SessionHost, clientName: string | undefined) {
+	private constructor(
+		host: SessionHost,
+		clientName: string | undefined,
+		prepare: ClineCoreOptions["prepare"],
+		teamToolsFactory: TeamToolsFactory | undefined,
+	) {
 		this.clientName = clientName;
 		this.host = host;
+		this.prepare = prepare;
+		this.teamToolsFactory = teamToolsFactory;
+		this.unsubscribeBootstrapCleanup = this.host.subscribe((event) => {
+			if (event.type !== "ended") {
+				return;
+			}
+			void this.disposeSessionBootstrap(event.payload.sessionId);
+		});
 	}
 
 	static async create(options: ClineCoreOptions = {}): Promise<ClineCore> {
 		const host = await createSessionHost(options);
-		return new ClineCore(host, options.clientName);
+		return new ClineCore(
+			host,
+			options.clientName,
+			options.prepare,
+			options.teamToolsFactory,
+		);
+	}
+
+	private async disposeSessionBootstrap(sessionId: string): Promise<void> {
+		const bootstrap = this.activeSessionBootstraps.get(sessionId);
+		if (!bootstrap) {
+			return;
+		}
+		this.activeSessionBootstraps.delete(sessionId);
+		await Promise.resolve(bootstrap.dispose?.());
 	}
 
-	start: SessionHost["start"] = (...args) => this.host.start(...args);
+	start: SessionHost["start"] = async (input) => {
+		const inputWithFactory: StartSessionInput = this.teamToolsFactory
+			? { teamToolsFactory: this.teamToolsFactory, ...input }
+			: input;
+		const bootstrap = await this.prepare?.(inputWithFactory);
+		try {
+			const effectiveInput = bootstrap
+				? await bootstrap.applyToStartSessionInput(inputWithFactory)
+				: inputWithFactory;
+			const result = await this.host.start(effectiveInput);
+			if (bootstrap) {
+				const activeSession = await this.host.get(result.sessionId);
+				if (activeSession) {
+					this.activeSessionBootstraps.set(result.sessionId, bootstrap);
+				} else {
+					await Promise.resolve(bootstrap.dispose?.());
+				}
+			}
+			return result;
+		} catch (error) {
+			await Promise.resolve(bootstrap?.dispose?.());
+			throw error;
+		}
+	};
 	send: SessionHost["send"] = (...args) => this.host.send(...args);
 	getAccumulatedUsage: SessionHost["getAccumulatedUsage"] = (...args) =>
 		this.host.getAccumulatedUsage(...args);
 	abort: SessionHost["abort"] = (...args) => this.host.abort(...args);
-	stop: SessionHost["stop"] = (...args) => this.host.stop(...args);
-	dispose: SessionHost["dispose"] = (...args) => this.host.dispose(...args);
+	stop: SessionHost["stop"] = async (sessionId) => {
+		await this.host.stop(sessionId);
+		await this.disposeSessionBootstrap(sessionId);
+	};
+	dispose: SessionHost["dispose"] = async (...args) => {
+		try {
+			await this.host.dispose(...args);
+		} finally {
+			this.unsubscribeBootstrapCleanup();
+			const sessionIds = [...this.activeSessionBootstraps.keys()];
+			await Promise.allSettled(
+				sessionIds.map((sessionId) => this.disposeSessionBootstrap(sessionId)),
+			);
+		}
+	};
 	get: SessionHost["get"] = (...args) => this.host.get(...args);
 	list: SessionHost["list"] = (...args) => this.host.list(...args);
-	delete: SessionHost["delete"] = (...args) => this.host.delete(...args);
+	delete: SessionHost["delete"] = async (sessionId) => {
+		const deleted = await this.host.delete(sessionId);
+		if (deleted) {
+			await this.disposeSessionBootstrap(sessionId);
+		}
+		return deleted;
+	};
 	readMessages: SessionHost["readMessages"] = (...args) =>
 		this.host.readMessages(...args);
 	readTranscript: SessionHost["readTranscript"] = (...args) =>

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

@@ -82,6 +82,90 @@ describe("ClineAccountService", () => {
 		expect(transactions).toEqual([{ id: "tx-1" }]);
 	});
 
+	it("fetches remote config with organizations list", async () => {
+		const remoteConfigPayload = {
+			organizationId: "org-1",
+			value: '{"model":"claude-4"}',
+			enabled: true,
+			organizations: [
+				{ organizationId: "org-1", name: "Acme Corp" },
+				{ organizationId: "org-2", name: "Beta Inc" },
+			],
+		};
+
+		const fetchImpl = vi.fn(async (input: unknown) => {
+			expect(String(input)).toBe(
+				"https://api.cline.bot/api/v1/users/me/remote-config",
+			);
+			return new Response(
+				JSON.stringify({ success: true, data: remoteConfigPayload }),
+				{ 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 config = await service.fetchRemoteConfig();
+		expect(config).toEqual(remoteConfigPayload);
+		expect(config?.organizations).toHaveLength(2);
+		expect(config?.organizations?.[0]).toEqual({
+			organizationId: "org-1",
+			name: "Acme Corp",
+		});
+	});
+
+	it("fetches remote config with fallback org selected", async () => {
+		const remoteConfigPayload = {
+			organizationId: "org-fallback",
+			value: '{"model":"claude-4"}',
+			enabled: true,
+			organizations: [{ organizationId: "org-fallback", name: "Fallback Org" }],
+		};
+
+		const fetchImpl = vi.fn(async () => {
+			return new Response(
+				JSON.stringify({ success: true, data: remoteConfigPayload }),
+				{ 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 config = await service.fetchRemoteConfig();
+		expect(config?.organizationId).toBe("org-fallback");
+		expect(config?.organizations).toHaveLength(1);
+		expect(config?.organizations?.[0]).toEqual({
+			organizationId: "org-fallback",
+			name: "Fallback Org",
+		});
+	});
+
+	it("returns null when no org has remote config (data: null)", async () => {
+		const fetchImpl = vi.fn(async () => {
+			return new Response(JSON.stringify({ success: true, data: null }), {
+				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 config = await service.fetchRemoteConfig();
+		expect(config).toBeNull();
+	});
+
 	it("switchAccount sends null org id for personal account", async () => {
 		const fetchImpl = vi.fn(async (_input: unknown, init?: RequestInit) => {
 			expect(init?.method).toBe("PUT");

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

@@ -66,8 +66,8 @@ export class ClineAccountService {
 		return this.request<ClineAccountUser>("/api/v1/users/me");
 	}
 
-	public async fetchRemoteConfig(): Promise<UserRemoteConfigResponse> {
-		return this.request<UserRemoteConfigResponse>(
+	public async fetchRemoteConfig(): Promise<UserRemoteConfigResponse | null> {
+		return this.request<UserRemoteConfigResponse | null>(
 			"/api/v1/users/me/remote-config",
 		);
 	}

package/src/account/index.ts

@@ -19,5 +19,6 @@ export type {
 	ClineAccountUser,
 	ClineOrganization,
 	FeaturebaseTokenResponse,
+	UserRemoteConfigOrganization,
 	UserRemoteConfigResponse,
 } from "./types";

package/src/account/types.ts

@@ -16,10 +16,16 @@ export interface ClineAccountUser {
 	organizations: ClineAccountOrganization[];
 }
 
+export interface UserRemoteConfigOrganization {
+	organizationId: string;
+	name: string;
+}
+
 export interface UserRemoteConfigResponse {
 	organizationId: string;
 	value: string;
 	enabled: boolean;
+	organizations?: UserRemoteConfigOrganization[];
 }
 
 export interface ClineAccountBalance {

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

@@ -0,0 +1,38 @@
+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/bounded-ttl-cache.ts

@@ -0,0 +1,53 @@
+/**
+ * Small process-local string cache with TTL expiry and a hard entry cap.
+ * Used where unbounded Maps would grow without bound in long-running processes.
+ */
+export class BoundedTtlCache {
+	private readonly entries = new Map<
+		string,
+		{ value: string; expiresAt: number }
+	>();
+
+	constructor(
+		private readonly ttlMs: number,
+		private readonly maxEntries: number,
+	) {}
+
+	get(key: string, now = Date.now()): string | undefined {
+		this.pruneExpired(now);
+		const hit = this.entries.get(key);
+		if (!hit) {
+			return undefined;
+		}
+		// Bump recency for FIFO eviction under cap.
+		this.entries.delete(key);
+		this.entries.set(key, hit);
+		return hit.value;
+	}
+
+	set(
+		key: string,
+		value: string,
+		now = Date.now(),
+		ttlMsOverride = this.ttlMs,
+	): void {
+		this.pruneExpired(now);
+		this.entries.delete(key);
+		while (this.entries.size >= this.maxEntries) {
+			const first = this.entries.keys().next().value as string | undefined;
+			if (first === undefined) {
+				break;
+			}
+			this.entries.delete(first);
+		}
+		this.entries.set(key, { value, expiresAt: now + ttlMsOverride });
+	}
+
+	private pruneExpired(now: number): void {
+		for (const [k, v] of this.entries) {
+			if (v.expiresAt <= now) {
+				this.entries.delete(k);
+			}
+		}
+	}
+}