@cline/core 0.0.93 → 0.0.94

package/dist/extensions/plugin/plugin-config-loader.d.ts

@@ -29,18 +29,18 @@ export declare function resolveAgentPluginPathsWithDiagnostics(options?: Resolve
 export declare function resolveAgentPluginPaths(options?: ResolveAgentPluginPathsOptions): string[];
 export declare function resolvePluginSkillDirectoriesFromPaths(pluginPaths: ReadonlyArray<string>): string[];
 export declare function resolveAgentPluginSkillDirectories(options?: ResolveAgentPluginPathsOptions): string[];
-export type PluginExecutionMode = "sandbox" | "worker" | "in_process";
+export type PluginExecutionMode = "sandbox" | "worker";
 export declare const CLINE_PLUGIN_MODE_ENV = "CLINE_PLUGIN_MODE";
 /**
  * Where plugins run (`CLINE_PLUGIN_MODE`, or `mode`):
  * - `worker` (default): each plugin runs in its own worker thread per
  *   session, inside the host runtime. A plugin crash, `process.exit()`, or
  *   hung loop ends only its worker, and no `node`/`bun` is needed on PATH.
- * - `in_process`: plugins are imported into the host process.
  * - `sandbox`: the previous per-session `node`/`bun` subprocess.
  *
- * Builds that do not ship the sandbox bootstrap (a host bundle without it)
- * cannot start workers and fall back to `in_process`.
+ * Plugin code never runs on a host's main thread. Both modes need the
+ * sandbox bootstrap; a build that ships none fails every plugin load with
+ * `PluginBootstrapMissingError` rather than importing plugins into the host.
  */
 export declare function resolvePluginExecutionMode(mode?: PluginExecutionMode): PluginExecutionMode;
 export interface ResolveAndLoadAgentPluginsOptions extends ResolveAgentPluginPathsOptions, PluginTargeting {
@@ -54,9 +54,8 @@ export interface ResolveAndLoadAgentPluginsOptions extends ResolveAgentPluginPat
         payload?: unknown;
     }) => void;
     /**
-     * Structured workspace and git metadata. Forwarded to sandboxed plugins
-     * via PluginSetupCtx.workspaceInfo and made available to in-process plugins
-     * in the extension context.
+     * Structured workspace and git metadata, forwarded to plugins via
+     * PluginSetupCtx.workspaceInfo.
      */
     workspaceInfo?: WorkspaceInfo;
     session?: PluginSetupContext["session"];
@@ -67,14 +66,14 @@ export interface ResolveAndLoadAgentPluginsOptions extends ResolveAgentPluginPat
     telemetry?: PluginSetupContext["telemetry"];
     /**
      * Per-session plugin selection (`"*"` default plus per-plugin overrides).
-     * In-process only; the sandbox loads every discovered plugin.
+     * Worker mode only; the subprocess sandbox loads every discovered plugin.
      */
     policy?: PluginPolicies;
     /** How a failing plugin hook affects the run. Defaults to `"ignore"`. */
     hookErrorMode?: PluginHookErrorMode;
-    /** In-process registry. Defaults to the process-wide registry. */
+    /** Worker mode: the registry to load through. Defaults to the process-wide one. */
     registry?: PluginRegistry;
-    /** In-process only: a plugin this session uses became degraded or failed. */
+    /** Worker mode only: a plugin this session uses became degraded or failed. */
     onIssue?: (issue: SessionPluginIssue) => void;
 }
 export declare function resolveAndLoadAgentPlugins(options?: ResolveAndLoadAgentPluginsOptions): Promise<{

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

@@ -36,8 +36,8 @@ export interface CollectPluginContributionsResult {
 /**
  * Runs each plugin's `setup` with a collecting API, for settings surfaces
  * that list what plugins contribute without starting a session. Plugins load
- * the same way sessions load them: through the shared registry (in workers
- * by default, or in-process), so failures are recorded there like any
- * other, or through the subprocess sandbox when `CLINE_PLUGIN_MODE=sandbox`.
+ * the same way sessions load them: through the shared registry's workers, so
+ * failures are recorded there like any other, or through the subprocess
+ * sandbox when `CLINE_PLUGIN_MODE=sandbox`.
  */
 export declare function collectPluginContributions(input: CollectPluginContributionsInput): Promise<CollectPluginContributionsResult>;

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

@@ -1,6 +1,6 @@
 import type { AgentExtension, BasicLogger, PluginPolicies, PluginSetupContext, PluginStatusRecord, SessionPluginIssue } from "@cline/shared";
 import type { PluginInitializationFailure, PluginInitializationWarning } from "./plugin-load-report";
-import { type PluginTargeting } from "./plugin-targeting";
+import type { PluginTargeting } from "./plugin-targeting";
 export declare const DEFAULT_PLUGIN_IMPORT_TIMEOUT_MS = 4000;
 export declare const DEFAULT_PLUGIN_SETUP_TIMEOUT_MS = 4000;
 export declare const DEFAULT_PLUGIN_HOOK_TIMEOUT_MS = 3000;
@@ -22,17 +22,8 @@ export interface PluginRegistryOptions {
     toolTimeoutMs?: number;
     failureThreshold?: number;
 }
-/**
- * Where a session's plugin copies run. `in_process` imports them into the
- * host. `worker` runs each plugin in its own worker thread per session: the
- * host never loads plugin code, and a crash, `process.exit()`, or hung loop
- * ends only that worker.
- */
-export type PluginIsolation = "in_process" | "worker";
 export interface PluginSessionLoadInput extends PluginTargeting {
     sessionId?: string;
-    /** Defaults to `in_process`. */
-    isolation?: PluginIsolation;
     /** Resolved, enabled plugin module paths, in load order. */
     pluginPaths: ReadonlyArray<string>;
     /** Plugin paths turned off in settings; reported as `disabled`. */
@@ -78,20 +69,14 @@ export interface PluginSessionLoadResult {
 export type PluginStatusListener = (status: PluginStatusRecord) => void;
 /** The name a plugin is known by before its module is imported. */
 export declare function derivePluginNameFromPath(pluginPath: string): string;
-/**
- * Plugins written for the subprocess sandbox emit events through
- * `globalThis.__clinePluginHost.emitEvent`. In-process, route those calls to
- * the session whose hook or tool is running (async context follows timers and
- * promises the call started), else to the session that last called a plugin.
- */
-export declare function installPluginHostShim(): void;
 /**
  * Tracks plugins for the whole process and hands each session a guarded copy
- * of the plugins it enabled. Each session gets its own import of the module,
- * matching the per-session sandbox plugins were written for. Every import,
- * setup, hook, tool, command, rule, and message-builder call is wrapped with
- * a timeout and error capture, and the result is recorded per plugin so
- * failures are visible instead of silently dropping the plugin's tools.
+ * of the plugins it enabled. Each copy runs in its own worker thread, so
+ * module state is per session and plugin code never runs on the host's main
+ * thread. Every import, setup, hook, tool, command, rule, and message-builder
+ * call is wrapped with a timeout and error capture, and the result is
+ * recorded per plugin so failures are visible instead of silently dropping
+ * the plugin's tools.
  */
 export declare class PluginRegistry {
     private readonly entries;
@@ -105,42 +90,36 @@ export declare class PluginRegistry {
     list(): PluginStatusRecord[];
     get(nameOrPath: string): PluginStatusRecord[];
     /**
-     * Re-imports the matching plugins and resets their status. Sessions
-     * started afterwards use the new module; running sessions keep the copy
-     * they set up, which stays callable unless the re-import fails (the plugin
-     * is then turned off for every session, failing closed).
+     * Re-validates the matching plugins' current code in throwaway workers and
+     * resets their status. Sessions started afterwards use the new code;
+     * running sessions keep the copy they set up, which stays callable unless
+     * the re-import fails (the plugin is then turned off for every session,
+     * failing closed).
      */
     reload(nameOrPath: string): Promise<PluginStatusRecord[]>;
     /**
-     * Finds the plugin whose module root appears in `error`'s stack and turns
-     * it off for every session. Used by the Hub daemon so a stray plugin error
-     * does not take the process down.
+     * Loads each plugin in a throwaway worker without attaching it to a
+     * session, so the Hub can discover plugins at startup and report status
+     * (including import errors) before any session exists.
      */
-    attributeUncaughtError(error: unknown, label?: string): PluginStatusRecord | undefined;
+    preload(input: Pick<PluginSessionLoadInput, "pluginPaths" | "disabledPluginPaths" | "discoveryFailures" | "exportName" | "importTimeoutMs">): Promise<PluginStatusRecord[]>;
     /**
-     * Imports plugins without attaching them to a session, so the Hub can
-     * discover them at startup and report status before any session exists.
-     * The imported copy is kept for the first session to claim.
+     * Each plugin loads in its own worker for this session, and the copy
+     * handed to the session is a proxy whose calls go to that worker. The host
+     * never imports plugin code. Every setup, hook, tool, command, rule, and
+     * message-builder call is wrapped with a timeout and error capture, and
+     * the result is recorded per plugin.
      */
-    preload(input: Pick<PluginSessionLoadInput, "pluginPaths" | "disabledPluginPaths" | "discoveryFailures" | "exportName" | "importTimeoutMs" | "isolation">): Promise<PluginStatusRecord[]>;
     loadForSession(input: PluginSessionLoadInput): Promise<PluginSessionLoadResult>;
-    /**
-     * Worker isolation: each plugin loads in its own worker for this session,
-     * and the copy handed to the session is a proxy whose calls go to that
-     * worker. The copy goes through the same wrapping as an in-process one, so
-     * status, timeouts, failure counting, policy, and notices are unchanged.
-     * What differs is where the code runs: the host never imports it.
-     */
-    private loadIsolatedForSession;
     /**
      * Every worker imports the module fresh, so new code needs no host
      * re-import. A source change (or re-enabling) still starts a new import
      * id: the plugin gets a clean slate, and copies of the old code go stale.
      */
-    private refreshIsolatedEntry;
+    private refreshEntry;
     private startWorkerCopy;
-    /** Re-validates a worker plugin's current code in a throwaway worker. */
-    private reloadIsolated;
+    /** Re-validates a plugin's current code in a throwaway worker. */
+    private reloadEntry;
     private staleIssue;
     /**
      * Records discovery failures and settings-disabled plugins. Settings-
@@ -153,16 +132,6 @@ export declare class PluginRegistry {
     private resolveTimeouts;
     private match;
     private ensureEntry;
-    private ensureLoaded;
-    /** Imports one copy of the module in its own call scope. */
-    private importCopy;
-    /**
-     * Hands a session its own copy of the plugin module. Plugins written for
-     * the per-session sandbox keep state at module level (one plugin object
-     * per import), so sharing one copy across sessions would break them.
-     */
-    private claimInstance;
-    private importEntry;
     private wrapForSession;
     private runSetup;
     private wrapHooks;
@@ -173,8 +142,8 @@ export declare class PluginRegistry {
     /** A failing builder leaves the message unchanged. */
     private wrapMessageBuilder;
     /**
-     * Runs one plugin call in its session scope with a timeout, records the
-     * outcome against the plugin, and rethrows failures.
+     * Runs one plugin call with a timeout, records the outcome against the
+     * plugin, and rethrows failures.
      */
     private guardedCall;
     /**

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

@@ -106,13 +106,16 @@ export declare function selectBootstrapCandidate(options: {
     file: string;
 } | {
     sourcePath: string;
-};
+} | undefined;
 /**
- * Whether this build can start the sandbox bootstrap: the compiled file ships
- * beside it, or its TypeScript source exists (running from source). Bundles
- * that ship neither cannot isolate plugins.
+ * @internal Test hook: behave as a host that ships no bootstrap. Tests run
+ * from source, where the `.ts` bootstrap always resolves.
  */
-export declare function isPluginSandboxBootstrapAvailable(): boolean;
+export declare function setPluginBootstrapUnavailableForTests(unavailable: boolean): void;
+/** This build ships no `plugin-sandbox-bootstrap.js`, so no plugin can run. */
+export declare class PluginBootstrapMissingError extends Error {
+    constructor();
+}
 export declare function loadSandboxedPlugins(options: PluginSandboxOptions): Promise<{
     extensions: AgentConfig["extensions"];
     pluginPaths: string[];