@cline/core 0.0.38-nightly.1778113663

package/dist/extensions/tools/team/spawn-agent-tool.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Reusable spawn_agent tool for delegating tasks to sub-agents.
+ */
+import { type AgentConfig, type AgentEvent, type AgentHooks, type AgentResult, type AgentTool, type AgentToolContext, type BasicLogger, type HookErrorMode, type ITelemetryService, type ToolApprovalRequest, type ToolApprovalResult, type ToolPolicy } from "@cline/shared";
+import { z } from "zod";
+import { type DelegatedAgentConfigProvider } from "./delegated-agent";
+type AgentExtension = NonNullable<AgentConfig["extensions"]>[number];
+type AgentFinishReason = AgentResult["finishReason"];
+export declare const SpawnAgentInputSchema: z.ZodObject<{
+    systemPrompt: z.ZodString;
+    task: z.ZodString;
+}, z.core.$strip>;
+export type SpawnAgentInput = z.infer<typeof SpawnAgentInputSchema>;
+export interface SpawnAgentOutput {
+    text: string;
+    iterations: number;
+    finishReason: AgentFinishReason;
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+}
+export interface SubAgentStartContext {
+    subAgentId: string;
+    conversationId: string;
+    parentAgentId: string;
+    input: SpawnAgentInput;
+}
+export interface SubAgentEndContext {
+    subAgentId: string;
+    conversationId: string;
+    parentAgentId: string;
+    input: SpawnAgentInput;
+    result?: SpawnAgentOutput;
+    error?: Error;
+}
+export interface SpawnAgentToolConfig {
+    configProvider: DelegatedAgentConfigProvider;
+    defaultMaxIterations?: number;
+    subAgentTools?: AgentTool[];
+    createSubAgentTools?: (input: SpawnAgentInput, context: AgentToolContext) => AgentTool[] | Promise<AgentTool[]>;
+    onSubAgentEvent?: (event: AgentEvent) => void;
+    /**
+     * Lifecycle hooks forwarded to spawned sub-agent runs.
+     */
+    hooks?: AgentHooks;
+    /**
+     * Extension list forwarded to spawned sub-agent runs.
+     */
+    extensions?: AgentExtension[];
+    /**
+     * Error handling mode for forwarded lifecycle hooks.
+     */
+    hookErrorMode?: HookErrorMode;
+    /**
+     * Called after a sub-agent instance is created and before it starts running.
+     * Errors are ignored so lifecycle observers cannot break task execution.
+     */
+    onSubAgentStart?: (context: SubAgentStartContext) => void | Promise<void>;
+    /**
+     * Called once a sub-agent run finishes (success or error).
+     * Errors are ignored so lifecycle observers cannot break task execution.
+     */
+    onSubAgentEnd?: (context: SubAgentEndContext) => void | Promise<void>;
+    /**
+     * Optional per-tool policy for spawned sub-agents.
+     */
+    toolPolicies?: Record<string, ToolPolicy>;
+    /**
+     * Optional approval callback for spawned sub-agent tool calls.
+     */
+    requestToolApproval?: (request: ToolApprovalRequest) => Promise<ToolApprovalResult> | ToolApprovalResult;
+    /**
+     * Optional logger forwarded to spawned sub-agent runs.
+     */
+    logger?: BasicLogger;
+    telemetry?: ITelemetryService;
+}
+/**
+ * Create a spawn_agent tool that can run a delegated task with a focused sub-agent.
+ */
+export declare function createSpawnAgentTool(config: SpawnAgentToolConfig): AgentTool<SpawnAgentInput, SpawnAgentOutput>;
+export {};

package/dist/extensions/tools/team/subagent-prompts.d.ts

@@ -0,0 +1,3 @@
+import type { DelegatedAgentRuntimeConfig } from "./delegated-agent";
+export declare function buildTeammateSystemPrompt(prompt: string, config: DelegatedAgentRuntimeConfig): string;
+export declare function buildSubAgentSystemPrompt(prompt: string, config: DelegatedAgentRuntimeConfig): string;

package/dist/extensions/tools/team/team-tools.d.ts

@@ -0,0 +1,35 @@
+import { type AgentTool, type TeamRuntimeState, type TeamTeammateSpec } from "@cline/shared";
+import { type DelegatedAgentConfigProvider, type DelegatedAgentRuntimeConfig } from "./delegated-agent";
+import type { AgentTeamsRuntime } from "./multi-agent";
+export type TeamTeammateRuntimeConfig = DelegatedAgentRuntimeConfig;
+export interface CreateAgentTeamsToolsOptions {
+    runtime: AgentTeamsRuntime;
+    requesterId: string;
+    teammateConfigProvider: DelegatedAgentConfigProvider;
+    createBaseTools?: () => AgentTool[];
+    allowSpawn?: boolean;
+    includeSpawnTool?: boolean;
+    includeManagementTools?: boolean;
+    onLeadToolsUnlocked?: (tools: AgentTool[]) => void;
+}
+export interface BootstrapAgentTeamsOptions {
+    runtime: AgentTeamsRuntime;
+    teammateConfigProvider: DelegatedAgentConfigProvider;
+    createBaseTools?: () => AgentTool[];
+    leadAgentId?: string;
+    restoredTeammates?: TeamTeammateSpec[];
+    restoredFromPersistence?: boolean;
+    includeLeadSpawnTool?: boolean;
+    includeLeadManagementTools?: boolean;
+    onLeadToolsUnlocked?: (tools: AgentTool[]) => void;
+}
+export interface BootstrapAgentTeamsResult {
+    tools: AgentTool[];
+    restoredFromPersistence: boolean;
+    restoredTeammates: string[];
+}
+export declare const TEAM_TOOL_NAMES: readonly ["team_spawn_teammate", "team_shutdown_teammate", "team_status", "team_task", "team_run_task", "team_cancel_run", "team_list_runs", "team_await_runs", "team_send_message", "team_broadcast", "team_read_mailbox", "team_mission_log", "team_cleanup", "team_create_outcome", "team_attach_outcome_fragment", "team_review_outcome_fragment", "team_finalize_outcome", "team_list_outcomes"];
+export declare function bootstrapAgentTeams(options: BootstrapAgentTeamsOptions): BootstrapAgentTeamsResult;
+export declare function createAgentTeamsTools(options: CreateAgentTeamsToolsOptions): AgentTool[];
+export declare function reviveTeamStateDates(state: TeamRuntimeState): TeamRuntimeState;
+export declare function sanitizeTeamName(name: string): string;

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

@@ -0,0 +1,254 @@
+/**
+ * Types for Default Tools
+ *
+ * Type definitions for executors, configuration, and results.
+ */
+import type { AgentToolContext, ImageContent, TextContent } from "@cline/shared";
+import type { ApplyPatchInput, EditFileInput, ReadFileRequest, StructuredCommandInput } from "./schemas";
+/**
+ * Result from a single tool operation
+ */
+export interface ToolOperationResult {
+    /** The query/input that was executed */
+    query: string;
+    /** The result content (if successful) */
+    result: unknown;
+    /** Error message (if failed) */
+    error?: string;
+    /** Whether the operation succeeded */
+    success: boolean;
+    /** Duration in MS */
+    duration?: number;
+}
+export type FileReadResultContent = string | Array<TextContent | ImageContent>;
+/**
+ * Executor for reading files
+ *
+ * @param request - File path and optional inclusive line range to read
+ * @param context - Tool execution context
+ * @returns The file content as a string
+ */
+export type FileReadExecutor = (request: ReadFileRequest, context: AgentToolContext) => Promise<FileReadResultContent>;
+/**
+ * Executor for searching the codebase
+ *
+ * @param query - Regex pattern to search for
+ * @param cwd - Current working directory for the search
+ * @param context - Tool execution context
+ * @returns Search results as a formatted string
+ */
+export type SearchExecutor = (query: string, cwd: string, context: AgentToolContext) => Promise<string>;
+/**
+ * Executor for running shell commands
+ *
+ * @param command - Shell command to execute
+ * @param cwd - Current working directory for execution
+ * @param context - Tool execution context
+ * @returns Command output (stdout)
+ */
+export type BashExecutor = (command: string | StructuredCommandInput, cwd: string, context: AgentToolContext) => Promise<string>;
+/**
+ * Executor for fetching web content
+ *
+ * @param url - URL to fetch
+ * @param prompt - Analysis prompt for the content
+ * @param context - Tool execution context
+ * @returns Analyzed/extracted content
+ */
+export type WebFetchExecutor = (url: string, prompt: string, context: AgentToolContext) => Promise<string>;
+/**
+ * Executor for editing files
+ *
+ * @param input - Editor command input
+ * @param cwd - Current working directory for filesystem operations
+ * @param context - Tool execution context
+ * @returns A formatted operation result string
+ */
+export type EditorExecutor = (input: EditFileInput, cwd: string, context: AgentToolContext) => Promise<string>;
+/**
+ * Executor for apply_patch operations
+ *
+ * @param input - apply_patch command payload
+ * @param cwd - Current working directory for filesystem operations
+ * @param context - Tool execution context
+ * @returns A formatted operation result string
+ */
+export type ApplyPatchExecutor = (input: ApplyPatchInput, cwd: string, context: AgentToolContext) => Promise<string>;
+/**
+ * Executor for invoking configured skills
+ *
+ * @param skill - Skill name to invoke
+ * @param args - Optional arguments for the skill
+ * @param context - Tool execution context
+ * @returns Skill loading/invocation result
+ */
+export type SkillsExecutor = (skill: string, args: string | undefined, context: AgentToolContext) => Promise<string>;
+/**
+ * Executor for asking a single follow-up question with selectable options
+ *
+ * @param question - Single clarifying question for the user
+ * @param options - 2-5 selectable answer options
+ * @param context - Tool execution context
+ * @returns Executor-specific result payload
+ */
+export type AskQuestionExecutor = (question: string, options: string[], context: AgentToolContext) => Promise<string>;
+/**
+ * Skill metadata exposed by SkillsExecutor for clients/UI
+ */
+export interface SkillsExecutorSkillMetadata {
+    /** Normalized skill id (usually lowercased name) */
+    id: string;
+    /** Display name for the skill */
+    name: string;
+    /** Optional short description */
+    description?: string;
+    /** True when configured but intentionally disabled */
+    disabled: boolean;
+}
+/**
+ * A callable executor that can also expose configured skill metadata.
+ */
+export interface SkillsExecutorWithMetadata {
+    (skill: string, args: string | undefined, context: AgentToolContext): Promise<string>;
+    configuredSkills?: SkillsExecutorSkillMetadata[];
+}
+/**
+ * Executor for verifying a user's response to a question
+ *
+ * @param summary - Summary of the solution ans steps taken
+ * @param verified - Boolean indicating if the solution has been verified
+ * @param context - Tool execution context
+ * @returns Executor-specific result payload
+ */
+export type VerifySubmitExecutor = (summary: string, verified: boolean, context: AgentToolContext) => Promise<string>;
+/**
+ * Collection of all tool executors
+ */
+export interface ToolExecutors {
+    /** File reading implementation */
+    readFile?: FileReadExecutor;
+    /** Codebase search implementation */
+    search?: SearchExecutor;
+    /** Shell command execution implementation */
+    bash?: BashExecutor;
+    /** Web content fetching implementation */
+    webFetch?: WebFetchExecutor;
+    /** Filesystem editor implementation */
+    editor?: EditorExecutor;
+    /** Apply patch implementation */
+    applyPatch?: ApplyPatchExecutor;
+    /** Skill invocation implementation */
+    skills?: SkillsExecutorWithMetadata;
+    /** Follow-up question implementation */
+    askQuestion?: AskQuestionExecutor;
+    /** Final submission implementation */
+    submit?: VerifySubmitExecutor;
+}
+/**
+ * Names of available default tools
+ */
+export type DefaultToolName = "read_files" | "search_codebase" | "run_commands" | "fetch_web_content" | "apply_patch" | "editor" | "skills" | "ask_question" | "submit_and_exit";
+/**
+ * Configuration for enabling/disabling default tools
+ */
+export interface DefaultToolsConfig {
+    /**
+     * Enable the read_files tool
+     * @default true
+     */
+    enableReadFiles?: boolean;
+    /**
+     * Enable the search_codebase tool
+     * @default true
+     */
+    enableSearch?: boolean;
+    /**
+     * Enable the run_commands tool
+     * @default true
+     */
+    enableBash?: boolean;
+    /**
+     * Enable the fetch_web_content tool
+     * @default true
+     */
+    enableWebFetch?: boolean;
+    /**
+     * Enable the apply_patch tool
+     * @default true
+     */
+    enableApplyPatch?: boolean;
+    /**
+     * Enable the editor tool
+     * @default true
+     */
+    enableEditor?: boolean;
+    /**
+     * Enable the skills tool
+     * @default true
+     */
+    enableSkills?: boolean;
+    /**
+     * Enable the ask_followup_question tool
+     * @default true
+     */
+    enableAskQuestion?: boolean;
+    /**
+     * Enable the submit_and_exit tool
+     * @default false
+     */
+    enableSubmitAndExit?: boolean;
+    /**
+     * Current working directory for tools that need it
+     */
+    cwd?: string;
+    /**
+     * Timeout for file read operations in milliseconds
+     * @default 10000
+     */
+    fileReadTimeoutMs?: number;
+    /**
+     * Timeout for bash command execution in milliseconds
+     * @default 30000
+     */
+    bashTimeoutMs?: number;
+    /**
+     * Timeout for web fetch operations in milliseconds
+     * @default 30000
+     */
+    webFetchTimeoutMs?: number;
+    /**
+     * Timeout for search operations in milliseconds
+     * @default 30000
+     */
+    searchTimeoutMs?: number;
+    /**
+     * Timeout for apply_patch operations in milliseconds
+     * @default 30000
+     */
+    applyPatchTimeoutMs?: number;
+    /**
+     * Timeout for editor operations in milliseconds
+     * @default 30000
+     */
+    editorTimeoutMs?: number;
+    /**
+     * Timeout for skills operations in milliseconds
+     * @default 15000
+     */
+    skillsTimeoutMs?: number;
+    /**
+     * Timeout for submit_and_exit operations in milliseconds
+     * @default 15000
+     */
+    submitTimeoutMs?: number;
+}
+/**
+ * Options for creating default tools
+ */
+export interface CreateDefaultToolsOptions extends DefaultToolsConfig {
+    /**
+     * Executor implementations for the tools
+     * Only tools with provided executors will be available
+     */
+    executors: ToolExecutors;
+}

package/dist/hooks/checkpoint-hooks.d.ts

@@ -0,0 +1,45 @@
+import type { AgentHooks, BasicLogger } from "@cline/shared";
+export interface CheckpointEntry {
+    ref: string;
+    createdAt: number;
+    runCount: number;
+    kind?: "stash" | "commit";
+}
+export interface CheckpointMetadata {
+    latest: CheckpointEntry;
+    history: CheckpointEntry[];
+}
+type CreateCheckpointHooksOptions = {
+    cwd: string;
+    sessionId: string;
+    logger?: BasicLogger;
+    readSessionMetadata: () => Promise<Record<string, unknown> | undefined>;
+    writeSessionMetadata: (metadata: Record<string, unknown>) => Promise<void> | void;
+    /**
+     * Optional custom checkpoint implementation. When provided, the built-in
+     * git stash/ref logic is skipped entirely and this function is called
+     * instead. Return `undefined` to skip writing a checkpoint for that run.
+     */
+    createCheckpoint?: (context: {
+        cwd: string;
+        sessionId: string;
+        runCount: number;
+    }) => Promise<CheckpointEntry | undefined> | CheckpointEntry | undefined;
+    /**
+     * Starting value for the internal run counter. Use this when a session
+     * is created with initial messages (e.g. after a checkpoint restore) so
+     * that new checkpoint entries get runCount values that don't collide
+     * with entries carried over from the source session.
+     */
+    initialRunCount?: number;
+};
+/**
+ * Deletes all private git refs under refs/cline/checkpoints/{sessionId}/ that
+ * were created by the checkpoint system to keep stash objects reachable.
+ * Errors are swallowed - if the cwd is not a git repo or the refs don't exist,
+ * the delete is a no-op.
+ */
+export declare function deleteCheckpointRefs(cwd: string | null | undefined, sessionId: string): Promise<void>;
+export declare function retainCheckpointRefs(cwd: string | null | undefined, sessionId: string, checkpoints: readonly CheckpointEntry[]): Promise<void>;
+export declare function createCheckpointHooks(options: CreateCheckpointHooksOptions): AgentHooks;
+export {};

package/dist/hooks/hook-extension.d.ts

@@ -0,0 +1,2 @@
+import type { AgentExtension, AgentHooks } from "@cline/shared";
+export declare function createAgentHooksExtension(name: string, hooks: AgentHooks | undefined): AgentExtension | undefined;

package/dist/hooks/hook-file-config.d.ts

@@ -0,0 +1,24 @@
+import { HOOKS_CONFIG_DIRECTORY_NAME } from "@cline/shared/storage";
+import type { HookEventName } from "./subprocess";
+export { HOOKS_CONFIG_DIRECTORY_NAME };
+export declare function resolveHooksConfigSearchPaths(workspacePath?: string): string[];
+export declare enum HookConfigFileName {
+    TaskStart = "TaskStart",
+    TaskResume = "TaskResume",
+    TaskCancel = "TaskCancel",
+    TaskComplete = "TaskComplete",
+    TaskError = "TaskError",
+    PreToolUse = "PreToolUse",
+    PostToolUse = "PostToolUse",
+    UserPromptSubmit = "UserPromptSubmit",
+    PreCompact = "PreCompact",
+    SessionShutdown = "SessionShutdown"
+}
+export declare const HOOK_CONFIG_FILE_EVENT_MAP: Readonly<Record<HookConfigFileName, HookEventName | undefined>>;
+export declare function toHookConfigFileName(fileName: string): HookConfigFileName | undefined;
+export interface HookConfigFileEntry {
+    fileName: HookConfigFileName;
+    hookEventName?: HookEventName;
+    path: string;
+}
+export declare function listHookConfigFiles(workspacePath?: string): HookConfigFileEntry[];

package/dist/hooks/hook-file-hooks.d.ts

@@ -0,0 +1,21 @@
+import type { AgentExtension, AgentHooks } from "@cline/shared";
+import { type BasicLogger, type WorkspaceInfo } from "@cline/shared";
+type HookRuntimeOptions = {
+    cwd: string;
+    workspacePath: string;
+    rootSessionId?: string;
+    logger?: BasicLogger;
+    toolCallTimeoutMs?: number;
+    /** Structured git + path metadata forwarded into every hook payload. */
+    workspaceInfo?: WorkspaceInfo;
+};
+export declare function getWindowsPythonFallbackCommand(command: string[], platform?: NodeJS.Platform, error?: unknown): string[] | undefined;
+export declare function createHookAuditHooks(options: {
+    rootSessionId?: string;
+    workspacePath: string;
+    workspaceInfo?: WorkspaceInfo;
+}): AgentHooks;
+export declare function createHookConfigFileHooks(options: HookRuntimeOptions): AgentHooks | undefined;
+export declare function createHookConfigFileExtension(options: HookRuntimeOptions): AgentExtension | undefined;
+export declare function mergeAgentHooks(layers: Array<AgentHooks | undefined>): AgentHooks | undefined;
+export {};

package/dist/hooks/index.d.ts

@@ -0,0 +1,5 @@
+export { createAgentHooksExtension } from "./hook-extension";
+export { HOOK_CONFIG_FILE_EVENT_MAP, HOOKS_CONFIG_DIRECTORY_NAME, type HookConfigFileEntry, HookConfigFileName, listHookConfigFiles, resolveHooksConfigSearchPaths, toHookConfigFileName, } from "./hook-file-config";
+export { createHookAuditHooks, createHookConfigFileExtension, createHookConfigFileHooks, mergeAgentHooks, } from "./hook-file-hooks";
+export { createSubprocessHooks, type HookEventName, HookEventNameSchema, type HookEventPayload, HookEventPayloadSchema, parseHookEventPayload, type RunHookOptions, type RunHookResult, runHook, type SubprocessHookControl, type SubprocessHooksOptions, } from "./subprocess";
+export { type RunSubprocessEventOptions, type RunSubprocessEventResult, runSubprocessEvent, } from "./subprocess-runner";

package/dist/hooks/subprocess-runner.d.ts

@@ -0,0 +1,21 @@
+export interface RunSubprocessEventOptions {
+    command: string[];
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    detached?: boolean;
+    timeoutMs?: number;
+    onSpawn?: (event: {
+        command: string[];
+        pid?: number;
+        detached: boolean;
+    }) => void;
+}
+export interface RunSubprocessEventResult {
+    exitCode: number | null;
+    stdout: string;
+    stderr: string;
+    parsedJson?: unknown;
+    parseError?: string;
+    timedOut?: boolean;
+}
+export declare function runSubprocessEvent(payload: unknown, options: RunSubprocessEventOptions): Promise<RunSubprocessEventResult | undefined>;

package/dist/hooks/subprocess.d.ts

@@ -0,0 +1,68 @@
+import { type AgentAbortHookPayload, type AgentEndHookPayload, type AgentErrorHookPayload, type AgentHooks, type AgentResumeHookPayload, type AgentStartHookPayload, type HookEventName, HookEventNameSchema, type HookEventPayload, type HookEventPayloadBase, HookEventPayloadSchema, type HookSessionContextProvider, type PostToolUseData, type PreCompactData, type PreCompactHookPayload, type PreToolUseData, type PromptSubmitHookPayload, parseHookEventPayload, type SessionShutdownHookPayload, type TaskCancelData, type TaskCompleteData, type TaskResumeData, type TaskStartData, type ToolCallHookPayload, type ToolResultHookPayload, type UserPromptSubmitData, type WorkspaceInfo } from "@cline/shared";
+import { z } from "zod";
+import { type RunSubprocessEventResult } from "./subprocess-runner";
+export interface HookOutput {
+    contextModification: string;
+    cancel: boolean;
+    review?: boolean;
+    errorMessage: string;
+}
+export declare const HookOutputSchema: z.ZodObject<{
+    contextModification: z.ZodOptional<z.ZodString>;
+    cancel: z.ZodOptional<z.ZodBoolean>;
+    review: z.ZodOptional<z.ZodBoolean>;
+    errorMessage: z.ZodOptional<z.ZodString>;
+    context: z.ZodOptional<z.ZodString>;
+    overrideInput: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$loose>;
+export { HookEventNameSchema, HookEventPayloadSchema, parseHookEventPayload };
+export type { AgentAbortHookPayload, AgentEndHookPayload, AgentErrorHookPayload, AgentResumeHookPayload, AgentStartHookPayload, HookEventName, HookEventPayload, HookEventPayloadBase, PostToolUseData, PreCompactData, PreCompactHookPayload, PreToolUseData, PromptSubmitHookPayload, SessionShutdownHookPayload, TaskCancelData, TaskCompleteData, TaskResumeData, TaskStartData, ToolCallHookPayload, ToolResultHookPayload, UserPromptSubmitData, };
+export interface RunHookOptions {
+    command?: string[];
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    detached?: boolean;
+    timeoutMs?: number;
+    onSpawn?: (event: {
+        command: string[];
+        pid?: number;
+        detached: boolean;
+    }) => void;
+}
+export type RunHookResult = RunSubprocessEventResult;
+export declare function runHook(payload: HookEventPayload, options?: RunHookOptions): Promise<RunHookResult | undefined>;
+export interface SubprocessHooksOptions {
+    command?: string[];
+    cwd?: string;
+    /**
+     * Structured workspace and git metadata forwarded into every hook payload
+     * as `workspaceInfo`. Obtained from `generateWorkspaceInfo` at session
+     * startup and passed here so hook scripts can inspect branch, commit, and
+     * remote without running their own `git` commands.
+     */
+    workspaceInfo?: WorkspaceInfo;
+    env?: NodeJS.ProcessEnv;
+    timeoutMs?: number;
+    onDispatchError?: (error: Error, payload: HookEventPayload) => void;
+    onDispatch?: (event: {
+        payload: HookEventPayload;
+        result?: RunHookResult;
+        detached: boolean;
+    }) => void;
+    onSpawn?: (event: {
+        command: string[];
+        pid?: number;
+        detached: boolean;
+    }) => void;
+    sessionContext?: HookSessionContextProvider;
+}
+export interface SubprocessHookControl {
+    hooks: AgentHooks;
+    shutdown: (ctx: {
+        agentId: string;
+        conversationId: string;
+        parentAgentId: string | null;
+        reason?: string;
+    }) => Promise<void>;
+}
+export declare function createSubprocessHooks(options?: SubprocessHooksOptions): SubprocessHookControl;

package/dist/hub/client/connect.d.ts

@@ -0,0 +1,14 @@
+import type { HubCommandEnvelope, HubReplyEnvelope } from "@cline/shared";
+import { type HubEndpointOverrides } from "../discovery/defaults";
+export interface HubConnection {
+    send(envelope: HubCommandEnvelope): Promise<HubReplyEnvelope>;
+    close(): void;
+}
+export interface HubCommandRequest extends Omit<HubCommandEnvelope, "version" | "clientId"> {
+    version?: HubCommandEnvelope["version"];
+    clientId?: string;
+}
+export declare function resolveHubUrl(overrides?: HubEndpointOverrides): Promise<string>;
+export declare function connectToHub(url: string): Promise<HubConnection>;
+export declare function probeHubConnection(url: string): Promise<boolean>;
+export declare function sendHubCommand(overrides: HubEndpointOverrides, envelope: HubCommandRequest): Promise<HubReplyEnvelope>;

package/dist/hub/client/index.d.ts

@@ -0,0 +1,88 @@
+import { type HubCommandEnvelope, type HubEventEnvelope, type HubReplyEnvelope } from "@cline/shared";
+export interface HubClientOptions {
+    url: string;
+    clientId?: string;
+    clientType?: string;
+    displayName?: string;
+    workspaceRoot?: string;
+    cwd?: string;
+    authToken?: string;
+}
+export interface LocalHubResolutionOptions {
+    endpoint?: string;
+    strategy?: "prefer-hub" | "require-hub";
+    workspaceRoot?: string;
+    cwd?: string;
+}
+export type HubTransportErrorCode = "hub_connect_timeout" | "hub_connect_failed" | "hub_connection_closed" | "hub_connection_not_open";
+export declare class HubTransportError extends Error {
+    readonly code: HubTransportErrorCode;
+    readonly details?: {
+        closeCode?: number;
+        closeReason?: string;
+    } | undefined;
+    constructor(code: HubTransportErrorCode, message: string, details?: {
+        closeCode?: number;
+        closeReason?: string;
+    } | undefined);
+}
+export declare function isHubReconnectableTransportError(error: unknown): error is HubTransportError;
+export declare class HubCommandError extends Error {
+    readonly command: HubCommandEnvelope["command"];
+    readonly code: string | undefined;
+    constructor(command: HubCommandEnvelope["command"], code: string | undefined, message: string);
+}
+export declare function isHubCommandTimeoutError(error: unknown, command?: HubCommandEnvelope["command"]): boolean;
+export declare function rememberRecoverableLocalHubUrl(url: string, authToken?: string): string;
+export declare class NodeHubClient {
+    private readonly options;
+    private socket;
+    private connectPromise;
+    private readonly clientId;
+    private currentUrl;
+    private recoveryPromise;
+    private readonly pendingReplies;
+    private readonly listeners;
+    private readonly subscriptionCounts;
+    private reconnectTimer;
+    private reconnectAttempt;
+    private closedByClient;
+    private lastCloseError;
+    private sawSocketClose;
+    private registered;
+    constructor(options: HubClientOptions);
+    getClientId(): string;
+    getUrl(): string;
+    connect(): Promise<void>;
+    subscribe(listener: (event: HubEventEnvelope) => void, options?: {
+        sessionId?: string;
+    }): () => void;
+    command(command: HubCommandEnvelope["command"], payload?: Record<string, unknown>, sessionId?: string, options?: {
+        timeoutMs?: number | null;
+    }): Promise<HubReplyEnvelope>;
+    private commandOnce;
+    private recoverLocalHubTransport;
+    private hasActiveSubscriptions;
+    private clearReconnectTimer;
+    private scheduleReconnect;
+    private reconnectSubscribedTransport;
+    close(): void;
+    dispose(): Promise<void>;
+    private sendFrame;
+    private sendSubscriptionFrame;
+    private adjustSubscriptionCount;
+    private subscriptionKeyForSessionId;
+    private subscriptionSessionIdFromKey;
+    private handleFrame;
+}
+export declare function normalizeHubWebSocketUrl(url: string): string;
+export declare function verifyHubConnection(url: string, options?: Pick<HubClientOptions, "workspaceRoot" | "cwd" | "authToken">): Promise<boolean>;
+export declare function resolveCompatibleLocalHubUrl(options?: LocalHubResolutionOptions): Promise<string | undefined>;
+export declare function ensureCompatibleLocalHubUrl(options?: LocalHubResolutionOptions): Promise<string | undefined>;
+export declare function requestHubShutdown(url: string, authToken?: string): Promise<boolean>;
+export declare function stopLocalHubServerGracefully(): Promise<boolean>;
+export declare function restartLocalHubIfIdleAfterStartupTimeout(options: {
+    url: string;
+    workspaceRoot?: string;
+    cwd?: string;
+}): Promise<string | undefined>;