@clinebot/core 0.0.6 → 0.0.10

package/src/session/rpc-spawn-lease.test.ts

@@ -0,0 +1,49 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { tryAcquireRpcSpawnLease } from "./rpc-spawn-lease";
+
+describe("tryAcquireRpcSpawnLease", () => {
+	const tempDirs: string[] = [];
+
+	afterEach(() => {
+		delete process.env.CLINE_DATA_DIR;
+		for (const dir of tempDirs.splice(0)) {
+			rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("allows only one active lease per address", () => {
+		const dataDir = mkdtempSync(path.join(os.tmpdir(), "rpc-spawn-lease-"));
+		tempDirs.push(dataDir);
+		process.env.CLINE_DATA_DIR = dataDir;
+
+		const first = tryAcquireRpcSpawnLease("127.0.0.1:4317");
+		const second = tryAcquireRpcSpawnLease("127.0.0.1:4317");
+
+		expect(first).toBeDefined();
+		expect(second).toBeUndefined();
+
+		first?.release();
+
+		const third = tryAcquireRpcSpawnLease("127.0.0.1:4317");
+		expect(third).toBeDefined();
+		third?.release();
+	});
+
+	it("lets different addresses acquire independent leases", () => {
+		const dataDir = mkdtempSync(path.join(os.tmpdir(), "rpc-spawn-lease-"));
+		tempDirs.push(dataDir);
+		process.env.CLINE_DATA_DIR = dataDir;
+
+		const first = tryAcquireRpcSpawnLease("127.0.0.1:4317");
+		const second = tryAcquireRpcSpawnLease("127.0.0.1:4318");
+
+		expect(first).toBeDefined();
+		expect(second).toBeDefined();
+
+		first?.release();
+		second?.release();
+	});
+});

package/src/session/rpc-spawn-lease.ts

@@ -0,0 +1,122 @@
+import {
+	closeSync,
+	existsSync,
+	mkdirSync,
+	openSync,
+	readFileSync,
+	rmSync,
+	writeFileSync,
+} from "node:fs";
+import { dirname, resolve } from "node:path";
+import { resolveSessionDataDir } from "@clinebot/shared/storage";
+
+const DEFAULT_LEASE_TTL_MS = 15_000;
+
+interface RpcSpawnLeaseRecord {
+	address: string;
+	pid: number;
+	createdAt: number;
+}
+
+export interface RpcSpawnLease {
+	path: string;
+	release: () => void;
+}
+
+function encodeAddress(address: string): string {
+	return Buffer.from(address).toString("base64url");
+}
+
+function getLeasePath(address: string): string {
+	return resolve(
+		resolveSessionDataDir(),
+		"rpc",
+		"spawn-leases",
+		`${encodeAddress(address)}.lock`,
+	);
+}
+
+function isProcessAlive(pid: number): boolean {
+	if (!Number.isInteger(pid) || pid <= 0) {
+		return false;
+	}
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+function shouldClearLease(path: string, ttlMs: number): boolean {
+	try {
+		const raw = readFileSync(path, "utf8");
+		const parsed = JSON.parse(raw) as Partial<RpcSpawnLeaseRecord>;
+		const createdAt = Number(parsed.createdAt ?? 0);
+		if (!Number.isFinite(createdAt) || createdAt <= 0) {
+			return true;
+		}
+		if (Date.now() - createdAt > ttlMs) {
+			return true;
+		}
+		return !isProcessAlive(Number(parsed.pid ?? 0));
+	} catch {
+		return true;
+	}
+}
+
+export function tryAcquireRpcSpawnLease(
+	address: string,
+	options?: { ttlMs?: number },
+): RpcSpawnLease | undefined {
+	const ttlMs = Math.max(1_000, options?.ttlMs ?? DEFAULT_LEASE_TTL_MS);
+	const path = getLeasePath(address);
+	mkdirSync(dirname(path), { recursive: true });
+
+	if (existsSync(path) && shouldClearLease(path, ttlMs)) {
+		rmSync(path, { force: true });
+	}
+
+	let fd: number | undefined;
+	try {
+		fd = openSync(path, "wx");
+		const record: RpcSpawnLeaseRecord = {
+			address,
+			pid: process.pid,
+			createdAt: Date.now(),
+		};
+		writeFileSync(fd, JSON.stringify(record), "utf8");
+	} catch {
+		if (typeof fd === "number") {
+			try {
+				closeSync(fd);
+			} catch {
+				// Best effort.
+			}
+		}
+		return undefined;
+	}
+
+	let released = false;
+	return {
+		path,
+		release: () => {
+			if (released) {
+				return;
+			}
+			released = true;
+			try {
+				if (typeof fd === "number") {
+					closeSync(fd);
+				}
+			} catch {
+				// Best effort.
+			}
+			try {
+				rmSync(path, { force: true });
+			} catch {
+				// Best effort.
+			}
+		},
+	};
+}

package/src/session/runtime-oauth-token-manager.ts

@@ -1,4 +1,9 @@
-import type { providers as LlmsProviders } from "@clinebot/llms";
+import type { LlmsProviders } from "@clinebot/llms";
+import {
+	type ITelemetryService,
+	isOAuthProviderId,
+	type OAuthProviderId,
+} from "@clinebot/shared";
 import {
 	type ClineOAuthCredentials,
 	getValidClineCredentials,
@@ -11,14 +16,7 @@ import { ProviderSettingsManager } from "../storage/provider-settings-manager";
 const DEFAULT_CLINE_API_BASE_URL = "https://api.cline.bot";
 const WORKOS_TOKEN_PREFIX = "workos:";
 
-const MANAGED_OAUTH_PROVIDERS = ["cline", "oca", "openai-codex"] as const;
-type ManagedOAuthProviderId = (typeof MANAGED_OAUTH_PROVIDERS)[number];
-
-function isManagedOAuthProviderId(
-	providerId: string,
-): providerId is ManagedOAuthProviderId {
-	return (MANAGED_OAUTH_PROVIDERS as readonly string[]).includes(providerId);
-}
+type ManagedOAuthProviderId = OAuthProviderId;
 
 function toStoredAccessToken(
 	providerId: ManagedOAuthProviderId,
@@ -143,21 +141,26 @@ export type RuntimeOAuthResolution = {
 
 export class RuntimeOAuthTokenManager {
 	private readonly providerSettingsManager: ProviderSettingsManager;
+	private readonly telemetry?: ITelemetryService;
 	private readonly refreshInFlight = new Map<
 		ManagedOAuthProviderId,
 		Promise<RuntimeOAuthResolution | null>
 	>();
 
-	constructor(options?: { providerSettingsManager?: ProviderSettingsManager }) {
+	constructor(options?: {
+		providerSettingsManager?: ProviderSettingsManager;
+		telemetry?: ITelemetryService;
+	}) {
 		this.providerSettingsManager =
 			options?.providerSettingsManager ?? new ProviderSettingsManager();
+		this.telemetry = options?.telemetry;
 	}
 
 	public async resolveProviderApiKey(input: {
 		providerId: string;
 		forceRefresh?: boolean;
 	}): Promise<RuntimeOAuthResolution | null> {
-		if (!isManagedOAuthProviderId(input.providerId)) {
+		if (!isOAuthProviderId(input.providerId)) {
 			return null;
 		}
 		return this.resolveWithSingleFlight(input.providerId, input.forceRefresh);
@@ -249,6 +252,7 @@ export class RuntimeOAuthTokenManager {
 				currentCredentials,
 				{
 					apiBaseUrl: settings.baseUrl?.trim() || DEFAULT_CLINE_API_BASE_URL,
+					telemetry: this.telemetry,
 				},
 				{ forceRefresh },
 			);
@@ -256,10 +260,13 @@ export class RuntimeOAuthTokenManager {
 		if (providerId === "oca") {
 			return getValidOcaCredentials(
 				currentCredentials,
-				{ forceRefresh },
-				{ mode: settings.oca?.mode },
+				{ forceRefresh, telemetry: this.telemetry },
+				{ mode: settings.oca?.mode, telemetry: this.telemetry },
 			);
 		}
-		return getValidOpenAICodexCredentials(currentCredentials, { forceRefresh });
+		return getValidOpenAICodexCredentials(currentCredentials, {
+			forceRefresh,
+			telemetry: this.telemetry,
+		});
 	}
 }

package/src/session/session-agent-events.ts

@@ -0,0 +1,159 @@
+import type { AgentEvent } from "@clinebot/agents";
+import {
+	captureConversationTurnEvent,
+	captureDiffEditFailure,
+	captureProviderApiError,
+	captureSkillUsed,
+	captureTokenUsage,
+	captureToolUsage,
+} 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";
+
+export function extractSkillNameFromToolInput(
+	input: unknown,
+): string | undefined {
+	if (!input || typeof input !== "object") return undefined;
+	const record = input as Record<string, unknown>;
+	const skillName = record.skill ?? record.skill_name ?? record.skillName;
+	if (typeof skillName !== "string") return undefined;
+	const trimmed = skillName.trim();
+	return trimmed.length > 0 ? trimmed : undefined;
+}
+
+export interface AgentEventContext {
+	sessionId: string;
+	config: CoreSessionConfig;
+	liveSession: ActiveSession | undefined;
+	usageBySession: Map<string, SessionAccumulatedUsage>;
+	persistMessages: (
+		sessionId: string,
+		messages: unknown[],
+		systemPrompt?: string,
+	) => void;
+	emit: (event: CoreSessionEvent) => void;
+}
+
+export function handleAgentEvent(
+	ctx: AgentEventContext,
+	event: AgentEvent,
+): void {
+	const { sessionId, config, liveSession, emit } = ctx;
+	const telemetry = config.telemetry;
+
+	if (
+		event.type === "content_start" &&
+		event.contentType === "tool" &&
+		event.toolName === "skills"
+	) {
+		const skillName = extractSkillNameFromToolInput(event.input);
+		if (skillName) {
+			captureSkillUsed(telemetry, {
+				ulid: sessionId,
+				skillName,
+				skillSource: "project",
+				skillsAvailableGlobal: 0,
+				skillsAvailableProject: 0,
+				provider: config.providerId,
+				modelId: config.modelId,
+			});
+		}
+	}
+
+	if (event.type === "content_end" && event.contentType === "tool") {
+		const toolName = event.toolName ?? "unknown";
+		const success = !event.error;
+		captureToolUsage(telemetry, {
+			ulid: sessionId,
+			tool: toolName,
+			autoApproved: undefined,
+			success,
+			modelId: config.modelId,
+			provider: config.providerId,
+			isNativeToolCall: false,
+		});
+		if (!success && (toolName === "editor" || toolName === "apply_patch")) {
+			captureDiffEditFailure(telemetry, {
+				ulid: sessionId,
+				modelId: config.modelId,
+				provider: config.providerId,
+				errorType: event.error,
+				isNativeToolCall: false,
+			});
+		}
+	}
+
+	if (event.type === "notice" && event.reason === "api_error") {
+		captureProviderApiError(telemetry, {
+			ulid: sessionId,
+			model: config.modelId,
+			provider: config.providerId,
+			errorMessage: event.message,
+		});
+	}
+
+	if (event.type === "error") {
+		captureProviderApiError(telemetry, {
+			ulid: sessionId,
+			model: config.modelId,
+			provider: config.providerId,
+			errorMessage: event.error?.message ?? "unknown error",
+		});
+	}
+
+	if (event.type === "usage" && liveSession?.turnUsageBaseline) {
+		ctx.usageBySession.set(
+			sessionId,
+			accumulateUsageTotals(liveSession.turnUsageBaseline, {
+				inputTokens: event.totalInputTokens,
+				outputTokens: event.totalOutputTokens,
+				totalCost: event.totalCost,
+			}),
+		);
+		captureConversationTurnEvent(telemetry, {
+			ulid: sessionId,
+			provider: config.providerId,
+			model: config.modelId,
+			source: "assistant",
+			mode: config.mode,
+			tokensIn: event.inputTokens,
+			tokensOut: event.outputTokens,
+			cacheWriteTokens: event.cacheWriteTokens,
+			cacheReadTokens: event.cacheReadTokens,
+			totalCost: event.cost,
+			isNativeToolCall: false,
+		});
+		captureTokenUsage(telemetry, {
+			ulid: sessionId,
+			tokensIn: event.inputTokens,
+			tokensOut: event.outputTokens,
+			model: config.modelId,
+		});
+	}
+
+	if (event.type === "iteration_end") {
+		ctx.persistMessages(
+			sessionId,
+			liveSession?.agent.getMessages() ?? [],
+			liveSession?.config.systemPrompt,
+		);
+	}
+
+	emit({
+		type: "agent_event",
+		payload: { sessionId, event },
+	});
+	emit({
+		type: "chunk",
+		payload: {
+			sessionId,
+			stream: "agent",
+			chunk: serializeAgentEvent(event),
+			ts: Date.now(),
+		},
+	});
+}

package/src/session/session-config-builder.ts

@@ -0,0 +1,111 @@
+import type { LlmsProviders } from "@clinebot/llms";
+import type { ITelemetryService } from "@clinebot/shared";
+import { resolveAndLoadAgentPlugins } from "../agents/plugin-config-loader";
+import {
+	createHookAuditHooks,
+	createHookConfigFileHooks,
+	mergeAgentHooks,
+} from "../runtime/hook-file-hooks";
+import type { ProviderSettingsManager } from "../storage/provider-settings-manager";
+import type { CoreSessionConfig } from "../types/config";
+import {
+	type ProviderSettings,
+	toProviderConfig,
+} from "../types/provider-settings";
+import type { StartSessionInput } from "./session-manager";
+import { hasRuntimeHooks, mergeAgentExtensions } from "./utils/helpers";
+
+export function resolveWorkspacePath(config: CoreSessionConfig): string {
+	return config.workspaceRoot ?? config.cwd;
+}
+
+export async function buildEffectiveConfig(
+	input: StartSessionInput,
+	hookPath: string,
+	sessionId: string,
+	defaultTelemetry: ITelemetryService | undefined,
+): Promise<{
+	config: CoreSessionConfig;
+	pluginSandboxShutdown?: () => Promise<void>;
+}> {
+	const workspacePath = resolveWorkspacePath(input.config);
+
+	const fileHooks = createHookConfigFileHooks({
+		cwd: input.config.cwd,
+		workspacePath,
+		rootSessionId: sessionId,
+		hookLogPath: hookPath,
+		logger: input.config.logger,
+	});
+	const auditHooks = hasRuntimeHooks(input.config.hooks)
+		? undefined
+		: createHookAuditHooks({
+				hookLogPath: hookPath,
+				rootSessionId: sessionId,
+				workspacePath,
+			});
+	const effectiveHooks = mergeAgentHooks([
+		input.config.hooks,
+		fileHooks,
+		auditHooks,
+	]);
+
+	const loadedPlugins = await resolveAndLoadAgentPlugins({
+		pluginPaths: input.config.pluginPaths,
+		workspacePath,
+		cwd: input.config.cwd,
+	});
+	const effectiveExtensions = mergeAgentExtensions(
+		input.config.extensions,
+		loadedPlugins.extensions,
+	);
+
+	return {
+		config: {
+			...input.config,
+			hooks: effectiveHooks,
+			extensions: effectiveExtensions,
+			telemetry: input.config.telemetry ?? defaultTelemetry,
+		},
+		pluginSandboxShutdown: loadedPlugins.shutdown,
+	};
+}
+
+export function buildResolvedProviderConfig(
+	config: CoreSessionConfig,
+	providerSettingsManager: ProviderSettingsManager,
+	resolveReasoningFn: (
+		config: CoreSessionConfig,
+		storedReasoning: ProviderSettings["reasoning"],
+	) => ProviderSettings["reasoning"],
+): LlmsProviders.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: resolveReasoningFn(config, stored?.reasoning),
+	};
+	const providerConfig = toProviderConfig(settings);
+	if (config.knownModels) {
+		providerConfig.knownModels = config.knownModels;
+	}
+	return providerConfig;
+}
+
+export 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 } : {}),
+	};
+}

package/src/session/session-graph.ts

@@ -70,6 +70,8 @@ export function deriveSubsessionStatus(event: HookEventPayload): SessionStatus {
 	switch (event.hookName) {
 		case "agent_end":
 			return "completed";
+		case "agent_error":
+			return "failed";
 		case "session_shutdown": {
 			const reason = String(event.reason ?? "").toLowerCase();
 			if (

package/src/session/session-host.ts

@@ -14,6 +14,7 @@ import { SqliteSessionStore } from "../storage/sqlite-session-store";
 import type { ToolExecutors } from "../tools";
 import { DefaultSessionManager } from "./default-session-manager";
 import { RpcCoreSessionService } from "./rpc-session-service";
+import { tryAcquireRpcSpawnLease } from "./rpc-spawn-lease";
 import type { SessionManager } from "./session-manager";
 import { CoreSessionService } from "./session-service";
 
@@ -43,14 +44,29 @@ export interface CreateSessionHostOptions {
 
 export type SessionHost = SessionManager;
 
+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) =>
@@ -75,6 +91,7 @@ function startRpcServerInBackground(address: string): void {
 		cwd: process.cwd(),
 	});
 	child.unref();
+	setTimeout(() => lease.release(), 10_000).unref();
 }
 
 async function tryConnectRpcBackend(
@@ -148,12 +165,14 @@ export async function resolveSessionBackend(
 	backendInitPromise = (async () => {
 		if (mode === "local") {
 			cachedBackend = createLocalBackend();
+			await reconcileDeadSessionsIfSupported(cachedBackend);
 			return cachedBackend;
 		}
 
 		const existingRpcBackend = await tryConnectRpcBackend(address);
 		if (existingRpcBackend) {
 			cachedBackend = existingRpcBackend;
+			await reconcileDeadSessionsIfSupported(cachedBackend);
 			return cachedBackend;
 		}
 
@@ -172,6 +191,7 @@ export async function resolveSessionBackend(
 				const rpcBackend = await tryConnectRpcBackend(address);
 				if (rpcBackend) {
 					cachedBackend = rpcBackend;
+					await reconcileDeadSessionsIfSupported(cachedBackend);
 					return cachedBackend;
 				}
 				if (delayMs > 0) {
@@ -181,6 +201,7 @@ export async function resolveSessionBackend(
 		}
 
 		cachedBackend = createLocalBackend();
+		await reconcileDeadSessionsIfSupported(cachedBackend);
 		return cachedBackend;
 	})().finally(() => {
 		backendInitPromise = undefined;

package/src/session/session-manager.ts

@@ -1,5 +1,5 @@
 import type { AgentResult } from "@clinebot/agents";
-import type { providers as LlmsProviders } from "@clinebot/llms";
+import type { LlmsProviders } from "@clinebot/llms";
 import type { SessionSource } from "../types/common";
 import type { CoreSessionConfig } from "../types/config";
 import type { CoreSessionEvent } from "../types/events";
@@ -54,7 +54,7 @@ export interface SessionManager {
 	getAccumulatedUsage(
 		sessionId: string,
 	): Promise<SessionAccumulatedUsage | undefined>;
-	abort(sessionId: string): Promise<void>;
+	abort(sessionId: string, reason?: unknown): Promise<void>;
 	stop(sessionId: string): Promise<void>;
 	dispose(reason?: string): Promise<void>;
 	get(sessionId: string): Promise<SessionRecord | undefined>;