@sctg/cline-core 3.84.0-beta.20260524130712

package/dist/services/telemetry/OpenTelemetryAdapter.d.ts

@@ -0,0 +1,43 @@
+import type { LoggerProvider } from "@opentelemetry/sdk-logs";
+import type { MeterProvider } from "@opentelemetry/sdk-metrics";
+import type { ITelemetryAdapter, TelemetryMetadata, TelemetryProperties } from "./ITelemetryAdapter";
+export interface OpenTelemetryAdapterOptions {
+    readonly metadata: TelemetryMetadata;
+    readonly meterProvider?: MeterProvider | null;
+    readonly loggerProvider?: LoggerProvider | null;
+    readonly name?: string;
+    readonly enabled?: boolean | (() => boolean);
+    readonly distinctId?: string;
+    readonly commonProperties?: TelemetryProperties;
+}
+export declare class OpenTelemetryAdapter implements ITelemetryAdapter {
+    readonly name: string;
+    private readonly metadata;
+    private readonly meter;
+    private readonly logger;
+    private readonly enabled;
+    private distinctId?;
+    private commonProperties;
+    private counters;
+    private histograms;
+    private gauges;
+    private gaugeValues;
+    private readonly meterProvider?;
+    private readonly loggerProvider?;
+    constructor(options: OpenTelemetryAdapterOptions);
+    emit(event: string, properties?: TelemetryProperties): void;
+    emitRequired(event: string, properties?: TelemetryProperties): void;
+    recordCounter(name: string, value: number, attributes?: TelemetryProperties, description?: string, required?: boolean): void;
+    recordHistogram(name: string, value: number, attributes?: TelemetryProperties, description?: string, required?: boolean): void;
+    recordGauge(name: string, value: number | null, attributes?: TelemetryProperties, description?: string, required?: boolean): void;
+    isEnabled(): boolean;
+    setDistinctId(distinctId?: string): void;
+    setCommonProperties(properties: TelemetryProperties): void;
+    updateCommonProperties(properties: TelemetryProperties): void;
+    flush(): Promise<void>;
+    dispose(): Promise<void>;
+    private emitLog;
+    private buildAttributes;
+    private snapshotGaugeSeries;
+    private flattenProperties;
+}

package/dist/services/telemetry/OpenTelemetryProvider.d.ts

@@ -0,0 +1,83 @@
+import type { BasicLogger, ITelemetryService, OpenTelemetryClientConfig, TelemetryMetadata } from "@cline/shared";
+import { type Tracer } from "@opentelemetry/api";
+import { LoggerProvider } from "@opentelemetry/sdk-logs";
+import { MeterProvider } from "@opentelemetry/sdk-metrics";
+import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
+import { OpenTelemetryAdapter, type OpenTelemetryAdapterOptions } from "./OpenTelemetryAdapter";
+type OpenTelemetryExporterKind = "console" | "otlp";
+export interface OpenTelemetryProviderOptions extends Omit<OpenTelemetryClientConfig, "enabled" | "logsExporter" | "metricsExporter" | "tracesExporter"> {
+    serviceName?: string;
+    serviceVersion?: string;
+    enabled?: boolean;
+    logsExporter?: string | OpenTelemetryExporterKind[];
+    metricsExporter?: string | OpenTelemetryExporterKind[];
+    tracesExporter?: string | OpenTelemetryExporterKind[];
+    metricExportIntervalMs?: number;
+    logMaxQueueSize?: number;
+    logBatchSize?: number;
+    logBatchTimeoutMs?: number;
+}
+export interface CreateOpenTelemetryTelemetryServiceOptions extends OpenTelemetryProviderOptions, Pick<OpenTelemetryAdapterOptions, "name" | "distinctId" | "commonProperties"> {
+    metadata: TelemetryMetadata;
+    logger?: BasicLogger;
+}
+export declare class OpenTelemetryProvider {
+    readonly meterProvider: MeterProvider | null;
+    readonly loggerProvider: LoggerProvider | null;
+    readonly tracerProvider: NodeTracerProvider | null;
+    private readonly options;
+    constructor(options?: OpenTelemetryProviderOptions);
+    /**
+     * Returns a tracer for manual spans. Requires {@link OpenTelemetryProviderOptions.tracesExporter}
+     * so that a {@link NodeTracerProvider} is registered.
+     */
+    getTracer(name?: string, version?: string): Tracer;
+    createAdapter(options: Omit<OpenTelemetryAdapterOptions, "meterProvider" | "loggerProvider">): OpenTelemetryAdapter;
+    createTelemetryService(options: Omit<CreateOpenTelemetryTelemetryServiceOptions, keyof OpenTelemetryProviderOptions>): ITelemetryService;
+    forceFlush(): Promise<void>;
+    dispose(): Promise<void>;
+    private createMeterProvider;
+    private createTracerProvider;
+    private createLoggerProvider;
+}
+export declare function createOpenTelemetryTelemetryService(options: CreateOpenTelemetryTelemetryServiceOptions): {
+    provider: OpenTelemetryProvider;
+    telemetry: ITelemetryService;
+};
+export declare function createConfiguredTelemetryService(options: CreateOpenTelemetryTelemetryServiceOptions): {
+    provider?: OpenTelemetryProvider;
+    telemetry: ITelemetryService;
+};
+/**
+ * Telemetry service plus the lifecycle closures (`flush`, `dispose`) every
+ * host needs to drive the underlying provider during shutdown. Returned by
+ * {@link createConfiguredTelemetryHandle} so detached daemons, the VS Code
+ * extension, and the CLI can share one canonical implementation of the
+ * "best-effort flush; settle dispose" semantics instead of each
+ * re-implementing the same closures.
+ */
+export interface ConfiguredTelemetryHandle {
+    readonly telemetry: ITelemetryService;
+    /**
+     * The underlying OpenTelemetry provider, when telemetry is enabled.
+     * `undefined` when telemetry is disabled or opted out so callers can
+     * detect the inactive case without inspecting `enabled` themselves.
+     */
+    readonly provider?: OpenTelemetryProvider;
+    /**
+     * Best-effort flush of any pending telemetry batches. Errors are
+     * swallowed so callers can `await` this in shutdown paths without
+     * blocking deactivation on a misbehaving exporter.
+     */
+    flush: () => Promise<void>;
+    /** Disposes the telemetry service and its provider concurrently. */
+    dispose: () => Promise<void>;
+}
+/**
+ * Builds a {@link ConfiguredTelemetryHandle} so hosts (CLI, VS Code, hub
+ * daemon) share one canonical flush/dispose implementation. Without a
+ * shared helper each host re-derived the same closures and they tended
+ * to drift; this factory keeps the lifecycle uniform across hosts.
+ */
+export declare function createConfiguredTelemetryHandle(options: CreateOpenTelemetryTelemetryServiceOptions): ConfiguredTelemetryHandle;
+export {};

package/dist/services/telemetry/TelemetryLoggerSink.d.ts

@@ -0,0 +1,27 @@
+import type { BasicLogger } from "@cline/shared";
+import type { ITelemetryAdapter, TelemetryProperties } from "./ITelemetryAdapter";
+/**
+ * {@link ITelemetryAdapter} implementation that forwards telemetry to a {@link BasicLogger}.
+ *
+ * This is intentionally named *Sink* (not "adapter") to distinguish it from host logging bridges
+ * such as the CLI Pino bundle: it consumes telemetry events and writes them to the injected logger.
+ */
+export interface TelemetryLoggerSinkOptions {
+    logger?: BasicLogger;
+    name?: string;
+    enabled?: boolean | (() => boolean);
+}
+export declare class TelemetryLoggerSink implements ITelemetryAdapter {
+    readonly name: string;
+    private readonly logger?;
+    private readonly enabled;
+    constructor(options?: TelemetryLoggerSinkOptions);
+    emit(event: string, properties?: TelemetryProperties): void;
+    emitRequired(event: string, properties?: TelemetryProperties): void;
+    recordCounter(name: string, value: number, attributes?: TelemetryProperties, description?: string, required?: boolean): void;
+    recordHistogram(name: string, value: number, attributes?: TelemetryProperties, description?: string, required?: boolean): void;
+    recordGauge(name: string, value: number | null, attributes?: TelemetryProperties, description?: string, required?: boolean): void;
+    isEnabled(): boolean;
+    flush(): Promise<void>;
+    dispose(): Promise<void>;
+}

package/dist/services/telemetry/TelemetryService.d.ts

@@ -0,0 +1,34 @@
+import type { BasicLogger, ITelemetryService, TelemetryMetadata, TelemetryProperties } from "@cline/shared";
+import type { ITelemetryAdapter } from "./ITelemetryAdapter";
+export interface TelemetryServiceOptions {
+    adapters?: ITelemetryAdapter[];
+    metadata?: Partial<TelemetryMetadata>;
+    distinctId?: string;
+    commonProperties?: TelemetryProperties;
+    logger?: BasicLogger;
+}
+export declare class TelemetryService implements ITelemetryService {
+    private adapters;
+    private metadata;
+    private distinctId?;
+    private commonProperties;
+    constructor(options?: TelemetryServiceOptions);
+    addAdapter(adapter: ITelemetryAdapter): void;
+    setDistinctId(distinctId?: string): void;
+    setMetadata(metadata: Partial<TelemetryMetadata>): void;
+    updateMetadata(metadata: Partial<TelemetryMetadata>): void;
+    setCommonProperties(properties: TelemetryProperties): void;
+    updateCommonProperties(properties: TelemetryProperties): void;
+    isEnabled(): boolean;
+    capture(input: {
+        event: string;
+        properties?: TelemetryProperties;
+    }): void;
+    captureRequired(event: string, properties?: TelemetryProperties): void;
+    recordCounter(name: string, value: number, attributes?: TelemetryProperties, description?: string, required?: boolean): void;
+    recordHistogram(name: string, value: number, attributes?: TelemetryProperties, description?: string, required?: boolean): void;
+    recordGauge(name: string, value: number | null, attributes?: TelemetryProperties, description?: string, required?: boolean): void;
+    flush(): Promise<void>;
+    dispose(): Promise<void>;
+    private buildAttributes;
+}

package/dist/services/telemetry/core-events.d.ts

@@ -0,0 +1,276 @@
+import { type ITelemetryService, type TelemetryProperties } from "@cline/shared";
+export type TelemetryAgentKind = "root" | "subagent" | "team_lead" | "team_teammate";
+export interface TelemetryAgentIdentityProperties {
+    agentId: string;
+    agentKind: TelemetryAgentKind;
+    conversationId?: string;
+    parentAgentId?: string;
+    createdByAgentId?: string;
+    isSubagent: boolean;
+    teamId?: string;
+    teamName?: string;
+    teamRole?: "lead" | "teammate";
+    teamAgentId?: string;
+}
+export declare const CORE_TELEMETRY_EVENTS: {
+    readonly CLIENT: {
+        readonly EXTENSION_ACTIVATED: "user.extension_activated";
+    };
+    readonly SESSION: {
+        readonly STARTED: "session.started";
+        readonly ENDED: "session.ended";
+    };
+    readonly USER: {
+        readonly AUTH_STARTED: "user.auth_started";
+        readonly AUTH_SUCCEEDED: "user.auth_succeeded";
+        readonly AUTH_FAILED: "user.auth_failed";
+        readonly AUTH_LOGGED_OUT: "user.auth_logged_out";
+        readonly PROVIDER_CONFIGURED: "user.provider_configured";
+        readonly TELEMETRY_OPT_OUT: "user.opt_out";
+    };
+    readonly TASK: {
+        readonly CREATED: "task.created";
+        readonly RESTARTED: "task.restarted";
+        readonly COMPLETED: "task.completed";
+        readonly CONVERSATION_TURN: "task.conversation_turn";
+        readonly TOKEN_USAGE: "task.tokens";
+        readonly MODE_SWITCH: "task.mode";
+        readonly TOOL_USED: "task.tool_used";
+        readonly SKILL_USED: "task.skill_used";
+        readonly DIFF_EDIT_FAILED: "task.diff_edit_failed";
+        readonly PROVIDER_API_ERROR: "task.provider_api_error";
+        readonly MENTION_USED: "task.mention_used";
+        readonly MENTION_FAILED: "task.mention_failed";
+        readonly MENTION_SEARCH_RESULTS: "task.mention_search_results";
+        readonly AGENT_CREATED: "task.agent_created";
+        readonly AGENT_TEAM_CREATED: "task.agent_team_created";
+        readonly SUBAGENT_STARTED: "task.subagent_started";
+        readonly SUBAGENT_COMPLETED: "task.subagent_completed";
+        readonly COMPACTION_EXECUTED: "task.compaction_executed";
+        readonly COMPACTION_SKIPPED: "task.compaction_skipped";
+    };
+    readonly HOOKS: {
+        readonly DISCOVERY_COMPLETED: "hooks.discovery_completed";
+    };
+    readonly WORKSPACE: {
+        readonly INITIALIZED: "workspace.initialized";
+        readonly INIT_ERROR: "workspace.init_error";
+        readonly PATH_RESOLVED: "workspace.path_resolved";
+    };
+    readonly SDK: {
+        readonly ERROR: "sdk.error";
+    };
+};
+export interface WorkspaceInitializedProperties {
+    root_count: number;
+    vcs_types: ReadonlyArray<string>;
+    init_duration_ms?: number;
+    feature_flag_enabled?: boolean;
+    is_remote_workspace?: boolean;
+}
+export interface WorkspaceInitErrorProperties {
+    fallback_to_single_root: boolean;
+    workspace_count?: number;
+}
+export interface WorkspacePathResolvedProperties {
+    ulid: string;
+    context: string;
+    resolution_type: "hint_provided" | "fallback_to_primary" | "cross_workspace_search";
+    hint_type?: "workspace_name" | "workspace_path" | "invalid";
+    resolution_success?: boolean;
+    target_workspace_index?: number;
+    is_multi_root_enabled?: boolean;
+}
+export declare function captureExtensionActivated(telemetry: ITelemetryService | undefined): void;
+export declare function captureWorkspaceInitialized(telemetry: ITelemetryService | undefined, properties: WorkspaceInitializedProperties): void;
+export declare function captureWorkspaceInitError(telemetry: ITelemetryService | undefined, error: Error | string, properties: WorkspaceInitErrorProperties): void;
+export declare function captureWorkspacePathResolved(telemetry: ITelemetryService | undefined, properties: WorkspacePathResolvedProperties): void;
+export declare function captureAuthStarted(telemetry: ITelemetryService | undefined, provider?: string): void;
+export declare function captureAuthSucceeded(telemetry: ITelemetryService | undefined, provider?: string): void;
+export declare function captureAuthFailed(telemetry: ITelemetryService | undefined, provider?: string, errorMessage?: string): void;
+export declare function captureAuthLoggedOut(telemetry: ITelemetryService | undefined, provider?: string, reason?: string): void;
+/**
+ * Fires when the user finishes configuring a "bring your own provider"
+ * (API-key based) provider during onboarding or via settings.
+ *
+ * Unlike the OAuth/device-code `captureAuth*` events, the configure step is a
+ * synchronous local credential save with no network roundtrip, so there is no
+ * start/fail counterpart — the credential is validated lazily on the first
+ * subsequent API call. Mirrors the `{ provider }` payload shape of
+ * {@link captureAuthSucceeded} for funnel consistency.
+ */
+export declare function captureProviderConfigured(telemetry: ITelemetryService | undefined, provider?: string): void;
+export declare function captureTelemetryOptOut(telemetry: ITelemetryService | undefined, properties?: TelemetryProperties): void;
+export declare function identifyAccount(telemetry: ITelemetryService | undefined, account: {
+    id?: string;
+    email?: string;
+    provider?: string;
+    organizationId?: string;
+    organizationName?: string;
+    memberId?: string;
+}): void;
+export declare function captureTaskCreated(telemetry: ITelemetryService | undefined, properties: {
+    ulid: string;
+    apiProvider?: string;
+    openAiCompatibleDomain?: string;
+} & Partial<TelemetryAgentIdentityProperties>): void;
+export declare function captureTaskRestarted(telemetry: ITelemetryService | undefined, properties: {
+    ulid: string;
+    apiProvider?: string;
+    openAiCompatibleDomain?: string;
+} & Partial<TelemetryAgentIdentityProperties>): void;
+/**
+ * Distinguishes the trigger that produced a `task.completed` telemetry event.
+ *
+ * - `submit_and_exit`: the assistant explicitly declared completion by
+ *   invoking the canonical completion tool. Parity with original Cline's
+ *   `attempt_completion`-anchored emission.
+ * - `shutdown`: the session lifecycle completed (typically a non-interactive
+ *   single-run that finished without an explicit completion tool). Acts as a
+ *   safety-net so we still report completed runs that never observed
+ *   `submit_and_exit`.
+ */
+export type TaskCompletedSource = "submit_and_exit" | "shutdown";
+export declare function captureTaskCompleted(telemetry: ITelemetryService | undefined, properties: {
+    ulid: string;
+    provider?: string;
+    modelId?: string;
+    mode?: string;
+    durationMs?: number;
+    source?: TaskCompletedSource;
+} & Partial<TelemetryAgentIdentityProperties>): void;
+export declare function captureConversationTurnEvent(telemetry: ITelemetryService | undefined, properties: {
+    ulid: string;
+    provider?: string;
+    model?: string;
+    source: "user" | "assistant";
+    mode?: string;
+} & Partial<TelemetryAgentIdentityProperties>): void;
+export declare function captureTokenUsage(telemetry: ITelemetryService | undefined, properties: {
+    ulid: string;
+    tokensIn: number;
+    tokensOut: number;
+    cacheWriteTokens?: number;
+    cacheReadTokens?: number;
+    totalCost?: number;
+    model: string;
+} & Partial<TelemetryAgentIdentityProperties>): void;
+export declare function captureModeSwitch(telemetry: ITelemetryService | undefined, ulid: string, mode?: string): void;
+export declare function captureToolUsage(telemetry: ITelemetryService | undefined, properties: {
+    ulid: string;
+    tool: string;
+    modelId?: string;
+    provider?: string;
+    autoApproved?: boolean;
+    success: boolean;
+} & Partial<TelemetryAgentIdentityProperties>): void;
+export declare function captureSkillUsed(telemetry: ITelemetryService | undefined, properties: {
+    ulid: string;
+    skillName: string;
+    skillSource: "global" | "project";
+    skillsAvailableGlobal: number;
+    skillsAvailableProject: number;
+    provider?: string;
+    modelId?: string;
+} & Partial<TelemetryAgentIdentityProperties>): void;
+export declare function captureDiffEditFailure(telemetry: ITelemetryService | undefined, properties: {
+    ulid: string;
+    modelId?: string;
+    provider?: string;
+    errorType?: string;
+} & Partial<TelemetryAgentIdentityProperties>): void;
+export declare function captureProviderApiError(telemetry: ITelemetryService | undefined, properties: {
+    ulid: string;
+    model: string;
+    errorMessage: string;
+    provider?: string;
+    errorStatus?: number;
+    requestId?: string;
+} & Partial<TelemetryAgentIdentityProperties>): void;
+export declare function captureMentionUsed(telemetry: ITelemetryService | undefined, mentionType: "file" | "folder" | "url" | "problems" | "terminal" | "git-changes" | "commit", contentLength?: number): void;
+export declare 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;
+export declare function captureMentionSearchResults(telemetry: ITelemetryService | undefined, query: string, resultCount: number, searchType: "file" | "folder" | "all", isEmpty: boolean): void;
+export declare function captureAgentCreated(telemetry: ITelemetryService | undefined, properties: {
+    ulid: string;
+    modelId?: string;
+    provider?: string;
+} & TelemetryAgentIdentityProperties): void;
+export declare function captureAgentTeamCreated(telemetry: ITelemetryService | undefined, properties: {
+    ulid: string;
+    teamId: string;
+    teamName: string;
+    leadAgentId?: string;
+    restoredFromPersistence?: boolean;
+}): void;
+export declare function captureSubagentExecution(telemetry: ITelemetryService | undefined, properties: {
+    ulid: string;
+    durationMs: number;
+    outputLines?: number;
+    event: "created" | "started" | "ended";
+    agentId: string;
+    parentId?: string;
+    errorMessage?: string;
+    type?: "agent" | "team";
+} & Partial<TelemetryAgentIdentityProperties>): void;
+export declare function captureHookDiscovery(telemetry: ITelemetryService | undefined, hookName: string, globalCount: number, workspaceCount: number): void;
+/**
+ * Identifies which compaction implementation produced a
+ * `task.compaction_executed` / `task.compaction_skipped` event.
+ *
+ * - `basic`   — built-in token-budget truncation
+ *   (see `extensions/context/basic-compaction.ts`).
+ * - `agentic` — built-in LLM-powered summarization
+ *   (see `extensions/context/agentic-compaction.ts`).
+ * - `custom`  — user-supplied `compaction.compact()` callback on
+ *   `CoreSessionConfig`.
+ */
+export type TelemetryCompactionStrategy = "basic" | "agentic" | "custom";
+/**
+ * Trigger mode for a compaction attempt.
+ *
+ * - `auto`   — fired automatically by `createContextCompactionPrepareTurn`
+ *   when input tokens exceed the configured threshold.
+ * - `manual` — user-initiated (e.g. CLI `/compact`).
+ */
+export type TelemetryCompactionMode = "auto" | "manual";
+export interface CaptureCompactionExecutedProperties {
+    ulid: string;
+    strategy: TelemetryCompactionStrategy;
+    mode: TelemetryCompactionMode;
+    messagesBefore: number;
+    messagesAfter: number;
+    messagesRemoved: number;
+    tokensBefore: number;
+    tokensAfter: number;
+    tokensSaved: number;
+    triggerTokens: number;
+    maxInputTokens: number;
+    thresholdRatio: number;
+    durationMs: number;
+    provider?: string;
+    modelId?: string;
+}
+export declare function captureCompactionExecuted(telemetry: ITelemetryService | undefined, properties: CaptureCompactionExecutedProperties & Partial<TelemetryAgentIdentityProperties>): void;
+export interface CaptureCompactionSkippedProperties {
+    ulid: string;
+    strategy: TelemetryCompactionStrategy;
+    mode: TelemetryCompactionMode;
+    /**
+     * Why the strategy decided not to compact. Currently only one value is
+     * emitted by the wrapper:
+     * - `no_result` — strategy returned `undefined` (e.g. there was nothing
+     *   safe to remove). Strategy *exceptions* propagate up instead of
+     *   firing telemetry, so no `strategy_error` value is emitted today.
+     * The field is kept loosely typed (`string`) so additional reasons can
+     * be introduced without changing the schema.
+     */
+    reason: string;
+    tokensBefore: number;
+    triggerTokens: number;
+    maxInputTokens: number;
+    thresholdRatio: number;
+    durationMs: number;
+    provider?: string;
+    modelId?: string;
+}
+export declare function captureCompactionSkipped(telemetry: ITelemetryService | undefined, properties: CaptureCompactionSkippedProperties & Partial<TelemetryAgentIdentityProperties>): void;

package/dist/services/telemetry/distinct-id.d.ts

@@ -0,0 +1 @@
+export declare function resolveCoreDistinctId(explicitDistinctId?: string): string;

package/dist/services/telemetry/index.d.ts

@@ -0,0 +1,3 @@
+export type { ITelemetryAdapter, TelemetryArray, TelemetryMetadata, TelemetryObject, TelemetryPrimitive, TelemetryProperties, TelemetryValue, } from "./ITelemetryAdapter";
+export { OpenTelemetryAdapter, type OpenTelemetryAdapterOptions, } from "./OpenTelemetryAdapter";
+export { type ConfiguredTelemetryHandle, type CreateOpenTelemetryTelemetryServiceOptions, createConfiguredTelemetryHandle, createConfiguredTelemetryService, createOpenTelemetryTelemetryService, OpenTelemetryProvider, type OpenTelemetryProviderOptions, } from "./OpenTelemetryProvider";

package/dist/services/telemetry/index.js

@@ -0,0 +1 @@
+class u{name;metadata;meter;logger;enabled;distinctId;commonProperties;counters=new Map;histograms=new Map;gauges=new Map;gaugeValues=new Map;meterProvider;loggerProvider;constructor(e){this.name=e.name??"OpenTelemetryAdapter",this.metadata={...e.metadata},this.meterProvider=e.meterProvider,this.loggerProvider=e.loggerProvider,this.meter=e.meterProvider?.getMeter("cline")??null,this.logger=e.loggerProvider?.getLogger("cline")??null,this.enabled=e.enabled??!0,this.distinctId=e.distinctId,this.commonProperties=e.commonProperties?{...e.commonProperties}:{}}emit(e,t){if(!this.isEnabled())return;this.emitLog(e,t,!1)}emitRequired(e,t){this.emitLog(e,t,!0)}recordCounter(e,t,a,l,i=!1){if(!this.meter||!i&&!this.isEnabled())return;let r=this.counters.get(e);if(!r)r=this.meter.createCounter(e,l?{description:l}:void 0),this.counters.set(e,r);r.add(t,this.flattenProperties(this.buildAttributes(a)))}recordHistogram(e,t,a,l,i=!1){if(!this.meter||!i&&!this.isEnabled())return;let r=this.histograms.get(e);if(!r)r=this.meter.createHistogram(e,l?{description:l}:void 0),this.histograms.set(e,r);r.record(t,this.flattenProperties(this.buildAttributes(a)))}recordGauge(e,t,a,l,i=!1){if(!this.meter||!i&&!this.isEnabled())return;let r=this.buildAttributes(a),d=JSON.stringify(r),g=this.gaugeValues.get(e);if(t===null){if(g){if(g.delete(d),g.size===0)this.gaugeValues.delete(e),this.gauges.delete(e)}return}let n=g;if(!n)n=new Map,this.gaugeValues.set(e,n);if(!this.gauges.has(e)){let s=this.meter.createObservableGauge(e,l?{description:l}:void 0);s.addCallback((h)=>{for(let G of this.snapshotGaugeSeries(e))h.observe(G.value,this.flattenProperties(G.attributes))}),this.gauges.set(e,s)}n.set(d,{value:t,attributes:r})}isEnabled(){return typeof this.enabled==="function"?this.enabled():this.enabled}setDistinctId(e){this.distinctId=e}setCommonProperties(e){this.commonProperties={...e}}updateCommonProperties(e){this.commonProperties={...this.commonProperties,...e}}async flush(){await Promise.all([this.meterProvider?.forceFlush?.(),this.loggerProvider?.forceFlush?.()])}async dispose(){await Promise.all([this.meterProvider?.shutdown?.(),this.loggerProvider?.shutdown?.()])}emitLog(e,t,a){if(!this.logger)return;let l=this.flattenProperties(this.buildAttributes(t,a));this.logger.emit({severityText:"INFO",body:e,attributes:l})}buildAttributes(e,t=!1){return{...this.commonProperties,...this.metadata,...e,...this.distinctId?{distinct_id:this.distinctId}:{},...t?{_required:!0}:{}}}snapshotGaugeSeries(e){let t=this.gaugeValues.get(e);if(!t)return[];return Array.from(t.values(),(a)=>({value:a.value,attributes:a.attributes?{...a.attributes}:void 0}))}flattenProperties(e,t="",a=new WeakSet,l=0){if(!e)return{};let i={},r=100,d=10;for(let[g,n]of Object.entries(e)){if(g==="__proto__"||g==="constructor"||g==="prototype")continue;let s=t?`${t}.${g}`:g;if(n===null||n===void 0){i[s]=String(n);continue}if(Array.isArray(n)){let h=n.length>r?n.slice(0,r):n;try{i[s]=JSON.stringify(h)}catch{i[s]="[UnserializableArray]"}if(n.length>r)i[`${s}_truncated`]=!0,i[`${s}_original_length`]=n.length;continue}if(typeof n==="object"){if(n instanceof Date){i[s]=n.toISOString();continue}if(n instanceof Error){i[s]=n.message;continue}if(a.has(n)){i[s]="[Circular]";continue}if(l>=d){i[s]="[MaxDepthExceeded]";continue}a.add(n),Object.assign(i,this.flattenProperties(n,s,a,l+1));continue}if(J(n)){i[s]=n;continue}try{i[s]=JSON.stringify(n)}catch{i[s]=String(n)}}return i}}function J(e){return typeof e==="string"||typeof e==="number"||typeof e==="boolean"}import{metrics as Y,trace as R}from"@opentelemetry/api";import{logs as _}from"@opentelemetry/api-logs";import{OTLPLogExporter as p}from"@opentelemetry/exporter-logs-otlp-http";import{OTLPMetricExporter as E}from"@opentelemetry/exporter-metrics-otlp-http";import{OTLPTraceExporter as ee}from"@opentelemetry/exporter-trace-otlp-http";import{resourceFromAttributes as te}from"@opentelemetry/resources";import{BatchLogRecordProcessor as ae,ConsoleLogRecordExporter as ie,LoggerProvider as le}from"@opentelemetry/sdk-logs";import{ConsoleMetricExporter as re,MeterProvider as ne,PeriodicExportingMetricReader as z}from"@opentelemetry/sdk-metrics";import{BatchSpanProcessor as se,ConsoleSpanExporter as de,SimpleSpanProcessor as ge}from"@opentelemetry/sdk-trace-base";import{NodeTracerProvider as fe}from"@opentelemetry/sdk-trace-node";import{ATTR_SERVICE_NAME as ue,ATTR_SERVICE_VERSION as be}from"@opentelemetry/semantic-conventions";import{mkdirSync as Se,readFileSync as $,statSync as I,writeFileSync as we}from"node:fs";import{resolveGlobalSettingsPath as W}from"@cline/shared/storage";import{z as f}from"zod";import{SDK_ERROR_TELEMETRY_EVENT as Ae}from"@cline/shared";var O=f.preprocess((e)=>Array.isArray(e)?e.filter((t)=>typeof t==="string").map((t)=>t.trim()).filter(Boolean):void 0,f.array(f.string()).optional()).transform((e)=>{if(!e)return;let t=[...new Set(e)].sort((a,l)=>a.localeCompare(l));return t.length>0?t:void 0}),S=f.object({telemetryOptOut:f.boolean().default(!1).catch(!1),disabledTools:O.optional(),disabledPlugins:O.optional()}).strip().transform((e)=>{let t={telemetryOptOut:e.telemetryOptOut};if(e.disabledTools?.length)t.disabledTools=e.disabledTools;if(e.disabledPlugins?.length)t.disabledPlugins=e.disabledPlugins;return t});function b(){return S.parse({})}var P;function B(e){if(e.disabledTools)Object.freeze(e.disabledTools);if(e.disabledPlugins)Object.freeze(e.disabledPlugins);return Object.freeze(e)}function K(e){let t;try{t=$(e,"utf8")}catch{return b()}try{let a=S.safeParse(JSON.parse(t));return a.success?a.data:b()}catch{return b()}}function U(){let e=W(),t=I(e,{throwIfNoEntry:!1}),a=t?.mtimeMs??0,l=t?.size??0,i=P;if(i&&i.path===e&&i.mtimeMs===a&&i.size===l)return i;let r=B(t?K(e):b());return P={path:e,mtimeMs:a,size:l,value:r},P}function k(){return U().value}function w(){return k().telemetryOptOut}import{existsSync as Q,mkdirSync as Z,readFileSync as X,writeFileSync as x}from"node:fs";import{resolve as T}from"node:path";import{resolveSessionDataDir as D}from"@cline/shared/storage";import{nanoid as q}from"nanoid";import*as C from"node-machine-id";var M="machine-id";function c(e){let t=e?.trim();if(t)return t;let a=N();if(a)return a;return V()}function L(){let e=C;return e.machineIdSync??e.default?.machineIdSync}function N(){try{let e=L();if(!e)return;return e().trim()||void 0}catch{return}}function V(){let e=D(),t=T(e,M);try{if(Q(t)){let l=X(t,"utf8").trim();if(l.length>0)return l}}catch{}let a=`cl-${q()}`;try{Z(e,{recursive:!0}),x(t,a,"utf8")}catch{}return a}class y{name;logger;enabled;constructor(e={}){this.name=e.name??"TelemetryLoggerSink",this.logger=e.logger,this.enabled=e.enabled??!0}emit(e,t){if(!this.isEnabled())return;this.logger?.log("telemetry.event",{telemetrySink:this.name,event:e,properties:t})}emitRequired(e,t){this.logger?.log("telemetry.required_event",{telemetrySink:this.name,severity:"warn",event:e,properties:t})}recordCounter(e,t,a,l,i){if(!i&&!this.isEnabled())return;this.logger?.debug("telemetry.metric",{telemetrySink:this.name,instrument:"counter",name:e,value:t,attributes:a,description:l,required:i===!0})}recordHistogram(e,t,a,l,i){if(!i&&!this.isEnabled())return;this.logger?.debug("telemetry.metric",{telemetrySink:this.name,instrument:"histogram",name:e,value:t,attributes:a,description:l,required:i===!0})}recordGauge(e,t,a,l,i){if(!i&&!this.isEnabled())return;this.logger?.debug("telemetry.metric",{telemetrySink:this.name,instrument:"gauge",name:e,value:t,attributes:a,description:l,required:i===!0})}isEnabled(){return typeof this.enabled==="function"?this.enabled():this.enabled}async flush(){}async dispose(){}}class m{adapters;metadata;distinctId;commonProperties;constructor(e={}){if(this.adapters=[...e.adapters??[]],e.logger)this.adapters.push(new y({logger:e.logger}));this.metadata={...e.metadata??{}},this.distinctId=e.distinctId,this.commonProperties={...e.commonProperties??{}}}addAdapter(e){this.adapters.push(e)}setDistinctId(e){this.distinctId=e}setMetadata(e){this.metadata={...e}}updateMetadata(e){this.metadata={...this.metadata,...e}}setCommonProperties(e){this.commonProperties={...e}}updateCommonProperties(e){this.commonProperties={...this.commonProperties,...e}}isEnabled(){return this.adapters.some((e)=>e.isEnabled())}capture(e){let t=this.buildAttributes(e.properties);for(let a of this.adapters)a.emit(e.event,t)}captureRequired(e,t){let a=this.buildAttributes(t);for(let l of this.adapters)l.emitRequired(e,a)}recordCounter(e,t,a,l,i=!1){let r=this.buildAttributes(a);for(let d of this.adapters)d.recordCounter(e,t,r,l,i)}recordHistogram(e,t,a,l,i=!1){let r=this.buildAttributes(a);for(let d of this.adapters)d.recordHistogram(e,t,r,l,i)}recordGauge(e,t,a,l,i=!1){let r=this.buildAttributes(a);for(let d of this.adapters)d.recordGauge(e,t,r,l,i)}async flush(){await Promise.all(this.adapters.map((e)=>e.flush()))}async dispose(){await Promise.all(this.adapters.map((e)=>e.dispose()))}buildAttributes(e){return{...this.commonProperties,...e,...this.metadata,...this.distinctId?{distinct_id:this.distinctId}:{}}}}class j{distinctId;metadata;commonProperties;constructor(e={}){this.distinctId=e.distinctId,this.metadata={...e.metadata??{}},this.commonProperties={...e.commonProperties??{}}}setDistinctId(e){this.distinctId=e}setMetadata(e){this.metadata={...e}}updateMetadata(e){this.metadata={...this.metadata,...e}}setCommonProperties(e){this.commonProperties={...e}}updateCommonProperties(e){this.commonProperties={...this.commonProperties,...e}}isEnabled(){return!1}capture(e){this.resolveProperties(e.properties)}captureRequired(e,t){this.resolveProperties(t)}recordCounter(){}recordHistogram(){}recordGauge(){}async flush(){}async dispose(){}resolveProperties(e){return{...this.commonProperties,...e,...this.metadata,...this.distinctId?{distinct_id:this.distinctId}:{}}}}class A{meterProvider;loggerProvider;tracerProvider;options;constructor(e={}){this.options=e;let t=te({[ue]:e.serviceName??"cline",...e.serviceVersion?{[be]:e.serviceVersion}:{}});if(this.meterProvider=this.createMeterProvider(t),this.loggerProvider=this.createLoggerProvider(t),this.tracerProvider=this.createTracerProvider(t),this.meterProvider)Y.setGlobalMeterProvider(this.meterProvider);if(this.loggerProvider)_.setGlobalLoggerProvider(this.loggerProvider);if(this.tracerProvider)this.tracerProvider.register()}getTracer(e="cline",t){return R.getTracer(e,t??this.options.serviceVersion)}createAdapter(e){return new u({...e,meterProvider:this.meterProvider,loggerProvider:this.loggerProvider})}createTelemetryService(e){let t=this.createAdapter({name:e.name,enabled:this.options.enabled,metadata:e.metadata});return new m({...e,adapters:[t],distinctId:c(e.distinctId)})}async forceFlush(){await Promise.all([this.meterProvider?.forceFlush?.(),this.loggerProvider?.forceFlush?.(),this.tracerProvider?.forceFlush?.()])}async dispose(){await Promise.all([this.meterProvider?.shutdown?.(),this.loggerProvider?.shutdown?.(),this.tracerProvider?.shutdown?.()])}createMeterProvider(e){let t=o(this.options.metricsExporter);if(t.length===0)return null;let a=Math.max(1000,this.options.metricExportIntervalMs??this.options.metricExportInterval??60000),l=Math.min(30000,Math.floor(a*0.8)),i=t.map((r)=>ce(r,{endpoint:this.options.otlpEndpoint,headers:this.options.otlpHeaders,insecure:this.options.otlpInsecure??!1,protocol:"http/json",interval:a,timeout:l})).filter((r)=>r!==null);if(i.length===0)return null;return new ne({resource:e,readers:i})}createTracerProvider(e){let t=o(this.options.tracesExporter);if(t.length===0)return null;let a=this.options.otlpTracesEndpoint??this.options.otlpEndpoint,l=this.options.otlpTracesHeaders??this.options.otlpHeaders,i=[];for(let r of t){let d=Pe(r,{endpoint:a,headers:l,insecure:this.options.otlpInsecure??!1,protocol:"http/json"});if(d)i.push(d)}if(i.length===0)return null;return new fe({resource:e,spanProcessors:i})}createLoggerProvider(e){let t=o(this.options.logsExporter);if(t.length===0)return null;let a=t.map((l)=>{let i=he(l,{endpoint:this.options.otlpEndpoint,headers:this.options.otlpHeaders,insecure:this.options.otlpInsecure??!1,protocol:"http/json"});if(!i)return null;return new ae(i,{maxQueueSize:this.options.logMaxQueueSize??2048,maxExportBatchSize:this.options.logBatchSize??512,scheduledDelayMillis:this.options.logBatchTimeoutMs??this.options.logBatchTimeout??5000})}).filter((l)=>l!==null);if(a.length===0)return null;return new le({resource:e,processors:a})}}function F(e){let t=new A(e),a=t.createTelemetryService(e);return a.captureRequired("telemetry.provider_created",{provider:"opentelemetry",enabled:e.enabled??!0,logsExporter:Array.isArray(e.logsExporter)?e.logsExporter.join(","):e.logsExporter,metricsExporter:Array.isArray(e.metricsExporter)?e.metricsExporter.join(","):e.metricsExporter,tracesExporter:Array.isArray(e.tracesExporter)?e.tracesExporter.join(","):e.tracesExporter,otlpProtocol:e.otlpProtocol,hasOtlpEndpoint:Boolean(e.otlpEndpoint),serviceName:e.serviceName,serviceVersion:e.serviceVersion}),{provider:t,telemetry:a}}function H(e){if(w())return{telemetry:new j(e)};if(e.enabled!==!0)return{telemetry:new m({...e,distinctId:c(e.distinctId)})};return F(e)}function me(e){let{telemetry:t,provider:a}=H(e);return{telemetry:t,provider:a,flush:async()=>{let r=a;if(r&&typeof r.forceFlush==="function")try{await r.forceFlush()}catch{}},dispose:async()=>{await Promise.allSettled([t.dispose(),a?.dispose()])}}}function o(e){if(!e)return[];return(Array.isArray(e)?e:e.split(",")).map((a)=>a.trim()).filter((a)=>a==="console"||a==="otlp")}function he(e,t){if(e==="console")return new ie;if(!t.endpoint)return null;let a=v(t.endpoint,"/v1/logs");return new p({url:a,headers:t.headers})}function Pe(e,t){if(e==="console")return new ge(new de);if(!t.endpoint)return null;let a=v(t.endpoint,"/v1/traces");return new se(new ee({url:a,headers:t.headers}))}function ce(e,t){if(e==="console")return new z({exporter:new re,exportIntervalMillis:t.interval,exportTimeoutMillis:t.timeout});if(!t.endpoint)return null;let a=v(t.endpoint,"/v1/metrics");return new z({exporter:new E({url:a,headers:t.headers}),exportIntervalMillis:t.interval,exportTimeoutMillis:t.timeout})}function v(e,t){let a=new URL(e),l=a.pathname.endsWith("/")?a.pathname.slice(0,-1):a.pathname;return a.pathname=l.endsWith(t)?l:`${l}${t}`,a.toString()}export{F as createOpenTelemetryTelemetryService,H as createConfiguredTelemetryService,me as createConfiguredTelemetryHandle,A as OpenTelemetryProvider,u as OpenTelemetryAdapter};

package/dist/services/usage.d.ts

@@ -0,0 +1,19 @@
+import type * as LlmsProviders from "@cline/llms";
+import type { SessionAccumulatedUsage } from "../runtime/host/runtime-host";
+export declare function createInitialAccumulatedUsage(): SessionAccumulatedUsage;
+export declare function accumulateUsageTotals(baseline: SessionAccumulatedUsage, usage: {
+    inputTokens?: number;
+    outputTokens?: number;
+    cacheReadTokens?: number;
+    cacheWriteTokens?: number;
+    totalCost?: number;
+}): SessionAccumulatedUsage;
+export declare function sumUsageTotals(usages: Iterable<SessionAccumulatedUsage>): SessionAccumulatedUsage;
+export declare function summarizeUsageFromMessages(messages: LlmsProviders.Message[]): SessionAccumulatedUsage;
+/**
+ * Current model context-window usage, derived from the latest assistant LLM
+ * call. Provider usage is normalized so `inputTokens` is already the full
+ * prompt size, including any cache-read/cache-write portions. Do not add cache
+ * fields back on top.
+ */
+export declare function getCurrentContextSize(messages: readonly LlmsProviders.Message[]): number | undefined;

package/dist/services/workspace/file-indexer.d.ts

@@ -0,0 +1,5 @@
+export interface FastFileIndexOptions {
+    ttlMs?: number;
+}
+export declare function getFileIndex(cwd: string, options?: FastFileIndexOptions): Promise<Set<string>>;
+export declare function prewarmFileIndex(cwd: string, options?: FastFileIndexOptions): Promise<void>;

package/dist/services/workspace/index.d.ts

@@ -0,0 +1,4 @@
+export type { FastFileIndexOptions } from "./file-indexer";
+export { getFileIndex, prewarmFileIndex } from "./file-indexer";
+export type { MentionEnricherOptions, MentionEnrichmentResult, } from "./mention-enricher";
+export { enrichPromptWithMentions } from "./mention-enricher";

package/dist/services/workspace/mention-enricher.d.ts

@@ -0,0 +1,13 @@
+import { type FastFileIndexOptions } from "./file-indexer";
+export interface MentionEnricherOptions extends FastFileIndexOptions {
+    maxFiles?: number;
+    maxFileBytes?: number;
+    maxTotalBytes?: number;
+}
+export interface MentionEnrichmentResult {
+    prompt: string;
+    mentions: string[];
+    matchedFiles: string[];
+    ignoredMentions: string[];
+}
+export declare function enrichPromptWithMentions(input: string, cwd: string, options?: MentionEnricherOptions): Promise<MentionEnrichmentResult>;

package/dist/services/workspace/workspace-manager.d.ts

@@ -0,0 +1,27 @@
+import { type WorkspaceInfo, type WorkspaceManifest } from "@cline/shared";
+export interface WorkspaceManagerEvent {
+    type: "workspace_added" | "workspace_switched";
+    workspace: WorkspaceInfo;
+}
+export interface WorkspaceManager {
+    addWorkspacePath(workspacePath: string): Promise<WorkspaceInfo>;
+    switchWorkspace(workspacePath: string): Promise<WorkspaceInfo>;
+    subscribe(listener: (event: WorkspaceManagerEvent) => void): () => void;
+    getCurrentWorkspace(): WorkspaceInfo | undefined;
+    getWorkspace(workspacePath: string): WorkspaceInfo | undefined;
+    listWorkspaces(): WorkspaceInfo[];
+    getManifest(): WorkspaceManifest;
+}
+export declare class InMemoryWorkspaceManager implements WorkspaceManager {
+    private manifest;
+    private readonly listeners;
+    constructor(manifest?: WorkspaceManifest);
+    addWorkspacePath(workspacePath: string): Promise<WorkspaceInfo>;
+    switchWorkspace(workspacePath: string): Promise<WorkspaceInfo>;
+    subscribe(listener: (event: WorkspaceManagerEvent) => void): () => void;
+    getCurrentWorkspace(): WorkspaceInfo | undefined;
+    getWorkspace(workspacePath: string): WorkspaceInfo | undefined;
+    listWorkspaces(): WorkspaceInfo[];
+    getManifest(): WorkspaceManifest;
+    private emit;
+}

package/dist/services/workspace/workspace-manifest.d.ts

@@ -0,0 +1,31 @@
+import type { WorkspaceInfo } from "@cline/shared";
+export interface WorkspaceInfoDiagnostics {
+    info: WorkspaceInfo;
+    vcsType: "git" | "none";
+    error?: {
+        errorType: string;
+        message: string;
+    };
+}
+export interface BuiltWorkspaceMetadata {
+    workspaceInfo: WorkspaceInfo;
+    workspaceMetadata: string;
+    durationMs: number;
+    vcsType: "git" | "none";
+    initError?: {
+        errorType: string;
+        message: string;
+    };
+}
+export declare function normalizeWorkspacePath(workspacePath: string): string;
+export declare function generateWorkspaceInfo(workspacePath: string): Promise<WorkspaceInfo>;
+export declare function generateWorkspaceInfoWithDiagnostics(workspacePath: string): Promise<WorkspaceInfoDiagnostics>;
+export declare function buildWorkspaceMetadata(cwd: string): Promise<string>;
+/**
+ * Generate workspace metadata as both a structured `WorkspaceInfo` object and
+ * its pre-serialized string form.
+ *
+ * Use this instead of calling `buildWorkspaceMetadata` + `generateWorkspaceInfo`
+ * separately so the git I/O only happens once.
+ */
+export declare function buildWorkspaceMetadataWithInfo(cwd: string): Promise<BuiltWorkspaceMetadata>;

package/dist/services/workspace/workspace-telemetry.d.ts

@@ -0,0 +1,18 @@
+import type { ITelemetryService, WorkspaceInfo } from "@cline/shared";
+export interface WorkspaceLifecycleTelemetryInput {
+    telemetry?: ITelemetryService;
+    rootPath: string;
+    workspaceInfo?: WorkspaceInfo;
+    rootCount?: number;
+    vcsType?: "git" | "none";
+    vcsTypes?: ReadonlyArray<string>;
+    durationMs?: number;
+    initError?: {
+        errorType: string;
+        message: string;
+    };
+    featureFlagEnabled?: boolean;
+    isRemoteWorkspace?: boolean;
+}
+export declare function emitWorkspaceLifecycleTelemetry(input: WorkspaceLifecycleTelemetryInput): void;
+export declare function resetWorkspaceTelemetryForTests(): void;