@cline/core 0.0.38-nightly.1778113663

package/dist/extensions/config/unified-config-file-watcher.d.ts

@@ -0,0 +1,77 @@
+export interface UnifiedConfigFileContext<TType extends string = string> {
+    type: TType;
+    directoryPath: string;
+    fileName: string;
+    filePath: string;
+    content: string;
+}
+export interface UnifiedConfigFileCandidate {
+    directoryPath: string;
+    fileName: string;
+    filePath: string;
+}
+export interface UnifiedConfigDefinition<TType extends string = string, TItem = unknown> {
+    type: TType;
+    directories: ReadonlyArray<string>;
+    discoverFiles?: (directoryPath: string) => Promise<ReadonlyArray<UnifiedConfigFileCandidate>>;
+    includeFile?: (fileName: string, filePath: string) => boolean;
+    parseFile: (context: UnifiedConfigFileContext<TType>) => TItem;
+    resolveId: (item: TItem, context: UnifiedConfigFileContext<TType>) => string;
+}
+export interface UnifiedConfigWatcherOptions {
+    debounceMs?: number;
+    emitParseErrors?: boolean;
+}
+export interface UnifiedConfigRecord<TType extends string = string, TItem = unknown> {
+    type: TType;
+    id: string;
+    item: TItem;
+    filePath: string;
+}
+export type UnifiedConfigWatcherEvent<TType extends string = string, TItem = unknown> = {
+    kind: "upsert";
+    record: UnifiedConfigRecord<TType, TItem>;
+} | {
+    kind: "remove";
+    type: TType;
+    id: string;
+    filePath: string;
+} | {
+    kind: "error";
+    type: TType;
+    error: unknown;
+    filePath?: string;
+};
+export declare class UnifiedConfigFileWatcher<TType extends string = string, TItem = unknown> {
+    private readonly definitions;
+    private readonly debounceMs;
+    private readonly emitParseErrors;
+    private readonly listeners;
+    private readonly recordsByType;
+    private readonly watchersByDirectory;
+    private readonly baseTypesByDirectory;
+    private watchedTypesByDirectory;
+    private readonly discoveredDirectoriesByType;
+    private readonly definitionsByType;
+    private readonly pendingTypes;
+    private flushTimer;
+    private refreshQueue;
+    private started;
+    constructor(definitions: ReadonlyArray<UnifiedConfigDefinition<TType, TItem>>, options?: UnifiedConfigWatcherOptions);
+    subscribe(listener: (event: UnifiedConfigWatcherEvent<TType, TItem>) => void): () => void;
+    start(): Promise<void>;
+    stop(): void;
+    refreshAll(): Promise<void>;
+    refreshType(type: TType): Promise<void>;
+    getSnapshot(type: TType): Map<string, UnifiedConfigRecord<TType, TItem>>;
+    getAllSnapshots(): Map<TType, Map<string, UnifiedConfigRecord<TType, TItem>>>;
+    private emit;
+    private enqueueRefresh;
+    private startDirectoryWatchers;
+    private syncDirectoryWatchers;
+    private scheduleFlush;
+    private refreshTypeInternal;
+    private loadDefinition;
+    private buildDesiredTypesByDirectory;
+    private readDirectoryFileCandidates;
+}

package/dist/extensions/config/user-instruction-config-loader.d.ts

@@ -0,0 +1,64 @@
+import { RULES_CONFIG_DIRECTORY_NAME, SKILLS_CONFIG_DIRECTORY_NAME, WORKFLOWS_CONFIG_DIRECTORY_NAME } from "@cline/shared/storage";
+import { type UnifiedConfigDefinition, UnifiedConfigFileWatcher, type UnifiedConfigWatcherEvent } from "./unified-config-file-watcher";
+export { RULES_CONFIG_DIRECTORY_NAME, SKILLS_CONFIG_DIRECTORY_NAME, WORKFLOWS_CONFIG_DIRECTORY_NAME, };
+export interface ParseMarkdownFrontmatterResult {
+    data: Record<string, unknown>;
+    body: string;
+    hadFrontmatter: boolean;
+    parseError?: string;
+}
+export interface SkillConfig {
+    name: string;
+    description?: string;
+    disabled?: boolean;
+    instructions: string;
+    frontmatter: Record<string, unknown>;
+}
+export interface RuleConfig {
+    name: string;
+    disabled?: boolean;
+    instructions: string;
+    frontmatter: Record<string, unknown>;
+}
+export interface WorkflowConfig {
+    name: string;
+    disabled?: boolean;
+    description?: string;
+    instructions: string;
+    frontmatter: Record<string, unknown>;
+}
+export type UserInstructionConfigType = "skill" | "rule" | "workflow";
+export type UserInstructionConfig = SkillConfig | RuleConfig | WorkflowConfig;
+export type UserInstructionConfigWatcher = UnifiedConfigFileWatcher<UserInstructionConfigType, UserInstructionConfig>;
+export type UserInstructionConfigWatcherEvent = UnifiedConfigWatcherEvent<UserInstructionConfigType, UserInstructionConfig>;
+export interface CreateInstructionWatcherOptions {
+    debounceMs?: number;
+    emitParseErrors?: boolean;
+}
+export interface CreateSkillsConfigDefinitionOptions {
+    directories?: ReadonlyArray<string>;
+    workspacePath?: string;
+}
+export interface CreateRulesConfigDefinitionOptions {
+    directories?: ReadonlyArray<string>;
+    workspacePath?: string;
+}
+export interface CreateWorkflowsConfigDefinitionOptions {
+    directories?: ReadonlyArray<string>;
+    workspacePath?: string;
+}
+export declare function parseSkillConfigFromMarkdown(content: string, fallbackName: string): SkillConfig;
+export declare function parseRuleConfigFromMarkdown(content: string, fallbackName: string): RuleConfig;
+export declare function parseWorkflowConfigFromMarkdown(content: string, fallbackName: string): WorkflowConfig;
+export declare function resolveSkillsConfigSearchPaths(workspacePath?: string): string[];
+export declare function resolveRulesConfigSearchPaths(workspacePath?: string): string[];
+export declare function resolveWorkflowsConfigSearchPaths(workspacePath?: string): string[];
+export declare function createSkillsConfigDefinition(options?: CreateSkillsConfigDefinitionOptions): UnifiedConfigDefinition<"skill", SkillConfig>;
+export declare function createRulesConfigDefinition(options?: CreateRulesConfigDefinitionOptions): UnifiedConfigDefinition<"rule", RuleConfig>;
+export declare function createWorkflowsConfigDefinition(options?: CreateWorkflowsConfigDefinitionOptions): UnifiedConfigDefinition<"workflow", WorkflowConfig>;
+export interface CreateUserInstructionConfigWatcherOptions extends CreateInstructionWatcherOptions {
+    skills?: CreateSkillsConfigDefinitionOptions;
+    rules?: CreateRulesConfigDefinitionOptions;
+    workflows?: CreateWorkflowsConfigDefinitionOptions;
+}
+export declare function createUserInstructionConfigWatcher(options?: CreateUserInstructionConfigWatcherOptions): UserInstructionConfigWatcher;

package/dist/extensions/config/user-instruction-plugin.d.ts

@@ -0,0 +1,25 @@
+import type { AgentExtension } from "@cline/shared";
+import { type SkillsExecutorWithMetadata } from "../tools";
+import type { SkillConfig, UserInstructionConfigWatcher } from "./user-instruction-config-loader";
+type SkillsExecutorMetadataItem = {
+    id: string;
+    name: string;
+    description?: string;
+    disabled: boolean;
+};
+type ConfiguredSkill = SkillsExecutorMetadataItem & {
+    skill: SkillConfig;
+};
+export interface CreateUserInstructionPluginOptions {
+    watcher: UserInstructionConfigWatcher;
+    watcherReady?: Promise<void>;
+    includeRules?: boolean;
+    includeSkills?: boolean;
+    includeWorkflows?: boolean;
+    registerSkillsTool?: boolean;
+    allowedSkillNames?: ReadonlyArray<string>;
+}
+export declare function getConfiguredSkillsFromWatcher(watcher: UserInstructionConfigWatcher, allowedSkillNames?: ReadonlyArray<string>): ConfiguredSkill[];
+export declare function createUserInstructionSkillsExecutor(watcher: UserInstructionConfigWatcher, watcherReady?: Promise<void>, allowedSkillNames?: ReadonlyArray<string>): SkillsExecutorWithMetadata;
+export declare function createUserInstructionPlugin(options: CreateUserInstructionPluginOptions): AgentExtension;
+export {};

package/dist/extensions/config/user-instruction-service.d.ts

@@ -0,0 +1,23 @@
+import type { AgentExtension } from "@cline/shared";
+import { type AvailableRuntimeCommand } from "./runtime-commands";
+import { type CreateUserInstructionConfigWatcherOptions, type UserInstructionConfig, type UserInstructionConfigType } from "./user-instruction-config-loader";
+import { type CreateUserInstructionPluginOptions } from "./user-instruction-plugin";
+export interface UserInstructionConfigRecord<TConfig extends UserInstructionConfig = UserInstructionConfig> {
+    type: UserInstructionConfigType;
+    id: string;
+    filePath: string;
+    item: TConfig;
+}
+export interface CreateUserInstructionConfigServiceOptions extends CreateUserInstructionConfigWatcherOptions {
+}
+export interface UserInstructionConfigService {
+    start(): Promise<void>;
+    stop(): void;
+    refreshType(type: UserInstructionConfigType): Promise<void>;
+    listRecords<TConfig extends UserInstructionConfig = UserInstructionConfig>(type: UserInstructionConfigType): UserInstructionConfigRecord<TConfig>[];
+    listRuntimeCommands(): AvailableRuntimeCommand[];
+    resolveRuntimeSlashCommand(input: string): string;
+    hasConfiguredSkills(allowedSkillNames?: ReadonlyArray<string>): boolean;
+    createExtension(options: Omit<CreateUserInstructionPluginOptions, "watcher" | "watcherReady">): AgentExtension;
+}
+export declare function createUserInstructionConfigService(options?: CreateUserInstructionConfigServiceOptions): UserInstructionConfigService;

package/dist/extensions/context/agentic-compaction.d.ts

@@ -0,0 +1,12 @@
+import type { BasicLogger } from "@cline/shared";
+import type { CoreCompactionContext, CoreCompactionResult, CoreCompactionSummarizerConfig } from "../../types/config";
+import type { ProviderConfig } from "../../types/provider-settings";
+import { type EstimateMessageTokens } from "./compaction-shared";
+export declare function runAgenticCompaction(options: {
+    context: CoreCompactionContext;
+    providerConfig: ProviderConfig;
+    summarizer?: CoreCompactionSummarizerConfig;
+    preserveRecentTokens: number;
+    estimateMessageTokens: EstimateMessageTokens;
+    logger?: BasicLogger;
+}): Promise<CoreCompactionResult | undefined>;

package/dist/extensions/context/basic-compaction.d.ts

@@ -0,0 +1,8 @@
+import type { BasicLogger } from "@cline/shared";
+import type { CoreCompactionContext, CoreCompactionResult } from "../../types/config";
+import { type EstimateMessageTokens } from "./compaction-shared";
+export declare function runBasicCompaction(options: {
+    context: CoreCompactionContext;
+    estimateMessageTokens: EstimateMessageTokens;
+    logger?: BasicLogger;
+}): CoreCompactionResult | undefined;

package/dist/extensions/context/compaction-shared.d.ts

@@ -0,0 +1,60 @@
+import type { ToolResultContent } from "@cline/llms";
+import type { MessageWithMetadata } from "@cline/shared";
+import type { CoreCompactionContext, CoreCompactionSummarizerConfig } from "../../types/config";
+import type { ProviderConfig } from "../../types/provider-settings";
+export declare const DEFAULT_CONTEXT_WINDOW_TOKENS = 200000;
+export declare const DEFAULT_THRESHOLD_RATIO = 0.95;
+export declare const DEFAULT_RESERVE_TOKENS = 16384;
+export declare const DEFAULT_PRESERVE_RECENT_TOKENS = 20000;
+export declare const DEFAULT_SUMMARY_MAX_OUTPUT_TOKENS = 1024;
+export declare const TOOL_RESULT_CHAR_LIMIT = 2000;
+export declare const FILE_CONTENT_CHAR_LIMIT = 2000;
+export declare const MIN_TRUNCATED_MESSAGE_TOKENS = 8;
+export interface FileOperationSummary {
+    readFiles: string[];
+    modifiedFiles: string[];
+}
+export interface CompactionSummaryMetadata {
+    kind: "compaction_summary";
+    summary: string;
+    details: FileOperationSummary;
+    tokensBefore: number;
+    generatedAt: number;
+}
+export type EstimateMessageTokens = (message: MessageWithMetadata) => number;
+export declare function estimateTokens(text: string): number;
+export declare function truncateText(text: string, limit: number): string;
+export declare function flattenToolResultContent(content: ToolResultContent["content"]): string;
+export declare function formatToolInput(input: Record<string, unknown>): string;
+export declare function serializeMessage(message: MessageWithMetadata): string;
+export declare function serializeConversation(messages: MessageWithMetadata[]): string;
+export declare function createTokenEstimator(): EstimateMessageTokens;
+export declare function isCompactionSummaryMessage(message: MessageWithMetadata): boolean;
+export declare function getCompactionSummaryMetadata(message: MessageWithMetadata): CompactionSummaryMetadata | undefined;
+export declare function isToolResultOnlyUserMessage(message: MessageWithMetadata): boolean;
+export declare function isTurnStartMessage(message: MessageWithMetadata): boolean;
+export declare function findFirstUserMessageIndex(messages: MessageWithMetadata[]): number;
+export declare function findLastTurnStartIndex(messages: MessageWithMetadata[]): number;
+export declare function findLastAssistantIndex(messages: MessageWithMetadata[]): number;
+export declare function findLatestSummaryIndex(messages: MessageWithMetadata[]): number;
+export declare function findCutIndex(messages: MessageWithMetadata[], preserveRecentTokens: number, estimateMessageTokens: EstimateMessageTokens): number;
+export declare function collectPaths(value: unknown): string[];
+export declare function mergeUnique(base: string[], next: Iterable<string>): string[];
+export declare function extractFileOps(messages: MessageWithMetadata[]): FileOperationSummary;
+export declare function renderFilesSection(fileOps: FileOperationSummary): string;
+export declare function ensureFilesSection(summary: string, fileOps: FileOperationSummary): string;
+export declare function buildSummaryRequest(options: {
+    previousSummary?: string;
+    conversationText: string;
+    fileOps: FileOperationSummary;
+}): string;
+export declare function resolveSummarizerConfig(options: {
+    activeProviderConfig: ProviderConfig;
+    summarizer?: CoreCompactionSummarizerConfig;
+}): ProviderConfig;
+export declare function buildSummaryMessage(options: {
+    summary: string;
+    fileOps: FileOperationSummary;
+    tokensBefore: number;
+}): MessageWithMetadata;
+export declare function getContextWindowTokens(context: Pick<CoreCompactionContext, "contextWindowTokens">): number;

package/dist/extensions/context/compaction.d.ts

@@ -0,0 +1,24 @@
+import type { CoreCompactionContext, CoreSessionConfig } from "../../types/config";
+export interface ContextPipelinePrepareTurnInput {
+    agentId: string;
+    conversationId: string;
+    parentAgentId: string | null;
+    iteration: number;
+    messages: CoreCompactionContext["messages"];
+    apiMessages: CoreCompactionContext["messages"];
+    abortSignal: AbortSignal;
+    systemPrompt: string;
+    tools: unknown[];
+    model: CoreCompactionContext["model"];
+    emitStatusNotice?: (message: string, metadata?: Record<string, unknown>) => void;
+}
+export interface ContextPipelinePrepareTurnResult {
+    messages: CoreCompactionContext["messages"];
+    systemPrompt?: string;
+}
+export type ContextCompactionMode = "auto" | "manual";
+export interface ContextCompactionPrepareTurnOptions {
+    mode?: ContextCompactionMode;
+    manualTargetRatio?: number;
+}
+export declare function createContextCompactionPrepareTurn(config: Pick<CoreSessionConfig, "providerConfig" | "providerId" | "modelId" | "compaction" | "logger">, options?: ContextCompactionPrepareTurnOptions): ((context: ContextPipelinePrepareTurnInput) => Promise<ContextPipelinePrepareTurnResult | undefined>) | undefined;

package/dist/extensions/index.d.ts

@@ -0,0 +1,5 @@
+export type { ResolveAgentPluginPathsOptions } from "./plugin/plugin-config-loader";
+export { discoverPluginModulePaths, resolveAgentPluginPaths, resolveAndLoadAgentPlugins, resolvePluginConfigSearchPaths, } from "./plugin/plugin-config-loader";
+export type { PluginInitializationFailure, PluginInitializationWarning, PluginLoadDiagnostics, } from "./plugin/plugin-load-report";
+export type { LoadAgentPluginFromPathOptions } from "./plugin/plugin-loader";
+export { loadAgentPluginFromPath, loadAgentPluginsFromPaths, loadAgentPluginsFromPathsWithDiagnostics, } from "./plugin/plugin-loader";

package/dist/extensions/mcp/client.d.ts

@@ -0,0 +1,2 @@
+import type { McpServerClientFactory } from "./types";
+export declare function createDefaultMcpServerClientFactory(): McpServerClientFactory;

package/dist/extensions/mcp/config-loader.d.ts

@@ -0,0 +1,15 @@
+import type { McpManager, McpServerRegistration } from "./types";
+export interface McpSettingsFile {
+    mcpServers: Record<string, Omit<McpServerRegistration, "name">>;
+}
+export interface LoadMcpSettingsOptions {
+    filePath?: string;
+}
+export interface RegisterMcpServersFromSettingsOptions {
+    filePath?: string;
+}
+export declare function resolveDefaultMcpSettingsPath(): string;
+export declare function loadMcpSettingsFile(options?: LoadMcpSettingsOptions): McpSettingsFile;
+export declare function hasMcpSettingsFile(options?: LoadMcpSettingsOptions): boolean;
+export declare function resolveMcpServerRegistrations(options?: LoadMcpSettingsOptions): McpServerRegistration[];
+export declare function registerMcpServersFromSettingsFile(manager: Pick<McpManager, "registerServer">, options?: RegisterMcpServersFromSettingsOptions): Promise<McpServerRegistration[]>;

package/dist/extensions/mcp/index.d.ts

@@ -0,0 +1,8 @@
+export { createDefaultMcpServerClientFactory } from "./client";
+export type { LoadMcpSettingsOptions, McpSettingsFile, RegisterMcpServersFromSettingsOptions, } from "./config-loader";
+export { hasMcpSettingsFile, loadMcpSettingsFile, registerMcpServersFromSettingsFile, resolveDefaultMcpSettingsPath, resolveMcpServerRegistrations, } from "./config-loader";
+export { InMemoryMcpManager } from "./manager";
+export type { CreateDisabledMcpToolPoliciesOptions, CreateDisabledMcpToolPolicyOptions, } from "./policies";
+export { createDisabledMcpToolPolicies, createDisabledMcpToolPolicy, } from "./policies";
+export { createMcpTools } from "./tools";
+export type { CreateMcpToolsOptions, McpConnectionStatus, McpManager, McpManagerOptions, McpServerClient, McpServerClientFactory, McpServerRegistration, McpServerSnapshot, McpServerTransportConfig, McpSseTransportConfig, McpStdioTransportConfig, McpStreamableHttpTransportConfig, McpToolCallRequest, McpToolCallResult, McpToolDescriptor, McpToolNameTransform, McpToolProvider, } from "./types";

package/dist/extensions/mcp/manager.d.ts

@@ -0,0 +1,23 @@
+import type { McpManager, McpManagerOptions, McpServerRegistration, McpServerSnapshot, McpToolCallRequest, McpToolCallResult, McpToolDescriptor } from "./types";
+export declare class InMemoryMcpManager implements McpManager {
+    private readonly toolsCacheTtlMs;
+    private readonly clientFactory;
+    private readonly servers;
+    private readonly operationLocks;
+    constructor(options: McpManagerOptions);
+    registerServer(registration: McpServerRegistration): Promise<void>;
+    unregisterServer(serverName: string): Promise<void>;
+    connectServer(serverName: string): Promise<void>;
+    disconnectServer(serverName: string): Promise<void>;
+    setServerDisabled(serverName: string, disabled: boolean): Promise<void>;
+    listServers(): readonly McpServerSnapshot[];
+    listTools(serverName: string): Promise<readonly McpToolDescriptor[]>;
+    refreshTools(serverName: string): Promise<readonly McpToolDescriptor[]>;
+    callTool(request: McpToolCallRequest): Promise<McpToolCallResult>;
+    dispose(): Promise<void>;
+    private ensureConnectedClient;
+    private connectState;
+    private disconnectState;
+    private requireServer;
+    private runExclusive;
+}

package/dist/extensions/mcp/name-transform.d.ts

@@ -0,0 +1,2 @@
+import type { McpToolNameTransform } from "./types";
+export declare const defaultMcpToolNameTransform: McpToolNameTransform;

package/dist/extensions/mcp/policies.d.ts

@@ -0,0 +1,14 @@
+import type { ToolPolicy } from "@cline/shared";
+import type { McpToolNameTransform } from "./types";
+export interface CreateDisabledMcpToolPolicyOptions {
+    serverName: string;
+    toolName: string;
+    nameTransform?: McpToolNameTransform;
+}
+export interface CreateDisabledMcpToolPoliciesOptions {
+    serverName: string;
+    toolNames: readonly string[];
+    nameTransform?: McpToolNameTransform;
+}
+export declare function createDisabledMcpToolPolicy(options: CreateDisabledMcpToolPolicyOptions): Record<string, ToolPolicy>;
+export declare function createDisabledMcpToolPolicies(options: CreateDisabledMcpToolPoliciesOptions): Record<string, ToolPolicy>;

package/dist/extensions/mcp/tools.d.ts

@@ -0,0 +1,3 @@
+import { type AgentTool } from "@cline/shared";
+import type { CreateMcpToolsOptions } from "./types";
+export declare function createMcpTools(options: CreateMcpToolsOptions): Promise<AgentTool[]>;

package/dist/extensions/mcp/types.d.ts

@@ -0,0 +1,94 @@
+import type { AgentToolContext } from "@cline/shared";
+export interface McpToolDescriptor {
+    name: string;
+    description?: string;
+    inputSchema: Record<string, unknown>;
+}
+export interface McpToolCallRequest {
+    serverName: string;
+    toolName: string;
+    arguments?: Record<string, unknown>;
+    context?: AgentToolContext;
+}
+export type McpToolCallResult = unknown;
+export interface McpToolProvider {
+    listTools(serverName: string): Promise<readonly McpToolDescriptor[]>;
+    callTool(request: McpToolCallRequest): Promise<McpToolCallResult>;
+}
+export type McpToolNameTransform = (input: {
+    serverName: string;
+    toolName: string;
+}) => string;
+export interface CreateMcpToolsOptions {
+    serverName: string;
+    provider: McpToolProvider;
+    nameTransform?: McpToolNameTransform;
+    timeoutMs?: number;
+    retryable?: boolean;
+    maxRetries?: number;
+}
+export type McpConnectionStatus = "disconnected" | "connecting" | "connected";
+export interface McpStdioTransportConfig {
+    type: "stdio";
+    command: string;
+    args?: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+}
+export interface McpSseTransportConfig {
+    type: "sse";
+    url: string;
+    headers?: Record<string, string>;
+}
+export interface McpStreamableHttpTransportConfig {
+    type: "streamableHttp";
+    url: string;
+    headers?: Record<string, string>;
+}
+export type McpServerTransportConfig = McpStdioTransportConfig | McpSseTransportConfig | McpStreamableHttpTransportConfig;
+export interface McpServerRegistration {
+    name: string;
+    transport: McpServerTransportConfig;
+    disabled?: boolean;
+    metadata?: Record<string, unknown>;
+}
+export interface McpServerSnapshot {
+    name: string;
+    status: McpConnectionStatus;
+    disabled: boolean;
+    lastError?: string;
+    toolCount: number;
+    updatedAt: number;
+    metadata?: Record<string, unknown>;
+}
+export interface McpServerClient {
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    listTools(): Promise<readonly McpToolDescriptor[]>;
+    callTool(request: {
+        name: string;
+        arguments?: Record<string, unknown>;
+        context?: AgentToolContext;
+    }): Promise<McpToolCallResult>;
+}
+export type McpServerClientFactory = (registration: McpServerRegistration) => Promise<McpServerClient> | McpServerClient;
+export interface McpManagerOptions {
+    clientFactory: McpServerClientFactory;
+    /**
+     * Cache TTL for tools/list responses.
+     * A short cache avoids repeated list requests while keeping server metadata fresh.
+     * @default 5000
+     */
+    toolsCacheTtlMs?: number;
+}
+export interface McpManager extends McpToolProvider {
+    registerServer(registration: McpServerRegistration): Promise<void>;
+    unregisterServer(serverName: string): Promise<void>;
+    connectServer(serverName: string): Promise<void>;
+    disconnectServer(serverName: string): Promise<void>;
+    setServerDisabled(serverName: string, disabled: boolean): Promise<void>;
+    listServers(): readonly McpServerSnapshot[];
+    refreshTools(serverName: string): Promise<readonly McpToolDescriptor[]>;
+    callTool(request: McpToolCallRequest): Promise<McpToolCallResult>;
+    dispose(): Promise<void>;
+}

package/dist/extensions/plugin/plugin-config-loader.d.ts

@@ -0,0 +1,40 @@
+import type { AgentConfig, PluginSetupContext, WorkspaceInfo } from "@cline/shared";
+import type { PluginLoadDiagnostics } from "./plugin-load-report";
+import type { PluginTargeting } from "./plugin-targeting";
+type AgentPlugin = NonNullable<AgentConfig["extensions"]>[number];
+export declare function resolvePluginConfigSearchPaths(workspacePath?: string): string[];
+export declare function discoverPluginModulePaths(directoryPath: string): string[];
+export interface ResolveAgentPluginPathsOptions {
+    pluginPaths?: ReadonlyArray<string>;
+    workspacePath?: string;
+    cwd?: string;
+}
+export declare function resolveAgentPluginPaths(options?: ResolveAgentPluginPathsOptions): string[];
+export interface ResolveAndLoadAgentPluginsOptions extends ResolveAgentPluginPathsOptions, PluginTargeting {
+    mode?: "sandbox" | "in_process";
+    exportName?: string;
+    importTimeoutMs?: number;
+    hookTimeoutMs?: number;
+    contributionTimeoutMs?: number;
+    onEvent?: (event: {
+        name: string;
+        payload?: unknown;
+    }) => void;
+    /**
+     * Structured workspace and git metadata. Forwarded to sandboxed plugins
+     * via PluginSetupCtx.workspaceInfo and made available to in-process plugins
+     * in the extension context.
+     */
+    workspaceInfo?: WorkspaceInfo;
+    session?: PluginSetupContext["session"];
+    client?: PluginSetupContext["client"];
+    user?: PluginSetupContext["user"];
+    automation?: PluginSetupContext["automation"];
+    logger?: PluginSetupContext["logger"];
+    telemetry?: PluginSetupContext["telemetry"];
+}
+export declare function resolveAndLoadAgentPlugins(options?: ResolveAndLoadAgentPluginsOptions): Promise<{
+    extensions: AgentPlugin[];
+    shutdown?: () => Promise<void>;
+} & PluginLoadDiagnostics>;
+export {};

package/dist/extensions/plugin/plugin-load-report.d.ts

@@ -0,0 +1,18 @@
+export interface PluginInitializationFailure {
+    pluginPath: string;
+    pluginName?: string;
+    phase: "load" | "setup";
+    message: string;
+    stack?: string;
+}
+export interface PluginInitializationWarning {
+    type: "duplicate_plugin_override";
+    pluginPath: string;
+    pluginName: string;
+    overriddenPluginPath: string;
+    message: string;
+}
+export interface PluginLoadDiagnostics {
+    failures: PluginInitializationFailure[];
+    warnings: PluginInitializationWarning[];
+}

package/dist/extensions/plugin/plugin-loader.d.ts

@@ -0,0 +1,22 @@
+import type { AgentExtension, PluginSetupContext } from "@cline/shared";
+import type { PluginInitializationFailure, PluginInitializationWarning } from "./plugin-load-report";
+import { type PluginTargeting } from "./plugin-targeting";
+export interface LoadAgentPluginFromPathOptions {
+    exportName?: string;
+    cwd?: string;
+    useCache?: boolean;
+    session?: PluginSetupContext["session"];
+    client?: PluginSetupContext["client"];
+    user?: PluginSetupContext["user"];
+    workspaceInfo?: PluginSetupContext["workspaceInfo"];
+    automation?: PluginSetupContext["automation"];
+    logger?: PluginSetupContext["logger"];
+    telemetry?: PluginSetupContext["telemetry"];
+}
+export declare function loadAgentPluginFromPath(pluginPath: string, options?: LoadAgentPluginFromPathOptions): Promise<AgentExtension>;
+export declare function loadAgentPluginsFromPaths(pluginPaths: string[], options?: LoadAgentPluginFromPathOptions & PluginTargeting): Promise<AgentExtension[]>;
+export declare function loadAgentPluginsFromPathsWithDiagnostics(pluginPaths: string[], options?: LoadAgentPluginFromPathOptions & PluginTargeting): Promise<{
+    plugins: AgentExtension[];
+    failures: PluginInitializationFailure[];
+    warnings: PluginInitializationWarning[];
+}>;

package/dist/extensions/plugin/plugin-module-import.d.ts

@@ -0,0 +1,4 @@
+export interface ImportPluginModuleOptions {
+    useCache?: boolean;
+}
+export declare function importPluginModule(pluginPath: string, options?: ImportPluginModuleOptions): Promise<Record<string, unknown>>;

package/dist/extensions/plugin/plugin-sandbox.d.ts

@@ -0,0 +1,36 @@
+import type { AgentConfig, PluginSetupContext, WorkspaceInfo } from "@cline/shared";
+import type { PluginLoadDiagnostics } from "./plugin-load-report";
+import type { PluginTargeting } from "./plugin-targeting";
+export type SandboxedPluginSetupContext = Pick<PluginSetupContext, "session" | "client" | "user" | "workspaceInfo" | "logger">;
+export interface PluginSandboxOptions extends PluginTargeting {
+    pluginPaths: string[];
+    exportName?: string;
+    importTimeoutMs?: number;
+    hookTimeoutMs?: number;
+    contributionTimeoutMs?: number;
+    onEvent?: (event: {
+        name: string;
+        payload?: unknown;
+    }) => void;
+    /**
+     * The session's working directory. Forwarded to the sandbox subprocess so
+     * that `process.cwd()` returns the correct path inside the sandbox even
+     * when `--cwd` was passed without calling `process.chdir()` on the host.
+     */
+    cwd?: string;
+    /**
+     * Structured workspace and git metadata (branch, commit, remotes) generated
+     * at session startup. Forwarded to plugins via PluginSetupCtx.workspaceInfo
+     * so they can inspect git state without running their own commands.
+     */
+    workspaceInfo?: WorkspaceInfo;
+    session?: SandboxedPluginSetupContext["session"];
+    client?: SandboxedPluginSetupContext["client"];
+    user?: SandboxedPluginSetupContext["user"];
+    /** Enables a logger bridge that forwards sandbox log calls to the host. */
+    logger?: SandboxedPluginSetupContext["logger"];
+}
+export declare function loadSandboxedPlugins(options: PluginSandboxOptions): Promise<{
+    extensions: AgentConfig["extensions"];
+    shutdown: () => Promise<void>;
+} & PluginLoadDiagnostics>;

package/dist/extensions/plugin/plugin-targeting.d.ts

@@ -0,0 +1,6 @@
+import type { PluginManifest } from "@cline/shared";
+export interface PluginTargeting {
+    providerId?: string;
+    modelId?: string;
+}
+export declare function matchesPluginManifestTargeting(manifest: PluginManifest | undefined, targeting: PluginTargeting | undefined): boolean;

package/dist/extensions/plugin-sandbox-bootstrap.js

@@ -0,0 +1 @@
+import{createRequire as n}from"node:module";var t=n(import.meta.url);import{normalizePluginManifest as GY}from"@cline/shared";import{existsSync as z,readFileSync as k}from"node:fs";import{builtinModules as r,createRequire as E}from"node:module";import{dirname as j,extname as S,isAbsolute as a,resolve as K}from"node:path";import{fileURLToPath as y}from"node:url";import{PLUGIN_FILE_EXTENSIONS as s}from"@cline/shared";var i=j(y(import.meta.url)),x=E(import.meta.url),e=K(i,"..","..","..","..",".."),N=YY(e),O=new Set(r.flatMap((Y)=>[Y,Y.replace(/^node:/,"")])),L=new Set(s);function YY(Y){let Z={},$={"@cline/agents":K(Y,"packages/agents/src/index.ts"),"@cline/core":K(Y,"packages/core/src/index.ts"),"@cline/llms":K(Y,"packages/llms/src/index.ts"),"@cline/shared":K(Y,"packages/shared/src/index.ts"),"@cline/shared/storage":K(Y,"packages/shared/src/storage/index.ts"),"@cline/shared/db":K(Y,"packages/shared/src/db/index.ts")};for(let[Q,q]of Object.entries($))if(z(q))Z[Q]=q;return Z}function f(Y){return!(Y.startsWith(".")||Y.startsWith("/")||Y.startsWith("file:")||Y.startsWith("data:")||Y.startsWith("http:")||Y.startsWith("https:"))}function b(Y){if(Y.startsWith("@")){let[Z,$]=Y.split("/",3);return $?`${Z}/${$}`:Y}return Y.split("/",1)[0]??Y}function v(Y,Z){let $=b(Z),Q=j(Y);while(!0){let q=K(Q,"node_modules",$);if(z(q)||z(K(q,"package.json")))return!0;let G=K(Q,"..");if(G===Q)return!1;Q=G}}function ZY(Y){try{return x.resolve(Y),!0}catch{return!1}}function $Y(Y){try{return x.resolve(Y)}catch{return null}}function QY(Y){let $=j(Y);for(let Q=0;Q<4;Q++){let q=K($,"package.json");if(z(q))try{let V=JSON.parse(k(q,"utf8"));return V!=null&&typeof V==="object"&&"cline"in V}catch{return!1}let G=K($,"..");if(G===$)return!1;$=G}return!1}function qY(Y,Z){let $=Z.startsWith("file:")?y(Z):a(Z)?Z:K(j(Y),Z);if(z($)&&L.has(S($)))return $;for(let Q of L){let q=`${$}${Q}`;if(z(q))return q}for(let Q of L){let q=K($,`index${Q}`);if(z(q))return q}return null}function h(Y){let Z=new Set,$=[/\bimport\s+(?:type\s+)?[^"'`]*?\bfrom\s*["'`]([^"'`]+)["'`]/g,/\bexport\s+[^"'`]*?\bfrom\s*["'`]([^"'`]+)["'`]/g,/\bimport\s*\(\s*["'`]([^"'`]+)["'`]\s*\)/g,/\brequire\s*\(\s*["'`]([^"'`]+)["'`]\s*\)/g];for(let Q of $)for(let q of Y.matchAll(Q)){let G=q[1];if(G)Z.add(G)}return[...Z]}function P(Y,Z,$=new Set){if($.has(Y)||!z(Y))return;if($.add(Y),!L.has(S(Y)))return;let Q=k(Y,"utf8");for(let q of h(Q)){if(q.startsWith("node:")||O.has(q))continue;if(f(q)){if(Object.hasOwn(N,q)||Object.hasOwn(N,b(q))||v(Y,q)||Z&&ZY(q))continue;throw Error(`Cannot find module '${b(q)}'`)}let G=qY(Y,q);if(G)P(G,Z,$)}}function wY(Y,Z){let $=E(Y),Q={};for(let[q,G]of Object.entries(N)){try{$.resolve(q);continue}catch{}Q[q]=G}if(Z){let q=k(Y,"utf8");for(let G of h(q)){if(!f(G)||G.startsWith("node:")||O.has(G)||Object.hasOwn(Q,G)||v(Y,G))continue;let V=$Y(G);if(V)Q[G]=V}}return Q}async function m(Y,Z={}){let $=!QY(Y);P(Y,$);let Q=wY(Y,$),q=await import("jiti"),G=typeof q==="function"?q:typeof q.default==="function"?q.default:void 0;if(!G)throw Error("Unable to load jiti");return await G(Y,{alias:Q,cache:Z.useCache,requireCache:Z.useCache,esmResolve:!0,interopDefault:!1,nativeModules:[...O],transformModules:Object.keys(Q)}).import(Y,{})}function d(Y,Z){if(!Y)return!0;if(Y.providerIds?.length){if(!Z?.providerId||!Y.providerIds.includes(Z.providerId))return!1}if(Y.modelIds?.length){if(!Z?.modelId||!Y.modelIds.includes(Z.modelId))return!1}return!0}function X(Y){return typeof Y==="object"&&Y!==null}function c(Y){return Array.isArray(Y)&&Y.every((Z)=>typeof Z==="string")}function JY(Y,Z){if(!X(Y))throw Error(`Invalid plugin module: ${Z}`);if(typeof Y.name!=="string"||!Y.name)throw Error(`Invalid plugin name: ${Z}`);if(!X(Y.manifest))throw Error(`Invalid plugin manifest: ${Z}`);if(Object.hasOwn(Y.manifest,"providerIds")&&!c(Y.manifest.providerIds))throw Error(`Invalid plugin manifest.providerIds: ${Z}`);if(Object.hasOwn(Y.manifest,"modelIds")&&!c(Y.manifest.modelIds))throw Error(`Invalid plugin manifest.modelIds: ${Z}`)}function KY(Y){if(!X(Y))throw Error("Plugin setup context must be an object");if(Y.session!==void 0&&!X(Y.session))throw Error("Plugin setup context session must be an object");if(Y.client!==void 0&&!X(Y.client))throw Error("Plugin setup context client must be an object");if(Y.user!==void 0&&!X(Y.user))throw Error("Plugin setup context user must be an object");if(Y.workspaceInfo!==void 0&&!X(Y.workspaceInfo))throw Error("Plugin setup context workspaceInfo must be an object");if(Y.automation!==void 0&&!X(Y.automation))throw Error("Plugin setup context automation must be an object");if(Y.automation!==void 0&&typeof Y.automation.ingestEvent!=="function")throw Error("Plugin setup context automation.ingestEvent must be a function");if(Y.logger!==void 0&&!X(Y.logger))throw Error("Plugin setup context logger must be an object")}var o=0,A=new Map,T=new Map;function VY(Y){let Z=Y instanceof Error?Y.message:String(Y),$=Y instanceof Error?Y.stack:void 0;return{message:Z,stack:$}}function R(Y,Z,$,Q){if(!process.send)return;process.send({type:"response",id:Y,ok:Z,result:$,error:Q})}function I(Y,Z){if(!process.send)return;process.send({type:"event",name:Y,payload:Z})}globalThis.__clinePluginHost={emitEvent:I};globalThis.__clineSessionEnv={cwd:void 0,workspaceInfo:void 0};function u(Y){if(!Y||typeof Y!=="object")return{};return Y}function WY(Y){if(!Y||typeof Y!=="object")return;let Z={...Y};if(Z.error instanceof Error)Z.error={name:Z.error.name,message:Z.error.message,stack:Z.error.stack};return Z}function XY(Y){let Z=($,Q,q)=>{I("plugin_log",{level:$,pluginName:Y,message:Q,metadata:WY(q)})};return{debug:($,Q)=>Z("debug",$,Q),log:($,Q)=>Z("log",$,Q),error:($,Q)=>Z("error",$,Q)}}function C(Y,Z){let $=`${Y}:${Z}`,Q=(T.get($)??0)+1;return T.set($,Q),`${Y}_${Z}_${Q}`}function FY(Y){let Z=typeof Y.eventType==="string"?Y.eventType.trim():"",$=typeof Y.source==="string"?Y.source.trim():"";if(!Z)throw Error("Automation event type contribution requires eventType");if(!$)throw Error("Automation event type contribution requires source");return{...Y,eventType:Z,source:$,examples:Y.examples?[...Y.examples]:void 0,metadata:Y.metadata?u(Y.metadata):void 0}}function _(Y){let Z=A.get(Y);if(!Z)throw Error(`Unknown sandbox plugin id: ${Y}`);return Z}async function zY(Y){if(A.clear(),o=0,T.clear(),Y.cwd)try{process.chdir(Y.cwd)}catch{}let Z=globalThis.__clineSessionEnv;if(Z)Z.cwd=Y.cwd,Z.workspaceInfo=Y.workspaceInfo;let $=[],Q=[],q=[],G=Y.exportName||"plugin",V=new Map,l={providerId:Y.providerId,modelId:Y.modelId};for(let M of Y.pluginPaths||[]){let J;try{let F=await m(M);if(J=F.default??F[G],JY(J,M),J.manifest=GY(J.manifest),!d(J.manifest,l))continue;let U=`plugin_${++o}`,B={tools:[],commands:[],messageBuilders:[],providers:[],automationEventTypes:[],shortcuts:[],flags:[]},H={tools:new Map,commands:new Map,messageBuilders:new Map},g={registerTool:(w)=>{let W=C(U,"tool");H.tools.set(W,w.execute),B.tools.push({id:W,name:w.name,description:w.description,inputSchema:w.inputSchema,timeoutMs:w.timeoutMs,retryable:w.retryable})},registerCommand:(w)=>{let W=C(U,"command");if(typeof w.handler==="function")H.commands.set(W,w.handler);B.commands.push({id:W,name:w.name,description:w.description})},registerMessageBuilder:(w)=>{let W=C(U,"builder");H.messageBuilders.set(W,w.build),B.messageBuilders.push({id:W,name:w.name})},registerProvider:(w)=>{B.providers.push({id:C(U,"provider"),name:w.name,description:w.description,metadata:u(w.metadata)})},registerAutomationEventType:(w)=>{B.automationEventTypes.push({id:C(U,"automation_event"),...FY(w)})}};if(typeof J.setup==="function")try{let w={session:Y.session,client:Y.client,user:Y.user,workspaceInfo:Y.workspaceInfo,...Y.loggerEnabled?{logger:XY(J.name)}:{},...J.manifest.capabilities.includes("automationEvents")?{automation:{ingestEvent:(W)=>{I("automation_event",W)}}}:{}};KY(w),await J.setup(g,w)}catch(w){Q.push({pluginPath:M,pluginName:J.name,phase:"setup",message:w instanceof Error?w.message:String(w),stack:w instanceof Error?w.stack:void 0});continue}let D=V.get(J.name);if(D!==void 0){let w=$[D];if(!w)V.delete(J.name);else{q.push({type:"duplicate_plugin_override",pluginName:J.name,pluginPath:M,overriddenPluginPath:w.pluginPath,message:`Plugin "${J.name}" from ${M} overrides ${w.pluginPath}`}),A.delete(w.pluginId),$.splice(D,1),V.clear();for(let[W,p]of $.entries())V.set(p.name,W)}}A.set(U,{plugin:J,handlers:H}),V.set(J.name,$.length),$.push({pluginId:U,pluginPath:M,name:J.name,manifest:J.manifest,hooks:J.hooks?Object.entries(J.hooks).filter(([,w])=>typeof w==="function").map(([w])=>w):void 0,contributions:B})}catch(F){Q.push({pluginPath:M,pluginName:J?.name,phase:"load",message:F instanceof Error?F.message:String(F),stack:F instanceof Error?F.stack:void 0})}}return{plugins:$,failures:Q,warnings:q}}async function MY(Y){let $=_(Y.pluginId).plugin.hooks?.[Y.hookName];if(typeof $!=="function")return;return await $(Y.payload)}async function UY(Y){let $=_(Y.pluginId).handlers.tools.get(Y.contributionId);if(typeof $!=="function")throw Error("Unknown sandbox tool contribution");return await $(Y.input,Y.context)}async function BY(Y){let $=_(Y.pluginId).handlers.commands.get(Y.contributionId);if(typeof $!=="function")return"";return await $(Y.input)}async function CY(Y){let $=_(Y.pluginId).handlers.messageBuilders.get(Y.contributionId);if(typeof $!=="function")return[];return await $(Y.messages)}var HY={initialize:zY,invokeHook:MY,executeTool:UY,executeCommand:BY,buildMessages:CY};process.on("message",async(Y)=>{if(!Y||Y.type!=="call")return;let Z=HY[Y.method];if(!Z){R(Y.id,!1,void 0,{message:`Unknown method: ${String(Y.method)}`});return}try{let $=await Z(Y.args||{});R(Y.id,!0,$)}catch($){R(Y.id,!1,void 0,VY($))}});