@clinebot/core 0.0.14 → 0.0.15

package/dist/session/default-session-manager.d.ts

@@ -6,11 +6,12 @@ import { ProviderSettingsManager } from "../storage/provider-settings-manager";
 import { type ToolExecutors } from "../tools";
 import type { CoreSessionEvent } from "../types/events";
 import type { SessionRecord } from "../types/sessions";
+import type { FileSessionService } from "./file-session-service";
 import type { RpcCoreSessionService } from "./rpc-session-service";
 import { RuntimeOAuthTokenManager } from "./runtime-oauth-token-manager";
 import type { SendSessionInput, SessionAccumulatedUsage, SessionManager, StartSessionInput, StartSessionResult } from "./session-manager";
 import type { CoreSessionService } from "./session-service";
-type SessionBackend = CoreSessionService | RpcCoreSessionService;
+type SessionBackend = CoreSessionService | RpcCoreSessionService | FileSessionService;
 export interface DefaultSessionManagerOptions {
     distinctId: string;
     sessionService: SessionBackend;

package/dist/session/file-session-service.d.ts

@@ -0,0 +1,5 @@
+import { UnifiedSessionPersistenceService } from "./unified-session-persistence-service";
+export declare class FileSessionService extends UnifiedSessionPersistenceService {
+    constructor(sessionsDir?: string);
+    ensureSessionsDir(): string;
+}

package/dist/session/session-host.d.ts

@@ -1,10 +1,11 @@
 import type { AgentConfig, ToolApprovalRequest, ToolApprovalResult } from "@clinebot/agents";
 import type { ITelemetryService } from "@clinebot/shared";
 import type { ToolExecutors } from "../tools";
+import { FileSessionService } from "./file-session-service";
 import { RpcCoreSessionService } from "./rpc-session-service";
 import type { SessionManager } from "./session-manager";
 import { CoreSessionService } from "./session-service";
-export type SessionBackend = RpcCoreSessionService | CoreSessionService;
+export type SessionBackend = RpcCoreSessionService | CoreSessionService | FileSessionService;
 export interface CreateSessionHostOptions {
     distinctId?: string;
     sessionService?: SessionBackend;

package/dist/storage/file-team-store.d.ts

@@ -0,0 +1,27 @@
+import type { TeamEvent, TeamRuntimeState, TeamTeammateSpec } from "@clinebot/agents";
+import type { TeamStore } from "../types/storage";
+export interface FileTeamStoreOptions {
+    teamDir?: string;
+}
+export interface TeamRuntimeLoadResult {
+    state?: TeamRuntimeState;
+    teammates: TeamTeammateSpec[];
+    interruptedRunIds: string[];
+}
+export declare class FileTeamStore implements TeamStore {
+    private readonly teamDirPath;
+    constructor(options?: FileTeamStoreOptions);
+    init(): void;
+    listTeamNames(): string[];
+    readState(teamName: string): TeamRuntimeState | undefined;
+    readHistory(teamName: string, limit?: number): unknown[];
+    loadRuntime(teamName: string): TeamRuntimeLoadResult;
+    handleTeamEvent(teamName: string, event: TeamEvent): void;
+    persistRuntime(teamName: string, state: TeamRuntimeState, teammates: TeamTeammateSpec[]): void;
+    markInProgressRunsInterrupted(teamName: string, reason: string): string[];
+    private ensureTeamDir;
+    private ensureTeamSubdir;
+    private statePath;
+    private historyPath;
+    private readEnvelope;
+}

package/dist/storage/team-store.d.ts

@@ -1,2 +1,15 @@
 export type { TeamStore } from "../types/storage";
+export { FileTeamStore, type FileTeamStoreOptions, } from "./file-team-store";
 export { SqliteTeamStore, type SqliteTeamStoreOptions, } from "./sqlite-team-store";
+import { FileTeamStore } from "./file-team-store";
+import { type SqliteTeamStoreOptions } from "./sqlite-team-store";
+export declare function createLocalTeamStore(options?: SqliteTeamStoreOptions): {
+    init(): void;
+    listTeamNames(): string[];
+    readState(teamName: string): ReturnType<FileTeamStore["readState"]>;
+    readHistory(teamName: string, limit?: number): unknown[];
+    loadRuntime(teamName: string): ReturnType<FileTeamStore["loadRuntime"]>;
+    handleTeamEvent: FileTeamStore["handleTeamEvent"];
+    persistRuntime: FileTeamStore["persistRuntime"];
+    markInProgressRunsInterrupted: FileTeamStore["markInProgressRunsInterrupted"];
+};

package/package.json

@@ -1,11 +1,11 @@
 {
 	"name": "@clinebot/core",
-	"version": "0.0.14",
+	"version": "0.0.15",
 	"main": "./dist/index.node.js",
 	"dependencies": {
-		"@clinebot/agents": "0.0.14",
-		"@clinebot/llms": "0.0.14",
-		"@clinebot/shared": "0.0.14",
+		"@clinebot/agents": "0.0.15",
+		"@clinebot/llms": "0.0.15",
+		"@clinebot/shared": "0.0.15",
 		"@opentelemetry/api": "^1.9.0",
 		"@opentelemetry/api-logs": "^0.56.0",
 		"@opentelemetry/exporter-logs-otlp-http": "^0.56.0",

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

@@ -6,6 +6,7 @@ import type {
 	ClineAccountPaymentTransaction,
 	ClineAccountUsageTransaction,
 	ClineAccountUser,
+	UserRemoteConfigResponse,
 } from "./types";
 
 const DEFAULT_TIMEOUT_MS = 30_000;
@@ -63,6 +64,12 @@ export class ClineAccountService {
 		return this.request<ClineAccountUser>("/api/v1/users/me");
 	}
 
+	public async fetchRemoteConfig(): Promise<UserRemoteConfigResponse> {
+		return this.request<UserRemoteConfigResponse>(
+			"/api/v1/users/me/remote-config",
+		);
+	}
+
 	public async fetchBalance(userId?: string): Promise<ClineAccountBalance> {
 		const resolvedUserId = await this.resolveUserId(userId);
 		return this.request<ClineAccountBalance>(

package/src/account/types.ts

@@ -16,6 +16,12 @@ export interface ClineAccountUser {
 	organizations: ClineAccountOrganization[];
 }
 
+export interface UserRemoteConfigResponse {
+	organizationId: string;
+	value: string;
+	enabled: boolean;
+}
+
 export interface ClineAccountBalance {
 	balance: number;
 	userId: string;

package/src/index.node.ts

@@ -103,6 +103,22 @@ export {
 export async function loadOpenTelemetryAdapter() {
 	return import("./telemetry/opentelemetry.js");
 }
+export {
+	type ClineAccountBalance,
+	type ClineAccountOperations,
+	type ClineAccountOrganization,
+	type ClineAccountOrganizationBalance,
+	type ClineAccountOrganizationUsageTransaction,
+	type ClineAccountPaymentTransaction,
+	ClineAccountService,
+	type ClineAccountServiceOptions,
+	type ClineAccountUsageTransaction,
+	type ClineAccountUser,
+	executeRpcClineAccountAction,
+	isRpcClineAccountActionRequest,
+	RpcClineAccountService,
+	type RpcProviderActionExecutor,
+} from "./account";
 export { startLocalOAuthServer } from "./auth/server";
 export type {
 	OAuthCredentials,
@@ -127,6 +143,28 @@ export {
 	getFileIndex,
 	prewarmFileIndex,
 } from "./input";
+export {
+	hasMcpSettingsFile,
+	InMemoryMcpManager,
+	type LoadMcpSettingsOptions,
+	loadMcpSettingsFile,
+	type McpConnectionStatus,
+	type McpManager,
+	type McpManagerOptions,
+	type McpServerClient,
+	type McpServerClientFactory,
+	type McpServerRegistration,
+	type McpServerSnapshot,
+	type McpServerTransportConfig,
+	type McpSettingsFile,
+	type McpSseTransportConfig,
+	type McpStdioTransportConfig,
+	type McpStreamableHttpTransportConfig,
+	type RegisterMcpServersFromSettingsOptions,
+	registerMcpServersFromSettingsFile,
+	resolveDefaultMcpSettingsPath,
+	resolveMcpServerRegistrations,
+} from "./mcp";
 export {
 	addLocalProvider,
 	ensureCustomProvidersLoaded,

package/src/runtime/runtime-builder.team-persistence.test.ts

@@ -49,13 +49,12 @@ vi.mock("../default-tools", () => ({
 	},
 }));
 
-let teamStoreInstance: MockSqliteTeamStore | undefined;
-class MockSqliteTeamStore {
+let teamStoreInstance: MockTeamStore | undefined;
+class MockTeamStore {
 	constructor() {
 		teamStoreInstance = this;
 	}
 
-	init = vi.fn();
 	loadRuntime = vi.fn(() => ({
 		state: {
 			teamId: "team_1",
@@ -82,8 +81,8 @@ class MockSqliteTeamStore {
 	persistRuntime = vi.fn();
 }
 
-vi.mock("../storage/sqlite-team-store", () => ({
-	SqliteTeamStore: MockSqliteTeamStore,
+vi.mock("../storage/team-store", () => ({
+	createLocalTeamStore: () => new MockTeamStore(),
 }));
 
 describe("DefaultRuntimeBuilder team persistence boundary", () => {

package/src/runtime/runtime-builder.ts

@@ -14,7 +14,7 @@ import {
 	type SkillConfig,
 	type UserInstructionConfigWatcher,
 } from "../agents";
-import { SqliteTeamStore } from "../storage/sqlite-team-store";
+import { createLocalTeamStore } from "../storage/team-store";
 import {
 	createBuiltinTools,
 	DEFAULT_MODEL_TOOL_ROUTING_RULES,
@@ -418,9 +418,8 @@ export class DefaultRuntimeBuilder implements RuntimeBuilder {
 
 		let teamRuntime: AgentTeamsRuntime | undefined;
 		const teamStore = normalized.enableAgentTeams
-			? new SqliteTeamStore()
+			? createLocalTeamStore()
 			: undefined;
-		teamStore?.init();
 		const restoredTeam = teamStore?.loadRuntime(effectiveTeamName);
 		const restoredTeamState = restoredTeam?.state;
 		const restoredTeammateSpecs = restoredTeam?.teammates ?? [];

package/src/session/default-session-manager.ts

@@ -36,6 +36,7 @@ import { SessionSource, type SessionStatus } from "../types/common";
 import type { CoreSessionConfig } from "../types/config";
 import type { CoreSessionEvent } from "../types/events";
 import type { SessionRecord } from "../types/sessions";
+import type { FileSessionService } from "./file-session-service";
 import type { RpcCoreSessionService } from "./rpc-session-service";
 import {
 	OAuthReauthRequiredError,
@@ -92,7 +93,10 @@ import {
 	createInitialAccumulatedUsage,
 } from "./utils/usage";
 
-type SessionBackend = CoreSessionService | RpcCoreSessionService;
+type SessionBackend =
+	| CoreSessionService
+	| RpcCoreSessionService
+	| FileSessionService;
 
 const MAX_SCAN_LIMIT = 5000;
 const MAX_USER_FILE_BYTES = 20 * 1_000 * 1_024;

package/src/session/file-session-service.ts

@@ -0,0 +1,280 @@
+import {
+	existsSync,
+	mkdirSync,
+	readFileSync,
+	renameSync,
+	writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import { resolveSessionDataDir } from "@clinebot/shared/storage";
+import type { SessionRow } from "./session-service";
+import type {
+	PersistedSessionUpdateInput,
+	SessionPersistenceAdapter,
+} from "./unified-session-persistence-service";
+import { UnifiedSessionPersistenceService } from "./unified-session-persistence-service";
+
+interface FileSessionIndex {
+	version: 1;
+	sessions: Record<string, SessionRow>;
+}
+
+interface FileSpawnRequest {
+	id: number;
+	rootSessionId: string;
+	parentAgentId: string;
+	task?: string;
+	systemPrompt?: string;
+	createdAt: string;
+	consumedAt?: string;
+}
+
+interface FileSpawnQueue {
+	version: 1;
+	nextId: number;
+	requests: FileSpawnRequest[];
+}
+
+function nowIso(): string {
+	return new Date().toISOString();
+}
+
+function atomicWriteJson(path: string, value: unknown): void {
+	const tempPath = `${path}.tmp`;
+	writeFileSync(tempPath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+	renameSync(tempPath, path);
+}
+
+function defaultSessionsDir(): string {
+	return resolveSessionDataDir();
+}
+
+class FileSessionPersistenceAdapter implements SessionPersistenceAdapter {
+	constructor(
+		private readonly sessionsDirPath: string = defaultSessionsDir(),
+	) {}
+
+	ensureSessionsDir(): string {
+		if (!existsSync(this.sessionsDirPath)) {
+			mkdirSync(this.sessionsDirPath, { recursive: true });
+		}
+		return this.sessionsDirPath;
+	}
+
+	private indexPath(): string {
+		return join(this.ensureSessionsDir(), "sessions.index.json");
+	}
+
+	private spawnQueuePath(): string {
+		return join(this.ensureSessionsDir(), "subagent-spawn-queue.json");
+	}
+
+	private readIndex(): FileSessionIndex {
+		const path = this.indexPath();
+		if (!existsSync(path)) {
+			return { version: 1, sessions: {} };
+		}
+		try {
+			const parsed = JSON.parse(readFileSync(path, "utf8")) as FileSessionIndex;
+			if (parsed?.version === 1 && parsed.sessions) {
+				return parsed;
+			}
+		} catch {
+			// Ignore invalid persistence and fall back to an empty index.
+		}
+		return { version: 1, sessions: {} };
+	}
+
+	private writeIndex(index: FileSessionIndex): void {
+		atomicWriteJson(this.indexPath(), index);
+	}
+
+	private readQueue(): FileSpawnQueue {
+		const path = this.spawnQueuePath();
+		if (!existsSync(path)) {
+			return { version: 1, nextId: 1, requests: [] };
+		}
+		try {
+			const parsed = JSON.parse(readFileSync(path, "utf8")) as FileSpawnQueue;
+			if (
+				parsed?.version === 1 &&
+				typeof parsed.nextId === "number" &&
+				Array.isArray(parsed.requests)
+			) {
+				return parsed;
+			}
+		} catch {
+			// Ignore invalid persistence and fall back to an empty queue.
+		}
+		return { version: 1, nextId: 1, requests: [] };
+	}
+
+	private writeQueue(queue: FileSpawnQueue): void {
+		atomicWriteJson(this.spawnQueuePath(), queue);
+	}
+
+	async upsertSession(row: SessionRow): Promise<void> {
+		const index = this.readIndex();
+		index.sessions[row.sessionId] = row;
+		this.writeIndex(index);
+	}
+
+	async getSession(sessionId: string): Promise<SessionRow | undefined> {
+		return this.readIndex().sessions[sessionId];
+	}
+
+	async listSessions(options: {
+		limit: number;
+		parentSessionId?: string;
+		status?: string;
+	}): Promise<SessionRow[]> {
+		return Object.values(this.readIndex().sessions)
+			.filter((row) =>
+				options.parentSessionId !== undefined
+					? row.parentSessionId === options.parentSessionId
+					: true,
+			)
+			.filter((row) =>
+				options.status !== undefined ? row.status === options.status : true,
+			)
+			.sort((a, b) => b.startedAt.localeCompare(a.startedAt))
+			.slice(0, options.limit);
+	}
+
+	async updateSession(
+		input: PersistedSessionUpdateInput,
+	): Promise<{ updated: boolean; statusLock: number }> {
+		const index = this.readIndex();
+		const existing = index.sessions[input.sessionId];
+		if (!existing) {
+			return { updated: false, statusLock: 0 };
+		}
+		if (
+			input.expectedStatusLock !== undefined &&
+			existing.statusLock !== input.expectedStatusLock
+		) {
+			return { updated: false, statusLock: existing.statusLock };
+		}
+
+		const nextStatusLock =
+			input.expectedStatusLock !== undefined
+				? input.expectedStatusLock + 1
+				: existing.statusLock;
+		const next: SessionRow = {
+			...existing,
+			status: input.status ?? existing.status,
+			endedAt:
+				input.endedAt !== undefined
+					? input.endedAt
+					: (existing.endedAt ?? null),
+			exitCode:
+				input.exitCode !== undefined
+					? input.exitCode
+					: (existing.exitCode ?? null),
+			prompt:
+				input.prompt !== undefined ? input.prompt : (existing.prompt ?? null),
+			metadata:
+				input.metadata !== undefined
+					? (input.metadata ?? null)
+					: (existing.metadata ?? null),
+			parentSessionId:
+				input.parentSessionId !== undefined
+					? (input.parentSessionId ?? null)
+					: (existing.parentSessionId ?? null),
+			parentAgentId:
+				input.parentAgentId !== undefined
+					? (input.parentAgentId ?? null)
+					: (existing.parentAgentId ?? null),
+			agentId:
+				input.agentId !== undefined
+					? (input.agentId ?? null)
+					: (existing.agentId ?? null),
+			conversationId:
+				input.conversationId !== undefined
+					? (input.conversationId ?? null)
+					: (existing.conversationId ?? null),
+			statusLock: nextStatusLock,
+			isSubagent:
+				input.setRunning || input.parentSessionId !== undefined
+					? true
+					: existing.isSubagent,
+			updatedAt: nowIso(),
+		};
+
+		if (input.setRunning) {
+			next.status = "running";
+			next.endedAt = null;
+			next.exitCode = null;
+		}
+
+		index.sessions[input.sessionId] = next;
+		this.writeIndex(index);
+		return { updated: true, statusLock: next.statusLock };
+	}
+
+	async deleteSession(sessionId: string, cascade: boolean): Promise<boolean> {
+		const index = this.readIndex();
+		const existing = index.sessions[sessionId];
+		if (!existing) {
+			return false;
+		}
+		delete index.sessions[sessionId];
+		if (cascade) {
+			for (const row of Object.values(index.sessions)) {
+				if (row.parentSessionId === sessionId) {
+					delete index.sessions[row.sessionId];
+				}
+			}
+		}
+		this.writeIndex(index);
+		return true;
+	}
+
+	async enqueueSpawnRequest(input: {
+		rootSessionId: string;
+		parentAgentId: string;
+		task?: string;
+		systemPrompt?: string;
+	}): Promise<void> {
+		const queue = this.readQueue();
+		queue.requests.push({
+			id: queue.nextId,
+			rootSessionId: input.rootSessionId,
+			parentAgentId: input.parentAgentId,
+			task: input.task,
+			systemPrompt: input.systemPrompt,
+			createdAt: nowIso(),
+		});
+		queue.nextId += 1;
+		this.writeQueue(queue);
+	}
+
+	async claimSpawnRequest(
+		rootSessionId: string,
+		parentAgentId: string,
+	): Promise<string | undefined> {
+		const queue = this.readQueue();
+		const request = queue.requests.find(
+			(item) =>
+				item.rootSessionId === rootSessionId &&
+				item.parentAgentId === parentAgentId &&
+				!item.consumedAt,
+		);
+		if (!request) {
+			return undefined;
+		}
+		request.consumedAt = nowIso();
+		this.writeQueue(queue);
+		return request.task;
+	}
+}
+
+export class FileSessionService extends UnifiedSessionPersistenceService {
+	constructor(sessionsDir?: string) {
+		super(new FileSessionPersistenceAdapter(sessionsDir));
+	}
+
+	override ensureSessionsDir(): string {
+		return super.ensureSessionsDir();
+	}
+}

package/src/session/session-host.test.ts

@@ -0,0 +1,29 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("@clinebot/rpc", () => ({
+	getRpcServerDefaultAddress: () => "ws://127.0.0.1:0",
+	getRpcServerHealth: vi.fn(async () => undefined),
+}));
+
+describe("resolveSessionBackend", () => {
+	afterEach(() => {
+		vi.resetModules();
+		vi.restoreAllMocks();
+	});
+
+	it("falls back to file session storage when sqlite initialization fails", async () => {
+		vi.doMock("../storage/sqlite-session-store", () => ({
+			SqliteSessionStore: class {
+				init(): void {
+					throw new Error("sqlite unavailable");
+				}
+			},
+		}));
+
+		const { resolveSessionBackend } = await import("./session-host");
+		const { FileSessionService } = await import("./file-session-service");
+
+		const backend = await resolveSessionBackend({ backendMode: "local" });
+		expect(backend).toBeInstanceOf(FileSessionService);
+	});
+});

package/src/session/session-host.ts

@@ -13,6 +13,7 @@ import { nanoid } from "nanoid";
 import { SqliteSessionStore } from "../storage/sqlite-session-store";
 import type { ToolExecutors } from "../tools";
 import { DefaultSessionManager } from "./default-session-manager";
+import { FileSessionService } from "./file-session-service";
 import { RpcCoreSessionService } from "./rpc-session-service";
 import { tryAcquireRpcSpawnLease } from "./rpc-spawn-lease";
 import type { SessionManager } from "./session-manager";
@@ -21,7 +22,10 @@ import { CoreSessionService } from "./session-service";
 const DEFAULT_RPC_ADDRESS =
 	process.env.CLINE_RPC_ADDRESS?.trim() || getRpcServerDefaultAddress();
 
-export type SessionBackend = RpcCoreSessionService | CoreSessionService;
+export type SessionBackend =
+	| RpcCoreSessionService
+	| CoreSessionService
+	| FileSessionService;
 
 let cachedBackend: SessionBackend | undefined;
 let backendInitPromise: Promise<SessionBackend> | undefined;
@@ -111,8 +115,18 @@ async function tryConnectRpcBackend(
 	}
 }
 
-function createLocalBackend(): CoreSessionService {
-	return new CoreSessionService(new SqliteSessionStore());
+function createLocalBackend(): SessionBackend {
+	try {
+		const store = new SqliteSessionStore();
+		store.init();
+		return new CoreSessionService(store);
+	} catch (error) {
+		console.warn(
+			"SQLite session persistence unavailable, falling back to file-based session storage.",
+			error,
+		);
+		return new FileSessionService();
+	}
 }
 
 function resolveHostDistinctId(explicitDistinctId: string | undefined): string {

package/src/session/session-team-coordination.ts

@@ -163,11 +163,12 @@ export function shouldAutoContinueTeamRuns(
 	session: ActiveSession,
 	finishReason: AgentResult["finishReason"],
 ): boolean {
-	if (
-		session.aborting ||
-		finishReason === "aborted" ||
-		finishReason === "error"
-	) {
+	if (session.aborting) {
+		return false;
+	}
+	const canAutoContinue =
+		finishReason === "completed" || finishReason === "max_iterations";
+	if (!canAutoContinue) {
 		return false;
 	}
 	return (