jeopi-cli 16.4.2 → 16.4.3

package/src/eval/py/tool-bridge.ts

@@ -15,6 +15,7 @@ export interface PyToolBridgeEntry {
 	toolSession: ToolSession;
 	signal?: AbortSignal;
 	emitStatus?: (event: JsStatusEvent) => void;
+	abortRequested?: () => boolean;
 }
 
 export interface PyToolBridgeInfo {
@@ -31,23 +32,21 @@ const registrations = new Map<string, PyToolBridgeEntry>();
 let serverPromise: Promise<BridgeServer> | null = null;
 
 /**
- * Forward a bridge call to {@link callSessionTool}, but resolve the HTTP request
- * the instant the cell's signal aborts instead of waiting for the tool/subagent
- * to fully tear down.
+ * Forward a bridge call to {@link callSessionTool} while respecting eval abort
+ * shielding.
  *
- * The kernel invokes this bridge with a *blocking* `urllib` request from a
- * worker thread (each `agent()` / `tool.*` call). When the cell is interrupted,
- * `parallel()`'s `ThreadPoolExecutor.__exit__` joins those worker threads
- * (`shutdown(wait=True)`), so they cannot unwind until their `urllib` call
- * returns — i.e. until this handler responds. A host-side `agent()` teardown
- * (aborting nested LLM streams + tools across a wide fan-out) routinely exceeds
- * the kernel's SIGINT escalation window, so the kernel was hard-killed and its
- * persistent state lost while the subagents were still winding down. Responding
- * immediately on abort lets the kernel raise through the blocked call and settle
- * cleanly (preserving state); the already-signaled call keeps tearing down in
- * the background, its eventual result/rejection swallowed.
+ * Python invokes this bridge with blocking `urllib` requests from worker threads
+ * (each `agent()` / `tool.*` call). The base executor defers the registered
+ * signal while a bridge call is already paused so in-flight subagents can finish
+ * and persist output instead of being orphaned. Once an abort has been requested,
+ * later bridge calls are rejected before starting; once the shielded signal
+ * finally aborts, this handler still resolves the HTTP request promptly so the
+ * kernel can unwind without being hard-killed.
  */
 async function callSessionToolPromptOnAbort(name: string, args: unknown, entry: PyToolBridgeEntry): Promise<unknown> {
+	if (entry.abortRequested?.()) {
+		throw new Error(`bridge call ${JSON.stringify(name)} aborted: eval cell was interrupted`);
+	}
 	const call = callSessionTool(name, args, {
 		session: entry.toolSession,
 		signal: entry.signal,

package/src/exec/non-interactive-env.ts

@@ -15,7 +15,6 @@ export const NON_INTERACTIVE_ENV: Readonly<Record<string, string>> = {
 	LESS: "FRX",
 	// Disable terminal features that can block the process.
 	TERM: "dumb",
-	GPG_TTY: "not a tty",
 	NO_COLOR: "1",
 	PYTHONUNBUFFERED: "1",
 	// Disable editor and terminal credential prompts.

package/src/export/ttsr.ts

@@ -447,9 +447,6 @@ export class TtsrManager {
 				strictness: AstMatchStrictness.Smart,
 				limit: 1,
 			});
-			if (result.parseErrors && result.parseErrors.length > 0) {
-				logger.debug("TTSR ast match reported parse errors", { parseErrors: result.parseErrors });
-			}
 			return result.totalMatches > 0;
 		} catch (error) {
 			logger.warn("TTSR ast match failed, treating as no match", {

package/src/extensibility/custom-tools/loader.ts

@@ -24,23 +24,53 @@ import type { CustomToolAPI, CustomToolFactory, LoadedCustomTool, ToolLoadError
 /**
  * Load a single tool module using native Bun import.
  */
+interface LoadToolResult {
+	tools: LoadedCustomTool[];
+	errors: ToolLoadError[];
+}
+
+function isLoadableCustomTool(value: unknown): value is LoadedCustomTool["tool"] {
+	return (
+		typeof value === "object" &&
+		value !== null &&
+		"name" in value &&
+		typeof value.name === "string" &&
+		value.name.length > 0 &&
+		"description" in value &&
+		typeof value.description === "string" &&
+		"parameters" in value &&
+		"execute" in value &&
+		typeof value.execute === "function"
+	);
+}
+
+function invalidToolError(path: string, index: number, source: ToolLoadError["source"]): ToolLoadError {
+	return {
+		path,
+		error: `Tool factory returned invalid tool at index ${index}: expected object with string name, string description, parameters, and execute function`,
+		source,
+	};
+}
+
 async function loadTool(
 	toolPath: string,
 	cwd: string,
 	sharedApi: CustomToolAPI,
 	source?: { provider: string; providerName: string; level: "user" | "project" },
-): Promise<{ tools: LoadedCustomTool[] | null; error: ToolLoadError | null }> {
+): Promise<LoadToolResult> {
 	const resolvedPath = resolvePath(toolPath, cwd);
 
 	// Skip declarative tool files (.md, .json) - these are metadata only, not executable modules
 	if (resolvedPath.endsWith(".md") || resolvedPath.endsWith(".json")) {
 		return {
-			tools: null,
-			error: {
-				path: toolPath,
-				error: "Declarative tool files (.md, .json) cannot be loaded as executable modules",
-				source,
-			},
+			tools: [],
+			errors: [
+				{
+					path: toolPath,
+					error: "Declarative tool files (.md, .json) cannot be loaded as executable modules",
+					source,
+				},
+			],
 		};
 	}
 
@@ -49,23 +79,32 @@ async function loadTool(
 		const factory = (module.default ?? module) as CustomToolFactory;
 
 		if (typeof factory !== "function") {
-			return { tools: null, error: { path: toolPath, error: "Tool must export a default function", source } };
+			return { tools: [], errors: [{ path: toolPath, error: "Tool must export a default function", source }] };
 		}
 
-		const toolResult = await factory(sharedApi);
+		const toolResult: unknown = await factory(sharedApi);
 		const toolsArray = Array.isArray(toolResult) ? toolResult : [toolResult];
 
-		const loadedTools: LoadedCustomTool[] = toolsArray.map(tool => ({
-			path: toolPath,
-			resolvedPath,
-			tool,
-			source,
-		}));
+		const loadedTools: LoadedCustomTool[] = [];
+		const errors: ToolLoadError[] = [];
+		for (const [index, tool] of toolsArray.entries()) {
+			if (!isLoadableCustomTool(tool)) {
+				errors.push(invalidToolError(toolPath, index, source));
+				continue;
+			}
+
+			loadedTools.push({
+				path: toolPath,
+				resolvedPath,
+				tool,
+				source,
+			});
+		}
 
-		return { tools: loadedTools, error: null };
+		return { tools: loadedTools, errors };
 	} catch (err) {
 		const message = err instanceof Error ? err.message : String(err);
-		return { tools: null, error: { path: toolPath, error: `Failed to load tool: ${message}`, source } };
+		return { tools: [], errors: [{ path: toolPath, error: `Failed to load tool: ${message}`, source }] };
 	}
 }
 
@@ -129,28 +168,22 @@ export class CustomToolLoader {
 
 	async load(pathsWithSources: ToolPathWithSource[]): Promise<void> {
 		for (const { path: toolPath, source } of pathsWithSources) {
-			const { tools: loadedTools, error } = await loadTool(toolPath, this.#sharedApi.cwd, this.#sharedApi, source);
+			const { tools: loadedTools, errors } = await loadTool(toolPath, this.#sharedApi.cwd, this.#sharedApi, source);
+			this.errors.push(...errors);
 
-			if (error) {
-				this.errors.push(error);
-				continue;
-			}
-
-			if (loadedTools) {
-				for (const loadedTool of loadedTools) {
-					// Check for name conflicts
-					if (this.#seenNames.has(loadedTool.tool.name)) {
-						this.errors.push({
-							path: toolPath,
-							error: `Tool name "${loadedTool.tool.name}" conflicts with existing tool`,
-							source,
-						});
-						continue;
-					}
-
-					this.#seenNames.add(loadedTool.tool.name);
-					this.tools.push(loadedTool);
+			for (const loadedTool of loadedTools) {
+				// Check for name conflicts
+				if (this.#seenNames.has(loadedTool.tool.name)) {
+					this.errors.push({
+						path: toolPath,
+						error: `Tool name "${loadedTool.tool.name}" conflicts with existing tool`,
+						source,
+					});
+					continue;
 				}
+
+				this.#seenNames.add(loadedTool.tool.name);
+				this.tools.push(loadedTool);
 			}
 		}
 	}

package/src/extensibility/custom-tools/types.ts

@@ -24,6 +24,7 @@ import type { Settings } from "../../config/settings";
 import type { ExecOptions, ExecResult } from "../../exec/exec";
 import type { HookUIContext } from "../../extensibility/hooks/types";
 import type * as PiCodingAgent from "../../index";
+import type { LocalProtocolOptions } from "../../internal-urls/local-protocol";
 import type { Theme } from "../../modes/theme/theme";
 import type { ReadonlySessionManager } from "../../session/session-manager";
 import type { TodoItem } from "../../tools/todo";
@@ -96,6 +97,8 @@ export interface CustomToolContext {
 	settings?: Settings;
 	/** Fetch implementation for outbound HTTP; defaults to global fetch when omitted. */
 	fetch?: FetchImpl;
+	/** Calling session's `local://` root mapping for tools that bridge out of the OMP process. */
+	localProtocolOptions?: LocalProtocolOptions;
 	/** Whether to auto-approve all destructive tool operations (--auto-approve CLI flag) */
 	autoApprove?: boolean;
 }

package/src/extensibility/extensions/runner.ts

@@ -7,6 +7,7 @@ import type { KeyId } from "jeopi-tui";
 import { logger } from "jeopi-utils";
 import type { ModelRegistry } from "../../config/model-registry";
 import type { Settings } from "../../config/settings";
+import type { LocalProtocolOptions } from "../../internal-urls/local-protocol";
 import type { MemoryRuntimeContext } from "../../memory-backend";
 import { type Theme, theme } from "../../modes/theme/theme";
 import type { SessionManager } from "../../session/session-manager";
@@ -255,6 +256,7 @@ export class ExtensionRunner {
 		private readonly modelRegistry: ModelRegistry,
 		getMemory?: () => MemoryRuntimeContext | undefined,
 		private readonly settings?: Settings,
+		private readonly localProtocolOptions?: LocalProtocolOptions,
 	) {
 		this.#uiContext = noOpUIContext;
 		this.#getMemoryFn = getMemory;
@@ -537,6 +539,7 @@ export class ExtensionRunner {
 			hasPendingMessages: () => this.#hasPendingMessagesFn(),
 			shutdown: () => this.#shutdownHandler(),
 			getSystemPrompt: () => this.#getSystemPromptFn(),
+			localProtocolOptions: this.localProtocolOptions,
 			memory: this.#getMemoryFn?.(),
 		};
 	}

package/src/extensibility/extensions/types.ts

@@ -42,6 +42,7 @@ import type { PythonResult } from "../../eval/py/executor";
 import type { BashResult } from "../../exec/bash-executor";
 import type { ExecOptions, ExecResult } from "../../exec/exec";
 import type * as PiCodingAgent from "../../index";
+import type { LocalProtocolOptions } from "../../internal-urls/local-protocol";
 import type { MemoryRuntimeContext } from "../../memory-backend";
 import type { CustomEditor } from "../../modes/components/custom-editor";
 import type { Theme } from "../../modes/theme/theme";
@@ -346,6 +347,8 @@ export interface ExtensionContext {
 	sessionManager: ReadonlySessionManager;
 	/** Model registry for API key resolution */
 	modelRegistry: ModelRegistry;
+	/** Calling session's `local://` root mapping for external tool bridges. */
+	localProtocolOptions?: LocalProtocolOptions;
 	/** Current model (may be undefined) */
 	model: Model | undefined;
 	/** Read-only model query facade: list / current / resolve / family. */

package/src/extensibility/plugins/manager.ts

@@ -212,6 +212,16 @@ export class PluginManager {
 		}
 	}
 
+	async #removeDependencyEntry(pkgJsonPath: string, name: string): Promise<void> {
+		const pkgJson: { dependencies?: Record<string, string>; [key: string]: unknown } =
+			await Bun.file(pkgJsonPath).json();
+		if (!pkgJson.dependencies || !(name in pkgJson.dependencies)) {
+			return;
+		}
+		delete pkgJson.dependencies[name];
+		await Bun.write(pkgJsonPath, JSON.stringify(pkgJson, null, 2));
+	}
+
 	#collectInstalledNames(deps: Record<string, string>, config: PluginRuntimeConfig): Set<string> {
 		const installedNames = new Set<string>();
 		for (const name of Object.keys(deps)) {
@@ -451,6 +461,17 @@ export class PluginManager {
 		// validation throws.
 		let actualName: string | undefined;
 		try {
+			// Bun treats a dependency replacement from `repo#old-ref` to the same
+			// package at `repo`/`repo#new-ref` as a self-edge and bails with
+			// DependencyLoop. Remove only the stale manifest edge; rollback restores
+			// the original package.json and node_modules snapshot on failure.
+			if (gitSource && existingActualName) {
+				const installedSource = parseGitUrl(depsBefore[existingActualName] ?? "");
+				if (installedSource && installedSource.ref !== gitSource.ref) {
+					await this.#removeDependencyEntry(pkgJsonPath, existingActualName);
+				}
+			}
+
 			// Step 1: write the spec into plugins/package.json + node_modules.
 			const installProc = Bun.spawn(["bun", "install", packageInstallSpec], {
 				cwd: getPluginsDir(),