@cline/core 0.0.71-nightly.1786157470 → 0.0.72

package/dist/extensions/mcp/client.d.ts

@@ -1,6 +1,6 @@
 import type { FetchLike } from "@modelcontextprotocol/sdk/shared/transport.js";
 import type { McpServerClientFactory } from "./types";
-export declare const DEFAULT_MCP_CONNECT_TIMEOUT_MS = 30000;
+export declare const DEFAULT_MCP_CONNECT_TIMEOUT_MS = 3000;
 export interface DefaultMcpServerClientFactoryOptions {
     settingsPath?: string;
     clientName?: string;

package/dist/extensions/plugin/plugin-sandbox.d.ts

@@ -43,6 +43,30 @@ export interface PluginSandboxOptions extends PluginTargeting {
      */
     telemetryAvailable?: boolean;
 }
+/**
+ * Pick the bootstrap the sandbox subprocess should run.
+ *
+ * Sibling compiled candidates always match the running host build, so they
+ * win. When the host runs from source (the `.ts` bootstrap exists next to
+ * this module), the sandbox must run that SAME source bootstrap: the
+ * wrapper/executable fallbacks locate compiled bootstraps from a separately
+ * installed CLI package (e.g. a published version in the package-manager
+ * cache), and mixing that code with a source host silently breaks plugin
+ * loading because its module resolution points at the other installation's
+ * layout. Those fallbacks exist only for compiled hosts
+ * (`bun build --compile`) where import.meta points inside the binary and no
+ * sibling file exists on real disk.
+ */
+export declare function selectBootstrapCandidate(options: {
+    siblingCandidates: string[];
+    sourceBootstrapPath: string;
+    installedCandidates: Array<string | undefined>;
+    exists?: (path: string) => boolean;
+}): {
+    file: string;
+} | {
+    sourcePath: string;
+};
 export declare function loadSandboxedPlugins(options: PluginSandboxOptions): Promise<{
     extensions: AgentConfig["extensions"];
     pluginPaths: string[];

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

@@ -3,3 +3,13 @@
  * lifecycle handlers are installed.
  */
 export declare const hubDaemonReady: Promise<void>;
+/**
+ * Abort-family rejections are expected daemon noise, not fatal faults: when a
+ * user cancels a turn, in-flight provider streams and fetches can reject on a
+ * floating promise after the run has already settled (DOMException
+ * "AbortError" from fetch/undici, Node ABORT_ERR, or the runtime's own
+ * AgentRuntimeAbortError). Exiting on those kills every resident session in
+ * the daemon — the next message from any connected client then lands on
+ * `session_not_found` and forces a rebuild from disk.
+ */
+export declare function isAbortRejection(reason: unknown): boolean;