@clinebot/core 0.0.34 → 0.0.36

package/src/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/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/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();
-	});
-});

package/src/telemetry/TelemetryService.test.ts

@@ -1,134 +0,0 @@
-import type { BasicLogger } from "@clinebot/shared";
-import { describe, expect, it, vi } from "vitest";
-import type { ITelemetryAdapter } from "./ITelemetryAdapter";
-import { TelemetryService } from "./TelemetryService";
-
-describe("TelemetryService", () => {
-	it("merges metadata and forwards calls to adapters", async () => {
-		const { adapter, emit, recordCounter } = createAdapter();
-		const service = new TelemetryService({
-			adapters: [adapter],
-			metadata: {
-				extension_version: "1.2.3",
-				cline_type: "cli",
-			},
-			distinctId: "distinct-1",
-			commonProperties: {
-				organization_id: "org-1",
-			},
-		});
-
-		service.capture({
-			event: "session.started",
-			properties: { sessionId: "session-1" },
-		});
-		service.recordCounter("cline.session.starts.total", 1, {
-			sessionId: "session-1",
-		});
-		await service.flush();
-		await service.dispose();
-
-		expect(emit).toHaveBeenCalledWith(
-			"session.started",
-			expect.objectContaining({
-				sessionId: "session-1",
-				organization_id: "org-1",
-				extension_version: "1.2.3",
-				cline_type: "cli",
-				distinct_id: "distinct-1",
-			}),
-		);
-		expect(recordCounter).toHaveBeenCalledWith(
-			"cline.session.starts.total",
-			1,
-			expect.objectContaining({
-				sessionId: "session-1",
-				distinct_id: "distinct-1",
-			}),
-			undefined,
-			false,
-		);
-	});
-
-	it("mirrors telemetry events into the logger when provided", () => {
-		const logger: BasicLogger = {
-			debug: vi.fn(),
-			log: vi.fn(),
-			error: vi.fn(),
-		};
-		const service = new TelemetryService({
-			logger,
-			metadata: {
-				extension_version: "1.2.3",
-				cline_type: "cli",
-			},
-			distinctId: "distinct-1",
-		});
-
-		service.capture({
-			event: "session.started",
-			properties: { sessionId: "session-1" },
-		});
-		service.captureRequired("user.opt_out", { reason: "manual" });
-		service.recordCounter("cline.session.starts.total", 1, {
-			sessionId: "session-1",
-		});
-
-		expect(logger.log).toHaveBeenCalledWith(
-			"telemetry.event",
-			expect.objectContaining({
-				telemetrySink: "TelemetryLoggerSink",
-				event: "session.started",
-				properties: expect.objectContaining({
-					sessionId: "session-1",
-					extension_version: "1.2.3",
-					distinct_id: "distinct-1",
-				}),
-			}),
-		);
-		expect(logger.log).toHaveBeenCalledWith(
-			"telemetry.required_event",
-			expect.objectContaining({
-				telemetrySink: "TelemetryLoggerSink",
-				severity: "warn",
-				event: "user.opt_out",
-				properties: expect.objectContaining({
-					reason: "manual",
-					extension_version: "1.2.3",
-				}),
-			}),
-		);
-		expect(logger.debug).toHaveBeenCalledWith(
-			"telemetry.metric",
-			expect.objectContaining({
-				telemetrySink: "TelemetryLoggerSink",
-				instrument: "counter",
-				name: "cline.session.starts.total",
-			}),
-		);
-	});
-});
-
-function createAdapter(): {
-	adapter: ITelemetryAdapter;
-	emit: ReturnType<typeof vi.fn>;
-	recordCounter: ReturnType<typeof vi.fn>;
-} {
-	const emit = vi.fn();
-	const recordCounter = vi.fn();
-	return {
-		adapter: {
-			name: "test",
-			emit,
-			emitRequired: vi.fn(),
-			recordCounter,
-			recordHistogram: vi.fn(),
-			recordGauge: vi.fn(),
-			isEnabled: vi.fn(() => true),
-			flush: vi.fn().mockResolvedValue(undefined),
-			dispose: vi.fn().mockResolvedValue(undefined),
-		},
-		emit,
-		recordCounter,
-	};
-}

package/src/telemetry/distinct-id.test.ts

@@ -1,57 +0,0 @@
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-const machineIdSyncMock = vi.hoisted(() => vi.fn());
-
-vi.mock("node-machine-id", () => ({
-	machineIdSync: machineIdSyncMock,
-}));
-
-describe("resolveCoreDistinctId", () => {
-	beforeEach(() => {
-		vi.resetModules();
-	});
-
-	afterEach(() => {
-		machineIdSyncMock.mockReset();
-		vi.unstubAllEnvs();
-		vi.restoreAllMocks();
-	});
-
-	it("returns the explicit distinct ID override when provided", async () => {
-		const { resolveCoreDistinctId } = await import("./distinct-id");
-
-		expect(resolveCoreDistinctId("  user-provided-id  ")).toBe(
-			"user-provided-id",
-		);
-		expect(machineIdSyncMock).not.toHaveBeenCalled();
-	});
-
-	it("uses node-machine-id when no explicit override is provided", async () => {
-		machineIdSyncMock.mockReturnValue("machine-id-123");
-		const { resolveCoreDistinctId } = await import("./distinct-id");
-
-		expect(resolveCoreDistinctId()).toBe("machine-id-123");
-	});
-
-	it("persists and reuses a generated fallback when machine ID lookup fails", async () => {
-		const tempDir = mkdtempSync(join(tmpdir(), "cline-distinct-id-"));
-		try {
-			vi.stubEnv("CLINE_DATA_DIR", tempDir);
-			machineIdSyncMock.mockImplementation(() => {
-				throw new Error("machine id unavailable");
-			});
-
-			const { resolveCoreDistinctId } = await import("./distinct-id");
-			const first = resolveCoreDistinctId();
-			const second = resolveCoreDistinctId();
-
-			expect(first).toMatch(/^cl-/);
-			expect(second).toBe(first);
-		} finally {
-			rmSync(tempDir, { recursive: true, force: true });
-		}
-	});
-});