@clinebot/core 0.0.33 → 0.0.35

package/src/runtime/subprocess-sandbox.ts

@@ -61,6 +61,22 @@ export class SubprocessSandbox {
 		this.options = options;
 	}
 
+	private get processLabel(): string {
+		return this.options.name ?? "sandbox";
+	}
+
+	private clearPendingRequest(id: string): PendingRequest | undefined {
+		const pending = this.pending.get(id);
+		if (!pending) {
+			return undefined;
+		}
+		this.pending.delete(id);
+		if (pending.timeout) {
+			clearTimeout(pending.timeout);
+		}
+		return pending;
+	}
+
 	start(): void {
 		if (this.process && this.process.exitCode === null) {
 			return;
@@ -96,7 +112,7 @@ export class SubprocessSandbox {
 		child.on("error", (error) => {
 			this.failPending(
 				new Error(
-					`${this.options.name ?? "sandbox"} process error: ${asError(error).message}`,
+					`${this.processLabel} process error: ${asError(error).message}`,
 				),
 			);
 		});
@@ -119,9 +135,7 @@ export class SubprocessSandbox {
 		this.start();
 		const child = this.process;
 		if (!child || child.exitCode !== null) {
-			throw new Error(
-				`${this.options.name ?? "sandbox"} process is not available`,
-			);
+			throw new Error(`${this.processLabel} process is not available`);
 		}
 
 		const id = `req_${++this.requestCounter}`;
@@ -139,13 +153,13 @@ export class SubprocessSandbox {
 			};
 			if ((options.timeoutMs ?? 0) > 0) {
 				pending.timeout = setTimeout(() => {
-					this.pending.delete(id);
+					this.clearPendingRequest(id);
 					this.shutdown().catch(() => {
 						// Best-effort process shutdown after timeout.
 					});
 					reject(
 						new Error(
-							`${this.options.name ?? "sandbox"} call timed out after ${options.timeoutMs}ms: ${method}`,
+							`${this.processLabel} call timed out after ${options.timeoutMs}ms: ${method}`,
 						),
 					);
 				}, options.timeoutMs);
@@ -155,17 +169,13 @@ export class SubprocessSandbox {
 				if (!error) {
 					return;
 				}
-				const entry = this.pending.get(id);
+				const entry = this.clearPendingRequest(id);
 				if (!entry) {
 					return;
 				}
-				this.pending.delete(id);
-				if (entry.timeout) {
-					clearTimeout(entry.timeout);
-				}
 				entry.reject(
 					new Error(
-						`${this.options.name ?? "sandbox"} failed to send call "${method}": ${asError(error).message}`,
+						`${this.processLabel} failed to send call "${method}": ${asError(error).message}`,
 					),
 				);
 			});
@@ -176,7 +186,7 @@ export class SubprocessSandbox {
 		const child = this.process;
 		this.process = null;
 		if (!child || child.exitCode !== null) {
-			this.failPending(new Error(`${this.options.name ?? "sandbox"} shutdown`));
+			this.failPending(new Error(`${this.processLabel} shutdown`));
 			return;
 		}
 		await new Promise<void>((resolve) => {
@@ -199,7 +209,7 @@ export class SubprocessSandbox {
 				resolve();
 			}
 		});
-		this.failPending(new Error(`${this.options.name ?? "sandbox"} shutdown`));
+		this.failPending(new Error(`${this.processLabel} shutdown`));
 	}
 
 	private onMessage(
@@ -220,23 +230,16 @@ export class SubprocessSandbox {
 		if (message.type !== "response" || !message.id) {
 			return;
 		}
-		const pending = this.pending.get(message.id);
+		const pending = this.clearPendingRequest(message.id);
 		if (!pending) {
 			return;
 		}
-		this.pending.delete(message.id);
-		if (pending.timeout) {
-			clearTimeout(pending.timeout);
-		}
 		if (message.ok) {
 			pending.resolve(message.result);
 			return;
 		}
 		pending.reject(
-			new Error(
-				message.error?.message ||
-					`${this.options.name ?? "sandbox"} call failed`,
-			),
+			new Error(message.error?.message || `${this.processLabel} call failed`),
 		);
 	}
 

package/src/runtime/tool-approval.ts

@@ -18,6 +18,14 @@ function delay(ms: number): Promise<void> {
 	return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+async function unlinkIfPresent(path: string): Promise<void> {
+	try {
+		await unlink(path);
+	} catch {
+		// Best-effort cleanup.
+	}
+}
+
 export async function requestDesktopToolApproval(
 	request: ToolApprovalRequest,
 	options: DesktopToolApprovalOptions = {},
@@ -77,16 +85,10 @@ export async function requestDesktopToolApproval(
 				approved: parsed.approved === true,
 				reason: typeof parsed.reason === "string" ? parsed.reason : undefined,
 			};
-			try {
-				await unlink(decisionPath);
-			} catch {
-				// Best-effort cleanup.
-			}
-			try {
-				await unlink(requestPath);
-			} catch {
-				// Best-effort cleanup.
-			}
+			await Promise.all([
+				unlinkIfPresent(decisionPath),
+				unlinkIfPresent(requestPath),
+			]);
 			return result;
 		} catch {
 			// Decision not available yet.
@@ -94,11 +96,7 @@ export async function requestDesktopToolApproval(
 		await delay(pollIntervalMs);
 	}
 
-	try {
-		await unlink(requestPath);
-	} catch {
-		// Best-effort cleanup.
-	}
+	await unlinkIfPresent(requestPath);
 
 	return { approved: false, reason: "Tool approval request timed out" };
 }

package/src/{session/session-agent-events.ts → services/agent-events.ts}

@@ -1,4 +1,9 @@
 import type { AgentEvent } from "@clinebot/shared";
+import type { SessionAccumulatedUsage } from "../runtime/runtime-host";
+import type { CoreSessionConfig } from "../types/config";
+import type { CoreSessionEvent } from "../types/events";
+import type { ActiveSession } from "../types/session";
+import { serializeAgentEvent } from "./session-data";
 import {
 	captureConversationTurnEvent,
 	captureDiffEditFailure,
@@ -7,13 +12,8 @@ import {
 	captureTokenUsage,
 	captureToolUsage,
 	type TelemetryAgentIdentityProperties,
-} from "../telemetry/core-events";
-import type { CoreSessionConfig } from "../types/config";
-import type { CoreSessionEvent } from "../types/events";
-import type { SessionAccumulatedUsage } from "./session-manager";
-import { serializeAgentEvent } from "./utils/helpers";
-import type { ActiveSession } from "./utils/types";
-import { accumulateUsageTotals } from "./utils/usage";
+} from "./telemetry/core-events";
+import { accumulateUsageTotals } from "./usage";
 
 export function extractSkillNameFromToolInput(
 	input: unknown,

package/src/services/config.ts

@@ -0,0 +1,5 @@
+import type { CoreSessionConfig } from "../types/config";
+
+export function resolveWorkspacePath(config: CoreSessionConfig): string {
+	return config.workspaceRoot ?? config.cwd;
+}

package/src/services/local-runtime-bootstrap.ts

@@ -0,0 +1,280 @@
+import type {
+	AgentConfig,
+	AgentHooks,
+	ITelemetryService,
+	Tool,
+	ToolApprovalRequest,
+	ToolApprovalResult,
+} from "@clinebot/shared";
+import { resolveAndLoadAgentPlugins } from "../extensions/plugin/plugin-config-loader";
+import type {
+	PluginInitializationFailure,
+	PluginInitializationWarning,
+} from "../extensions/plugin/plugin-load-report";
+import type { ToolExecutors } from "../extensions/tools";
+import type { TeamEvent } from "../extensions/tools/team";
+import { createCheckpointHooks } from "../hooks/checkpoint-hooks";
+import {
+	createHookAuditHooks,
+	createHookConfigFileHooks,
+	mergeAgentHooks,
+} from "../hooks/hook-file-hooks";
+import type {
+	LocalRuntimeConfigOverrides,
+	LocalRuntimeStartOptions,
+	StartSessionInput,
+} from "../runtime/runtime-host";
+import type {
+	RuntimeBuilderInput,
+	TeamToolsFactory,
+} from "../runtime/session-runtime";
+import type { CoreSessionConfig } from "../types/config";
+import {
+	type ProviderConfig,
+	type ProviderSettings,
+	toProviderConfig,
+} from "../types/provider-settings";
+import { resolveWorkspacePath } from "./config";
+import { hasRuntimeHooks, mergeAgentExtensions } from "./session-data";
+import type { ProviderSettingsManager } from "./storage/provider-settings-manager";
+import { buildWorkspaceMetadata } from "./workspace-manifest";
+
+function formatPluginFailure(failure: PluginInitializationFailure): string {
+	const label = failure.pluginName ?? failure.pluginPath;
+	return `${label}: ${failure.message}`;
+}
+
+function logPluginDiagnostics(
+	failures: PluginInitializationFailure[],
+	warnings: PluginInitializationWarning[],
+	logger: CoreSessionConfig["logger"],
+): void {
+	if (warnings.length > 0) {
+		for (const warning of warnings) {
+			logger?.log(warning.message, { severity: "warn" });
+		}
+	}
+	if (failures.length === 0) {
+		return;
+	}
+	const preview = failures.slice(0, 3).map(formatPluginFailure).join("; ");
+	const suffix = failures.length > 3 ? `; and ${failures.length - 3} more` : "";
+	logger?.log(
+		`Some plugins failed to initialize. ${preview}${suffix}. Use --verbose for more details.`,
+		{ severity: "warn" },
+	);
+	for (const failure of failures) {
+		logger?.log(
+			`Plugin initialization failed (${failure.phase}) for ${failure.pluginPath}`,
+			{
+				severity: "warn",
+				stack: failure.stack,
+				pluginPath: failure.pluginPath,
+				pluginName: failure.pluginName,
+			},
+		);
+	}
+}
+
+function resolveReasoningSettings(
+	config: CoreSessionConfig,
+	storedReasoning: ProviderSettings["reasoning"],
+): ProviderSettings["reasoning"] {
+	const hasThinking = typeof config.thinking === "boolean";
+	const hasEffort = typeof config.reasoningEffort === "string";
+	if (!hasThinking && !hasEffort) return storedReasoning;
+	return {
+		...(storedReasoning ?? {}),
+		...(hasThinking ? { enabled: config.thinking } : {}),
+		...(hasEffort ? { effort: config.reasoningEffort } : {}),
+	};
+}
+
+function buildProviderConfig(
+	config: CoreSessionConfig,
+	providerSettingsManager: ProviderSettingsManager,
+): ProviderConfig {
+	const stored = providerSettingsManager.getProviderSettings(config.providerId);
+	const settings: ProviderSettings = {
+		...(stored ?? {}),
+		provider: config.providerId,
+		model: config.modelId,
+		apiKey: config.apiKey ?? stored?.apiKey,
+		baseUrl: config.baseUrl ?? stored?.baseUrl,
+		headers: config.headers ?? stored?.headers,
+		reasoning: resolveReasoningSettings(config, stored?.reasoning),
+	};
+	const providerConfig = toProviderConfig(settings);
+	if (config.knownModels) {
+		providerConfig.knownModels = config.knownModels;
+	}
+	if (config.extensionContext) {
+		providerConfig.extensionContext = config.extensionContext;
+	}
+	return providerConfig;
+}
+
+export interface PrepareLocalRuntimeBootstrapOptions {
+	input: StartSessionInput;
+	localRuntime?: LocalRuntimeStartOptions;
+	sessionId: string;
+	providerSettingsManager: ProviderSettingsManager;
+	defaultTelemetry?: ITelemetryService;
+	defaultToolExecutors?: Partial<ToolExecutors>;
+	teamToolsFactory?: TeamToolsFactory;
+	defaultToolPolicies?: AgentConfig["toolPolicies"];
+	defaultRequestToolApproval?: (
+		request: ToolApprovalRequest,
+	) => Promise<ToolApprovalResult>;
+	onPluginEvent: (event: { name: string; payload?: unknown }) => void;
+	onTeamEvent: (event: TeamEvent) => void;
+	createSpawnTool: () => Tool;
+	readSessionMetadata: () => Promise<Record<string, unknown> | undefined>;
+	writeSessionMetadata: (
+		metadata: Record<string, unknown>,
+	) => Promise<void> | void;
+}
+
+export interface LocalRuntimeBootstrap {
+	effectiveInput: StartSessionInput;
+	config: CoreSessionConfig;
+	providerConfig: ProviderConfig;
+	workspaceMetadata: string;
+	extensions: AgentConfig["extensions"];
+	hooks: AgentHooks | undefined;
+	toolPolicies: AgentConfig["toolPolicies"];
+	requestToolApproval?: (
+		request: ToolApprovalRequest,
+	) => Promise<ToolApprovalResult>;
+	pluginSandboxShutdown?: () => Promise<void>;
+	runtimeBuilderInput: RuntimeBuilderInput;
+}
+
+export async function prepareLocalRuntimeBootstrap(
+	options: PrepareLocalRuntimeBootstrapOptions,
+): Promise<LocalRuntimeBootstrap> {
+	const {
+		input,
+		sessionId,
+		providerSettingsManager,
+		defaultTelemetry,
+		defaultToolExecutors,
+		teamToolsFactory,
+		defaultToolPolicies,
+		defaultRequestToolApproval,
+		onPluginEvent,
+		onTeamEvent,
+		createSpawnTool,
+		localRuntime,
+		readSessionMetadata,
+		writeSessionMetadata,
+	} = options;
+	const workspacePath = resolveWorkspacePath(input.config);
+	const configOverrides = localRuntime?.configOverrides as
+		| Partial<LocalRuntimeConfigOverrides>
+		| undefined;
+
+	const fileHooks = createHookConfigFileHooks({
+		cwd: input.config.cwd,
+		workspacePath,
+		rootSessionId: sessionId,
+		logger: configOverrides?.logger,
+	});
+	const auditHooks = hasRuntimeHooks(configOverrides?.hooks)
+		? undefined
+		: createHookAuditHooks({
+				rootSessionId: sessionId,
+				workspacePath,
+			});
+	const baseHooks = mergeAgentHooks([
+		configOverrides?.hooks,
+		fileHooks,
+		auditHooks,
+	]);
+
+	let loadedPlugins:
+		| Awaited<ReturnType<typeof resolveAndLoadAgentPlugins>>
+		| undefined;
+	try {
+		loadedPlugins = await resolveAndLoadAgentPlugins({
+			pluginPaths: configOverrides?.pluginPaths,
+			workspacePath,
+			cwd: input.config.cwd,
+			onEvent: onPluginEvent,
+		});
+		logPluginDiagnostics(
+			loadedPlugins.failures,
+			loadedPlugins.warnings,
+			configOverrides?.logger,
+		);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		configOverrides?.logger?.log?.(
+			`plugin loading failed; continuing without plugins (${message})`,
+		);
+	}
+
+	const extensions = mergeAgentExtensions(
+		configOverrides?.extensions,
+		loadedPlugins?.extensions,
+	);
+	const workspaceMetadata = await buildWorkspaceMetadata(input.config.cwd);
+	const baseConfig: CoreSessionConfig = {
+		...input.config,
+		...(configOverrides ?? {}),
+		hooks: baseHooks,
+		extensions,
+		telemetry: configOverrides?.telemetry ?? defaultTelemetry,
+	};
+	const providerConfig = buildProviderConfig(
+		baseConfig,
+		providerSettingsManager,
+	);
+	const hooks = mergeAgentHooks([
+		baseConfig.hooks,
+		baseConfig.checkpoint?.enabled === true
+			? createCheckpointHooks({
+					cwd: baseConfig.cwd,
+					sessionId,
+					logger: baseConfig.logger,
+					createCheckpoint: baseConfig.checkpoint?.createCheckpoint,
+					readSessionMetadata,
+					writeSessionMetadata,
+				})
+			: undefined,
+	]);
+	const config: CoreSessionConfig = {
+		...baseConfig,
+		providerConfig,
+		workspaceMetadata,
+		hooks,
+	};
+	const toolPolicies = input.toolPolicies ?? defaultToolPolicies;
+	const requestToolApproval =
+		input.requestToolApproval ?? defaultRequestToolApproval;
+
+	return {
+		effectiveInput: input,
+		config,
+		providerConfig,
+		workspaceMetadata,
+		extensions,
+		hooks,
+		toolPolicies,
+		requestToolApproval,
+		pluginSandboxShutdown: loadedPlugins?.shutdown,
+		runtimeBuilderInput: {
+			config,
+			hooks,
+			extensions,
+			onTeamEvent,
+			createSpawnTool,
+			onTeamRestored: localRuntime?.onTeamRestored,
+			userInstructionWatcher: localRuntime?.userInstructionWatcher,
+			defaultToolExecutors,
+			logger: config.logger,
+			telemetry: config.telemetry,
+			teamToolsFactory,
+		},
+	};
+}

package/src/{providers → services/providers}/local-provider-service.ts

@@ -8,10 +8,10 @@ import type {
 	RpcProviderModel,
 	RpcSaveProviderSettingsActionRequest,
 } from "@clinebot/shared";
-import { createOAuthClientCallbacks } from "../auth/client";
-import { loginClineOAuth } from "../auth/cline";
-import { loginOpenAICodex } from "../auth/codex";
-import { loginOcaOAuth } from "../auth/oca";
+import { createOAuthClientCallbacks } from "../../auth/client";
+import { loginClineOAuth } from "../../auth/cline";
+import { loginOpenAICodex } from "../../auth/codex";
+import { loginOcaOAuth } from "../../auth/oca";
 import type { ProviderSettingsManager } from "../storage/provider-settings-manager";
 import {
 	readModelsFile,

package/src/{session → services}/session-artifacts.ts

@@ -3,10 +3,14 @@ import {
 	mkdirSync,
 	readdirSync,
 	rmdirSync,
+	rmSync,
 	unlinkSync,
 } from "node:fs";
 import { dirname, join } from "node:path";
-import { parseSubSessionId, parseTeamTaskSubSessionId } from "./session-graph";
+import {
+	parseSubSessionId,
+	parseTeamTaskSubSessionId,
+} from "../session/session-graph";
 
 export function nowIso(): string {
 	return new Date().toISOString();
@@ -24,8 +28,6 @@ export function unlinkIfExists(path: string | null | undefined): void {
 }
 
 export interface SessionArtifactPaths {
-	transcriptPath: string;
-	hookPath: string;
 	messagesPath: string;
 }
 
@@ -70,25 +72,14 @@ export class SessionArtifacts {
 		return dir;
 	}
 
-	public sessionTranscriptPath(sessionId: string): string {
-		return join(this.ensureSessionArtifactsDir(sessionId), `${sessionId}.log`);
-	}
-
-	public sessionHookPath(sessionId: string): string {
-		return join(
-			this.ensureSessionArtifactsDir(sessionId),
-			`${sessionId}.hooks.jsonl`,
-		);
-	}
-
 	public sessionMessagesPath(sessionId: string): string {
 		return join(
-			this.ensureSessionArtifactsDir(sessionId),
+			this.sessionArtifactsDir(sessionId),
 			`${sessionId}.messages.json`,
 		);
 	}
 
-	public sessionManifestPath(sessionId: string, ensureDir = true): string {
+	public sessionManifestPath(sessionId: string, ensureDir = false): string {
 		const base = ensureDir
 			? this.ensureSessionArtifactsDir(sessionId)
 			: this.sessionArtifactsDir(sessionId);
@@ -116,6 +107,21 @@ export class SessionArtifacts {
 		}
 	}
 
+	public removeSessionDir(sessionId: string): void {
+		this.removeDir(this.sessionArtifactsDir(sessionId));
+	}
+
+	public removeDir(dir: string): void {
+		if (!existsSync(dir)) {
+			return;
+		}
+		try {
+			rmSync(dir, { recursive: true, force: true });
+		} catch {
+			// Best-effort cleanup.
+		}
+	}
+
 	public subagentArtifactPaths(
 		sessionId: string,
 		subAgentId: string,
@@ -124,10 +130,8 @@ export class SessionArtifacts {
 		void subAgentId;
 		void activeTeamTaskSessionId;
 		const { rootSessionId, fileStem } = childArtifactFileStem(sessionId);
-		const dir = this.ensureSessionArtifactsDir(rootSessionId);
+		const dir = this.sessionArtifactsDir(rootSessionId);
 		return {
-			transcriptPath: join(dir, `${fileStem}.log`),
-			hookPath: join(dir, `${fileStem}.hooks.jsonl`),
 			messagesPath: join(dir, `${fileStem}.messages.json`),
 		};
 	}

package/src/{session/utils/helpers.test.ts → services/session-data.test.ts}

@@ -1,7 +1,7 @@
 import type { MessageWithMetadata } from "@clinebot/llms";
 import type { AgentResult } from "@clinebot/shared";
 import { describe, expect, it } from "vitest";
-import { withLatestAssistantTurnMetadata } from "./helpers";
+import { withLatestAssistantTurnMetadata } from "./session-data";
 
 type LegacyStoredMessage = MessageWithMetadata & {
 	providerId?: string;