@cline/shared 0.0.38-nightly.1778113663

package/dist/rpc/runtime.d.ts

@@ -0,0 +1,320 @@
+import z from "zod";
+import type { HubToolExecutorName } from "../hub";
+import type { RuntimeConfigExtensionKind, SessionExecutionConfig, SessionPromptConfig } from "../session/runtime-config";
+export interface ChatRuntimeConfig extends SessionPromptConfig {
+    cwd?: string;
+    apiKey?: string;
+    logger?: RuntimeLoggerConfig;
+    enableTools: boolean;
+    enableSpawn?: boolean;
+    enableTeams?: boolean;
+    disableMcpSettingsTools?: boolean;
+    autoApproveTools?: boolean;
+    missionStepInterval?: number;
+    missionTimeIntervalMs?: number;
+    timeoutSeconds?: number;
+    toolPolicies?: SessionExecutionConfig["toolPolicies"];
+    toolExecutors?: HubToolExecutorName[];
+    configExtensions?: RuntimeConfigExtensionKind[];
+}
+export interface RuntimeLoggerConfig {
+    enabled?: boolean;
+    level?: "trace" | "debug" | "info" | "warn" | "error" | "fatal" | "silent";
+    destination?: string;
+    name?: string;
+    bindings?: Record<string, string | number | boolean>;
+}
+export interface ChatStartSessionRequest extends ChatRuntimeConfig {
+    sessionId?: string;
+    workspaceRoot: string;
+    provider: string;
+    model: string;
+    source?: string;
+    interactive?: boolean;
+}
+export interface ChatStartSessionArtifacts {
+    sessionId: string;
+    manifestPath: string;
+    messagesPath: string;
+}
+export interface ChatStartSessionResponse {
+    sessionId: string;
+    startResult?: ChatStartSessionArtifacts;
+}
+export interface ChatAttachmentFile {
+    name: string;
+    content: string;
+}
+export interface ChatAttachments {
+    userImages?: string[];
+    userFiles?: ChatAttachmentFile[];
+}
+export interface ChatRunTurnRequest {
+    config: ChatStartSessionRequest;
+    prompt: string;
+    attachments?: ChatAttachments;
+    delivery?: "queue" | "steer";
+}
+export interface ChatToolCallResult {
+    name: string;
+    input?: unknown;
+    output?: unknown;
+    error?: string;
+    durationMs?: number;
+}
+export interface ChatTurnResult {
+    text: string;
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+        cacheReadTokens?: number;
+        cacheWriteTokens?: number;
+        totalCost?: number;
+    };
+    inputTokens: number;
+    outputTokens: number;
+    iterations: number;
+    finishReason: string;
+    toolCalls: ChatToolCallResult[];
+}
+export interface EnterpriseContext {
+    projectId?: string;
+    workspaceId?: string;
+    organizationId?: string;
+}
+export interface EnterpriseAuthenticateRequest extends EnterpriseContext {
+    providerId: string;
+    workspacePath: string;
+    rootPath?: string;
+}
+export interface EnterpriseAuthenticateResponse {
+    providerId: string;
+    authenticated: boolean;
+    roles: string[];
+    claims?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+}
+export interface EnterpriseSyncRequest extends EnterpriseContext {
+    providerId: string;
+    workspacePath: string;
+    rootPath?: string;
+    useCachedBundle?: boolean;
+}
+export interface EnterpriseSyncResponse {
+    providerId: string;
+    authenticated: boolean;
+    hasCachedBundle: boolean;
+    appliedConfigVersion?: string;
+    roles: string[];
+    hasTelemetryOverrides: boolean;
+    rulesCount: number;
+    workflowsCount: number;
+    skillsCount: number;
+    claims?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+}
+export interface EnterpriseStatusRequest {
+    providerId: string;
+    workspacePath: string;
+    rootPath?: string;
+}
+export type EnterpriseStatusResponse = EnterpriseSyncResponse;
+export interface ProviderModel {
+    id: string;
+    name: string;
+    supportsAttachments?: boolean;
+    supportsVision?: boolean;
+    supportsReasoning?: boolean;
+}
+export interface ProviderListItem {
+    id: string;
+    name: string;
+    models: number | null;
+    color: string;
+    letter: string;
+    enabled: boolean;
+    apiKey?: string;
+    oauthAccessTokenPresent?: boolean;
+    baseUrl?: string;
+    defaultModelId?: string;
+    protocol?: ProviderProtocol;
+    client?: ProviderClient;
+    authDescription: string;
+    baseUrlDescription: string;
+    modelList?: ProviderModel[];
+    family?: string;
+}
+export interface ProviderCatalogResponse {
+    providers: ProviderListItem[];
+    settingsPath: string;
+}
+export interface ProviderModelsResponse {
+    providerId: string;
+    models: ProviderModel[];
+}
+import type { OAuthProviderId } from "../types/auth";
+export declare const ProviderCapabilitySchema: z.ZodEnum<{
+    tools: "tools";
+    streaming: "streaming";
+    "prompt-cache": "prompt-cache";
+    reasoning: "reasoning";
+    "computer-use": "computer-use";
+    temperature: "temperature";
+    files: "files";
+    "provider-tools": "provider-tools";
+    oauth: "oauth";
+    vision: "vision";
+    "local-auth": "local-auth";
+}>;
+export type ProviderCapability = z.infer<typeof ProviderCapabilitySchema>;
+export declare const ProviderProtocolSchema: z.ZodEnum<{
+    "openai-responses": "openai-responses";
+    anthropic: "anthropic";
+    gemini: "gemini";
+    "openai-chat": "openai-chat";
+    "openai-r1": "openai-r1";
+    "ai-sdk": "ai-sdk";
+}>;
+export type ProviderProtocol = z.infer<typeof ProviderProtocolSchema>;
+export declare const ProviderClientSchema: z.ZodEnum<{
+    custom: "custom";
+    anthropic: "anthropic";
+    gemini: "gemini";
+    "openai-r1": "openai-r1";
+    "ai-sdk": "ai-sdk";
+    "ai-sdk-community": "ai-sdk-community";
+    openai: "openai";
+    "openai-compatible": "openai-compatible";
+    bedrock: "bedrock";
+    fetch: "fetch";
+    vertex: "vertex";
+}>;
+export type ProviderClient = z.infer<typeof ProviderClientSchema>;
+export interface ListProvidersActionRequest {
+    action: "listProviders";
+}
+export interface GetProviderModelsActionRequest {
+    action: "getProviderModels";
+    providerId: string;
+}
+export interface SaveProviderSettingsActionRequest {
+    action: "saveProviderSettings";
+    providerId: string;
+    enabled?: boolean;
+    apiKey?: string;
+    auth?: {
+        apiKey?: string;
+        accessToken?: string;
+        refreshToken?: string;
+        expiresAt?: number;
+        accountId?: string;
+    };
+    model?: string;
+    protocol?: ProviderProtocol;
+    client?: ProviderClient;
+    routingProviderId?: string;
+    maxTokens?: number;
+    contextWindow?: number;
+    baseUrl?: string;
+    headers?: Record<string, string>;
+    timeout?: number;
+    reasoning?: {
+        enabled?: boolean;
+        effort?: "none" | "low" | "medium" | "high" | "xhigh";
+        budgetTokens?: number;
+    };
+    aws?: {
+        accessKey?: string;
+        secretKey?: string;
+        sessionToken?: string;
+        region?: string;
+        profile?: string;
+        authentication?: "iam" | "api-key" | "profile";
+        usePromptCache?: boolean;
+        useCrossRegionInference?: boolean;
+        useGlobalInference?: boolean;
+        endpoint?: string;
+        customModelBaseId?: string;
+    };
+    gcp?: {
+        projectId?: string;
+        region?: string;
+    };
+    azure?: {
+        apiVersion?: string;
+        useIdentity?: boolean;
+    };
+    sap?: {
+        clientId?: string;
+        clientSecret?: string;
+        tokenUrl?: string;
+        resourceGroup?: string;
+        deploymentId?: string;
+        useOrchestrationMode?: boolean;
+        api?: "orchestration" | "foundation-models";
+        defaultSettings?: Record<string, unknown>;
+    };
+    oca?: {
+        mode?: "internal" | "external";
+        usePromptCache?: boolean;
+    };
+    region?: string;
+    apiLine?: "china" | "international";
+    capabilities?: ("reasoning" | "prompt-cache" | "streaming" | "tools" | "vision" | "computer-use" | "oauth")[];
+}
+export interface AddProviderActionRequest {
+    action: "addProvider";
+    providerId: string;
+    name: string;
+    baseUrl: string;
+    apiKey?: string;
+    headers?: Record<string, string>;
+    timeoutMs?: number;
+    models?: string[];
+    defaultModelId?: string;
+    modelsSourceUrl?: string;
+    protocol?: ProviderProtocol;
+    client?: ProviderClient;
+    capabilities?: ProviderCapability[];
+}
+export type ProviderSettingsActionRequest = ListProvidersActionRequest | GetProviderModelsActionRequest | SaveProviderSettingsActionRequest | AddProviderActionRequest;
+export type ClineAccountActionRequest = {
+    action: "clineAccount";
+    operation: "fetchMe";
+} | {
+    action: "clineAccount";
+    operation: "fetchBalance";
+    userId?: string;
+} | {
+    action: "clineAccount";
+    operation: "fetchUsageTransactions";
+    userId?: string;
+} | {
+    action: "clineAccount";
+    operation: "fetchPaymentTransactions";
+    userId?: string;
+} | {
+    action: "clineAccount";
+    operation: "fetchUserOrganizations";
+} | {
+    action: "clineAccount";
+    operation: "fetchOrganizationBalance";
+    organizationId: string;
+} | {
+    action: "clineAccount";
+    operation: "fetchOrganizationUsageTransactions";
+    organizationId: string;
+    memberId?: string;
+} | {
+    action: "clineAccount";
+    operation: "switchAccount";
+    organizationId?: string | null;
+} | {
+    action: "clineAccount";
+    operation: "fetchFeaturebaseToken";
+};
+export type ProviderActionRequest = ProviderSettingsActionRequest | ClineAccountActionRequest;
+export interface ProviderOAuthLoginResponse {
+    provider: OAuthProviderId;
+    accessToken: string;
+}

package/dist/rpc/team-progress.d.ts

@@ -0,0 +1,53 @@
+export declare const TEAM_PROGRESS_EVENT_TYPE = "runtime.team.progress.v1";
+export declare const TEAM_LIFECYCLE_EVENT_TYPE = "runtime.team.lifecycle.v1";
+export type TeamProgressMemberRole = "lead" | "teammate";
+export type TeamProgressMemberStatus = "idle" | "running" | "stopped";
+export type TeamProgressTaskStatus = "pending" | "in_progress" | "blocked" | "completed";
+export type TeamProgressRunStatus = "queued" | "running" | "completed" | "failed" | "cancelled" | "interrupted";
+export type TeamProgressOutcomeStatus = "draft" | "in_review" | "finalized";
+export type TeamProgressOutcomeFragmentStatus = "draft" | "reviewed" | "rejected";
+export interface TeamProgressCounts<TStatus extends string> {
+    total: number;
+    byStatus: Record<TStatus, number>;
+}
+export interface TeamProgressSummary {
+    teamName: string;
+    updatedAt: string;
+    members: TeamProgressCounts<TeamProgressMemberStatus> & {
+        leadCount: number;
+        teammateCount: number;
+    };
+    tasks: TeamProgressCounts<TeamProgressTaskStatus> & {
+        blockedTaskIds: string[];
+        readyTaskIds: string[];
+        completionPct: number;
+    };
+    runs: TeamProgressCounts<TeamProgressRunStatus> & {
+        activeRunIds: string[];
+        latestRunId?: string;
+    };
+    outcomes: TeamProgressCounts<TeamProgressOutcomeStatus> & {
+        finalizedPct: number;
+        missingRequiredSections: string[];
+    };
+    fragments: TeamProgressCounts<TeamProgressOutcomeFragmentStatus>;
+}
+export interface TeamProgressLifecycleEvent {
+    teamName: string;
+    sessionId: string;
+    eventType: string;
+    ts: string;
+    agentId?: string;
+    taskId?: string;
+    runId?: string;
+    outcomeId?: string;
+    fragmentId?: string;
+    message?: string;
+}
+export interface TeamProgressProjectionEvent {
+    type: "team_progress_projection";
+    version: 1;
+    sessionId: string;
+    summary: TeamProgressSummary;
+    lastEvent: TeamProgressLifecycleEvent;
+}

package/dist/runtime/build-env.d.ts

@@ -0,0 +1,13 @@
+export declare const CLINE_BUILD_ENV_ENV = "CLINE_BUILD_ENV";
+export declare const CLINE_DEBUG_HOST_ENV = "CLINE_DEBUG_HOST";
+export declare const CLINE_DEBUG_PORT_BASE_ENV = "CLINE_DEBUG_PORT_BASE";
+export type ClineBuildEnv = "development" | "production";
+export type ClineDebugRole = "rpc" | "hook" | "plugin-sandbox" | "connector" | "sandbox";
+export interface ResolveClineBuildEnvOptions {
+    env?: NodeJS.ProcessEnv;
+    execArgv?: string[];
+    debugRole?: ClineDebugRole;
+}
+export declare function resolveClineBuildEnv(options?: ResolveClineBuildEnvOptions): ClineBuildEnv;
+export declare function withResolvedClineBuildEnv(env?: NodeJS.ProcessEnv, options?: Omit<ResolveClineBuildEnvOptions, "env">): NodeJS.ProcessEnv;
+export declare function augmentNodeCommandForDebug(command: string[], options?: ResolveClineBuildEnvOptions): string[];

package/dist/runtime/hub-daemon-env.d.ts

@@ -0,0 +1,2 @@
+export declare const CLINE_RUN_AS_HUB_DAEMON_ENV = "CLINE_RUN_AS_HUB_DAEMON";
+export declare function isHubDaemonProcess(env?: Record<string, string | undefined>): boolean;

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

@@ -0,0 +1,6 @@
+import type { OpenTelemetryClientConfig, TelemetryMetadata } from "./telemetry";
+export interface ClineTelemetryServiceConfig extends OpenTelemetryClientConfig {
+    metadata: TelemetryMetadata;
+}
+export declare function createClineTelemetryServiceMetadata(overrides?: Partial<TelemetryMetadata>): TelemetryMetadata;
+export declare function createClineTelemetryServiceConfig(configOverrides?: Partial<ClineTelemetryServiceConfig>): ClineTelemetryServiceConfig;

package/dist/services/telemetry.d.ts

@@ -0,0 +1,117 @@
+export type TelemetryPrimitive = string | number | boolean | null | undefined;
+export type TelemetryValue = TelemetryPrimitive | TelemetryObject | TelemetryArray;
+export type TelemetryObject = {
+    [key: string]: TelemetryValue;
+};
+export type TelemetryArray = Array<TelemetryValue>;
+export type TelemetryProperties = TelemetryObject;
+export interface TelemetryMetadata {
+    extension_version: string;
+    cline_type: string;
+    platform: string;
+    platform_version: string;
+    os_type: string;
+    os_version: string;
+    is_dev?: string;
+    is_remote_workspace?: boolean;
+}
+export interface ITelemetryService {
+    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>;
+}
+export interface OpenTelemetryClientConfig {
+    /**
+     * Whether telemetry is enabled via OTEL_TELEMETRY_ENABLED
+     */
+    enabled: boolean;
+    /**
+     * Metrics exporter type(s) - can be comma-separated for multiple exporters
+     * Examples: "console", "otlp", "prometheus", "console,otlp"
+     */
+    metricsExporter?: string;
+    /**
+     * Logs/events exporter type(s) - can be comma-separated for multiple exporters
+     * Examples: "console", "otlp"
+     */
+    logsExporter?: string;
+    /**
+     * Distributed tracing exporter type(s) - comma-separated for multiple exporters.
+     * Examples: "console", "otlp". When unset, no `TracerProvider` is registered.
+     */
+    tracesExporter?: string;
+    /**
+     * Protocol for OTLP exporters. SDK support is currently limited to "http/json".
+     */
+    otlpProtocol?: string;
+    /**
+     * General OTLP endpoint (used if specific endpoints not set)
+     */
+    otlpEndpoint?: string;
+    /**
+     * General OTLP headers
+     */
+    otlpHeaders?: Record<string, string>;
+    /**
+     * Metrics-specific OTLP protocol
+     */
+    otlpMetricsProtocol?: string;
+    /**
+     * Metrics-specific OTLP endpoint
+     */
+    otlpMetricsEndpoint?: string;
+    otlpMetricsHeaders?: Record<string, string>;
+    /**
+     * Logs-specific OTLP protocol
+     */
+    otlpLogsProtocol?: string;
+    /**
+     * Logs-specific OTLP endpoint
+     */
+    otlpLogsEndpoint?: string;
+    otlpLogsHeaders?: Record<string, string>;
+    /**
+     * Traces-specific OTLP protocol (SDK support is currently limited to "http/json")
+     */
+    otlpTracesProtocol?: string;
+    /**
+     * Traces-specific OTLP endpoint (defaults to {@link otlpEndpoint} when exporting OTLP traces)
+     */
+    otlpTracesEndpoint?: string;
+    otlpTracesHeaders?: Record<string, string>;
+    /**
+     * Metric export interval in milliseconds (for console exporter)
+     */
+    metricExportInterval?: number;
+    /**
+     * Whether to use insecure (non-TLS) connections for gRPC OTLP exporters
+     * Set to "true" for local development without TLS
+     * Default: false (uses TLS)
+     */
+    otlpInsecure?: boolean;
+    /**
+     * Maximum batch size for log records (default: 512)
+     */
+    logBatchSize?: number;
+    /**
+     * Maximum time to wait before exporting logs in milliseconds (default: 5000)
+     */
+    logBatchTimeout?: number;
+    /**
+     * Maximum queue size for log records (default: 2048)
+     */
+    logMaxQueueSize?: number;
+}

package/dist/session/hook-context.d.ts

@@ -0,0 +1,12 @@
+export interface HookSessionContext {
+    rootSessionId?: string;
+}
+export interface HookSessionContextLookup {
+    hookName?: string;
+    conversationId?: string;
+    agentId?: string;
+    parentAgentId?: string | null;
+}
+export type HookSessionContextProvider = HookSessionContext | ((input?: HookSessionContextLookup) => HookSessionContext | undefined);
+export declare function resolveHookSessionContext(provider?: HookSessionContextProvider, input?: HookSessionContextLookup): HookSessionContext | undefined;
+export declare function resolveRootSessionId(context: HookSessionContext | undefined): string | undefined;

package/dist/session/index.d.ts

@@ -0,0 +1 @@
+export declare function createSessionId(prefix?: string, suffix?: string): string;

package/dist/session/records.d.ts

@@ -0,0 +1,31 @@
+export declare const SESSION_STATUS_VALUES: readonly ["running", "completed", "failed", "cancelled"];
+export type SharedSessionStatus = (typeof SESSION_STATUS_VALUES)[number];
+export interface SessionLineage {
+    parentSessionId?: string;
+    agentId?: string;
+    parentAgentId?: string;
+    conversationId?: string;
+    isSubagent: boolean;
+}
+export interface SessionRuntimeRecordShape extends SessionLineage {
+    source: string;
+    pid?: number;
+    startedAt: string;
+    endedAt?: string | null;
+    exitCode?: number | null;
+    status: SharedSessionStatus;
+    interactive: boolean;
+    provider: string;
+    model: string;
+    cwd: string;
+    workspaceRoot: string;
+    teamName?: string;
+    enableTools: boolean;
+    enableSpawn: boolean;
+    enableTeams: boolean;
+    prompt?: string;
+    metadata?: Record<string, unknown>;
+    hookPath?: string;
+    messagesPath?: string;
+    updatedAt: string;
+}

package/dist/session/runtime-config.d.ts

@@ -0,0 +1,26 @@
+import type { ToolPolicy } from "../llms/tools";
+export type AgentMode = "act" | "plan" | "yolo" | "zen";
+export type RuntimeConfigExtensionKind = "rules" | "skills" | "workflows" | "plugins";
+export declare const RUNTIME_CONFIG_EXTENSION_KINDS: readonly ["rules", "skills", "workflows", "plugins"];
+export declare const DEFAULT_RUNTIME_CONFIG_EXTENSIONS: readonly ["rules", "skills", "workflows", "plugins"];
+export declare function isRuntimeConfigExtensionKind(value: unknown): value is RuntimeConfigExtensionKind;
+export declare function parseRuntimeConfigExtensions(value: unknown): RuntimeConfigExtensionKind[] | undefined;
+export declare function hasRuntimeConfigExtension(extensions: ReadonlyArray<RuntimeConfigExtensionKind> | undefined, kind: RuntimeConfigExtensionKind): boolean;
+export interface SessionPromptConfig {
+    mode?: AgentMode;
+    systemPrompt?: string;
+    rules?: string;
+    maxIterations?: number;
+}
+export interface SessionWorkspaceConfig {
+    cwd: string;
+    workspaceRoot?: string;
+}
+export interface SessionExecutionConfig {
+    enableTools: boolean;
+    teamName?: string;
+    missionLogIntervalSteps?: number;
+    missionLogIntervalMs?: number;
+    maxConsecutiveMistakes?: number;
+    toolPolicies?: Record<string, ToolPolicy>;
+}

package/dist/session/runtime-env.d.ts

@@ -0,0 +1,8 @@
+export interface RuntimeEnv {
+    name: string;
+    version: string;
+    platform: string;
+    platform_version: string;
+    os_type: string;
+    os_version: string;
+}

package/dist/session/workspace.d.ts

@@ -0,0 +1,28 @@
+import { z } from "zod";
+export declare const WorkspaceInfoSchema: z.ZodObject<{
+    rootPath: z.ZodString;
+    hint: z.ZodOptional<z.ZodString>;
+    associatedRemoteUrls: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    latestGitCommitHash: z.ZodOptional<z.ZodString>;
+    latestGitBranchName: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const WorkspaceManifestSchema: z.ZodObject<{
+    currentWorkspacePath: z.ZodOptional<z.ZodString>;
+    workspaces: z.ZodRecord<z.ZodString, z.ZodObject<{
+        rootPath: z.ZodString;
+        hint: z.ZodOptional<z.ZodString>;
+        associatedRemoteUrls: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        latestGitCommitHash: z.ZodOptional<z.ZodString>;
+        latestGitBranchName: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type WorkspaceManifest = z.infer<typeof WorkspaceManifestSchema>;
+export declare function emptyWorkspaceManifest(): WorkspaceManifest;
+export interface WorkspaceInfo {
+    rootPath: string;
+    hint?: string;
+    associatedRemoteUrls?: string[];
+    latestGitCommitHash?: string;
+    latestGitBranchName?: string;
+}
+export declare function upsertWorkspaceInfo(manifest: WorkspaceManifest, info: WorkspaceInfo): WorkspaceManifest;

package/dist/storage/index.d.ts

@@ -0,0 +1 @@
+export { AGENT_CONFIG_DIRECTORY_NAME, CLINE_MCP_SETTINGS_FILE_NAME, type CronSpecsScope, discoverPluginModulePaths, ensureFileExists, ensureHookLogDir, ensureParentDir, HOOKS_CONFIG_DIRECTORY_NAME, isPluginModulePath, type ResolveCronSpecsDirOptions, RULES_CONFIG_DIRECTORY_NAME, resolveAgentConfigSearchPaths, resolveAgentsConfigDirPath, resolveClineDataDir, resolveClineDir, resolveConfiguredPluginModulePaths, resolveCronDbPath, resolveCronEventsDir, resolveCronReportsDir, resolveCronSpecsDir, resolveDbDataDir, resolveDocumentsClineDirectoryPath, resolveDocumentsExtensionPath, resolveGlobalCronSpecsDir, resolveGlobalSettingsPath, resolveHooksConfigSearchPaths, resolveMcpSettingsPath, resolvePluginConfigSearchPaths, resolvePluginModuleEntries, resolveProviderSettingsPath, resolveRulesConfigSearchPaths, resolveSessionDataDir, resolveSkillsConfigSearchPaths, resolveTeamDataDir, resolveWorkflowsConfigSearchPaths, resolveWorkspaceCronSpecsDir, SKILLS_CONFIG_DIRECTORY_NAME, setClineDir, setClineDirIfUnset, setHomeDir, setHomeDirIfUnset, WORKFLOWS_CONFIG_DIRECTORY_NAME, } from "./paths";

package/dist/storage/index.js

@@ -0,0 +1 @@
+var i=Object.defineProperty;var e=(C)=>C;function a(C,S){this[C]=e.bind(null,S)}var $C=(C,S)=>{for(var M in S)i(C,M,{get:S[M],enumerable:!0,configurable:!0,set:a.bind(S,M)})};import{appendFileSync as t,existsSync as F,mkdirSync as Y,readdirSync as CC,readFileSync as SC,statSync as I}from"node:fs";import{homedir as OC}from"node:os";import{dirname as Z,join as O,resolve as R}from"node:path";var $=".clinerules",L=".cline",H=".agents",U="agents",z="hooks",B="skills",Q="rules",J="workflows",f="plugins",x="cline_mcp_settings.json";function MC(){let C=process?.env?.HOME?.trim();if(C&&C!=="~")return C;let S=process?.env?.USERPROFILE?.trim();if(S)return S;let M=process?.env?.HOMEDRIVE?.trim(),D=process?.env?.HOMEPATH?.trim();if(M&&D)return`${M}${D}`;let N=OC().trim();if(N&&N!=="~")return N;return"~"}var j=MC(),u=!1;function NC(C){let S=C.trim();if(!S)return;j=S,u=!0}function GC(C){if(u)return;let S=C.trim();if(!S)return;j=S}var E,y=!1;function DC(C){let S=C.trim();if(!S)return;E=S,y=!0}function FC(C){if(y)return;let S=C.trim();if(!S)return;E=S}function _(){if(E)return E;let C=process.env.CLINE_DIR?.trim();if(C)return C;return O(j,".cline")}function m(){return O(j,"Documents","Cline")}function q(C){return O(m(),C)}function g(){let C=process.env.CLINE_DATA_DIR?.trim();if(C)return C;return O(_(),"data")}function WC(){let C=process.env.CLINE_SESSION_DATA_DIR?.trim();if(C)return C;return O(g(),"sessions")}function _C(){let C=process.env.CLINE_TEAM_DATA_DIR?.trim();if(C)return C;return O(g(),"teams")}function w(){let C=process.env.CLINE_DB_DATA_DIR?.trim();if(C)return C;return O(g(),"db")}function gC(){let C=process.env.CLINE_CRON_DB_PATH?.trim();if(C)return C;return O(w(),"cron.db")}function s(){return O(_(),"cron")}function V(C){return O(C,".cline","cron")}function X(C){if(typeof C==="string")return V(C);if(C?.cronSpecsDir?.trim())return C.cronSpecsDir.trim();if(C?.scope==="workspace"){let S=C.workspaceRoot?.trim();if(!S)throw Error("workspaceRoot is required for workspace cron scope");return V(S)}return s()}function vC(C){return O(X(C),"reports")}function AC(C){return O(X(C),"events")}function KC(){let C=process.env.CLINE_PROVIDER_SETTINGS_PATH?.trim();if(C)return C;return O(g(),"settings","providers.json")}function IC(){let C=process.env.CLINE_GLOBAL_SETTINGS_PATH?.trim();if(C)return C;return O(g(),"settings","global-settings.json")}function RC(){let C=process.env.CLINE_MCP_SETTINGS_PATH?.trim();if(C)return C;return O(g(),"settings",x)}function v(C){let S=new Set,M=[];for(let D of C){if(!D||S.has(D))continue;S.add(D),M.push(D)}return M}function TC(C){if(!C)return[];return[$,L,H].map((S)=>O(C,S,B))}function k(){return O(_(),U)}function jC(C){return v([C?O(C,L,U):"",k()])}function qC(C){let S=[q("Hooks"),O(_(),z)];if(C)S.push(O(C,$,z),O(C,L,z));return v(S)}function zC(C){return v([...TC(C),O(_(),B),O(j,H,B)])}function BC(C){let S=C?[O(C,$),O(C,L,Q)]:[],M=C?[O(C,"AGENTS.md")]:[];return v([...M,...S,O(_(),Q),q("Rules")])}function EC(C){return v([C?O(C,".clinerules",J):"",q("Workflows")])}function LC(C){return v([C?O(C,".cline",f):"",O(_(),f),q("Plugins")])}var o=new Set([".js",".ts"]),d="package.json",QC=["index.ts","index.js"];function T(C){let S=C.lastIndexOf(".");if(S===-1)return!1;return o.has(C.slice(S))}function n(C){try{let S=JSON.parse(SC(C,"utf8"));if(!S.cline||typeof S.cline!=="object")return null;return S.cline}catch{return null}}function c(C){let S=C?.plugins;if(!Array.isArray(S))return[];return S.flatMap((M)=>M.paths??[])}function r(C){let S=R(C);if(!F(S)||!I(S).isDirectory())return null;let M=O(S,d);if(F(M)){let D=n(M),N=c(D).map((G)=>R(S,G)).filter((G)=>F(G)&&I(G).isFile()&&T(G));if(N.length>0)return N}for(let D of QC){let N=O(S,D);if(F(N)&&I(N).isFile())return[N]}return null}function p(C){let S=R(C);if(!F(S))return[];let M=[],D=[S];while(D.length>0){let N=D.pop();if(!N)continue;let G;try{G=CC(N,{withFileTypes:!0})}catch{continue}for(let A of G){let W=O(N,A.name);if(A.isDirectory()){let b=O(W,d);if(F(b)){let h=n(b),l=c(h).map((K)=>R(W,K)).filter((K)=>F(K)&&I(K).isFile()&&T(K));if(l.length>0){M.push(...l);continue}}D.push(W);continue}if(A.name.startsWith("."))continue;if(A.isFile()&&T(W))M.push(W)}}return M.sort((N,G)=>N.localeCompare(G))}function VC(C,S){let M=[];for(let D of C){let N=D.trim();if(!N)continue;let G=R(S,N);if(!F(G))throw Error(`Plugin path does not exist: ${G}`);if(I(G).isDirectory()){let W=r(G);if(W){M.push(...W);continue}M.push(...p(G));continue}if(!T(G))throw Error(`Plugin file must use a supported extension (${[...o].join(", ")}): ${G}`);M.push(G)}return M}function P(C){let S=Z(C);if(!F(S))Y(S,{recursive:!0})}function YC(C){Y(Z(C),{recursive:!0}),t(C,"")}function ZC(C){if(C?.trim())return P(C),Z(C);let S=O(g(),"logs");if(!F(S))Y(S,{recursive:!0});return S}export{GC as setHomeDirIfUnset,NC as setHomeDir,FC as setClineDirIfUnset,DC as setClineDir,V as resolveWorkspaceCronSpecsDir,EC as resolveWorkflowsConfigSearchPaths,_C as resolveTeamDataDir,zC as resolveSkillsConfigSearchPaths,WC as resolveSessionDataDir,BC as resolveRulesConfigSearchPaths,KC as resolveProviderSettingsPath,r as resolvePluginModuleEntries,LC as resolvePluginConfigSearchPaths,RC as resolveMcpSettingsPath,qC as resolveHooksConfigSearchPaths,IC as resolveGlobalSettingsPath,s as resolveGlobalCronSpecsDir,q as resolveDocumentsExtensionPath,m as resolveDocumentsClineDirectoryPath,w as resolveDbDataDir,X as resolveCronSpecsDir,vC as resolveCronReportsDir,AC as resolveCronEventsDir,gC as resolveCronDbPath,VC as resolveConfiguredPluginModulePaths,_ as resolveClineDir,g as resolveClineDataDir,k as resolveAgentsConfigDirPath,jC as resolveAgentConfigSearchPaths,T as isPluginModulePath,P as ensureParentDir,ZC as ensureHookLogDir,YC as ensureFileExists,p as discoverPluginModulePaths,J as WORKFLOWS_CONFIG_DIRECTORY_NAME,B as SKILLS_CONFIG_DIRECTORY_NAME,Q as RULES_CONFIG_DIRECTORY_NAME,z as HOOKS_CONFIG_DIRECTORY_NAME,x as CLINE_MCP_SETTINGS_FILE_NAME,U as AGENT_CONFIG_DIRECTORY_NAME};