@clinebot/core 0.0.33 → 0.0.35

package/src/transports/rpc.ts

@@ -0,0 +1,665 @@
+import { readFile } from "node:fs/promises";
+import type * as LlmsProviders from "@clinebot/llms";
+import { RpcSessionClient } from "@clinebot/rpc";
+import {
+	type AgentEvent,
+	type AgentResult,
+	createSessionId,
+	type RpcChatRunTurnRequest,
+	type RpcChatStartSessionRequest,
+	type RpcChatTurnResult,
+	type TeamProgressLifecycleEvent,
+	type TeamProgressSummary,
+	type ToolApprovalRequest,
+	type ToolApprovalResult,
+	type ToolPolicy,
+} from "@clinebot/shared";
+import type { HookEventPayload } from "../hooks";
+import type {
+	RuntimeHost,
+	SendSessionInput,
+	SessionAccumulatedUsage,
+	StartSessionInput,
+	StartSessionResult,
+} from "../runtime/runtime-host";
+import { toSessionRecord } from "../services/session-data";
+import type { RpcCoreSessionService } from "../session/rpc-session-service";
+import type { CoreSessionEvent } from "../types/events";
+import type { SessionRecord } from "../types/sessions";
+import {
+	cloneAccumulatedUsage,
+	RuntimeHostEventBus,
+	readPersistedMessagesFile,
+	replaySubagentHookEvent,
+} from "./runtime-host-support";
+
+type ApprovalRequester = (
+	request: ToolApprovalRequest,
+) => Promise<ToolApprovalResult>;
+
+const DEFAULT_MANUAL_APPROVAL_POLICY: ToolPolicy = {
+	enabled: true,
+	autoApprove: false,
+};
+
+function unsupportedRpcFeature(name: string): Error {
+	return new Error(
+		`RPC-backed ClineCore does not support ${name}. Use local backend mode for this session.`,
+	);
+}
+
+function validateRpcStartInput(input: StartSessionInput): void {
+	const overrides = input.localRuntime?.configOverrides;
+	if (
+		input.localRuntime?.userInstructionWatcher ||
+		input.localRuntime?.onTeamRestored ||
+		(overrides != null && Object.keys(overrides).length > 0)
+	) {
+		throw unsupportedRpcFeature("local runtime bootstrap options");
+	}
+}
+
+function toRpcStartRequest(
+	input: StartSessionInput,
+): RpcChatStartSessionRequest {
+	const workspaceRoot =
+		input.config.workspaceRoot?.trim() || input.config.cwd.trim();
+	return {
+		sessionId: input.config.sessionId?.trim() || undefined,
+		workspaceRoot,
+		cwd: input.config.cwd,
+		provider: input.config.providerId,
+		model: input.config.modelId,
+		mode: input.config.mode,
+		apiKey: input.config.apiKey?.trim() || "",
+		systemPrompt: input.config.systemPrompt,
+		rules: input.config.rules,
+		maxIterations: input.config.maxIterations,
+		enableTools: input.config.enableTools,
+		enableSpawn: input.config.enableSpawnAgent,
+		enableTeams: input.config.enableAgentTeams,
+		disableMcpSettingsTools: input.config.disableMcpSettingsTools,
+		autoApproveTools: input.toolPolicies?.["*"]?.autoApprove,
+		teamName: input.config.teamName ?? "",
+		missionStepInterval: input.config.missionLogIntervalSteps ?? 3,
+		missionTimeIntervalMs: input.config.missionLogIntervalMs ?? 120_000,
+		toolPolicies: input.toolPolicies,
+		initialMessages: input.initialMessages as
+			| RpcChatStartSessionRequest["initialMessages"]
+			| undefined,
+		sessions: undefined,
+		source: input.source,
+		interactive: input.interactive === true,
+	};
+}
+
+async function buildTurnRequest(
+	config: RpcChatStartSessionRequest,
+	messages: LlmsProviders.Message[] | undefined,
+	input: {
+		prompt: string;
+		userImages?: string[];
+		userFiles?: string[];
+		delivery?: "queue" | "steer";
+	},
+): Promise<RpcChatRunTurnRequest> {
+	return {
+		config,
+		messages: messages as RpcChatRunTurnRequest["messages"] | undefined,
+		prompt: input.prompt,
+		delivery: input.delivery,
+		attachments:
+			input.userImages?.length || input.userFiles?.length
+				? {
+						userImages: input.userImages,
+						userFiles: input.userFiles
+							? await Promise.all(
+									input.userFiles.map(async (path) => ({
+										name: path.split("/").at(-1) || path,
+										content: await readFile(path, "utf8"),
+									})),
+								)
+							: undefined,
+					}
+				: undefined,
+	};
+}
+
+function toAgentResult(
+	result: RpcChatTurnResult,
+	config: RpcChatStartSessionRequest,
+	startedAt: Date,
+): AgentResult {
+	const endedAt = new Date();
+	return {
+		text: result.text,
+		usage: result.usage,
+		messages: result.messages as LlmsProviders.Message[],
+		toolCalls: result.toolCalls.map((call) => ({
+			id: createSessionId(),
+			name: call.name,
+			input: call.input,
+			output: call.output,
+			error: call.error,
+			durationMs: call.durationMs ?? 0,
+			startedAt,
+			endedAt,
+		})),
+		iterations: result.iterations,
+		finishReason: result.finishReason as AgentResult["finishReason"],
+		model: {
+			id: config.model,
+			provider: config.provider,
+		},
+		startedAt,
+		endedAt,
+		durationMs: Math.max(0, endedAt.getTime() - startedAt.getTime()),
+	};
+}
+
+function accumulateUsage(
+	base: SessionAccumulatedUsage | undefined,
+	result: RpcChatTurnResult,
+): SessionAccumulatedUsage {
+	return {
+		inputTokens: (base?.inputTokens ?? 0) + result.usage.inputTokens,
+		outputTokens: (base?.outputTokens ?? 0) + result.usage.outputTokens,
+		cacheReadTokens:
+			(base?.cacheReadTokens ?? 0) + (result.usage.cacheReadTokens ?? 0),
+		cacheWriteTokens:
+			(base?.cacheWriteTokens ?? 0) + (result.usage.cacheWriteTokens ?? 0),
+		totalCost: (base?.totalCost ?? 0) + (result.usage.totalCost ?? 0),
+	};
+}
+
+export class RpcRuntimeHost implements RuntimeHost {
+	public readonly runtimeAddress: string;
+	private readonly client: RpcSessionClient;
+	private readonly events = new RuntimeHostEventBus();
+	private readonly sessionConfigs = new Map<
+		string,
+		RpcChatStartSessionRequest
+	>();
+	private readonly sessionApprovals = new Map<
+		string,
+		ApprovalRequester | undefined
+	>();
+	private readonly usageBySession = new Map<string, SessionAccumulatedUsage>();
+	private readonly trackedSessionIds = new Set<string>();
+	private stopEventStream?: () => void;
+
+	constructor(
+		private readonly backend: RpcCoreSessionService,
+		private readonly defaultToolPolicies?: RpcChatStartSessionRequest["toolPolicies"],
+		private readonly defaultRequestToolApproval?: ApprovalRequester,
+	) {
+		this.runtimeAddress = backend.address;
+		this.client = new RpcSessionClient({
+			address: backend.address,
+		});
+	}
+
+	async start(input: StartSessionInput): Promise<StartSessionResult> {
+		validateRpcStartInput(input);
+		const config = toRpcStartRequest(input);
+		if (!config.toolPolicies && this.defaultToolPolicies) {
+			config.toolPolicies = this.defaultToolPolicies;
+		}
+		const response = await this.client.startRuntimeSession(config);
+		const sessionId = response.sessionId.trim();
+		if (!sessionId) {
+			throw new Error("RPC runtime start returned an empty session id");
+		}
+		const startResult = response.startResult;
+		if (!startResult) {
+			throw new Error("RPC runtime start did not return session artifacts");
+		}
+
+		this.sessionConfigs.set(sessionId, { ...config, sessionId });
+		this.sessionApprovals.set(
+			sessionId,
+			input.requestToolApproval ?? this.defaultRequestToolApproval,
+		);
+		this.usageBySession.set(sessionId, {
+			inputTokens: 0,
+			outputTokens: 0,
+			cacheReadTokens: 0,
+			cacheWriteTokens: 0,
+			totalCost: 0,
+		});
+		this.trackedSessionIds.add(sessionId);
+		this.refreshEventStream();
+		this.emit({
+			type: "status",
+			payload: { sessionId, status: "running" },
+		});
+
+		let result: AgentResult | undefined;
+		if (input.prompt?.trim()) {
+			result = await this.send({
+				sessionId,
+				prompt: input.prompt,
+				userImages: input.userImages,
+				userFiles: input.userFiles,
+			});
+		}
+
+		const manifest = this.backend.readSessionManifest(sessionId);
+		if (!manifest) {
+			throw new Error(`Session manifest unavailable for ${sessionId}`);
+		}
+
+		return {
+			sessionId,
+			manifest,
+			manifestPath: startResult.manifestPath,
+			messagesPath: startResult.messagesPath,
+			result,
+		};
+	}
+
+	async send(input: SendSessionInput): Promise<AgentResult | undefined> {
+		const config = this.sessionConfigs.get(input.sessionId);
+		if (!config) {
+			throw new Error(
+				`RPC-backed session ${input.sessionId} is not attached to this ClineCore instance`,
+			);
+		}
+		const messages = await this.readMessages(input.sessionId);
+		const startedAt = new Date();
+		const response = await this.client.sendRuntimeSession(
+			input.sessionId,
+			await buildTurnRequest(config, messages, input),
+		);
+		if (!response.result) {
+			return undefined;
+		}
+		const usage = accumulateUsage(
+			this.usageBySession.get(input.sessionId),
+			response.result,
+		);
+		this.usageBySession.set(input.sessionId, usage);
+		const result = toAgentResult(response.result, config, startedAt);
+		await this.syncRemoteSessionState(input.sessionId);
+		return result;
+	}
+
+	async getAccumulatedUsage(
+		sessionId: string,
+	): Promise<SessionAccumulatedUsage | undefined> {
+		return cloneAccumulatedUsage(this.usageBySession.get(sessionId));
+	}
+
+	async abort(sessionId: string, reason?: unknown): Promise<void> {
+		void reason;
+		await this.client.abortRuntimeSession(sessionId);
+	}
+
+	async stop(sessionId: string): Promise<void> {
+		await this.client.stopRuntimeSession(sessionId);
+		this.detachSession(sessionId);
+		this.emit({
+			type: "status",
+			payload: { sessionId, status: "cancelled" },
+		});
+		this.emit({
+			type: "ended",
+			payload: {
+				sessionId,
+				reason: "rpc_stop_requested",
+				ts: Date.now(),
+			},
+		});
+	}
+
+	async dispose(reason = "rpc_session_host_dispose"): Promise<void> {
+		const sessionIds = [...this.trackedSessionIds];
+		await Promise.allSettled(
+			sessionIds.map(async (sessionId) => {
+				try {
+					await this.client.abortRuntimeSession(sessionId);
+				} catch {
+					// Best effort before stop.
+				}
+				try {
+					await this.client.stopRuntimeSession(sessionId);
+				} catch {
+					// Best effort during dispose.
+				}
+				this.emit({
+					type: "ended",
+					payload: { sessionId, reason, ts: Date.now() },
+				});
+			}),
+		);
+		this.stopEventStream?.();
+		this.stopEventStream = undefined;
+		this.sessionConfigs.clear();
+		this.sessionApprovals.clear();
+		this.usageBySession.clear();
+		this.trackedSessionIds.clear();
+		this.client.close();
+	}
+
+	async get(sessionId: string): Promise<SessionRecord | undefined> {
+		const row = await this.client.getSession(sessionId);
+		return row ? toSessionRecord(row) : undefined;
+	}
+
+	async list(limit = 200): Promise<SessionRecord[]> {
+		const rows = await this.backend.listSessions(limit);
+		return rows.map(toSessionRecord);
+	}
+
+	async delete(sessionId: string): Promise<boolean> {
+		const result = await this.backend.deleteSession(sessionId);
+		if (result.deleted) {
+			this.detachSession(sessionId);
+		}
+		return result.deleted;
+	}
+
+	async update(
+		sessionId: string,
+		updates: {
+			prompt?: string | null;
+			metadata?: Record<string, unknown> | null;
+			title?: string | null;
+		},
+	): Promise<{ updated: boolean }> {
+		const result = await this.backend.updateSession({
+			sessionId,
+			prompt: updates.prompt,
+			metadata: updates.metadata,
+			title: updates.title,
+		});
+		return { updated: result.updated };
+	}
+
+	async readMessages(sessionId: string): Promise<LlmsProviders.Message[]> {
+		const row = await this.client.getSession(sessionId);
+		return readPersistedMessagesFile(row?.messagesPath);
+	}
+
+	async handleHookEvent(payload: HookEventPayload): Promise<void> {
+		await replaySubagentHookEvent(payload, {
+			queueSpawnRequest: (event: HookEventPayload) =>
+				this.backend.queueSpawnRequest(event),
+			upsertSubagentSessionFromHook: (event: HookEventPayload) =>
+				this.backend.upsertSubagentSessionFromHook(event),
+			appendSubagentHookAudit: (sessionId: string, event: HookEventPayload) =>
+				this.backend.appendSubagentHookAudit(sessionId, event),
+			applySubagentStatus: (sessionId: string, event: HookEventPayload) =>
+				this.backend.applySubagentStatus(sessionId, event),
+		});
+	}
+
+	subscribe(listener: (event: CoreSessionEvent) => void): () => void {
+		const unsubscribe = this.events.subscribe(listener);
+		this.refreshEventStream();
+		return () => {
+			unsubscribe();
+			if (this.events.size === 0) {
+				this.stopEventStream?.();
+				this.stopEventStream = undefined;
+			}
+		};
+	}
+
+	async updateSessionModel(): Promise<void> {
+		// Model updates for remote sessions are applied per-turn from the stored config.
+	}
+
+	private emit(event: CoreSessionEvent): void {
+		this.events.emit(event);
+	}
+
+	private detachSession(sessionId: string): void {
+		this.sessionConfigs.delete(sessionId);
+		this.sessionApprovals.delete(sessionId);
+		this.usageBySession.delete(sessionId);
+		this.trackedSessionIds.delete(sessionId);
+		this.refreshEventStream();
+	}
+
+	private refreshEventStream(): void {
+		if (this.events.size === 0) {
+			return;
+		}
+		this.stopEventStream?.();
+		this.stopEventStream = undefined;
+		if (this.trackedSessionIds.size === 0) {
+			return;
+		}
+		this.stopEventStream = this.client.streamEvents(
+			{
+				clientId: `core-session-host-${createSessionId()}`,
+				sessionIds: [...this.trackedSessionIds],
+			},
+			{
+				onEvent: (event) => {
+					void this.handleRpcEvent(event);
+				},
+			},
+		);
+	}
+
+	private async handleRpcEvent(event: {
+		sessionId: string;
+		eventType: string;
+		payload: Record<string, unknown>;
+	}): Promise<void> {
+		if (event.eventType === "approval.requested") {
+			await this.handleApprovalRequest(event.sessionId, event.payload);
+			return;
+		}
+		const mapped = this.mapRpcEvent(
+			event.sessionId,
+			event.eventType,
+			event.payload,
+		);
+		if (mapped) {
+			this.emit(mapped);
+		}
+	}
+
+	private async handleApprovalRequest(
+		sessionId: string,
+		payload: Record<string, unknown>,
+	): Promise<void> {
+		const requester = this.sessionApprovals.get(sessionId);
+		if (!requester) {
+			return;
+		}
+		const approvalId =
+			typeof payload.approvalId === "string" ? payload.approvalId.trim() : "";
+		const toolCallId =
+			typeof payload.toolCallId === "string" ? payload.toolCallId.trim() : "";
+		const toolName =
+			typeof payload.toolName === "string" ? payload.toolName.trim() : "";
+		if (!approvalId || !toolCallId || !toolName) {
+			return;
+		}
+		let inputJson: unknown;
+		if (typeof payload.inputJson === "string" && payload.inputJson.trim()) {
+			try {
+				inputJson = JSON.parse(payload.inputJson);
+			} catch {
+				inputJson = payload.inputJson;
+			}
+		}
+		const decision = await requester({
+			agentId: "",
+			conversationId: sessionId,
+			iteration: 0,
+			toolCallId,
+			toolName,
+			input: inputJson,
+			policy: DEFAULT_MANUAL_APPROVAL_POLICY,
+		});
+		await this.client.respondToolApproval({
+			approvalId,
+			approved: decision.approved,
+			reason: decision.reason,
+			responderClientId: `core-session-host-${sessionId}`,
+		});
+	}
+
+	private mapRpcEvent(
+		sessionId: string,
+		eventType: string,
+		payload: Record<string, unknown>,
+	): CoreSessionEvent | undefined {
+		if (eventType === "runtime.chat.text_delta") {
+			return {
+				type: "agent_event",
+				payload: {
+					sessionId,
+					event: {
+						type: "content_start",
+						contentType: "text",
+						text: typeof payload.text === "string" ? payload.text : undefined,
+						accumulated:
+							typeof payload.accumulated === "string"
+								? payload.accumulated
+								: undefined,
+					} satisfies AgentEvent,
+				},
+			};
+		}
+		if (eventType === "runtime.chat.tool_call_start") {
+			return {
+				type: "agent_event",
+				payload: {
+					sessionId,
+					event: {
+						type: "content_start",
+						contentType: "tool",
+						toolCallId:
+							typeof payload.toolCallId === "string"
+								? payload.toolCallId
+								: undefined,
+						toolName:
+							typeof payload.toolName === "string"
+								? payload.toolName
+								: undefined,
+						input: payload.input,
+					} satisfies AgentEvent,
+				},
+			};
+		}
+		if (eventType === "runtime.chat.tool_call_end") {
+			return {
+				type: "agent_event",
+				payload: {
+					sessionId,
+					event: {
+						type: "content_end",
+						contentType: "tool",
+						toolCallId:
+							typeof payload.toolCallId === "string"
+								? payload.toolCallId
+								: undefined,
+						toolName:
+							typeof payload.toolName === "string"
+								? payload.toolName
+								: undefined,
+						output: payload.output,
+						error:
+							typeof payload.error === "string" ? payload.error : undefined,
+						durationMs:
+							typeof payload.durationMs === "number"
+								? payload.durationMs
+								: undefined,
+					} satisfies AgentEvent,
+				},
+			};
+		}
+		if (eventType === "runtime.chat.error") {
+			return {
+				type: "agent_event",
+				payload: {
+					sessionId,
+					event: {
+						type: "error",
+						error: new Error(
+							typeof payload.message === "string"
+								? payload.message
+								: "RPC runtime error",
+						),
+						recoverable: payload.recoverable === true,
+						iteration:
+							typeof payload.iteration === "number" ? payload.iteration : 0,
+					} satisfies AgentEvent,
+				},
+			};
+		}
+		if (eventType === "runtime.chat.pending_prompts") {
+			const prompts = Array.isArray(payload.prompts) ? payload.prompts : [];
+			return {
+				type: "pending_prompts",
+				payload: {
+					sessionId,
+					prompts: prompts.map((prompt) => {
+						const typed = prompt as Record<string, unknown>;
+						return {
+							id: typeof typed.id === "string" ? typed.id : "",
+							prompt: typeof typed.prompt === "string" ? typed.prompt : "",
+							delivery: typed.delivery === "steer" ? "steer" : "queue",
+							attachmentCount:
+								typeof typed.attachmentCount === "number"
+									? typed.attachmentCount
+									: 0,
+						};
+					}),
+				},
+			};
+		}
+		if (eventType === "runtime.team.progress.v1") {
+			const summary =
+				typeof payload.summary === "object" && payload.summary
+					? payload.summary
+					: undefined;
+			const lifecycle =
+				typeof payload.lastEvent === "object" && payload.lastEvent
+					? payload.lastEvent
+					: undefined;
+			if (!summary || !lifecycle) {
+				return undefined;
+			}
+			const typedSummary = summary as {
+				teamName?: string;
+			} & TeamProgressSummary;
+			return {
+				type: "team_progress",
+				payload: {
+					sessionId,
+					teamName: typedSummary.teamName ?? "",
+					summary: summary as TeamProgressSummary,
+					lifecycle: lifecycle as TeamProgressLifecycleEvent,
+				},
+			};
+		}
+		return undefined;
+	}
+
+	private async syncRemoteSessionState(sessionId: string): Promise<void> {
+		const row = await this.client.getSession(sessionId);
+		if (!row || row.status === "running") {
+			return;
+		}
+		this.emit({
+			type: "status",
+			payload: { sessionId, status: row.status },
+		});
+		this.emit({
+			type: "ended",
+			payload: {
+				sessionId,
+				reason: row.status,
+				ts: row.endedAt ? new Date(row.endedAt).getTime() : Date.now(),
+			},
+		});
+		this.detachSession(sessionId);
+	}
+}