@clinebot/core 0.0.7 → 0.0.11

package/src/auth/cline.ts

@@ -1,3 +1,11 @@
+import type { ITelemetryService } from "@clinebot/shared";
+import {
+	captureAuthFailed,
+	captureAuthLoggedOut,
+	captureAuthStarted,
+	captureAuthSucceeded,
+	identifyAccount,
+} from "../telemetry/core-events";
 import { startLocalOAuthServer } from "./server.js";
 import type {
 	OAuthCredentials,
@@ -63,6 +71,7 @@ export interface ClineOAuthProviderOptions {
 	callbackPath?: string;
 	callbackPorts?: number[];
 	requestTimeoutMs?: number;
+	telemetry?: ITelemetryService;
 	/**
 	 * Optional identity provider name for token exchange.
 	 */
@@ -253,6 +262,7 @@ export async function loginClineOAuth(
 		callbacks: OAuthLoginCallbacks;
 	},
 ): Promise<ClineOAuthCredentials> {
+	captureAuthStarted(options.telemetry, options.provider ?? "cline");
 	const callbackPorts = options.callbackPorts?.length
 		? options.callbackPorts
 		: DEFAULT_CALLBACK_PORTS;
@@ -312,7 +322,26 @@ export async function loginClineOAuth(
 			throw new Error("Missing authorization code");
 		}
 
-		return exchangeAuthorizationCode(code, callbackUrl, options, provider);
+		const credentials = await exchangeAuthorizationCode(
+			code,
+			callbackUrl,
+			options,
+			provider,
+		);
+		captureAuthSucceeded(options.telemetry, provider ?? "cline");
+		identifyAccount(options.telemetry, {
+			id: credentials.accountId,
+			email: credentials.email,
+			provider: provider ?? "cline",
+		});
+		return credentials;
+	} catch (error) {
+		captureAuthFailed(
+			options.telemetry,
+			options.provider ?? "cline",
+			error instanceof Error ? error.message : String(error),
+		);
+		throw error;
 	} finally {
 		localServer.close();
 	}
@@ -384,6 +413,11 @@ export async function getValidClineCredentials(
 		return await refreshClineToken(currentCredentials, providerOptions);
 	} catch (error) {
 		if (error instanceof ClineOAuthTokenError && error.isLikelyInvalidGrant()) {
+			captureAuthLoggedOut(
+				providerOptions.telemetry,
+				providerOptions.provider ?? "cline",
+				"invalid_grant",
+			);
 			return null;
 		}
 		if (currentCredentials.expires - Date.now() > retryableTokenGraceMs) {

package/src/auth/codex.ts

@@ -5,7 +5,15 @@
  * It is only intended for CLI use, not browser environments.
  */
 
+import type { ITelemetryService } from "@clinebot/shared";
 import { nanoid } from "nanoid";
+import {
+	captureAuthFailed,
+	captureAuthLoggedOut,
+	captureAuthStarted,
+	captureAuthSucceeded,
+	identifyAccount,
+} from "../telemetry/core-events";
 import { startLocalOAuthServer } from "./server.js";
 import type {
 	OAuthCredentials,
@@ -295,7 +303,9 @@ export async function loginOpenAICodex(options: {
 	onProgress?: (message: string) => void;
 	onManualCodeInput?: () => Promise<string>;
 	originator?: string;
+	telemetry?: ITelemetryService;
 }): Promise<OAuthCredentials> {
+	captureAuthStarted(options.telemetry, "openai-codex");
 	const callbackConfig = resolveCallbackServerConfig();
 	const { verifier, state, url } = await createAuthorizationFlow(
 		options.originator,
@@ -352,7 +362,21 @@ export async function loginOpenAICodex(options: {
 			throw new Error("Token exchange failed");
 		}
 
-		return toCodexCredentials(tokenResult);
+		const credentials = toCodexCredentials(tokenResult);
+		captureAuthSucceeded(options.telemetry, "openai-codex");
+		identifyAccount(options.telemetry, {
+			id: credentials.accountId,
+			email: credentials.email,
+			provider: "openai-codex",
+		});
+		return credentials;
+	} catch (error) {
+		captureAuthFailed(
+			options.telemetry,
+			"openai-codex",
+			error instanceof Error ? error.message : String(error),
+		);
+		throw error;
 	} finally {
 		server.close();
 	}
@@ -378,7 +402,7 @@ export async function refreshOpenAICodexToken(
 
 export async function getValidOpenAICodexCredentials(
 	currentCredentials: OAuthCredentials | null,
-	options?: RefreshTokenResolution,
+	options?: RefreshTokenResolution & { telemetry?: ITelemetryService },
 ): Promise<OAuthCredentials | null> {
 	if (!currentCredentials) {
 		return null;
@@ -409,6 +433,7 @@ export async function getValidOpenAICodexCredentials(
 			error instanceof OpenAICodexOAuthTokenError &&
 			error.isLikelyInvalidGrant()
 		) {
+			captureAuthLoggedOut(options?.telemetry, "openai-codex", "invalid_grant");
 			return null;
 		}
 		if (currentCredentials.expires - Date.now() > retryableTokenGraceMs) {

package/src/auth/oca.ts

@@ -1,4 +1,12 @@
+import type { ITelemetryService } from "@clinebot/shared";
 import { nanoid } from "nanoid";
+import {
+	captureAuthFailed,
+	captureAuthLoggedOut,
+	captureAuthStarted,
+	captureAuthSucceeded,
+	identifyAccount,
+} from "../telemetry/core-events";
 import { startLocalOAuthServer } from "./server.js";
 import type {
 	OAuthCredentials,
@@ -325,8 +333,12 @@ function buildAuthorizationUrl(input: {
 }
 
 export async function loginOcaOAuth(
-	options: OcaOAuthProviderOptions & { callbacks: OAuthLoginCallbacks },
+	options: OcaOAuthProviderOptions & {
+		callbacks: OAuthLoginCallbacks;
+		telemetry?: ITelemetryService;
+	},
 ): Promise<OAuthCredentials> {
+	captureAuthStarted(options.telemetry, "oca");
 	const config = resolveConfig(options.config);
 	const mode = resolveMode(options.mode);
 	const callbackPorts = options.callbackPorts?.length
@@ -391,13 +403,27 @@ export async function loginOcaOAuth(
 			throw new Error("State mismatch");
 		}
 
-		return await exchangeAuthorizationCode({
+		const credentials = await exchangeAuthorizationCode({
 			code,
 			state: returnedState,
 			mode,
 			config,
 			requestTimeoutMs,
 		});
+		captureAuthSucceeded(options.telemetry, "oca");
+		identifyAccount(options.telemetry, {
+			id: credentials.accountId,
+			email: credentials.email,
+			provider: "oca",
+		});
+		return credentials;
+	} catch (error) {
+		captureAuthFailed(
+			options.telemetry,
+			"oca",
+			error instanceof Error ? error.message : String(error),
+		);
+		throw error;
 	} finally {
 		localServer.close();
 	}
@@ -447,8 +473,8 @@ export async function refreshOcaToken(
 
 export async function getValidOcaCredentials(
 	currentCredentials: OAuthCredentials | null,
-	options?: OcaTokenResolution,
-	providerOptions?: OcaOAuthProviderOptions,
+	options?: OcaTokenResolution & { telemetry?: ITelemetryService },
+	providerOptions?: OcaOAuthProviderOptions & { telemetry?: ITelemetryService },
 ): Promise<OAuthCredentials | null> {
 	if (!currentCredentials) {
 		return null;
@@ -475,6 +501,7 @@ export async function getValidOcaCredentials(
 		return await refreshOcaToken(currentCredentials, providerOptions);
 	} catch (error) {
 		if (error instanceof OcaOAuthTokenError && error.isLikelyInvalidGrant()) {
+			captureAuthLoggedOut(providerOptions?.telemetry, "oca", "invalid_grant");
 			return null;
 		}
 		if (currentCredentials.expires - Date.now() > retryableTokenGraceMs) {

package/src/auth/types.ts

@@ -1,3 +1,5 @@
+import type { ITelemetryService } from "@clinebot/shared";
+
 export interface OAuthPrompt {
 	message: string;
 	defaultValue?: string;
@@ -69,6 +71,7 @@ export interface OcaOAuthProviderOptions {
 	requestTimeoutMs?: number;
 	refreshBufferMs?: number;
 	retryableTokenGraceMs?: number;
+	telemetry?: ITelemetryService;
 }
 
 export interface OcaTokenResolution {

package/src/index.ts

@@ -13,6 +13,7 @@ export {
 	type ToolApprovalResult,
 	type ToolContext,
 } from "@clinebot/agents";
+export { LlmsModels, LlmsProviders } from "@clinebot/llms";
 // Shared contracts and path helpers re-exported for app consumers.
 export type {
 	AgentMode,
@@ -57,7 +58,10 @@ export {
 	ensureHookLogDir,
 	ensureParentDir,
 	resolveClineDataDir,
+	resolveClineDir,
 	resolveSessionDataDir,
+	setClineDir,
+	setClineDirIfUnset,
 	setHomeDir,
 	setHomeDirIfUnset,
 } from "@clinebot/shared/storage";
@@ -123,6 +127,29 @@ export {
 	buildTeamProgressSummary,
 	toTeamProgressLifecycleEvent,
 } from "./team";
+export {
+	captureAuthFailed,
+	captureAuthLoggedOut,
+	captureAuthStarted,
+	captureAuthSucceeded,
+	captureConversationTurnEvent,
+	captureDiffEditFailure,
+	captureHookDiscovery,
+	captureMentionFailed,
+	captureMentionSearchResults,
+	captureMentionUsed,
+	captureModeSwitch,
+	captureProviderApiError,
+	captureSkillUsed,
+	captureSubagentExecution,
+	captureTaskCompleted,
+	captureTaskCreated,
+	captureTaskRestarted,
+	captureTokenUsage,
+	captureToolUsage,
+	identifyAccount,
+	LegacyTelemetryEvents,
+} from "./telemetry/core-events";
 export type { ITelemetryAdapter } from "./telemetry/ITelemetryAdapter";
 export {
 	LoggerTelemetryAdapter,

package/src/input/mention-enricher.test.ts

@@ -32,6 +32,7 @@ describe("enrichPromptWithMentions", () => {
 				cwd,
 			);
 
+			expect(result.mentions).toEqual(["src/index.ts"]);
 			expect(result.matchedFiles).toEqual(["src/index.ts"]);
 			expect(result.ignoredMentions).toEqual([]);
 			expect(result.prompt).toBe("Review @src/index.ts");
@@ -50,6 +51,7 @@ describe("enrichPromptWithMentions", () => {
 				cwd,
 			);
 
+			expect(result.mentions).toEqual(["missing/file.ts"]);
 			expect(result.matchedFiles).toEqual([]);
 			expect(result.ignoredMentions).toEqual(["missing/file.ts"]);
 			expect(result.prompt).toBe(
@@ -72,6 +74,7 @@ describe("enrichPromptWithMentions", () => {
 				{ maxTotalBytes: 5, maxFiles: 2, maxFileBytes: 5 },
 			);
 
+			expect(result.mentions).toEqual(["a.ts", "b.ts"]);
 			expect(result.matchedFiles).toEqual(["a.ts"]);
 			expect(result.ignoredMentions).toEqual(["b.ts"]);
 			expect(result.prompt).toBe("Use @a.ts and @b.ts");

package/src/input/mention-enricher.ts

@@ -13,6 +13,7 @@ export interface MentionEnricherOptions extends FastFileIndexOptions {
 
 export interface MentionEnrichmentResult {
 	prompt: string;
+	mentions: string[];
 	matchedFiles: string[];
 	ignoredMentions: string[];
 }
@@ -60,6 +61,7 @@ export async function enrichPromptWithMentions(
 	if (mentions.length === 0) {
 		return {
 			prompt: input,
+			mentions: [],
 			matchedFiles: [],
 			ignoredMentions: [],
 		};
@@ -113,6 +115,7 @@ export async function enrichPromptWithMentions(
 
 	return {
 		prompt: input,
+		mentions,
 		matchedFiles: matched,
 		ignoredMentions: ignored,
 	};

package/src/providers/local-provider-service.ts

@@ -1,7 +1,6 @@
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
-import type { providers as LlmsProviders } from "@clinebot/llms";
-import { models } from "@clinebot/llms";
+import { LlmsModels, type LlmsProviders } from "@clinebot/llms";
 import type {
 	RpcAddProviderActionRequest,
 	RpcOAuthProviderId,
@@ -215,7 +214,7 @@ function registerCustomProvider(
 		]),
 	);
 
-	models.registerProvider({
+	LlmsModels.registerProvider({
 		provider: {
 			id: providerId,
 			name: entry.provider.name.trim() || titleCaseFromId(providerId),
@@ -318,7 +317,7 @@ export async function addLocalProvider(
 }> {
 	const providerId = request.providerId.trim().toLowerCase();
 	if (!providerId) throw new Error("providerId is required");
-	if (models.hasProvider(providerId)) {
+	if (LlmsModels.hasProvider(providerId)) {
 		throw new Error(`provider "${providerId}" already exists`);
 	}
 	const providerName = request.name.trim();
@@ -411,10 +410,10 @@ export async function listLocalProviders(
 	settingsPath: string;
 }> {
 	const state = manager.read();
-	const ids = models.getProviderIds().sort((a, b) => a.localeCompare(b));
+	const ids = LlmsModels.getProviderIds().sort((a, b) => a.localeCompare(b));
 	const providerItems = await Promise.all(
 		ids.map(async (id): Promise<RpcProviderListItem> => {
-			const info = await models.getProvider(id);
+			const info = await LlmsModels.getProvider(id);
 			const providerModels = await getLocalProviderModels(id);
 			const persistedSettings = state.providers[id]?.settings;
 			const providerName = info?.name ?? titleCaseFromId(id);
@@ -450,7 +449,7 @@ export async function getLocalProviderModels(
 	providerId: string,
 ): Promise<{ providerId: string; models: RpcProviderModel[] }> {
 	const id = providerId.trim();
-	const modelMap = await models.getModelsForProvider(id);
+	const modelMap = await LlmsModels.getModelsForProvider(id);
 	const items = Object.entries(modelMap)
 		.sort(([a], [b]) => a.localeCompare(b))
 		.map(([modelId, info]) => toRpcProviderModel(modelId, info));

package/src/runtime/hook-file-hooks.ts

@@ -214,18 +214,14 @@ async function writeToChildStdin(
 	}
 
 	await new Promise<void>((resolve, reject) => {
-		const onError = (error: Error) => {
-			stdin.off("error", onError);
-			const code = (error as Error & { code?: string }).code;
-			if (code === "EPIPE" || code === "ERR_STREAM_DESTROYED") {
-				resolve();
+		let settled = false;
+		const finish = (error?: Error | null) => {
+			if (settled) {
 				return;
 			}
-			reject(error);
-		};
-		stdin.once("error", onError);
-		stdin.end(body, (error?: Error | null) => {
+			settled = true;
 			stdin.off("error", onError);
+			stdin.off("close", onClose);
 			if (error) {
 				const code = (error as Error & { code?: string }).code;
 				if (code === "EPIPE" || code === "ERR_STREAM_DESTROYED") {
@@ -236,7 +232,12 @@ async function writeToChildStdin(
 				return;
 			}
 			resolve();
-		});
+		};
+		const onError = (error: Error) => finish(error);
+		const onClose = () => finish();
+		stdin.on("error", onError);
+		stdin.once("close", onClose);
+		stdin.end(body, (error?: Error | null) => finish(error));
 	});
 }
 

package/src/runtime/session-runtime.ts

@@ -40,7 +40,7 @@ export interface RuntimeBuilder {
 export interface SessionRuntime {
 	start(config: CoreSessionConfig): Promise<{ sessionId: string }>;
 	send(sessionId: string, prompt: string): Promise<AgentResult | undefined>;
-	abort(sessionId: string): Promise<void>;
+	abort(sessionId: string, reason?: unknown): Promise<void>;
 	stop(sessionId: string): Promise<void>;
 	poll(): Promise<string[]>;
 }

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

@@ -10,7 +10,7 @@ import {
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import type { AgentResult } from "@clinebot/agents";
-import type { providers as LlmsProviders } from "@clinebot/llms";
+import type { LlmsProviders } from "@clinebot/llms";
 import { nanoid } from "nanoid";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import type { SessionSource, SessionStatus } from "../types/common";
@@ -348,6 +348,7 @@ describe("DefaultSessionManager e2e", () => {
 		await manager.stop(started.sessionId);
 		const stopped = await manager.get(started.sessionId);
 		expect(stopped?.status).toBe("cancelled");
+		expect(stopped?.exitCode).toBe(0);
 		expect(agentShutdown).toHaveBeenCalledTimes(1);
 		expect(runtimeShutdown).toHaveBeenCalledTimes(1);
 		const parsedManifest = JSON.parse(

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

@@ -309,6 +309,137 @@ describe("DefaultSessionManager", () => {
 		});
 	});
 
+	it("preserves per-turn metadata on prior assistant messages across turns", async () => {
+		const sessionId = "sess-meta-multi";
+		const manifest = createManifest(sessionId);
+		const persistSessionMessages = vi.fn();
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue({
+				tools: [],
+				shutdown: vi.fn(),
+			}),
+		};
+		const firstTurnMessages = [
+			{
+				role: "user" as const,
+				content: [{ type: "text" as const, text: "hello" }],
+			},
+			{
+				role: "assistant" as const,
+				content: [{ type: "text" as const, text: "world" }],
+			},
+		];
+		const secondTurnMessages = [
+			...firstTurnMessages,
+			{
+				role: "user" as const,
+				content: [{ type: "text" as const, text: "again" }],
+			},
+			{
+				role: "assistant" as const,
+				content: [{ type: "text" as const, text: "still here" }],
+			},
+		];
+		const run = vi.fn().mockResolvedValue(
+			createResult({
+				usage: {
+					inputTokens: 33,
+					outputTokens: 12,
+					cacheReadTokens: 4,
+					cacheWriteTokens: 1,
+					totalCost: 0.42,
+				},
+				model: {
+					id: "claude-sonnet-4-6",
+					provider: "anthropic",
+				},
+				endedAt: new Date("2026-01-01T00:00:02.000Z"),
+				messages: firstTurnMessages,
+			}),
+		);
+		const continueFn = vi.fn().mockResolvedValue(
+			createResult({
+				usage: {
+					inputTokens: 10,
+					outputTokens: 5,
+					cacheReadTokens: 2,
+					cacheWriteTokens: 0,
+					totalCost: 0.12,
+				},
+				model: {
+					id: "claude-sonnet-4-6",
+					provider: "anthropic",
+				},
+				endedAt: new Date("2026-01-01T00:00:03.000Z"),
+				messages: secondTurnMessages,
+			}),
+		);
+		const agent = {
+			run,
+			continue: continueFn,
+			abort: vi.fn(),
+			shutdown: vi.fn().mockResolvedValue(undefined),
+			restore: vi.fn(),
+			getMessages: vi.fn().mockReturnValue([]),
+			messages: [],
+		};
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest-meta-multi.json",
+				transcriptPath: "/tmp/transcript-meta-multi.log",
+				hookPath: "/tmp/hook-meta-multi.log",
+				messagesPath: "/tmp/messages-meta-multi.json",
+				manifest,
+			}),
+			persistSessionMessages,
+			updateSessionStatus: vi.fn().mockResolvedValue({ updated: true }),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const manager = new DefaultSessionManager({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder,
+			createAgent: () => agent as never,
+		});
+
+		await manager.start({
+			config: createConfig({
+				sessionId,
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4-6",
+			}),
+			interactive: true,
+		});
+
+		await manager.send({ sessionId, prompt: "hello" });
+		await manager.send({ sessionId, prompt: "again" });
+
+		const persisted = persistSessionMessages.mock.calls[1]?.[1];
+		expect(persisted?.[1]).toMatchObject({
+			role: "assistant",
+			metrics: {
+				inputTokens: 33,
+				outputTokens: 12,
+				cacheReadTokens: 4,
+				cacheWriteTokens: 1,
+				cost: 0.42,
+			},
+		});
+		expect(persisted?.[3]).toMatchObject({
+			role: "assistant",
+			metrics: {
+				inputTokens: 10,
+				outputTokens: 5,
+				cacheReadTokens: 2,
+				cacheWriteTokens: 0,
+				cost: 0.12,
+			},
+		});
+	});
+
 	it("persists rendered messages when a turn fails", async () => {
 		const sessionId = "sess-failed-turn";
 		const manifest = createManifest(sessionId);