@clinebot/core 0.0.34 → 0.0.36

package/src/session/session-host.ts

@@ -1,213 +0,0 @@
-import { spawn } from "node:child_process";
-import { existsSync } from "node:fs";
-import { resolve } from "node:path";
-import { getRpcServerDefaultAddress, getRpcServerHealth } from "@clinebot/rpc";
-import {
-	augmentNodeCommandForDebug,
-	withResolvedClineBuildEnv,
-} from "@clinebot/shared";
-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 command = augmentNodeCommandForDebug(
-		[
-			launcher,
-			...(conditionsArg ? [conditionsArg] : []),
-			entry,
-			"rpc",
-			"start",
-			"--address",
-			address,
-		],
-		{ debugRole: "rpc" },
-	);
-
-	const child = spawn(command[0] ?? launcher, command.slice(1), {
-		detached: true,
-		stdio: "ignore",
-		env: {
-			...withResolvedClineBuildEnv(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

@@ -1,74 +0,0 @@
-import type * as LlmsProviders from "@clinebot/llms";
-import type {
-	AgentResult,
-	ToolApprovalRequest,
-	ToolApprovalResult,
-} from "@clinebot/shared";
-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("../extensions/config").UserInstructionConfigWatcher;
-	onTeamRestored?: () => void;
-	defaultToolExecutors?: Partial<import("../tools").ToolExecutors>;
-	toolPolicies?: import("@clinebot/shared").AgentConfig["toolPolicies"];
-	requestToolApproval?: (
-		request: ToolApprovalRequest,
-	) => Promise<ToolApprovalResult>;
-	teamToolsFactory?: import("../runtime/session-runtime").TeamToolsFactory;
-}
-
-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-service.team-persistence.test.ts

@@ -1,48 +0,0 @@
-import { existsSync, mkdtempSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { describe, expect, it } from "vitest";
-import { AgentTeamsRuntime } from "../team";
-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();
-	});
-});

package/src/session/sqlite-rpc-session-backend.ts

@@ -1,303 +0,0 @@
-import type {
-	RpcSessionBackend,
-	RpcSessionRow,
-	RpcSessionStatus,
-	RpcSessionUpdateInput,
-	RpcSpawnQueueItem,
-} from "@clinebot/rpc";
-import {
-	asBool,
-	asOptionalString,
-	asString,
-	nowIso,
-	toBoolInt,
-} from "@clinebot/shared/db";
-import { SqliteSessionStore } from "../storage/sqlite-session-store";
-
-export interface SqliteRpcSessionBackendOptions {
-	sessionsDir?: string;
-}
-
-export class SqliteRpcSessionBackend implements RpcSessionBackend {
-	private readonly store: SqliteSessionStore;
-
-	constructor(options: SqliteRpcSessionBackendOptions = {}) {
-		this.store = new SqliteSessionStore({ sessionsDir: options.sessionsDir });
-	}
-
-	public init(): void {
-		this.store.init();
-	}
-
-	public upsertSession(row: RpcSessionRow): void {
-		this.store.run(
-			`INSERT OR REPLACE INTO sessions (
-				session_id, source, pid, started_at, ended_at, exit_code, status, status_lock, interactive,
-				provider, model, cwd, workspace_root, team_name, enable_tools, enable_spawn, enable_teams,
-				parent_session_id, parent_agent_id, agent_id, conversation_id, is_subagent, prompt,
-				metadata_json, transcript_path, hook_path, messages_path, updated_at
-			) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-			[
-				row.sessionId,
-				row.source,
-				row.pid,
-				row.startedAt,
-				row.endedAt ?? null,
-				row.exitCode ?? null,
-				row.status,
-				row.statusLock,
-				toBoolInt(row.interactive),
-				row.provider,
-				row.model,
-				row.cwd,
-				row.workspaceRoot,
-				row.teamName ?? null,
-				toBoolInt(row.enableTools),
-				toBoolInt(row.enableSpawn),
-				toBoolInt(row.enableTeams),
-				row.parentSessionId ?? null,
-				row.parentAgentId ?? null,
-				row.agentId ?? null,
-				row.conversationId ?? null,
-				toBoolInt(row.isSubagent),
-				row.prompt ?? null,
-				row.metadata ? JSON.stringify(row.metadata) : null,
-				row.transcriptPath,
-				row.hookPath,
-				row.messagesPath ?? null,
-				row.updatedAt || nowIso(),
-			],
-		);
-	}
-
-	public getSession(sessionId: string): RpcSessionRow | undefined {
-		const row = this.store.queryOne<Record<string, unknown>>(
-			`SELECT session_id, source, pid, started_at, ended_at, exit_code, status, status_lock, interactive,
-				provider, model, cwd, workspace_root, team_name, enable_tools, enable_spawn, enable_teams,
-				parent_session_id, parent_agent_id, agent_id, conversation_id, is_subagent, prompt,
-				metadata_json, transcript_path, hook_path, messages_path, updated_at
-			 FROM sessions WHERE session_id = ?`,
-			[sessionId],
-		);
-		if (!row) {
-			return undefined;
-		}
-		return {
-			sessionId: asString(row.session_id),
-			source: asString(row.source),
-			pid: Number(row.pid ?? 0),
-			startedAt: asString(row.started_at),
-			endedAt: (row.ended_at as string | null | undefined) ?? null,
-			exitCode: (row.exit_code as number | null | undefined) ?? null,
-			status: asString(row.status) as RpcSessionStatus,
-			statusLock: Number(row.status_lock ?? 0),
-			interactive: asBool(row.interactive),
-			provider: asString(row.provider),
-			model: asString(row.model),
-			cwd: asString(row.cwd),
-			workspaceRoot: asString(row.workspace_root),
-			teamName: asOptionalString(row.team_name),
-			enableTools: asBool(row.enable_tools),
-			enableSpawn: asBool(row.enable_spawn),
-			enableTeams: asBool(row.enable_teams),
-			parentSessionId: asOptionalString(row.parent_session_id),
-			parentAgentId: asOptionalString(row.parent_agent_id),
-			agentId: asOptionalString(row.agent_id),
-			conversationId: asOptionalString(row.conversation_id),
-			isSubagent: asBool(row.is_subagent),
-			prompt: asOptionalString(row.prompt),
-			metadata: (() => {
-				const raw = asOptionalString(row.metadata_json);
-				if (!raw) {
-					return undefined;
-				}
-				try {
-					const parsed = JSON.parse(raw) as unknown;
-					if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-						return parsed as Record<string, unknown>;
-					}
-				} catch {
-					// Ignore malformed metadata payloads.
-				}
-				return undefined;
-			})(),
-			transcriptPath: asString(row.transcript_path),
-			hookPath: asString(row.hook_path),
-			messagesPath: asOptionalString(row.messages_path),
-			updatedAt: asString(row.updated_at) || nowIso(),
-		};
-	}
-
-	public listSessions(options: {
-		limit: number;
-		parentSessionId?: string;
-		status?: string;
-	}): RpcSessionRow[] {
-		const where: string[] = [];
-		const params: unknown[] = [];
-		if (options.parentSessionId) {
-			where.push("parent_session_id = ?");
-			params.push(options.parentSessionId);
-		}
-		if (options.status) {
-			where.push("status = ?");
-			params.push(options.status);
-		}
-		const whereClause = where.length > 0 ? `WHERE ${where.join(" AND ")}` : "";
-		const limit = Math.max(1, Math.floor(options.limit));
-		const rows = this.store.queryAll<{ session_id?: string }>(
-			`SELECT session_id FROM sessions ${whereClause} ORDER BY started_at DESC LIMIT ?`,
-			[...params, limit],
-		);
-		const out: RpcSessionRow[] = [];
-		for (const row of rows) {
-			if (!row.session_id) {
-				continue;
-			}
-			const item = this.getSession(row.session_id);
-			if (item) {
-				out.push(item);
-			}
-		}
-		return out;
-	}
-
-	public updateSession(input: RpcSessionUpdateInput): {
-		updated: boolean;
-		statusLock: number;
-	} {
-		const existing = this.getSession(input.sessionId);
-		if (!existing) {
-			return { updated: false, statusLock: 0 };
-		}
-		if (
-			typeof input.expectedStatusLock === "number" &&
-			existing.statusLock !== input.expectedStatusLock
-		) {
-			return { updated: false, statusLock: existing.statusLock };
-		}
-		const nextLock = existing.statusLock + 1;
-		const nextStatus = input.setRunning
-			? "running"
-			: (input.status ?? existing.status);
-		const nextEndedAt =
-			input.setRunning === true
-				? null
-				: input.endedAt !== undefined
-					? input.endedAt
-					: (existing.endedAt ?? null);
-		const nextExitCode =
-			input.setRunning === true
-				? null
-				: input.exitCode !== undefined
-					? input.exitCode
-					: (existing.exitCode ?? null);
-		const nextPrompt =
-			input.prompt !== undefined
-				? (input.prompt ?? undefined)
-				: existing.prompt;
-		const nextMetadata =
-			input.metadata !== undefined
-				? (input.metadata ?? undefined)
-				: existing.metadata;
-
-		this.store.run(
-			`UPDATE sessions
-			 SET status = ?, ended_at = ?, exit_code = ?, prompt = ?, metadata_json = ?,
-				 parent_session_id = ?, parent_agent_id = ?, agent_id = ?, conversation_id = ?,
-				 status_lock = ?, updated_at = ?
-			 WHERE session_id = ?`,
-			[
-				nextStatus,
-				nextEndedAt,
-				nextExitCode,
-				nextPrompt ?? null,
-				nextMetadata ? JSON.stringify(nextMetadata) : null,
-				input.parentSessionId !== undefined
-					? (input.parentSessionId ?? null)
-					: (existing.parentSessionId ?? null),
-				input.parentAgentId !== undefined
-					? (input.parentAgentId ?? null)
-					: (existing.parentAgentId ?? null),
-				input.agentId !== undefined
-					? (input.agentId ?? null)
-					: (existing.agentId ?? null),
-				input.conversationId !== undefined
-					? (input.conversationId ?? null)
-					: (existing.conversationId ?? null),
-				nextLock,
-				nowIso(),
-				input.sessionId,
-			],
-		);
-		return { updated: true, statusLock: nextLock };
-	}
-
-	public deleteSession(sessionId: string): boolean {
-		const changes =
-			this.store.run("DELETE FROM sessions WHERE session_id = ?", [sessionId])
-				.changes ?? 0;
-		return changes > 0;
-	}
-
-	public deleteSessionsByParent(parentSessionId: string): void {
-		this.store.run("DELETE FROM sessions WHERE parent_session_id = ?", [
-			parentSessionId,
-		]);
-	}
-
-	public enqueueSpawnRequest(input: {
-		rootSessionId: string;
-		parentAgentId: string;
-		task?: string;
-		systemPrompt?: string;
-	}): void {
-		this.store.run(
-			`INSERT INTO subagent_spawn_queue (root_session_id, parent_agent_id, task, system_prompt, created_at, consumed_at)
-			 VALUES (?, ?, ?, ?, ?, NULL)`,
-			[
-				input.rootSessionId,
-				input.parentAgentId,
-				input.task ?? null,
-				input.systemPrompt ?? null,
-				nowIso(),
-			],
-		);
-	}
-
-	public claimSpawnRequest(
-		rootSessionId: string,
-		parentAgentId: string,
-	): RpcSpawnQueueItem | undefined {
-		const row = this.store.queryOne<Record<string, unknown>>(
-			`SELECT id, root_session_id, parent_agent_id, task, system_prompt, created_at, consumed_at
-			 FROM subagent_spawn_queue
-			 WHERE root_session_id = ? AND parent_agent_id = ? AND consumed_at IS NULL
-			 ORDER BY id ASC LIMIT 1`,
-			[rootSessionId, parentAgentId],
-		);
-		if (!row || typeof row.id !== "number") {
-			return undefined;
-		}
-		const consumedAt = nowIso();
-		this.store.run(
-			"UPDATE subagent_spawn_queue SET consumed_at = ? WHERE id = ?",
-			[consumedAt, row.id],
-		);
-		return {
-			id: row.id,
-			rootSessionId: asString(row.root_session_id),
-			parentAgentId: asString(row.parent_agent_id),
-			task: asOptionalString(row.task),
-			systemPrompt: asOptionalString(row.system_prompt),
-			createdAt: asString(row.created_at),
-			consumedAt,
-		};
-	}
-}
-
-export function createSqliteRpcSessionBackend(
-	options: SqliteRpcSessionBackendOptions = {},
-): RpcSessionBackend {
-	return new SqliteRpcSessionBackend(options);
-}