@sctg/cline-core 3.84.0-beta.20260524130712

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>;

package/dist/hub/client/session-client.d.ts

@@ -0,0 +1,118 @@
+import type * as LlmsProviders from "@cline/llms";
+import type { ChatRunTurnRequest, ChatStartSessionRequest, ChatStartSessionResponse, ChatTurnResult, TeamProgressProjectionEvent } from "@cline/shared";
+import type { CheckpointEntry } from "../../hooks/checkpoint-hooks";
+type ScheduleClientRecord = Record<string, unknown> & {
+    metadata?: Record<string, unknown>;
+};
+export interface HubSessionClientOptions {
+    address: string;
+    authToken?: string;
+    clientId?: string;
+    clientType?: string;
+    displayName?: string;
+    workspaceRoot?: string;
+    cwd?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface HubSessionRow {
+    sessionId: string;
+    parentSessionId?: string;
+    metadata?: Record<string, unknown>;
+    messagesPath?: string;
+}
+export interface HubStreamEvent {
+    sessionId: string;
+    eventType: string;
+    payload: Record<string, unknown>;
+}
+export interface HubRestoreRequest {
+    sessionId: string;
+    checkpointRunCount: number;
+    config?: ChatStartSessionRequest;
+    restore?: {
+        messages?: boolean;
+        workspace?: boolean;
+        omitCheckpointMessageFromSession?: boolean;
+    };
+}
+export interface HubRestoreResponse {
+    sessionId?: string;
+    startResult?: {
+        sessionId: string;
+        manifestPath: string;
+        messagesPath: string;
+    };
+    messages?: LlmsProviders.Message[];
+    checkpoint: CheckpointEntry;
+}
+export interface HubEventStreamHandlers {
+    onEvent?: (event: HubStreamEvent) => void;
+    onError?: (error: Error) => void;
+}
+export interface HubTeamProgressHandlers {
+    onProjection?: (event: TeamProgressProjectionEvent) => void;
+    onError?: (error: Error) => void;
+}
+export declare class HubSessionClient {
+    private readonly options;
+    private readonly client;
+    private metadataApplied;
+    constructor(options: HubSessionClientOptions);
+    private ensureMetadataApplied;
+    connect(): Promise<void>;
+    close(): void;
+    dispose(): Promise<void>;
+    startRuntimeSession(request: ChatStartSessionRequest): Promise<ChatStartSessionResponse>;
+    sendRuntimeSession(sessionId: string, request: ChatRunTurnRequest, options?: {
+        timeoutMs?: number | null;
+    }): Promise<{
+        result?: ChatTurnResult;
+    }>;
+    stopRuntimeSession(sessionId: string): Promise<{
+        applied: boolean;
+    }>;
+    abortRuntimeSession(sessionId: string): Promise<{
+        applied: boolean;
+    }>;
+    updateSession(input: {
+        sessionId: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<{
+        updated: boolean;
+    }>;
+    getSession(sessionId: string): Promise<HubSessionRow | undefined>;
+    readMessages(sessionId: string): Promise<LlmsProviders.Message[]>;
+    restore(input: HubRestoreRequest): Promise<HubRestoreResponse>;
+    listSessions(input?: {
+        limit?: number;
+    }): Promise<HubSessionRow[]>;
+    deleteSession(sessionId: string, deleteCheckpointRefs?: boolean): Promise<boolean>;
+    respondToolApproval(input: {
+        approvalId: string;
+        approved: boolean;
+        reason?: string;
+        responderClientId?: string;
+    }): Promise<void>;
+    streamEvents(input: {
+        clientId?: string;
+        sessionIds?: string[];
+    }, handlers: HubEventStreamHandlers): () => void;
+    streamTeamProgress(_input: {
+        clientId?: string;
+    }, handlers: HubTeamProgressHandlers): () => void;
+    createSchedule(input: Record<string, unknown>): Promise<ScheduleClientRecord | undefined>;
+    listSchedules(_input?: {
+        limit?: number;
+    }): Promise<ScheduleClientRecord[]>;
+    getSchedule(scheduleId: string): Promise<ScheduleClientRecord | undefined>;
+    updateSchedule(scheduleId: string, input: Record<string, unknown>): Promise<ScheduleClientRecord | undefined>;
+    pauseSchedule(scheduleId: string): Promise<ScheduleClientRecord | undefined>;
+    resumeSchedule(scheduleId: string): Promise<ScheduleClientRecord | undefined>;
+    deleteSchedule(scheduleId: string): Promise<boolean>;
+    triggerScheduleNow(scheduleId: string): Promise<Record<string, unknown> | undefined>;
+    listScheduleExecutions(scheduleId: string, limit?: number): Promise<Array<Record<string, unknown>>>;
+    getScheduleStats(): Promise<Record<string, unknown> | undefined>;
+    getActiveScheduledExecutions(): Promise<Array<Record<string, unknown>>>;
+    getUpcomingScheduledRuns(limit?: number): Promise<Array<Record<string, unknown>>>;
+}
+export {};

package/dist/hub/client/ui-client.d.ts

@@ -0,0 +1,45 @@
+import type { HubClientRecord, HubUINotifyPayload, HubUIShowWindowPayload, SessionRecord } from "@cline/shared";
+export interface HubUIClientOptions {
+    address: string;
+    authToken?: string;
+    clientId?: string;
+    clientType?: string;
+    displayName?: string;
+}
+/**
+ * A lightweight hub client for UI/notification concerns.
+ * Used by the menu bar app and other UI clients to send/receive
+ * UI events (notifications, show window, client tracking).
+ */
+export declare class HubUIClient {
+    private readonly client;
+    constructor(options: HubUIClientOptions);
+    connect(): Promise<void>;
+    close(): void;
+    dispose(): Promise<void>;
+    getClientId(): string;
+    /**
+     * Send a notification request to the hub.
+     * The hub will broadcast a "ui.notify" event to all subscribers (e.g. the menu bar app).
+     */
+    sendNotify(payload: HubUINotifyPayload): Promise<void>;
+    /**
+     * Request the hub to broadcast a "ui.show_window" event to all subscribers.
+     */
+    sendShowWindow(payload?: HubUIShowWindowPayload): Promise<void>;
+    listClients(): Promise<HubClientRecord[]>;
+    listSessions(limit?: number): Promise<SessionRecord[]>;
+    /**
+     * Subscribe to UI-relevant hub events.
+     * Returns an unsubscribe function.
+     */
+    subscribeUI(handlers: {
+        onNotify?: (payload: HubUINotifyPayload) => void;
+        onShowWindow?: (payload: HubUIShowWindowPayload) => void;
+        onClientRegistered?: (payload: Record<string, unknown>) => void;
+        onClientDisconnected?: (payload: Record<string, unknown>) => void;
+        onSessionCreated?: (payload: Record<string, unknown>) => void;
+        onSessionUpdated?: (payload: Record<string, unknown>) => void;
+        onSessionDetached?: (payload: Record<string, unknown>) => void;
+    }): () => void;
+}

package/dist/hub/daemon/entry.d.ts

@@ -0,0 +1 @@
+export {};