@cline/core 0.0.77 → 0.0.78

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

@@ -1,3 +1,4 @@
+import { type HubServerProbeRecord } from "../discovery";
 import { type HubEndpointOverrides } from "../discovery/defaults";
 export declare const __test__: {
     /** Retire attempts are module state keyed by URL; clear between cases. */
@@ -17,7 +18,27 @@ export declare function readSupersededHubDiscovery(discoveryPath: string): {
     authToken?: string;
     pid?: number;
 } | undefined;
+/**
+ * Gracefully retire a discovered hub. Shared by every replacement path
+ * (detached ensure, in-process ensure) so retirement always means the same
+ * thing: drain first, then an authenticated shutdown, SIGTERM only as a
+ * last resort, and discovery cleared only once the hub is actually gone.
+ */
+export declare function retireDiscoveredHub(record: {
+    url: string;
+    authToken?: string;
+    pid?: number;
+}, discoveryPath: string): Promise<boolean>;
 export type HubRetirementOutcome = "reusable" | "retired" | "deferred_busy" | "failed";
+/**
+ * Whether the Hub is currently serving sessions, and so must not be shut down
+ * under them.
+ *
+ * Failing open (treating an unanswerable Hub as idle) preserves the existing
+ * replacement path for a Hub that is wedged or too old to answer the query;
+ * only a Hub that positively reports live sessions is spared.
+ */
+export declare function hubHasLiveSessions(record: Pick<HubServerProbeRecord, "url" | "authToken">): Promise<boolean>;
 export declare function spawnDetachedHubServer(workspaceRoot: string, endpoint?: HubEndpointOverrides): void;
 export declare function spawnDetachedHubServerWithRetry(workspaceRoot: string, endpoint?: HubEndpointOverrides): Promise<void>;
 export declare function prewarmDetachedHubServer(workspaceRoot: string, endpoint?: HubEndpointOverrides & {

package/dist/hub/discovery/instance-lock.d.ts

@@ -0,0 +1,51 @@
+/**
+ * OS-backed exclusive Hub instance lock.
+ *
+ * Authority over a Hub owner context (the discovery path) is an
+ * operating-system exclusive lock, not a PID file, not a heartbeat, and not
+ * build arbitration: the lock is a SQLite database held inside a
+ * never-committed `BEGIN EXCLUSIVE` transaction, which SQLite maps onto OS
+ * file locks. The kernel releases the lock the instant the holding process
+ * dies — crashed holders cannot leak ownership, and a live holder cannot be
+ * displaced by deleting a file.
+ *
+ * A process that fails to acquire the lock must connect to the running Hub
+ * or diagnose — never kill it and never bind another endpoint on its own.
+ * This makes the historical mutual-retire loop (two installs SIGTERMing each
+ * other's daemon, #13145/#13230) structurally impossible: at most one live
+ * Hub can exist per owner context, enforced by the OS before either process
+ * gets a chance to disagree.
+ *
+ * The startup-lock directory (`<discoveryPath>.lock`, see `withHubLock`)
+ * remains a short-lived mutex around discovery reads/writes; this lock is a
+ * different thing — it is held for the entire lifetime of the serving Hub.
+ */
+/** Exit code for a daemon that lost the singleton race: diagnose, never replace. */
+export declare const HUB_LOCK_HELD_EXIT_CODE = 3;
+/** The lock is held by another live Hub process (or connection). */
+export declare class HubLockHeldError extends Error {
+    readonly lockFile: string;
+    constructor(lockFile: string);
+}
+export declare function isHubLockHeldError(error: unknown): error is HubLockHeldError;
+/** The lock file that guards one owner context (derived from its discovery path). */
+export declare function resolveHubInstanceLockPath(discoveryPath: string): string;
+export declare class HubInstanceLock {
+    private db;
+    readonly lockFile: string;
+    private constructor();
+    get held(): boolean;
+    /** Release the lock (process exit releases it too, via the OS). */
+    release(): void;
+    /**
+     * Attempt to take exclusive ownership of a Hub owner context. Throws
+     * `HubLockHeldError` when another live process holds it.
+     *
+     * Only a positively held lock (SQLITE_BUSY/LOCKED) refuses startup. Any
+     * other failure — SQLite unavailable in this runtime, an unwritable lock
+     * directory — degrades to an unheld lock (`held === false`) and the Hub
+     * starts without singleton enforcement, matching how the event log and
+     * run queue already degrade rather than making SQLite a hard requirement.
+     */
+    static acquire(lockFile: string): HubInstanceLock;
+}

package/dist/hub/index.d.ts

@@ -28,8 +28,11 @@ export * from "./daemon/runtime-handlers";
 export * from "./daemon/start-shared-server";
 export * from "./discovery";
 export * from "./discovery/defaults";
+export * from "./discovery/instance-lock";
 export * from "./discovery/workspace";
 export * from "./server";
 export * from "./server/browser-websocket";
 export * from "./server/command-transport";
+export * from "./server/hub-event-log";
+export * from "./server/hub-run-queue";
 export * from "./server/native-transport";