@sctg/cline-shared 3.84.0-beta.20260524130712

package/dist/rpc/runtime.d.ts

@@ -0,0 +1,322 @@
+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;
+    capabilities?: ProviderCapability[];
+    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";
+    popular: "popular";
+}>;
+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" | "apikey" | "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/cline-environment.d.ts

@@ -0,0 +1,17 @@
+export declare const CLINE_ENVIRONMENT_ENV = "CLINE_ENVIRONMENT";
+export declare const CLINE_ENVIRONMENT_OVERRIDE_ENV = "CLINE_ENVIRONMENT_OVERRIDE";
+export type ClineEnvironment = "production" | "staging" | "local";
+export interface ClineEnvironmentConfig {
+    readonly environment: ClineEnvironment;
+    readonly appBaseUrl: string;
+    readonly apiBaseUrl: string;
+    readonly mcpBaseUrl: string;
+    readonly workOsClientId: string;
+}
+export declare const CLINE_ENVIRONMENTS: Readonly<Record<ClineEnvironment, ClineEnvironmentConfig>>;
+export declare const DEFAULT_CLINE_ENVIRONMENT: ClineEnvironment;
+export interface ResolveClineEnvironmentOptions {
+    env?: Partial<NodeJS.ProcessEnv>;
+}
+export declare function resolveClineEnvironment(options?: ResolveClineEnvironmentOptions): ClineEnvironment;
+export declare function getClineEnvironmentConfig(environmentOrOptions?: ClineEnvironment | ResolveClineEnvironmentOptions): ClineEnvironmentConfig;

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,133 @@
+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 type SdkTelemetryErrorComponent = "shared" | "llms" | "agents" | "core" | "cli" | "vscode" | "desktop" | (string & {});
+export type SdkTelemetryErrorSeverity = "debug" | "info" | "warn" | "error" | "fatal";
+export interface CaptureSdkErrorInput {
+    component: SdkTelemetryErrorComponent;
+    operation: string;
+    error: unknown;
+    severity?: SdkTelemetryErrorSeverity;
+    handled?: boolean;
+    context?: TelemetryProperties;
+    event?: string;
+    messageLimit?: number;
+}
+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 declare const SDK_ERROR_TELEMETRY_EVENT = "sdk.error";
+export declare function captureSdkError(telemetry: ITelemetryService | undefined, input: CaptureSdkErrorInput): void;
+export declare function buildSdkErrorProperties(input: CaptureSdkErrorInput): TelemetryProperties;
+export declare function normalizeSdkError(error: unknown, messageLimit?: number): TelemetryProperties;
+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 ["idle", "running", "pending", "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,2 @@
+export { resolveExistingFilePath } from "./path-resolution";
+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";