@cline/core 0.0.76 → 0.0.78

package/dist/hub/server/command-transport.d.ts

@@ -11,4 +11,13 @@ export interface HubCommandTransport {
     subscribe(clientId: string, listener: (event: HubEventEnvelope) => void, options?: {
         sessionId?: string;
     }): Promise<() => void> | (() => void);
+    /**
+     * Durable events with `sequence > sinceSequence` (scoped when a sessionId
+     * is given), oldest first, bounded by `limit`. Absent on transports
+     * without a durable event log; callers must treat replay as best-effort.
+     */
+    replayEventsAfter?(sinceSequence: number, options: {
+        sessionId?: string;
+        limit: number;
+    }): HubEventEnvelope[];
 }

package/dist/hub/server/handlers/approval-handlers.d.ts

@@ -1,9 +1,16 @@
-import type { HubCommandEnvelope, HubReplyEnvelope, ToolApprovalRequest } from "@cline/shared";
+import type { HubCommandEnvelope, HubEventEnvelope, HubReplyEnvelope, ToolApprovalRequest } from "@cline/shared";
 import { type HubTransportContext } from "./context";
 export declare function requestToolApproval(ctx: HubTransportContext, request: ToolApprovalRequest): Promise<{
     approved: boolean;
     reason?: string;
 }>;
+/**
+ * Pending `approval.requested` events, optionally scoped to one session.
+ * Re-issued to a (re)subscribing client so an approval raised while nobody
+ * was connected — or while this client was disconnected — is neither lost
+ * nor implicitly answered.
+ */
+export declare function pendingApprovalEvents(ctx: HubTransportContext, sessionId?: string): HubEventEnvelope[];
 export declare function resolvePendingApproval(ctx: HubTransportContext, approvalId: string, result: {
     approved: boolean;
     reason?: string;

package/dist/hub/server/handlers/context.d.ts

@@ -8,6 +8,12 @@ export type PendingApproval = {
         approved: boolean;
         reason?: string;
     }) => void;
+    /**
+     * The `approval.requested` event as originally published. Pending
+     * approvals survive client disconnects, so a (re)subscribing client is
+     * re-issued this event instead of being left with a silently parked turn.
+     */
+    requestedEvent?: HubEventEnvelope;
 };
 export type PendingCapabilityRequest = {
     sessionId: string;
@@ -46,6 +52,13 @@ export interface HubTransportContext {
     /** Hub-owned extensions injected into every local session runtime. */
     readonly sessionExtensions?: readonly AgentExtension[];
     readonly sessionHost: RuntimeHost & Partial<CommandExecutionRuntimeService & PendingPromptsRuntimeService & SessionUsageRuntimeService & SessionConnectionRuntimeService>;
+    /**
+     * While draining, new mutating work (session.create, run.*) is refused
+     * with the retryable `hub_draining` error so the Hub can be replaced at a
+     * boundary an operator chose instead of being ambushed mid-turn.
+     * Optional: absent contexts (test fixtures) are never draining.
+     */
+    isDraining?(): boolean;
     publish(event: HubEventEnvelope): void;
     buildEvent(event: HubEventEnvelope["event"], payload?: Record<string, unknown>, sessionId?: string): HubEventEnvelope;
     requestCapability(sessionId: string, capabilityName: string, payload: Record<string, unknown>, targetClientId: string, onProgress?: (payload: Record<string, unknown>) => void): Promise<Record<string, unknown> | undefined>;

package/dist/hub/server/handlers/run-queue-handlers.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Queue-backed run admission (`run.enqueue`), queue introspection
+ * (`run.list`), and drain lifecycle (`hub.drain`, `hub.status`).
+ *
+ * `run.start` keeps its historical synchronous-reply contract untouched;
+ * `run.enqueue` is the additive path with app-server semantics: durable FIFO
+ * admission, an immediate `{runId, acceptedAt, queuePosition}` ack, and
+ * execution that never depends on the requesting socket staying alive.
+ */
+import type { HubCommandEnvelope, HubReplyEnvelope } from "@cline/shared";
+import { type HubRunQueue } from "../hub-run-queue";
+import { type HubTransportContext } from "./context";
+export declare const HUB_DRAINING_ERROR_CODE = "hub_draining";
+export declare function isDrainRefusedCommand(command: string): boolean;
+export declare function drainingReply(envelope: HubCommandEnvelope): HubReplyEnvelope;
+/**
+ * Serial per-session executor over the durable queue. Admission and
+ * execution are decoupled: `enqueue` acks immediately, `pump` runs turns one
+ * at a time per session through the same `handleSessionInput` path (and thus
+ * the same event projection) as `run.start`.
+ */
+export declare class HubRunExecutor {
+    private readonly ctx;
+    private readonly queue;
+    private readonly activeSessions;
+    constructor(ctx: HubTransportContext, queue: HubRunQueue);
+    /** Start (or continue) draining the session's queue in the background. */
+    pump(sessionId: string): void;
+    private drainSession;
+    private execute;
+}
+export declare function handleRunEnqueue(ctx: HubTransportContext, envelope: HubCommandEnvelope, queue: HubRunQueue, executor: HubRunExecutor): HubReplyEnvelope;
+export declare function handleRunList(envelope: HubCommandEnvelope, queue: HubRunQueue): HubReplyEnvelope;

package/dist/hub/server/handlers/session-handlers.d.ts

@@ -3,7 +3,7 @@ import type { SessionConnectionUpdate } from "../../../runtime/host/runtime-host
 import { type HubTransportContext } from "./context";
 export declare function selectSessionTools<T extends {
     name: string;
-}>(tools: readonly T[], mode: string): T[];
+}>(tools: readonly T[], mode: string, source?: string): T[];
 export declare function readSessionConnectionUpdate(value: unknown): SessionConnectionUpdate;
 export declare function resolveSessionAutoApproveTools(toolPolicies: unknown, runtimeOptions: Record<string, unknown>): boolean;
 export declare function handleSessionCreate(ctx: HubTransportContext, envelope: HubCommandEnvelope, requestToolApproval: (request: ToolApprovalRequest) => Promise<{

package/dist/hub/server/hub-event-log.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Durable, cursor-addressed Hub event log.
+ *
+ * Every event the Hub publishes is appended here with a monotonically
+ * increasing global sequence before it is fanned out to live sockets. A
+ * client that reconnects can resume exactly where it left off by passing
+ * `sinceSequence` on `stream.subscribe`: the adapter replays pages from this
+ * log, then live-tails. Nothing about delivery depends on who was watching
+ * when the event happened — disconnect never implies data loss.
+ *
+ * The log is a projection aid, not the source of truth for conversation
+ * history (session messages remain canonical on disk); it is bounded by a
+ * retention sweep so it can run forever.
+ */
+import type { HubEventEnvelope } from "@cline/shared";
+export interface HubEventLogOptions {
+    /** Database file. Defaults to an owner-scoped `<data>/db/hub-events-*.db`; use ":memory:" in tests. */
+    dbPath?: string;
+    /** Scopes the default `dbPath`; ignored when `dbPath` is given. */
+    ownerId?: string;
+    /** Events older than this are pruned. Defaults to 7 days. */
+    retentionMs?: number;
+    /** Hard cap on rows kept, oldest pruned first. Defaults to 200k. */
+    maxRows?: number;
+}
+export interface HubEventLogScope {
+    sessionId?: string;
+}
+/**
+ * Default log location, scoped per hub owner context so coexisting hubs
+ * (production and a dev shared hub) never interleave one log's sequences.
+ */
+export declare function resolveHubEventLogPath(ownerId?: string): string;
+export declare class HubEventLogStore {
+    private readonly db;
+    private readonly retentionMs;
+    private readonly maxRows;
+    private closed;
+    constructor(options?: HubEventLogOptions);
+    /**
+     * Append a durable event and return it stamped with its global sequence.
+     * The returned envelope (not the input) is what must be fanned out so
+     * live listeners and replaying clients observe identical frames.
+     */
+    append(envelope: HubEventEnvelope): HubEventEnvelope;
+    /** Events after `sequence`, oldest first, optionally scoped to a session. */
+    listAfter(sequence: number, scope: HubEventLogScope, limit: number): HubEventEnvelope[];
+    lastSequence(): number;
+    /** Bound the log: drop rows past retention, then enforce the row cap. */
+    prune(now?: number): void;
+    close(): void;
+}

package/dist/hub/server/hub-run-queue.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Durable FIFO run queue with immediate acknowledgement.
+ *
+ * `run.enqueue` admits a prompt into this queue and acks immediately with
+ * `{runId, acceptedAt, queuePosition}` — acceptance is decoupled from
+ * execution, so the reply never blocks on the turn and never dies with the
+ * socket. One run executes at a time per session, in admission order.
+ *
+ * Runs are durable: a daemon crash leaves `queued` rows to re-admit in FIFO
+ * order at the next startup, and `running` rows are marked `interrupted` —
+ * never silently resumed, never left dangling as ghost "running" state.
+ *
+ * Admission applies backpressure: a full per-session queue rejects with a
+ * retryable `run_admission_rejected` instead of accepting unbounded work.
+ */
+export type HubRunState = "queued" | "running" | "completed" | "failed" | "aborted" | "interrupted";
+export interface HubRunRecord {
+    runId: string;
+    sessionId: string;
+    state: HubRunState;
+    /** The `run.start`-shaped payload to execute (prompt, mode, attachments, ...). */
+    input: Record<string, unknown>;
+    clientId?: string;
+    acceptedAt: number;
+    startedAt?: number;
+    endedAt?: number;
+    error?: string;
+}
+export interface HubRunAccepted {
+    runId: string;
+    acceptedAt: number;
+    queuePosition: number;
+}
+export declare class HubRunAdmissionRejectedError extends Error {
+    readonly retryable = true;
+    constructor(sessionId: string, pending: number, limit: number);
+}
+export interface HubRunQueueOptions {
+    /** Database file. Defaults to an owner-scoped `<data>/db/hub-runs-*.db`; use ":memory:" in tests. */
+    dbPath?: string;
+    /** Scopes the default `dbPath`; ignored when `dbPath` is given. */
+    ownerId?: string;
+    maxPendingPerSession?: number;
+}
+/**
+ * Default queue location, scoped per hub owner context: startup recovery
+ * marks orphaned `running` rows interrupted, and a coexisting hub (dev
+ * shared next to production) must never reap another hub's live runs.
+ */
+export declare function resolveHubRunQueuePath(ownerId?: string): string;
+export declare class HubRunQueue {
+    private readonly db;
+    private readonly maxPendingPerSession;
+    private closed;
+    constructor(options?: HubRunQueueOptions);
+    /** Durable FIFO admission + immediate acknowledgement. */
+    admit(sessionId: string, input: Record<string, unknown>, clientId?: string): HubRunAccepted;
+    get(runId: string): HubRunRecord | undefined;
+    /** Oldest queued run for the session, if any. */
+    nextQueued(sessionId: string): HubRunRecord | undefined;
+    /** Whether a run is currently marked running for the session. */
+    hasRunning(sessionId: string): boolean;
+    countPendingBySession(sessionId: string): number;
+    countPending(): number;
+    markRunning(runId: string): void;
+    markTerminal(runId: string, state: Extract<HubRunState, "completed" | "failed" | "aborted" | "interrupted">, error?: string): void;
+    list(options?: {
+        sessionId?: string;
+        limit?: number;
+    }): HubRunRecord[];
+    /**
+     * Crash recovery, run once at daemon startup, before any new admission:
+     * runs left `running` by a dead daemon are marked `interrupted` (never
+     * auto-resumed — a resumed half-turn is worse than an honest interrupt),
+     * and committed `queued` runs are returned for FIFO re-admission.
+     */
+    recoverOnStartup(): {
+        interrupted: HubRunRecord[];
+        requeued: HubRunRecord[];
+    };
+    close(): void;
+}

package/dist/hub/server/hub-server-options.d.ts

@@ -5,6 +5,8 @@ import type { CommandExecutionRuntimeService, PendingPromptsRuntimeService, Runt
 import type { CoreSettingsService } from "../../settings";
 import type { AgendaTaskManagerOptions } from "../../tasks";
 import type { HubOwnerContext } from "../discovery";
+import type { HubEventLogOptions } from "./hub-event-log";
+import type { HubRunQueueOptions } from "./hub-run-queue";
 export interface HubWebSocketServerOptions {
     /** Workspace authority assigned by the Hub to authenticated clients. */
     workspaceRoot?: string;
@@ -52,6 +54,14 @@ export interface HubWebSocketServerOptions {
      * signals, and fatal errors through one shutdown coordinator.
      */
     onShutdownRequested?: () => void | Promise<void>;
+    /**
+     * Durable event log configuration. Pass `false` to disable persistence
+     * (events become fire-and-forget, the pre-log behavior; `stream.subscribe`
+     * replay cursors are then best-effort no-ops).
+     */
+    eventLog?: HubEventLogOptions | false;
+    /** Durable run queue configuration (`run.enqueue`). */
+    runQueue?: HubRunQueueOptions | false;
 }
 export interface HubWebSocketServer {
     host: string;

package/dist/hub/server/hub-server-transport.d.ts

@@ -24,12 +24,21 @@ export declare class HubServerTransport implements NativeHubTransport {
     private readonly sessionHost;
     private readonly hubId;
     private readonly ctx;
+    /** Durable event log; created on start(), absent in never-started tests. */
+    private eventLog?;
+    private eventLogPruneTimer?;
+    /** Durable run queue + serial per-session executor (run.enqueue). */
+    private runQueue?;
+    private runExecutor?;
+    private draining;
     constructor(options: HubWebSocketServerOptions);
     private startAgendaTaskSession;
     private runAgendaTaskSession;
     getCronService(): CronService | undefined;
     getHubId(): string;
     start(): Promise<void>;
+    private startEventLog;
+    private startRunQueue;
     stop(): Promise<void>;
     handleCommand(envelope: HubCommandEnvelope, authority?: HubConnectionAuthority | null): Promise<HubReplyEnvelope>;
     private dispatchCommand;
@@ -37,6 +46,22 @@ export declare class HubServerTransport implements NativeHubTransport {
     private commandTelemetryContext;
     private handleSettingsList;
     private handleSettingsToggle;
+    /**
+     * Explicit drain: refuse new mutating work while accepted runs finish.
+     * This is the graceful half of an upgrade — replacement happens at a
+     * boundary an operator chose, never as an ambush under a live turn.
+     */
+    private handleHubDrain;
+    private handleHubStatus;
+    private describeStatus;
+    /** Whether the hub is currently draining (exposed for the HTTP status). */
+    isDraining(): boolean;
+    /** Durable events after a cursor — the adapter's replay source. */
+    replayEventsAfter(sinceSequence: number, options: {
+        sessionId?: string;
+        limit: number;
+    }): HubEventEnvelope[];
+    lastEventSequence(): number;
     subscribe(clientId: string, listener: (event: HubEventEnvelope) => void, options?: {
         sessionId?: string;
     }): () => void;

package/dist/hub/server/native-transport.d.ts

@@ -5,6 +5,11 @@ export interface NativeHubTransport {
     subscribe(clientId: string, listener: (event: HubEventEnvelope) => void, options?: {
         sessionId?: string;
     }): () => void;
+    /** See {@link HubCommandTransport.replayEventsAfter}. */
+    replayEventsAfter?(sinceSequence: number, options: {
+        sessionId?: string;
+        limit: number;
+    }): HubEventEnvelope[];
 }
 export declare class NativeHubTransportAdapter implements HubCommandTransport {
     private readonly transport;
@@ -13,4 +18,8 @@ export declare class NativeHubTransportAdapter implements HubCommandTransport {
     subscribe(clientId: string, listener: (event: HubEventEnvelope) => void, options?: {
         sessionId?: string;
     }): () => void;
+    replayEventsAfter(sinceSequence: number, options: {
+        sessionId?: string;
+        limit: number;
+    }): HubEventEnvelope[];
 }

package/dist/index.d.ts

@@ -113,7 +113,7 @@ export { CORE_BUILD_VERSION } from "./version";
 export declare function loadOpenTelemetryAdapter(): Promise<typeof import("./services/telemetry")>;
 export { Agent, createAgentRuntime } from "@cline/agents";
 export { createCompactionStateAwarePrepareTurn, createContextCompactionPrepareTurn, } from "./extensions/context/compaction";
-export { ALL_DEFAULT_TOOL_NAMES, type ApplyPatchExecutor, type ApplyPatchInput, type AskQuestionExecutor, type BuiltinToolAvailabilityContext, CommandExitError, type CreateBuiltinToolsOptions, type CreateDefaultToolsOptions, computePatchChanges, createApplyPatchExecutor, createBuiltinTools, createDefaultExecutors, createDefaultShellExecutor, createDefaultTools, createDefaultToolsWithPreset, createEditorExecutor, createShellExecutor, createShellTool, createToolPoliciesWithPreset, type DefaultExecutorsOptions, type DefaultToolName, DefaultToolNames, type DefaultToolsConfig, type EditFileInput, type EditorExecutor, type EditorExecutorOptions, getCoreAcpToolNames, getCoreBuiltinToolCatalog, getCoreDefaultEnabledToolIds, getCoreHeadlessToolNames, isSkillsToolAvailable, MAX_COMMAND_OUTPUT_CHARS, PATCH_MARKERS, PatchActionType, type PatchFileChange, resolveCoreSelectedToolIds, type ShellExecutor, type ShellExecutorOptions, type StructuredCommandInput, StructuredCommandInputSchema, TEAM_TOOL_NAMES, type ToolCatalogEntry, type ToolExecutors, type ToolPolicyPresetName, type ToolPresetName, ToolPresets, truncateCommandOutput, } from "./extensions/tools";
+export { ALL_DEFAULT_TOOL_NAMES, type ApplyPatchExecutor, type ApplyPatchInput, type AskQuestionExecutor, type BuiltinToolAvailabilityContext, CommandExitError, type CreateBuiltinToolsOptions, type CreateDefaultToolsOptions, computePatchChanges, createApplyPatchExecutor, createBuiltinTools, createDefaultExecutors, createDefaultShellExecutor, createDefaultTools, createDefaultToolsWithPreset, createEditorExecutor, createShellExecutor, createShellTool, createToolPoliciesWithPreset, type DefaultExecutorsOptions, type DefaultToolName, DefaultToolNames, type DefaultToolsConfig, type EditFileInput, type EditorExecutor, type EditorExecutorOptions, getCoreAcpToolNames, getCoreBuiltinToolCatalog, getCoreDefaultEnabledToolIds, getCoreHeadlessToolNames, isCoreBuiltinToolAvailable, isSkillsToolAvailable, MAX_COMMAND_OUTPUT_CHARS, PATCH_MARKERS, PatchActionType, type PatchFileChange, resolveCoreSelectedToolIds, resolveToolClientType, type ShellExecutor, type ShellExecutorOptions, type StructuredCommandInput, StructuredCommandInputSchema, TEAM_TOOL_NAMES, type ToolCatalogEntry, type ToolClientType, type ToolExecutors, type ToolPolicyPresetName, type ToolPresetName, ToolPresets, truncateCommandOutput, } from "./extensions/tools";
 export { applyClineFeaturedModels, type ClineRecommendedModel, type ClineRecommendedModelsData, FALLBACK_CLINE_RECOMMENDED_MODELS, type FetchClineRecommendedModelsOptions, fetchClineRecommendedModels, getCachedClineRecommendedModels, peekClineRecommendedModels, resetClineRecommendedModelsCacheForTests, } from "./services/llms/cline-recommended-models";
 export { clearLiveModelsCatalogCache, clearPrivateModelsCatalogCache, DEFAULT_MODELS_CATALOG_URL, getLiveModelsCatalog, getProviderConfig, isPrivateModelCatalogProvider, OPENAI_COMPATIBLE_PROVIDERS, resolveProviderConfig, } from "./services/llms/provider-defaults";
 export type { AuthSettings, AwsSettings, AzureSettings, BuiltInProviderId, GcpSettings, ModelCatalogConfig, ModelCatalogSettings, OcaSettings, ProviderCapability, ProviderClient, ProviderConfig, ProviderDefaultsConfig, ProviderId, ProviderProtocol, ProviderSettings, ReasoningSettings, SapSettings, ToProviderConfigOptions, } from "./services/llms/provider-settings";