@clinebot/core 0.0.6 → 0.0.10

package/src/session/utils/helpers.ts

@@ -1,5 +1,5 @@
 import type { AgentConfig, AgentEvent, 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 { SessionRecord } from "../../types/sessions";
 import { nowIso } from "../session-artifacts";

package/src/session/utils/types.ts

@@ -1,5 +1,5 @@
 import type { Agent } from "@clinebot/agents";
-import type { providers as LlmsProviders } from "@clinebot/llms";
+import type { LlmsProviders } from "@clinebot/llms";
 import type { BuiltRuntime } from "../../runtime/session-runtime";
 import type { SessionSource } from "../../types/common";
 import type { CoreSessionConfig } from "../../types/config";

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");
+	});
+});

package/src/storage/provider-settings-legacy-migration.ts

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-import { models, providers } from "@clinebot/llms";
+import { LlmsModels, LlmsProviders } from "@clinebot/llms";
 import { resolveClineDataDir } from "@clinebot/shared/storage";
 import type { ProviderSettings } from "../types/provider-settings";
 import { emptyStoredProviderSettings } from "../types/provider-settings";
@@ -162,6 +162,53 @@ export interface MigrateLegacyProviderSettingsResult {
 	lastUsedProvider?: string;
 }
 
+export type LegacyClineUserInfo = {
+	idToken: string;
+	expiresAt: number;
+	refreshToken: string;
+	userInfo: {
+		id: string;
+		email: string;
+		displayName: string;
+		termsAcceptedAt: string;
+		clineBenchConsent: boolean;
+		createdAt: string;
+		updatedAt: string;
+	};
+	provider: string;
+	startedAt: number;
+};
+
+/**
+ * Resolves legacy Cline account auth data from the raw `cline:clineAccountId`
+ * secret string into the auth fields used by `ProviderSettings`.
+ *
+ * Returns `undefined` when the input is missing, empty, whitespace-only, or
+ * unparseable JSON.
+ */
+export function resolveLegacyClineAuth(
+	rawAccountData: string | undefined,
+): ProviderSettings["auth"] | undefined {
+	const trimmed = rawAccountData?.trim();
+	if (!trimmed) {
+		return undefined;
+	}
+	try {
+		const data = JSON.parse(trimmed) as LegacyClineUserInfo;
+		if (!data) {
+			return undefined;
+		}
+		return {
+			accessToken: data.idToken,
+			refreshToken: data.refreshToken,
+			expiresAt: data.expiresAt,
+			accountId: data.userInfo?.id,
+		};
+	} catch {
+		return undefined;
+	}
+}
+
 function trimNonEmpty(value: string | undefined): string | undefined {
 	const trimmed = value?.trim();
 	return trimmed ? trimmed : undefined;
@@ -326,7 +373,7 @@ function resolveLegacyCodexAuth(
 }
 
 function getDefaultModelForProvider(providerId: string): string | undefined {
-	const builtInModels = models.getGeneratedModelsForProvider(providerId);
+	const builtInModels = LlmsModels.getGeneratedModelsForProvider(providerId);
 	const firstModelId = Object.keys(builtInModels)[0];
 	return firstModelId ?? undefined;
 }
@@ -400,14 +447,19 @@ function buildLegacyProviderSettings(
 		Object.assign(providerSpecific, resolveLegacyCodexAuth(legacySecrets));
 	}
 	if (providerId === "cline") {
-		const accountId = trimNonEmpty(
-			legacySecrets["cline:clineAccountId"] ?? legacySecrets.clineAccountId,
-		);
-		if (accountId) {
-			providerSpecific.auth = {
-				...(providerSpecific.auth ?? {}),
-				accountId,
-			};
+		try {
+			const legacyAuthString = trimNonEmpty(
+				legacySecrets["cline:clineAccountId"],
+			);
+
+			if (legacyAuthString) {
+				providerSpecific.auth = {
+					...(providerSpecific.auth ?? {}),
+					...resolveLegacyClineAuth(legacyAuthString),
+				};
+			}
+		} catch {
+			// Failed to parse stored cline auth data
 		}
 	}
 	if (providerId === "openai" && legacyGlobalState.openAiHeaders) {
@@ -516,7 +568,7 @@ function buildLegacyProviderSettings(
 		...(timeout ? { timeout } : {}),
 		...providerSpecific,
 	};
-	const parsed = providers.ProviderSettingsSchema.safeParse(settings);
+	const parsed = LlmsProviders.ProviderSettingsSchema.safeParse(settings);
 	if (!parsed.success) {
 		return undefined;
 	}

package/src/telemetry/core-events.ts

@@ -0,0 +1,344 @@
+import type { ITelemetryService, TelemetryProperties } from "@clinebot/shared";
+
+const MAX_ERROR_MESSAGE_LENGTH = 500;
+
+export const LegacyTelemetryEvents = {
+	USER: {
+		AUTH_STARTED: "user.auth_started",
+		AUTH_SUCCEEDED: "user.auth_succeeded",
+		AUTH_FAILED: "user.auth_failed",
+		AUTH_LOGGED_OUT: "user.auth_logged_out",
+	},
+	TASK: {
+		CREATED: "task.created",
+		RESTARTED: "task.restarted",
+		COMPLETED: "task.completed",
+		CONVERSATION_TURN: "task.conversation_turn",
+		TOKEN_USAGE: "task.tokens",
+		MODE_SWITCH: "task.mode",
+		TOOL_USED: "task.tool_used",
+		SKILL_USED: "task.skill_used",
+		DIFF_EDIT_FAILED: "task.diff_edit_failed",
+		PROVIDER_API_ERROR: "task.provider_api_error",
+		MENTION_USED: "task.mention_used",
+		MENTION_FAILED: "task.mention_failed",
+		MENTION_SEARCH_RESULTS: "task.mention_search_results",
+		SUBAGENT_STARTED: "task.subagent_started",
+		SUBAGENT_COMPLETED: "task.subagent_completed",
+	},
+	HOOKS: {
+		DISCOVERY_COMPLETED: "hooks.discovery_completed",
+	},
+} as const;
+
+function emit(
+	telemetry: ITelemetryService | undefined,
+	event: string,
+	properties?: TelemetryProperties,
+): void {
+	telemetry?.capture({ event, properties });
+}
+
+function truncateErrorMessage(errorMessage?: string): string | undefined {
+	if (!errorMessage) {
+		return undefined;
+	}
+	return errorMessage.substring(0, MAX_ERROR_MESSAGE_LENGTH);
+}
+
+export function captureAuthStarted(
+	telemetry: ITelemetryService | undefined,
+	provider?: string,
+): void {
+	emit(telemetry, LegacyTelemetryEvents.USER.AUTH_STARTED, { provider });
+}
+
+export function captureAuthSucceeded(
+	telemetry: ITelemetryService | undefined,
+	provider?: string,
+): void {
+	emit(telemetry, LegacyTelemetryEvents.USER.AUTH_SUCCEEDED, { provider });
+}
+
+export function captureAuthFailed(
+	telemetry: ITelemetryService | undefined,
+	provider?: string,
+	errorMessage?: string,
+): void {
+	emit(telemetry, LegacyTelemetryEvents.USER.AUTH_FAILED, {
+		provider,
+		errorMessage: truncateErrorMessage(errorMessage),
+	});
+}
+
+export function captureAuthLoggedOut(
+	telemetry: ITelemetryService | undefined,
+	provider?: string,
+	reason?: string,
+): void {
+	emit(telemetry, LegacyTelemetryEvents.USER.AUTH_LOGGED_OUT, {
+		provider,
+		reason,
+	});
+}
+
+export function identifyAccount(
+	telemetry: ITelemetryService | undefined,
+	account: {
+		id?: string;
+		email?: string;
+		provider?: string;
+		organizationId?: string;
+		organizationName?: string;
+		memberId?: string;
+	},
+): void {
+	const distinctId = account.id?.trim();
+	if (distinctId) {
+		telemetry?.setDistinctId(distinctId);
+	}
+	telemetry?.updateCommonProperties({
+		account_id: account.id,
+		account_email: account.email,
+		provider: account.provider,
+		organization_id: account.organizationId,
+		organization_name: account.organizationName,
+		member_id: account.memberId,
+	});
+}
+
+export function captureTaskCreated(
+	telemetry: ITelemetryService | undefined,
+	properties: {
+		ulid: string;
+		apiProvider?: string;
+		openAiCompatibleDomain?: string;
+	},
+): void {
+	emit(telemetry, LegacyTelemetryEvents.TASK.CREATED, properties);
+}
+
+export function captureTaskRestarted(
+	telemetry: ITelemetryService | undefined,
+	properties: {
+		ulid: string;
+		apiProvider?: string;
+		openAiCompatibleDomain?: string;
+	},
+): void {
+	emit(telemetry, LegacyTelemetryEvents.TASK.RESTARTED, properties);
+}
+
+export function captureTaskCompleted(
+	telemetry: ITelemetryService | undefined,
+	properties: {
+		ulid: string;
+		provider?: string;
+		modelId?: string;
+		mode?: string;
+		durationMs?: number;
+	},
+): void {
+	emit(telemetry, LegacyTelemetryEvents.TASK.COMPLETED, properties);
+}
+
+export function captureConversationTurnEvent(
+	telemetry: ITelemetryService | undefined,
+	properties: {
+		ulid: string;
+		provider?: string;
+		model?: string;
+		source: "user" | "assistant";
+		mode?: string;
+		tokensIn?: number;
+		tokensOut?: number;
+		cacheWriteTokens?: number;
+		cacheReadTokens?: number;
+		totalCost?: number;
+		isNativeToolCall?: boolean;
+	},
+): void {
+	emit(telemetry, LegacyTelemetryEvents.TASK.CONVERSATION_TURN, {
+		...properties,
+		timestamp: new Date().toISOString(),
+	});
+}
+
+export function captureTokenUsage(
+	telemetry: ITelemetryService | undefined,
+	properties: {
+		ulid: string;
+		tokensIn: number;
+		tokensOut: number;
+		model: string;
+	},
+): void {
+	emit(telemetry, LegacyTelemetryEvents.TASK.TOKEN_USAGE, properties);
+}
+
+export function captureModeSwitch(
+	telemetry: ITelemetryService | undefined,
+	ulid: string,
+	mode?: string,
+): void {
+	emit(telemetry, LegacyTelemetryEvents.TASK.MODE_SWITCH, { ulid, mode });
+}
+
+export function captureToolUsage(
+	telemetry: ITelemetryService | undefined,
+	properties: {
+		ulid: string;
+		tool: string;
+		modelId?: string;
+		provider?: string;
+		autoApproved?: boolean;
+		success: boolean;
+		isNativeToolCall?: boolean;
+	},
+): void {
+	emit(telemetry, LegacyTelemetryEvents.TASK.TOOL_USED, properties);
+}
+
+export function captureSkillUsed(
+	telemetry: ITelemetryService | undefined,
+	properties: {
+		ulid: string;
+		skillName: string;
+		skillSource: "global" | "project";
+		skillsAvailableGlobal: number;
+		skillsAvailableProject: number;
+		provider?: string;
+		modelId?: string;
+	},
+): void {
+	emit(telemetry, LegacyTelemetryEvents.TASK.SKILL_USED, properties);
+}
+
+export function captureDiffEditFailure(
+	telemetry: ITelemetryService | undefined,
+	properties: {
+		ulid: string;
+		modelId?: string;
+		provider?: string;
+		errorType?: string;
+		isNativeToolCall?: boolean;
+	},
+): void {
+	emit(telemetry, LegacyTelemetryEvents.TASK.DIFF_EDIT_FAILED, properties);
+}
+
+export function captureProviderApiError(
+	telemetry: ITelemetryService | undefined,
+	properties: {
+		ulid: string;
+		model: string;
+		errorMessage: string;
+		provider?: string;
+		errorStatus?: number;
+		requestId?: string;
+		isNativeToolCall?: boolean;
+	},
+): void {
+	emit(telemetry, LegacyTelemetryEvents.TASK.PROVIDER_API_ERROR, {
+		...properties,
+		errorMessage: truncateErrorMessage(properties.errorMessage) ?? "unknown",
+		timestamp: new Date().toISOString(),
+	});
+}
+
+export function captureMentionUsed(
+	telemetry: ITelemetryService | undefined,
+	mentionType:
+		| "file"
+		| "folder"
+		| "url"
+		| "problems"
+		| "terminal"
+		| "git-changes"
+		| "commit",
+	contentLength?: number,
+): void {
+	emit(telemetry, LegacyTelemetryEvents.TASK.MENTION_USED, {
+		mentionType,
+		contentLength,
+		timestamp: new Date().toISOString(),
+	});
+}
+
+export function captureMentionFailed(
+	telemetry: ITelemetryService | undefined,
+	mentionType:
+		| "file"
+		| "folder"
+		| "url"
+		| "problems"
+		| "terminal"
+		| "git-changes"
+		| "commit",
+	errorType:
+		| "not_found"
+		| "permission_denied"
+		| "network_error"
+		| "parse_error"
+		| "unknown",
+	errorMessage?: string,
+): void {
+	emit(telemetry, LegacyTelemetryEvents.TASK.MENTION_FAILED, {
+		mentionType,
+		errorType,
+		errorMessage: truncateErrorMessage(errorMessage),
+		timestamp: new Date().toISOString(),
+	});
+}
+
+export function captureMentionSearchResults(
+	telemetry: ITelemetryService | undefined,
+	query: string,
+	resultCount: number,
+	searchType: "file" | "folder" | "all",
+	isEmpty: boolean,
+): void {
+	emit(telemetry, LegacyTelemetryEvents.TASK.MENTION_SEARCH_RESULTS, {
+		queryLength: query.length,
+		resultCount,
+		searchType,
+		isEmpty,
+		timestamp: new Date().toISOString(),
+	});
+}
+
+export function captureSubagentExecution(
+	telemetry: ITelemetryService | undefined,
+	properties: {
+		ulid: string;
+		durationMs: number;
+		outputLines: number;
+		success: boolean;
+	},
+): void {
+	emit(
+		telemetry,
+		properties.success
+			? LegacyTelemetryEvents.TASK.SUBAGENT_COMPLETED
+			: LegacyTelemetryEvents.TASK.SUBAGENT_STARTED,
+		{
+			...properties,
+			timestamp: new Date().toISOString(),
+		},
+	);
+}
+
+export function captureHookDiscovery(
+	telemetry: ITelemetryService | undefined,
+	hookName: string,
+	globalCount: number,
+	workspaceCount: number,
+): void {
+	emit(telemetry, LegacyTelemetryEvents.HOOKS.DISCOVERY_COMPLETED, {
+		hookName,
+		globalCount,
+		workspaceCount,
+		totalCount: globalCount + workspaceCount,
+		timestamp: new Date().toISOString(),
+	});
+}