@cline/core 0.0.73 → 0.0.74-nightly.1786676845

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

@@ -1,4 +1,23 @@
 import { type HubEndpointOverrides } from "../discovery/defaults";
+export declare const __test__: {
+    /** Retire attempts are module state keyed by URL; clear between cases. */
+    resetRetireAttempts(): void;
+};
+/**
+ * Reads the discovery record the npm postinstall set aside (see
+ * apps/cli/script/postinstall.mjs). Deliberately bypasses readHubDiscovery —
+ * the file is best-effort recovery metadata, not a live record — and stays
+ * synchronous so it adds no async boundary to the ensure flow.
+ *
+ * Exported for `cline doctor`, which must not mistake a shielded live hub for
+ * a stale daemon just because its record is set aside.
+ */
+export declare function readSupersededHubDiscovery(discoveryPath: string): {
+    url?: string;
+    authToken?: string;
+    pid?: number;
+} | undefined;
+export type HubRetirementOutcome = "reusable" | "retired" | "deferred_busy" | "failed";
 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/daemon/shutdown-coordinator.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Kept below the caller-side retirement wait so a current daemon exits through
+ * its own cleanup deadline before an older caller considers force retirement.
+ */
+export declare const HUB_DAEMON_SHUTDOWN_DEADLINE_MS = 2000;
+export interface HubDaemonShutdownRequest {
+    reason: string;
+    exitCode: number;
+}
+export type HubDaemonShutdownState = "idle" | "shutting_down" | "forced" | "finished";
+export interface HubDaemonShutdownCoordinatorOptions {
+    deadlineMs: number;
+    cleanup(): Promise<void>;
+    exit(code: number): void;
+    onCleanupError?(error: unknown): void;
+    onForcedExit?(request: HubDaemonShutdownRequest): void;
+}
+export interface HubDaemonShutdownCoordinator {
+    request(request: HubDaemonShutdownRequest): Promise<void>;
+    force(request: HubDaemonShutdownRequest): void;
+    getState(): HubDaemonShutdownState;
+}
+/**
+ * Owns the daemon's monotonic shutdown lifecycle.
+ *
+ * Every graceful trigger shares one cleanup promise. A later fatal trigger can
+ * raise the eventual exit code, but it cannot run cleanup twice. The deadline
+ * and an explicit second-signal path both use `force`, whose exit is also
+ * guarded so an injected test exit that returns cannot be called repeatedly.
+ */
+export declare function createHubDaemonShutdownCoordinator(options: HubDaemonShutdownCoordinatorOptions): HubDaemonShutdownCoordinator;

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

@@ -8,6 +8,7 @@ export interface HubServerDiscoveryRecord {
     capabilities?: readonly string[];
     coreVersion?: string;
     buildId?: string;
+    buildEpochMs?: number;
     authToken: string;
     host: string;
     port: number;
@@ -23,6 +24,7 @@ export type HubServerProbeRecord = {
     capabilities?: readonly string[];
     coreVersion?: string;
     buildId?: string;
+    buildEpochMs?: number;
     host: string;
     port: number;
     url: string;
@@ -38,6 +40,13 @@ export interface HubOwnerContext {
 }
 export declare function createHubAuthToken(): string;
 export declare function resolveHubBuildId(): string;
+/**
+ * When this SDK build was produced, embedded at bundle time. Orders builds so
+ * managed-Hub handling can distinguish a newer daemon (attach and prompt the
+ * user to update) from a stale one (retire and replace). Undefined when
+ * running from unbundled sources, where no meaningful ordering exists.
+ */
+export declare function resolveHubBuildEpochMs(): number | undefined;
 export type ManagedHubCompatibilityResult = {
     compatible: true;
 } | {
@@ -56,11 +65,59 @@ export type ManagedHubCompatibilityResult = {
 export declare function getManagedHubCompatibility(record: HubProtocolMetadata & {
     buildId?: string;
 }, expectedBuildId?: string): ManagedHubCompatibilityResult;
+export interface HubBuildIdentity {
+    buildId?: string;
+    buildEpochMs?: number;
+    coreVersion?: string;
+}
+/**
+ * Total order over Hub builds: negative when `a` is older than `b`, positive
+ * when newer, zero when the two are indistinguishable.
+ *
+ * The ordering is what keeps concurrent installations from replacing each
+ * other's daemons. A one-sided "may I reuse this?" predicate lets both sides
+ * answer no, and two clients then retire each other's Hub forever; a total
+ * order is antisymmetric by construction, so at most one side can ever decide
+ * to retire. Every tier below preserves that: a field decides only when both
+ * records carry it, and the final fallback is "equal", which means reuse.
+ *
+ * Tiers, in order: identical build, embedded build epoch, core release
+ * version, then build id as a deterministic tiebreak.
+ */
+export declare function compareHubBuilds(a: HubBuildIdentity, b: HubBuildIdentity): number;
+/**
+ * This build's own identity, in the same shape a daemon publishes into its
+ * discovery record.
+ *
+ * Self and peer identities must be built from the same fields. Enriching only
+ * the local side - filling in a `coreVersion` the wire record can omit, say -
+ * makes a build's identity depend on which role it is playing, and two
+ * installations then decide the comparison on different tiers and each
+ * conclude that it is the newer one. Callers that need a synthetic identity
+ * pass it verbatim rather than layering overrides onto this.
+ */
+export declare function resolveHubBuildIdentity(): HubBuildIdentity;
+/**
+ * Whether a client may keep using a managed local Hub instead of retiring it.
+ *
+ * A Hub is retired only when this client's build is *strictly newer* by
+ * {@link compareHubBuilds}. Same build, newer Hub, and indistinguishable
+ * builds all attach over the compatible wire protocol and let the
+ * build-mismatch watcher prompt the user to update. Because the decision is
+ * derived from a total order, two installations can never retire each other.
+ *
+ * Genuine protocol incompatibility is unaffected: those Hubs cannot be spoken
+ * to at all and are still replaced.
+ */
+export declare function isManagedHubReusable(record: HubProtocolMetadata & HubBuildIdentity, options?: {
+    self?: HubBuildIdentity;
+}): boolean;
 export declare function resolveHubOwnerContext(ownerBasis?: string): HubOwnerContext;
 export declare function createInMemoryHubOwnerContext(label?: string): HubOwnerContext;
 export declare function readHubDiscovery(discoveryPath: string): Promise<HubServerDiscoveryRecord | undefined>;
 export declare function writeHubDiscovery(discoveryPath: string, record: HubServerDiscoveryRecord): Promise<void>;
 export declare function clearHubDiscovery(discoveryPath: string): Promise<void>;
+export declare function clearHubDiscoveryIfOwned(discoveryPath: string, hubId: string): Promise<boolean>;
 export declare function withHubStartupLock<T>(discoveryPath: string, callback: () => Promise<T>): Promise<T>;
 export declare function probeHubServer(url: string, options?: {
     authToken?: string;

package/dist/hub/discovery/workspace.d.ts

@@ -1,4 +1,13 @@
 import { type HubOwnerContext } from ".";
 export declare function resolveWorkspaceHubOwnerContext(workspaceRoot: string): HubOwnerContext;
+/**
+ * Development builds change on every compile, so a single shared owner record
+ * puts every checkout and every rebuild in contention for one daemon - and the
+ * loser of that contention gets shut down mid-session. Scoping the owner by
+ * build id lets differing dev builds run their own Hub side by side instead of
+ * arbitrating over one. Production keeps a single owner (see
+ * {@link resolveProductionHubOwnerContext}), where the singleton matters and
+ * builds are ordered.
+ */
 export declare function resolveSharedHubOwnerContext(label?: string): HubOwnerContext;
 export declare function resolveProductionHubOwnerContext(): HubOwnerContext;

package/dist/hub/index.d.ts

@@ -18,6 +18,7 @@ export { HubScheduleService } from "../cron/service/schedule-service";
 export { type ConfiguredTelemetryHandle, type CreateOpenTelemetryTelemetryServiceOptions, createConfiguredTelemetryHandle, createConfiguredTelemetryService, } from "../services/telemetry/OpenTelemetryProvider";
 export * from "./client";
 export * from "./client/connect";
+export * from "./client/managed-hub-build-watcher";
 export * from "./client/session-client";
 export * from "./client/ui-client";
 export * from "./daemon";