@clinebot/core 0.0.5 → 0.0.7

package/src/session/default-session-manager.test.ts

@@ -3,6 +3,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import type { AgentResult } from "@clinebot/agents";
 import { describe, expect, it, vi } from "vitest";
+import { TelemetryService } from "../telemetry/TelemetryService";
 import { SessionSource } from "../types/common";
 import type { CoreSessionConfig } from "../types/config";
 import { DefaultSessionManager } from "./default-session-manager";
@@ -70,6 +71,77 @@ function createConfig(
 }
 
 describe("DefaultSessionManager", () => {
+	it("emits session lifecycle telemetry when configured", async () => {
+		const sessionId = "sess-telemetry";
+		const manifest = createManifest(sessionId);
+		const adapter = {
+			name: "test",
+			emit: vi.fn(),
+			emitRequired: vi.fn(),
+			recordCounter: vi.fn(),
+			recordHistogram: vi.fn(),
+			recordGauge: vi.fn(),
+			isEnabled: vi.fn(() => true),
+			flush: vi.fn().mockResolvedValue(undefined),
+			dispose: vi.fn().mockResolvedValue(undefined),
+		};
+		const telemetry = new TelemetryService({
+			adapters: [adapter],
+			distinctId: distinctId,
+		});
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest.json",
+				transcriptPath: "/tmp/transcript.log",
+				hookPath: "/tmp/hook.log",
+				messagesPath: "/tmp/messages.json",
+				manifest,
+			}),
+			persistSessionMessages: vi.fn(),
+			updateSessionStatus: vi.fn().mockResolvedValue({
+				updated: true,
+				endedAt: "2026-01-01T00:00:05.000Z",
+			}),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue({
+				tools: [],
+				shutdown: vi.fn(),
+			}),
+		};
+		const agent = {
+			run: vi.fn().mockResolvedValue(createResult()),
+			continue: vi.fn().mockResolvedValue(createResult()),
+			getMessages: vi.fn().mockReturnValue([]),
+			abort: vi.fn(),
+			shutdown: vi.fn().mockResolvedValue(undefined),
+		};
+		const manager = new DefaultSessionManager({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder: runtimeBuilder as never,
+			createAgent: () => agent as never,
+			telemetry,
+		});
+
+		await manager.start({
+			config: createConfig({ telemetry, sessionId }),
+			prompt: "hello",
+		});
+
+		expect(adapter.emit).toHaveBeenCalledWith(
+			"session.started",
+			expect.objectContaining({
+				sessionId,
+				distinct_id: distinctId,
+			}),
+		);
+	});
+
 	it("runs a non-interactive prompt and persists messages/status", async () => {
 		const sessionId = "sess-1";
 		const manifest = createManifest(sessionId);

package/src/session/default-session-manager.ts

@@ -14,7 +14,11 @@ import {
 	type ToolApprovalResult,
 } from "@clinebot/agents";
 import type { providers as LlmsProviders } from "@clinebot/llms";
-import { formatUserInputBlock, normalizeUserInput } from "@clinebot/shared";
+import {
+	formatUserInputBlock,
+	type ITelemetryService,
+	normalizeUserInput,
+} from "@clinebot/shared";
 import { setHomeDirIfUnset } from "@clinebot/shared/storage";
 import { nanoid } from "nanoid";
 import { resolveAndLoadAgentPlugins } from "../agents/plugin-config-loader";
@@ -89,6 +93,7 @@ export interface DefaultSessionManagerOptions {
 	toolPolicies?: AgentConfig["toolPolicies"];
 	providerSettingsManager?: ProviderSettingsManager;
 	oauthTokenManager?: RuntimeOAuthTokenManager;
+	telemetry?: ITelemetryService;
 	requestToolApproval?: (
 		request: ToolApprovalRequest,
 	) => Promise<ToolApprovalResult>;
@@ -120,6 +125,7 @@ export class DefaultSessionManager implements SessionManager {
 	private readonly defaultToolPolicies?: AgentConfig["toolPolicies"];
 	private readonly providerSettingsManager: ProviderSettingsManager;
 	private readonly oauthTokenManager: RuntimeOAuthTokenManager;
+	private readonly defaultTelemetry?: ITelemetryService;
 	private readonly defaultRequestToolApproval?: (
 		request: ToolApprovalRequest,
 	) => Promise<ToolApprovalResult>;
@@ -143,6 +149,7 @@ export class DefaultSessionManager implements SessionManager {
 			new RuntimeOAuthTokenManager({
 				providerSettingsManager: this.providerSettingsManager,
 			});
+		this.defaultTelemetry = options.telemetry;
 		this.defaultRequestToolApproval = options.requestToolApproval;
 	}
 
@@ -263,6 +270,7 @@ export class DefaultSessionManager implements SessionManager {
 			...input.config,
 			hooks: effectiveHooks,
 			extensions: effectiveExtensions,
+			telemetry: input.config.telemetry ?? this.defaultTelemetry,
 		};
 		const providerConfig =
 			this.buildResolvedProviderConfig(effectiveConfigBase);
@@ -276,6 +284,7 @@ export class DefaultSessionManager implements SessionManager {
 			hooks: effectiveHooks,
 			extensions: effectiveExtensions,
 			logger: effectiveConfig.logger,
+			telemetry: effectiveConfig.telemetry,
 			onTeamEvent: (event: TeamEvent) => {
 				void this.handleTeamEvent(sessionId, event);
 				effectiveConfig.onTeamEvent?.(event);
@@ -287,6 +296,18 @@ export class DefaultSessionManager implements SessionManager {
 				input.defaultToolExecutors ?? this.defaultToolExecutors,
 		});
 		const tools = [...runtime.tools, ...(effectiveConfig.extraTools ?? [])];
+		effectiveConfig.telemetry?.capture({
+			event: "session.started",
+			properties: {
+				sessionId,
+				source,
+				providerId: effectiveConfig.providerId,
+				modelId: effectiveConfig.modelId,
+				enableTools: effectiveConfig.enableTools,
+				enableSpawnAgent: effectiveConfig.enableSpawnAgent,
+				enableAgentTeams: effectiveConfig.enableAgentTeams,
+			},
+		});
 		const agent = this.createAgentInstance({
 			providerId: providerConfig.providerId,
 			modelId: providerConfig.modelId,
@@ -326,6 +347,14 @@ export class DefaultSessionManager implements SessionManager {
 						}),
 					);
 				}
+				if (event.type === "iteration_end") {
+					void this.invoke<void>(
+						"persistSessionMessages",
+						sessionId,
+						liveSession?.agent.getMessages() ?? [],
+						liveSession?.config.systemPrompt,
+					);
+				}
 				this.emit({
 					type: "agent_event",
 					payload: {
@@ -397,6 +426,15 @@ export class DefaultSessionManager implements SessionManager {
 		if (!session) {
 			throw new Error(`session not found: ${input.sessionId}`);
 		}
+		session.config.telemetry?.capture({
+			event: "session.input_sent",
+			properties: {
+				sessionId: input.sessionId,
+				promptLength: input.prompt.length,
+				userImageCount: input.userImages?.length ?? 0,
+				userFileCount: input.userFiles?.length ?? 0,
+			},
+		});
 		try {
 			const result = await this.runTurn(session, {
 				prompt: input.prompt,
@@ -428,6 +466,10 @@ export class DefaultSessionManager implements SessionManager {
 		if (!session) {
 			return;
 		}
+		session.config.telemetry?.capture({
+			event: "session.aborted",
+			properties: { sessionId },
+		});
 		session.aborting = true;
 		session.agent.abort();
 	}
@@ -437,6 +479,10 @@ export class DefaultSessionManager implements SessionManager {
 		if (!session) {
 			return;
 		}
+		session.config.telemetry?.capture({
+			event: "session.stopped",
+			properties: { sessionId },
+		});
 		await this.shutdownSession(session, {
 			status: "cancelled",
 			exitCode: null,
@@ -1200,4 +1246,16 @@ export class DefaultSessionManager implements SessionManager {
 			apiKey: resolved.apiKey,
 		});
 	}
+
+	async updateSessionModel(sessionId: string, modelId: string): Promise<void> {
+		const session = this.sessions.get(sessionId);
+		if (!session) {
+			throw new Error(`session not found: ${sessionId}`);
+		}
+		session.config.modelId = modelId;
+		const agentWithConnection = session.agent as Agent & {
+			updateConnection?: (overrides: { modelId?: string }) => void;
+		};
+		agentWithConnection.updateConnection?.({ modelId });
+	}
 }

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/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

@@ -7,12 +7,14 @@ import type {
 	ToolApprovalResult,
 } from "@clinebot/agents";
 import { getRpcServerDefaultAddress, getRpcServerHealth } from "@clinebot/rpc";
+import type { ITelemetryService } from "@clinebot/shared";
 import { resolveSessionDataDir } from "@clinebot/shared/storage";
 import { nanoid } from "nanoid";
 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";
 
@@ -33,6 +35,7 @@ export interface CreateSessionHostOptions {
 	rpcConnectAttempts?: number;
 	rpcConnectDelayMs?: number;
 	defaultToolExecutors?: Partial<ToolExecutors>;
+	telemetry?: ITelemetryService;
 	toolPolicies?: AgentConfig["toolPolicies"];
 	requestToolApproval?: (
 		request: ToolApprovalRequest,
@@ -42,13 +45,19 @@ export interface CreateSessionHostOptions {
 export type SessionHost = SessionManager;
 
 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) =>
@@ -73,6 +82,7 @@ function startRpcServerInBackground(address: string): void {
 		cwd: process.cwd(),
 	});
 	child.unref();
+	setTimeout(() => lease.release(), 10_000).unref();
 }
 
 async function tryConnectRpcBackend(
@@ -190,13 +200,16 @@ export async function resolveSessionBackend(
 export async function createSessionHost(
 	options: CreateSessionHostOptions,
 ): Promise<SessionHost> {
+	const distinctId = resolveHostDistinctId(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: resolveHostDistinctId(options.distinctId),
+		distinctId,
 	});
 }

package/src/session/session-manager.ts

@@ -64,4 +64,5 @@ export interface SessionManager {
 	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/storage/provider-settings-legacy-migration.test.ts

@@ -2,7 +2,11 @@ import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { afterEach, describe, expect, it } from "vitest";
-import { migrateLegacyProviderSettings } from "./provider-settings-legacy-migration";
+import {
+	type LegacyClineUserInfo,
+	migrateLegacyProviderSettings,
+	resolveLegacyClineAuth,
+} from "./provider-settings-legacy-migration";
 import { ProviderSettingsManager } from "./provider-settings-manager";
 
 describe("migrateLegacyProviderSettings", () => {
@@ -173,3 +177,131 @@ describe("migrateLegacyProviderSettings", () => {
 		);
 	});
 });
+
+// =============================================================================
+// resolveLegacyClineAuth – pure in-memory tests
+// =============================================================================
+
+/** Builds a realistic LegacyClineUserInfo JSON string. */
+function makeClineAccountJson(
+	overrides: Partial<LegacyClineUserInfo> & { userId?: string } = {},
+): string {
+	return JSON.stringify({
+		idToken: overrides.idToken ?? "id-token-abc",
+		expiresAt: overrides.expiresAt ?? 1750000000000,
+		refreshToken: overrides.refreshToken ?? "refresh-token-xyz",
+		userInfo: overrides.userInfo ?? {
+			id: overrides.userId ?? "user-42",
+			email: "test@example.com",
+			displayName: "Test User",
+			termsAcceptedAt: "2025-01-01T00:00:00Z",
+			clineBenchConsent: false,
+			createdAt: "2025-01-01T00:00:00Z",
+			updatedAt: "2025-01-01T00:00:00Z",
+		},
+		provider: overrides.provider ?? "google",
+		startedAt: overrides.startedAt ?? Date.now(),
+	} satisfies LegacyClineUserInfo);
+}
+
+describe("resolveLegacyClineAuth", () => {
+	it("extracts all auth fields from a complete legacy account JSON", () => {
+		const result = resolveLegacyClineAuth(
+			makeClineAccountJson({
+				idToken: "my-id-token",
+				expiresAt: 1750000000000,
+				refreshToken: "my-refresh",
+				userId: "user-123",
+			}),
+		);
+
+		expect(result).toEqual({
+			accessToken: "my-id-token",
+			refreshToken: "my-refresh",
+			expiresAt: 1750000000000,
+			accountId: "user-123",
+		});
+	});
+
+	it("maps idToken to accessToken", () => {
+		const result = resolveLegacyClineAuth(
+			makeClineAccountJson({ idToken: "tok-abc" }),
+		);
+		expect(result?.accessToken).toBe("tok-abc");
+	});
+
+	it("preserves expiresAt as a number", () => {
+		const result = resolveLegacyClineAuth(
+			makeClineAccountJson({ expiresAt: 9999999999999 }),
+		);
+		expect(result?.expiresAt).toBe(9999999999999);
+		expect(typeof result?.expiresAt).toBe("number");
+	});
+
+	it("maps userInfo.id to accountId", () => {
+		const result = resolveLegacyClineAuth(
+			makeClineAccountJson({ userId: "uid-xyz" }),
+		);
+		expect(result?.accountId).toBe("uid-xyz");
+	});
+
+	it("returns undefined accountId when userInfo is missing entirely", () => {
+		const raw = JSON.stringify({
+			idToken: "tok",
+			expiresAt: 1000,
+			refreshToken: "ref",
+			provider: "google",
+			startedAt: 1,
+		});
+
+		const result = resolveLegacyClineAuth(raw);
+		expect(result).toBeDefined();
+		expect(result?.accessToken).toBe("tok");
+		expect(result?.accountId).toBeUndefined();
+	});
+
+	it("returns undefined accountId when userInfo.id is missing", () => {
+		const raw = JSON.stringify({
+			idToken: "tok",
+			expiresAt: 1000,
+			refreshToken: "ref",
+			userInfo: {
+				email: "x@y.com",
+				displayName: "X",
+				termsAcceptedAt: "2025-01-01T00:00:00Z",
+				clineBenchConsent: false,
+				createdAt: "2025-01-01T00:00:00Z",
+				updatedAt: "2025-01-01T00:00:00Z",
+			},
+			provider: "google",
+			startedAt: 1,
+		});
+
+		const result = resolveLegacyClineAuth(raw);
+		expect(result).toBeDefined();
+		expect(result?.accountId).toBeUndefined();
+	});
+
+	it("returns undefined for invalid json", () => {
+		expect(resolveLegacyClineAuth(undefined)).toBeUndefined();
+		expect(resolveLegacyClineAuth("")).toBeUndefined();
+		expect(resolveLegacyClineAuth("   \n\t  ")).toBeUndefined();
+		expect(resolveLegacyClineAuth("not-json{{{")).toBeUndefined();
+		expect(resolveLegacyClineAuth("null")).toBeUndefined();
+	});
+
+	it("returns undefined fields when idToken/refreshToken are missing from JSON", () => {
+		const raw = JSON.stringify({
+			userInfo: { id: "uid" },
+			provider: "google",
+			startedAt: 1,
+		});
+
+		const result = resolveLegacyClineAuth(raw);
+		expect(result).toBeDefined();
+		expect(result?.accessToken).toBeUndefined();
+		expect(result?.refreshToken).toBeUndefined();
+		expect(result?.expiresAt).toBeUndefined();
+		expect(result?.accountId).toBe("uid");
+	});
+});