@clinebot/core 0.0.35 → 0.0.36

package/src/services/storage/provider-settings-manager.test.ts

@@ -1,191 +0,0 @@
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import * as LlmsModels from "@clinebot/llms";
-import { afterEach, describe, expect, it } from "vitest";
-import { ProviderSettingsManager } from "./provider-settings-manager";
-
-describe("ProviderSettingsManager", () => {
-	const tempDirs: string[] = [];
-
-	afterEach(() => {
-		LlmsModels.resetRegistry();
-		for (const dir of tempDirs.splice(0)) {
-			rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("persists and restores provider settings", () => {
-		const tempDir = mkdtempSync(
-			path.join(os.tmpdir(), "core-provider-settings-"),
-		);
-		tempDirs.push(tempDir);
-		const filePath = path.join(tempDir, "provider-settings.json");
-		const manager = new ProviderSettingsManager({ filePath });
-
-		manager.saveProviderSettings(
-			{
-				provider: "anthropic",
-				model: "claude-sonnet-4-6",
-				apiKey: "test-key",
-			},
-			{ setLastUsed: true },
-		);
-
-		const reloaded = new ProviderSettingsManager({ filePath });
-		expect(reloaded.getLastUsedProviderSettings()).toEqual({
-			provider: "anthropic",
-			model: "claude-sonnet-4-6",
-			apiKey: "test-key",
-		});
-		expect(reloaded.getProviderConfig("anthropic")?.providerId).toBe(
-			"anthropic",
-		);
-		expect(reloaded.getProviderConfig("anthropic")?.modelId).toBe(
-			"claude-sonnet-4-6",
-		);
-		expect(reloaded.read().providers.anthropic?.tokenSource).toBe("manual");
-	});
-
-	it("migrates legacy provider settings during manager construction", () => {
-		const tempDir = mkdtempSync(
-			path.join(os.tmpdir(), "core-provider-settings-"),
-		);
-		tempDirs.push(tempDir);
-		const filePath = path.join(tempDir, "settings", "providers.json");
-
-		writeFileSync(
-			path.join(tempDir, "globalState.json"),
-			JSON.stringify(
-				{
-					mode: "act",
-					actModeApiProvider: "anthropic",
-					actModeApiModelId: "claude-sonnet-4-6",
-				},
-				null,
-				2,
-			),
-		);
-		writeFileSync(
-			path.join(tempDir, "secrets.json"),
-			JSON.stringify({ apiKey: "legacy-key" }, null, 2),
-		);
-
-		const manager = new ProviderSettingsManager({ filePath, dataDir: tempDir });
-
-		expect(manager.getLastUsedProviderSettings()).toEqual({
-			provider: "anthropic",
-			model: "claude-sonnet-4-6",
-			apiKey: "legacy-key",
-		});
-		expect(manager.read().providers.anthropic?.tokenSource).toBe("migration");
-	});
-
-	it("registers migrated custom providers during manager construction", async () => {
-		const tempDir = mkdtempSync(
-			path.join(os.tmpdir(), "core-provider-settings-"),
-		);
-		tempDirs.push(tempDir);
-		const filePath = path.join(tempDir, "settings", "providers.json");
-
-		writeFileSync(
-			path.join(tempDir, "globalState.json"),
-			JSON.stringify(
-				{
-					mode: "act",
-					actModeApiProvider: "openai",
-					actModeOpenAiModelId: "gpt-oss-120b",
-					openAiBaseUrl: "https://gateway.example.invalid/v1",
-				},
-				null,
-				2,
-			),
-		);
-		writeFileSync(
-			path.join(tempDir, "secrets.json"),
-			JSON.stringify({ openAiApiKey: "legacy-key" }, null, 2),
-		);
-
-		const manager = new ProviderSettingsManager({ filePath, dataDir: tempDir });
-		const providers = await LlmsModels.getAllProviders();
-		const openAiProvider = providers.find(
-			(provider) => provider.id === "openai",
-		);
-
-		expect(manager.getProviderSettings("openai")).toEqual({
-			provider: "openai",
-			model: "gpt-oss-120b",
-			apiKey: "legacy-key",
-			baseUrl: "https://gateway.example.invalid/v1",
-		});
-		expect(openAiProvider).toMatchObject({
-			id: "openai",
-			baseUrl: "https://gateway.example.invalid/v1",
-			defaultModelId: "gpt-oss-120b",
-		});
-	});
-
-	it("tracks provider-specific settings while preserving last-used provider", () => {
-		const tempDir = mkdtempSync(
-			path.join(os.tmpdir(), "core-provider-settings-"),
-		);
-		tempDirs.push(tempDir);
-		const filePath = path.join(tempDir, "provider-settings.json");
-		const manager = new ProviderSettingsManager({ filePath });
-
-		manager.saveProviderSettings({
-			provider: "anthropic",
-			model: "claude-sonnet-4-6",
-		});
-		manager.saveProviderSettings(
-			{
-				provider: "openai-native",
-				model: "gpt-5",
-			},
-			{ setLastUsed: false },
-		);
-
-		expect(manager.getProviderSettings("anthropic")?.model).toBe(
-			"claude-sonnet-4-6",
-		);
-		expect(manager.getProviderSettings("openai-native")?.model).toBe("gpt-5");
-		expect(manager.getLastUsedProviderSettings()?.provider).toBe("anthropic");
-		expect(manager.read().providers["openai-native"]?.tokenSource).toBe(
-			"manual",
-		);
-	});
-
-	it("allows overriding token source metadata", () => {
-		const tempDir = mkdtempSync(
-			path.join(os.tmpdir(), "core-provider-settings-"),
-		);
-		tempDirs.push(tempDir);
-		const filePath = path.join(tempDir, "provider-settings.json");
-		const manager = new ProviderSettingsManager({ filePath });
-
-		manager.saveProviderSettings(
-			{
-				provider: "openai-codex",
-				apiKey: "oauth-token",
-			},
-			{ tokenSource: "oauth" },
-		);
-
-		expect(manager.read().providers["openai-codex"]?.tokenSource).toBe("oauth");
-	});
-
-	it("ignores invalid persisted JSON and falls back to empty state", () => {
-		const tempDir = mkdtempSync(
-			path.join(os.tmpdir(), "core-provider-settings-"),
-		);
-		tempDirs.push(tempDir);
-		const filePath = path.join(tempDir, "provider-settings.json");
-		writeFileSync(filePath, "{ not-json", "utf8");
-
-		const manager = new ProviderSettingsManager({ filePath });
-		expect(manager.read()).toEqual({
-			version: 1,
-			providers: {},
-		});
-	});
-});

package/src/services/telemetry/OpenTelemetryAdapter.test.ts

@@ -1,157 +0,0 @@
-import type { LoggerProvider } from "@opentelemetry/sdk-logs";
-import type { MeterProvider } from "@opentelemetry/sdk-metrics";
-import { describe, expect, it, vi } from "vitest";
-import { OpenTelemetryAdapter } from "./OpenTelemetryAdapter";
-
-describe("OpenTelemetryAdapter", () => {
-	it("emits events in the telemetry service log format", () => {
-		const emit = vi.fn();
-		const adapter = new OpenTelemetryAdapter({
-			metadata: makeMetadata(),
-			distinctId: "user-123",
-			commonProperties: {
-				organization_id: "org-1",
-			},
-			loggerProvider: {
-				getLogger: () => ({ emit }),
-			} as unknown as LoggerProvider,
-		});
-
-		adapter.emit("task.created", {
-			ulid: "01HXYZ",
-			nested: {
-				mode: "act",
-			},
-			items: ["a", "b"],
-			nullable: null,
-		});
-
-		expect(emit).toHaveBeenCalledWith({
-			severityText: "INFO",
-			body: "task.created",
-			attributes: expect.objectContaining({
-				ulid: "01HXYZ",
-				"nested.mode": "act",
-				items: JSON.stringify(["a", "b"]),
-				nullable: "null",
-				distinct_id: "user-123",
-				organization_id: "org-1",
-				extension_version: "1.2.3",
-				cline_type: "cli",
-				platform: "terminal",
-			}),
-		});
-	});
-
-	it("marks required events with the expected flag", () => {
-		const emit = vi.fn();
-		const adapter = new OpenTelemetryAdapter({
-			metadata: makeMetadata(),
-			loggerProvider: {
-				getLogger: () => ({ emit }),
-			} as unknown as LoggerProvider,
-			enabled: false,
-		});
-
-		adapter.emitRequired("user.opt_out");
-
-		expect(emit).toHaveBeenCalledWith({
-			severityText: "INFO",
-			body: "user.opt_out",
-			attributes: expect.objectContaining({
-				_required: true,
-			}),
-		});
-	});
-
-	it("records metrics with merged telemetry attributes and retires gauge series", () => {
-		const counterAdd = vi.fn();
-		const histogramRecord = vi.fn();
-		let gaugeCallback:
-			| ((result: {
-					observe: (
-						value: number,
-						attributes?: Record<string, string | number | boolean>,
-					) => void;
-			  }) => void)
-			| undefined;
-
-		const forceFlush = vi.fn().mockResolvedValue(undefined);
-		const shutdown = vi.fn().mockResolvedValue(undefined);
-
-		const adapter = new OpenTelemetryAdapter({
-			metadata: makeMetadata(),
-			distinctId: "user-123",
-			meterProvider: {
-				getMeter: () =>
-					({
-						createCounter: () => ({ add: counterAdd }),
-						createHistogram: () => ({ record: histogramRecord }),
-						createObservableGauge: () => ({
-							addCallback: (callback: typeof gaugeCallback) => {
-								gaugeCallback = callback;
-							},
-						}),
-					}) as never,
-				forceFlush,
-				shutdown,
-			} as unknown as MeterProvider,
-		});
-
-		adapter.recordCounter("cline.turns.total", 2, { ulid: "01HXYZ" });
-		adapter.recordHistogram("cline.api.duration.seconds", 1.5, {
-			ulid: "01HXYZ",
-		});
-		adapter.recordGauge("cline.workspace.active_roots", 3, { workspace: "a" });
-
-		expect(counterAdd).toHaveBeenCalledWith(
-			2,
-			expect.objectContaining({
-				ulid: "01HXYZ",
-				distinct_id: "user-123",
-				extension_version: "1.2.3",
-			}),
-		);
-		expect(histogramRecord).toHaveBeenCalledWith(
-			1.5,
-			expect.objectContaining({
-				ulid: "01HXYZ",
-				distinct_id: "user-123",
-			}),
-		);
-
-		const observe = vi.fn();
-		gaugeCallback?.({ observe });
-		expect(observe).toHaveBeenCalledWith(
-			3,
-			expect.objectContaining({
-				workspace: "a",
-				distinct_id: "user-123",
-			}),
-		);
-
-		adapter.recordGauge("cline.workspace.active_roots", null, {
-			workspace: "a",
-		});
-		const observeAfterRetire = vi.fn();
-		gaugeCallback?.({ observe: observeAfterRetire });
-		expect(observeAfterRetire).not.toHaveBeenCalled();
-
-		return Promise.all([adapter.flush(), adapter.dispose()]).then(() => {
-			expect(forceFlush).toHaveBeenCalledTimes(1);
-			expect(shutdown).toHaveBeenCalledTimes(1);
-		});
-	});
-});
-
-function makeMetadata() {
-	return {
-		extension_version: "1.2.3",
-		cline_type: "cli",
-		platform: "terminal",
-		platform_version: "1.0.0",
-		os_type: "darwin",
-		os_version: "24.0.0",
-		is_dev: "true",
-	};
-}

package/src/services/telemetry/OpenTelemetryProvider.test.ts

@@ -1,326 +0,0 @@
-import type { BasicLogger } from "@clinebot/shared";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import {
-	createConfiguredTelemetryService,
-	createOpenTelemetryTelemetryService,
-	OpenTelemetryProvider,
-} from "./OpenTelemetryProvider";
-import { TelemetryService } from "./TelemetryService";
-
-describe("createOpenTelemetryTelemetryService", () => {
-	afterEach(() => {
-		vi.restoreAllMocks();
-	});
-
-	it("logs a provider creation event during bootstrap", async () => {
-		const captureRequired = vi
-			.spyOn(TelemetryService.prototype, "captureRequired")
-			.mockImplementation(() => {});
-
-		const { provider } = createOpenTelemetryTelemetryService({
-			metadata: {
-				extension_version: "1.2.3",
-				cline_type: "cli",
-				platform: "terminal",
-				platform_version: process.version,
-				os_type: process.platform,
-				os_version: "unknown",
-			},
-			enabled: true,
-			logsExporter: "console",
-			metricsExporter: "otlp",
-			otlpProtocol: "http/json",
-			otlpEndpoint: "http://localhost:4318",
-			serviceName: "cline-cli",
-			serviceVersion: "1.2.3",
-		});
-
-		expect(captureRequired).toHaveBeenCalledWith(
-			"telemetry.provider_created",
-			expect.objectContaining({
-				provider: "opentelemetry",
-				enabled: true,
-				logsExporter: "console",
-				metricsExporter: "otlp",
-				otlpProtocol: "http/json",
-				hasOtlpEndpoint: true,
-				serviceName: "cline-cli",
-				serviceVersion: "1.2.3",
-			}),
-		);
-
-		await provider.dispose();
-	});
-
-	it("registers a tracer provider when tracesExporter is set", async () => {
-		const { provider } = createOpenTelemetryTelemetryService({
-			metadata: {
-				extension_version: "1.2.3",
-				cline_type: "cli",
-				platform: "terminal",
-				platform_version: process.version,
-				os_type: process.platform,
-				os_version: "unknown",
-			},
-			enabled: true,
-			tracesExporter: "console",
-			logsExporter: "console",
-			metricsExporter: "console",
-			serviceName: "cline-test",
-		});
-
-		expect(provider.tracerProvider).not.toBeNull();
-		const span = provider.getTracer("test").startSpan("verify.tracing");
-		span.end();
-		await provider.dispose();
-	});
-
-	it("does not create an OTEL provider when disabled", () => {
-		const providerSpy = vi.spyOn(
-			OpenTelemetryProvider.prototype,
-			"createTelemetryService",
-		);
-
-		const { telemetry, provider } = createConfiguredTelemetryService({
-			metadata: {
-				extension_version: "1.2.3",
-				cline_type: "cli",
-				platform: "terminal",
-				platform_version: process.version,
-				os_type: process.platform,
-				os_version: "unknown",
-			},
-			enabled: false,
-		});
-
-		expect(provider).toBeUndefined();
-		expect(providerSpy).not.toHaveBeenCalled();
-		expect(telemetry).toBeInstanceOf(TelemetryService);
-	});
-
-	it("preserves metadata when disabled", () => {
-		const metadata = {
-			extension_version: "1.0.0",
-			cline_type: "kanban",
-			platform: "kanban",
-			platform_version: "v22.0.0",
-			os_type: "darwin",
-			os_version: "15.0",
-		};
-		const { telemetry } = createConfiguredTelemetryService({
-			metadata,
-			enabled: false,
-		});
-		const spy = vi.fn();
-		(telemetry as any).adapters.push({
-			name: "test",
-			emit: spy,
-			emitRequired: spy,
-			isEnabled: () => true,
-			recordCounter: vi.fn(),
-			recordHistogram: vi.fn(),
-			recordGauge: vi.fn(),
-			flush: async () => {},
-			dispose: async () => {},
-		});
-		telemetry.captureRequired("test.event", {});
-		expect(spy).toHaveBeenCalledWith(
-			"test.event",
-			expect.objectContaining({
-				cline_type: "kanban",
-				platform: "kanban",
-			}),
-		);
-	});
-
-	it("preserves metadata in the enabled (OTEL) path", async () => {
-		const metadata = {
-			extension_version: "1.0.0",
-			cline_type: "kanban",
-			platform: "kanban",
-			platform_version: "v22.0.0",
-			os_type: "darwin",
-			os_version: "15.0",
-		};
-		const { telemetry, provider } = createOpenTelemetryTelemetryService({
-			metadata,
-			enabled: true,
-			logsExporter: "console",
-		});
-		const spy = vi.fn();
-		(telemetry as any).adapters.push({
-			name: "test",
-			emit: spy,
-			emitRequired: spy,
-			isEnabled: () => true,
-			recordCounter: vi.fn(),
-			recordHistogram: vi.fn(),
-			recordGauge: vi.fn(),
-			flush: async () => {},
-			dispose: async () => {},
-		});
-		telemetry.captureRequired("test.event", {});
-		expect(spy).toHaveBeenCalledWith(
-			"test.event",
-			expect.objectContaining({
-				cline_type: "kanban",
-				platform: "kanban",
-			}),
-		);
-		await provider.dispose();
-	});
-
-	it("delivers metadata to the OTEL logger without duplication", async () => {
-		const otelEmit = vi.fn();
-		const provider = new OpenTelemetryProvider({
-			enabled: true,
-		});
-		// Replace the loggerProvider with a mock so we can inspect emit calls
-		(provider as any).loggerProvider = {
-			getLogger: () => ({ emit: otelEmit }),
-			forceFlush: async () => {},
-			shutdown: async () => {},
-		};
-
-		const metadata = {
-			extension_version: "1.0.0",
-			cline_type: "kanban",
-			platform: "kanban",
-			platform_version: "v22.0.0",
-			os_type: "darwin",
-			os_version: "15.0",
-		};
-
-		const telemetry = provider.createTelemetryService({ metadata });
-
-		telemetry.captureRequired("test.otel_event", { custom_prop: "value" });
-
-		expect(otelEmit).toHaveBeenCalledTimes(1);
-		const emittedAttributes = otelEmit.mock.calls[0][0].attributes;
-
-		// Metadata fields must be present
-		expect(emittedAttributes).toMatchObject({
-			cline_type: "kanban",
-			platform: "kanban",
-			extension_version: "1.0.0",
-			custom_prop: "value",
-		});
-
-		// Verify no key appears more than once (flattened object can't have
-		// duplicate keys, but this guards against nested duplication patterns
-		// like metadata appearing under a sub-prefix)
-		const keys = Object.keys(emittedAttributes);
-		const metadataKeys = Object.keys(metadata);
-		for (const mk of metadataKeys) {
-			const occurrences = keys.filter((k) => k === mk || k.endsWith(`.${mk}`));
-			expect(
-				occurrences,
-				`metadata key "${mk}" should appear exactly once, found: ${occurrences.join(", ")}`,
-			).toHaveLength(1);
-		}
-
-		await provider.dispose();
-	});
-
-	it("propagates updateMetadata to OTEL logger output", async () => {
-		const otelEmit = vi.fn();
-		const provider = new OpenTelemetryProvider({
-			enabled: true,
-		});
-		(provider as any).loggerProvider = {
-			getLogger: () => ({ emit: otelEmit }),
-			forceFlush: async () => {},
-			shutdown: async () => {},
-		};
-
-		const metadata = {
-			extension_version: "1.0.0",
-			cline_type: "kanban",
-			platform: "kanban",
-			platform_version: "v22.0.0",
-			os_type: "darwin",
-			os_version: "15.0",
-		};
-
-		const telemetry = provider.createTelemetryService({ metadata });
-
-		// Update metadata after construction
-		telemetry.updateMetadata({ cline_type: "kanban-updated" });
-
-		telemetry.captureRequired("test.updated_event", {});
-
-		// The OTEL logger should see the updated value
-		const emittedAttributes =
-			otelEmit.mock.calls[otelEmit.mock.calls.length - 1][0].attributes;
-		expect(emittedAttributes.cline_type).toBe("kanban-updated");
-
-		await provider.dispose();
-	});
-
-	it("preserves logger when disabled", () => {
-		const logger: BasicLogger = {
-			debug: vi.fn(),
-			log: vi.fn(),
-			error: vi.fn(),
-		};
-		const { telemetry } = createConfiguredTelemetryService({
-			metadata: {
-				extension_version: "1.0.0",
-				cline_type: "kanban",
-				platform: "kanban",
-				platform_version: "v22.0.0",
-				os_type: "darwin",
-				os_version: "15.0",
-			},
-			enabled: false,
-			logger,
-		});
-
-		telemetry.capture({
-			event: "session.started",
-			properties: { sessionId: "session-1" },
-		});
-
-		expect(logger.log).toHaveBeenCalledWith(
-			"telemetry.event",
-			expect.objectContaining({
-				event: "session.started",
-			}),
-		);
-	});
-
-	it("attaches the logger adapter when creating configured telemetry", () => {
-		const logger: BasicLogger = {
-			debug: vi.fn(),
-			log: vi.fn(),
-			error: vi.fn(),
-		};
-		const { telemetry, provider } = createConfiguredTelemetryService({
-			metadata: {
-				extension_version: "1.2.3",
-				cline_type: "cli",
-				platform: "terminal",
-				platform_version: process.version,
-				os_type: process.platform,
-				os_version: "unknown",
-			},
-			enabled: true,
-			logsExporter: "console",
-			logger,
-		});
-
-		telemetry.capture({
-			event: "session.started",
-			properties: { sessionId: "session-1" },
-		});
-
-		expect(logger.log).toHaveBeenCalledWith(
-			"telemetry.event",
-			expect.objectContaining({
-				event: "session.started",
-			}),
-		);
-
-		return provider?.dispose();
-	});
-});

package/src/services/telemetry/TelemetryLoggerSink.test.ts

@@ -1,42 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { TelemetryLoggerSink } from "./TelemetryLoggerSink";
-
-describe("TelemetryLoggerSink", () => {
-	it("logs events and metrics through the provided logger", async () => {
-		const logger = {
-			debug: vi.fn(),
-			log: vi.fn(),
-		};
-		const sink = new TelemetryLoggerSink({ logger });
-
-		sink.emit("session.started", { sessionId: "s1" });
-		sink.emitRequired("user.opt_out", { reason: "manual" });
-		sink.recordCounter("cline.session.starts.total", 1, {
-			sessionId: "s1",
-		});
-
-		expect(logger.log).toHaveBeenCalledWith("telemetry.event", {
-			telemetrySink: "TelemetryLoggerSink",
-			event: "session.started",
-			properties: { sessionId: "s1" },
-		});
-		expect(logger.log).toHaveBeenCalledWith("telemetry.required_event", {
-			telemetrySink: "TelemetryLoggerSink",
-			severity: "warn",
-			event: "user.opt_out",
-			properties: { reason: "manual" },
-		});
-		expect(logger.debug).toHaveBeenCalledWith("telemetry.metric", {
-			telemetrySink: "TelemetryLoggerSink",
-			instrument: "counter",
-			name: "cline.session.starts.total",
-			value: 1,
-			attributes: { sessionId: "s1" },
-			description: undefined,
-			required: false,
-		});
-
-		await sink.flush();
-		await sink.dispose();
-	});
-});