@clinebot/core 0.0.22 → 0.0.24

package/src/session/session-host.ts

@@ -0,0 +1,205 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { getRpcServerDefaultAddress, getRpcServerHealth } from "@clinebot/rpc";
+import { resolveSessionDataDir } from "@clinebot/shared/storage";
+import type { ClineCoreOptions } from "../ClineCore";
+import { SqliteSessionStore } from "../storage/sqlite-session-store";
+import { resolveCoreDistinctId } from "../telemetry/distinct-id";
+import { DefaultSessionManager } from "./default-session-manager";
+import { FileSessionService } from "./file-session-service";
+import {
+	ensureRpcRuntimeAddress,
+	resolveRpcOwnerContext,
+} from "./rpc-runtime-ensure";
+import { RpcCoreSessionService } from "./rpc-session-service";
+import { tryAcquireRpcSpawnLease } from "./rpc-spawn-lease";
+import type { SessionManager } from "./session-manager";
+import { CoreSessionService } from "./session-service";
+
+const DEFAULT_RPC_ADDRESS =
+	process.env.CLINE_RPC_ADDRESS?.trim() || getRpcServerDefaultAddress();
+
+export type SessionBackend =
+	| RpcCoreSessionService
+	| CoreSessionService
+	| FileSessionService;
+
+export type SessionHost = SessionManager;
+
+let cachedBackend: SessionBackend | undefined;
+let backendInitPromise: Promise<SessionBackend> | undefined;
+
+async function reconcileDeadSessionsIfSupported(
+	backend: SessionBackend,
+): Promise<void> {
+	const service = backend as SessionBackend & {
+		reconcileDeadSessions?: (limit?: number) => Promise<number>;
+	};
+	await service.reconcileDeadSessions?.().catch(() => {});
+}
+
+function startRpcServerInBackground(address: string): void {
+	const lease = tryAcquireRpcSpawnLease(address);
+	if (!lease) {
+		return;
+	}
+	const launcher = process.execPath;
+	const entryArg = process.argv[1]?.trim();
+	if (!entryArg) {
+		lease.release();
+		return;
+	}
+	const entry = resolve(process.cwd(), entryArg);
+	if (!existsSync(entry)) {
+		lease.release();
+		return;
+	}
+	const conditionsArg = process.execArgv.find((arg) =>
+		arg.startsWith("--conditions="),
+	);
+	const args = [
+		...(conditionsArg ? [conditionsArg] : []),
+		entry,
+		"rpc",
+		"start",
+		"--address",
+		address,
+	];
+
+	const child = spawn(launcher, args, {
+		detached: true,
+		stdio: "ignore",
+		env: {
+			...process.env,
+			CLINE_NO_INTERACTIVE: "1",
+		},
+		cwd: process.cwd(),
+	});
+	child.unref();
+	setTimeout(() => lease.release(), 10_000).unref();
+}
+
+async function tryConnectRpcBackend(
+	address: string,
+): Promise<RpcCoreSessionService | undefined> {
+	try {
+		const health = await getRpcServerHealth(address);
+		if (!health) {
+			return undefined;
+		}
+		return new RpcCoreSessionService({
+			address,
+			sessionsDir: resolveSessionDataDir(),
+		});
+	} catch {
+		return undefined;
+	}
+}
+
+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();
+	}
+}
+
+export async function resolveSessionBackend(
+	options: ClineCoreOptions,
+): Promise<SessionBackend> {
+	if (cachedBackend) {
+		return cachedBackend;
+	}
+	if (backendInitPromise) {
+		return await backendInitPromise;
+	}
+
+	const mode = options.backendMode ?? "auto";
+	const requestedAddress = options.rpc?.address?.trim() || DEFAULT_RPC_ADDRESS;
+	const attempts = Math.max(1, options.rpc?.connectAttempts ?? 5);
+	const delayMs = Math.max(0, options.rpc?.connectDelayMs ?? 100);
+	const autoStartRpc = options.rpc?.autoStart !== false;
+
+	backendInitPromise = (async () => {
+		if (mode === "local") {
+			cachedBackend = createLocalBackend();
+			await reconcileDeadSessionsIfSupported(cachedBackend);
+			return cachedBackend;
+		}
+
+		let address = requestedAddress;
+		const existingRpcBackend = await tryConnectRpcBackend(address);
+		if (existingRpcBackend) {
+			cachedBackend = existingRpcBackend;
+			await reconcileDeadSessionsIfSupported(cachedBackend);
+			return cachedBackend;
+		}
+
+		if (mode === "rpc") {
+			throw new Error(`RPC backend unavailable at ${address}`);
+		}
+
+		if (autoStartRpc) {
+			try {
+				const ensured = await ensureRpcRuntimeAddress(address, {
+					resolveOwner: () => resolveRpcOwnerContext({ ownerPrefix: "core" }),
+					spawnIfNeeded: (rpcAddress) => {
+						startRpcServerInBackground(rpcAddress);
+					},
+				});
+				address = ensured.address;
+			} catch {
+				// Ignore launch failures and fall back to local backend.
+			}
+
+			for (let attempt = 0; attempt < attempts; attempt += 1) {
+				const rpcBackend = await tryConnectRpcBackend(address);
+				if (rpcBackend) {
+					cachedBackend = rpcBackend;
+					await reconcileDeadSessionsIfSupported(cachedBackend);
+					return cachedBackend;
+				}
+				if (delayMs > 0) {
+					await new Promise((resolve) => setTimeout(resolve, delayMs));
+				}
+			}
+		}
+
+		cachedBackend = createLocalBackend();
+		await reconcileDeadSessionsIfSupported(cachedBackend);
+		return cachedBackend;
+	})().finally(() => {
+		backendInitPromise = undefined;
+	});
+
+	return await backendInitPromise;
+}
+
+/**
+ * NOTE Internal only - replaced with ClineCore.create() for public API.
+ * Creates a SessionHost instance based on the provided options.
+ * This will attempt to connect to an RPC session service if configured, and fall back to a local session service if not.
+ */
+export async function createSessionHost(
+	options: ClineCoreOptions,
+): Promise<SessionHost> {
+	const distinctId = resolveCoreDistinctId(options.distinctId);
+	options.telemetry?.setDistinctId(distinctId);
+	const backend =
+		options.sessionService ?? (await resolveSessionBackend(options));
+	return new DefaultSessionManager({
+		sessionService: backend,
+		defaultToolExecutors: options.defaultToolExecutors,
+		telemetry: options.telemetry,
+		toolPolicies: options.toolPolicies,
+		requestToolApproval: options.requestToolApproval,
+		distinctId,
+	});
+}

package/src/session/session-manager.ts

@@ -0,0 +1,69 @@
+import type { AgentResult } from "@clinebot/agents";
+import type * as LlmsProviders from "@clinebot/llms/providers";
+import type { SessionSource } from "../types/common";
+import type { CoreSessionConfig } from "../types/config";
+import type { CoreSessionEvent } from "../types/events";
+import type { SessionRecord } from "../types/sessions";
+import type { SessionManifest } from "./session-manifest";
+
+export interface StartSessionInput {
+	config: CoreSessionConfig;
+	source?: SessionSource;
+	prompt?: string;
+	interactive?: boolean;
+	initialMessages?: LlmsProviders.Message[];
+	userImages?: string[];
+	userFiles?: string[];
+	userInstructionWatcher?: import("../agents").UserInstructionConfigWatcher;
+	onTeamRestored?: () => void;
+	defaultToolExecutors?: Partial<import("../tools").ToolExecutors>;
+	toolPolicies?: import("@clinebot/agents").AgentConfig["toolPolicies"];
+	requestToolApproval?: (
+		request: import("@clinebot/agents").ToolApprovalRequest,
+	) => Promise<import("@clinebot/agents").ToolApprovalResult>;
+}
+
+export interface StartSessionResult {
+	sessionId: string;
+	manifest: SessionManifest;
+	manifestPath: string;
+	transcriptPath: string;
+	hookPath: string;
+	messagesPath: string;
+	result?: AgentResult;
+}
+
+export interface SendSessionInput {
+	sessionId: string;
+	prompt: string;
+	userImages?: string[];
+	userFiles?: string[];
+	delivery?: "queue" | "steer";
+}
+
+export interface SessionAccumulatedUsage {
+	inputTokens: number;
+	outputTokens: number;
+	cacheReadTokens: number;
+	cacheWriteTokens: number;
+	totalCost: number;
+}
+
+export interface SessionManager {
+	start(input: StartSessionInput): Promise<StartSessionResult>;
+	send(input: SendSessionInput): Promise<AgentResult | undefined>;
+	getAccumulatedUsage(
+		sessionId: string,
+	): Promise<SessionAccumulatedUsage | undefined>;
+	abort(sessionId: string, reason?: unknown): Promise<void>;
+	stop(sessionId: string): Promise<void>;
+	dispose(reason?: string): Promise<void>;
+	get(sessionId: string): Promise<SessionRecord | undefined>;
+	list(limit?: number): Promise<SessionRecord[]>;
+	delete(sessionId: string): Promise<boolean>;
+	readMessages(sessionId: string): Promise<LlmsProviders.Message[]>;
+	readTranscript(sessionId: string, maxChars?: number): Promise<string>;
+	readHooks(sessionId: string, limit?: number): Promise<unknown[]>;
+	subscribe(listener: (event: CoreSessionEvent) => void): () => void;
+	updateSessionModel?(sessionId: string, modelId: string): Promise<void>;
+}

package/src/session/session-manifest.ts

@@ -0,0 +1,29 @@
+import { z } from "zod";
+import { SESSION_STATUSES } from "../types/common";
+
+const SessionStatusSchema = z.enum(SESSION_STATUSES);
+
+export const SessionManifestSchema = z.object({
+	version: z.literal(1),
+	session_id: z.string().min(1),
+	source: z.string().min(1),
+	pid: z.number().int(),
+	started_at: z.string().min(1),
+	ended_at: z.string().min(1).optional(),
+	exit_code: z.number().int().nullable().optional(),
+	status: SessionStatusSchema,
+	interactive: z.boolean(),
+	provider: z.string().min(1),
+	model: z.string().min(1),
+	cwd: z.string().min(1),
+	workspace_root: z.string().min(1),
+	team_name: z.string().min(1).optional(),
+	enable_tools: z.boolean(),
+	enable_spawn: z.boolean(),
+	enable_teams: z.boolean(),
+	prompt: z.string().optional(),
+	metadata: z.record(z.string(), z.unknown()).optional(),
+	messages_path: z.string().min(1).optional(),
+});
+
+export type SessionManifest = z.infer<typeof SessionManifestSchema>;

package/src/session/session-service.team-persistence.test.ts

@@ -0,0 +1,48 @@
+import { existsSync, mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { AgentTeamsRuntime } from "@clinebot/agents";
+import { describe, expect, it } from "vitest";
+import { FileTeamPersistenceStore } from "./session-service";
+
+describe("FileTeamPersistenceStore", () => {
+	it("does not create state.json for an empty runtime", () => {
+		const baseDir = mkdtempSync(join(tmpdir(), "team-store-"));
+		const store = new FileTeamPersistenceStore({
+			teamName: "agent-team-nmnn9",
+			baseDir,
+		});
+		const runtime = new AgentTeamsRuntime({ teamName: "agent-team-nmnn9" });
+
+		store.persist(runtime);
+
+		expect(
+			existsSync(join(baseDir, "agent-team-nmnn9", "state.json")),
+		).toBeFalsy();
+	});
+
+	it("removes persisted state when runtime becomes empty again", () => {
+		const baseDir = mkdtempSync(join(tmpdir(), "team-store-"));
+		const store = new FileTeamPersistenceStore({
+			teamName: "agent-team-cleanup",
+			baseDir,
+		});
+		const runtime = new AgentTeamsRuntime({ teamName: "agent-team-cleanup" });
+
+		store.upsertTeammateSpec({
+			agentId: "worker",
+			rolePrompt: "Implement tasks",
+		});
+		store.persist(runtime);
+		expect(
+			existsSync(join(baseDir, "agent-team-cleanup", "state.json")),
+		).toBeTruthy();
+
+		store.removeTeammateSpec("worker");
+		runtime.cleanup();
+		store.persist(runtime);
+		expect(
+			existsSync(join(baseDir, "agent-team-cleanup", "state.json")),
+		).toBeFalsy();
+	});
+});