@oh-my-pi/pi-coding-agent 11.8.3 → 11.9.0

package/src/modes/interactive-mode.ts

@@ -47,6 +47,7 @@ import { CommandController } from "./controllers/command-controller";
 import { EventController } from "./controllers/event-controller";
 import { ExtensionUiController } from "./controllers/extension-ui-controller";
 import { InputController } from "./controllers/input-controller";
+import { MCPCommandController } from "./controllers/mcp-command-controller";
 import { SelectorController } from "./controllers/selector-controller";
 import { setMermaidRenderCallback } from "./theme/mermaid-cache";
 import type { Theme } from "./theme/theme";
@@ -922,6 +923,11 @@ export class InteractiveMode implements InteractiveModeContext {
 		return this.#commandController.handlePythonCommand(code, excludeFromContext);
 	}
 
+	async handleMCPCommand(text: string): Promise<void> {
+		const controller = new MCPCommandController(this);
+		await controller.handle(text);
+	}
+
 	handleCompactCommand(customInstructions?: string): Promise<void> {
 		return this.#commandController.handleCompactCommand(customInstructions);
 	}

package/src/modes/types.ts

@@ -147,6 +147,7 @@ export interface InteractiveModeContext {
 	handleForkCommand(): Promise<void>;
 	handleBashCommand(command: string, excludeFromContext?: boolean): Promise<void>;
 	handlePythonCommand(code: string, excludeFromContext?: boolean): Promise<void>;
+	handleMCPCommand(text: string): Promise<void>;
 	handleCompactCommand(customInstructions?: string): Promise<void>;
 	handleHandoffCommand(customInstructions?: string): Promise<void>;
 	executeCompaction(customInstructionsOrOptions?: string | CompactOptions, isAuto?: boolean): Promise<void>;

package/src/sdk.ts

@@ -710,6 +710,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			// Always filter Exa - we have native integration
 			filterExa: true,
 			cacheStorage: settingsInstance.getStorage(),
+			authStorage,
 		});
 		time("discoverAndLoadMCPTools");
 		debugStartup("sdk:discoverAndLoadMCPTools");

package/src/session/agent-session.ts

@@ -44,6 +44,8 @@ import { type BashResult, executeBash as executeBashCommand } from "../exec/bash
 import { exportSessionToHtml } from "../export/html";
 import type { TtsrManager } from "../export/ttsr";
 import type { LoadedCustomCommand } from "../extensibility/custom-commands";
+import type { CustomTool, CustomToolContext } from "../extensibility/custom-tools/types";
+import { CustomToolAdapter } from "../extensibility/custom-tools/wrapper";
 import type {
 	ExtensionCommandContext,
 	ExtensionRunner,
@@ -57,6 +59,7 @@ import type {
 	TurnStartEvent,
 } from "../extensibility/extensions";
 import type { CompactOptions, ContextUsage } from "../extensibility/extensions/types";
+import { ExtensionToolWrapper } from "../extensibility/extensions/wrapper";
 import type { HookCommandContext } from "../extensibility/hooks/types";
 import type { Skill, SkillWarning } from "../extensibility/skills";
 import { expandSlashCommand, type FileSlashCommand } from "../extensibility/slash-commands";
@@ -965,6 +968,52 @@ export class AgentSession {
 		}
 	}
 
+	/**
+	 * Replace MCP tools in the registry and activate the latest MCP tool set immediately.
+	 * This allows /mcp add/remove/reauth to take effect without restarting the session.
+	 */
+	async refreshMCPTools(mcpTools: CustomTool[]): Promise<void> {
+		const prefix = "mcp_";
+		const existingNames = Array.from(this.#toolRegistry.keys());
+		for (const name of existingNames) {
+			if (name.startsWith(prefix)) {
+				this.#toolRegistry.delete(name);
+			}
+		}
+
+		const getCustomToolContext = (): CustomToolContext => ({
+			sessionManager: this.sessionManager,
+			modelRegistry: this.#modelRegistry,
+			model: this.model,
+			isIdle: () => !this.isStreaming,
+			hasQueuedMessages: () => this.queuedMessageCount > 0,
+			abort: () => {
+				this.agent.abort();
+			},
+		});
+
+		for (const customTool of mcpTools) {
+			const wrapped = CustomToolAdapter.wrap(customTool, getCustomToolContext) as AgentTool;
+			const finalTool = (
+				this.#extensionRunner ? new ExtensionToolWrapper(wrapped, this.#extensionRunner) : wrapped
+			) as AgentTool;
+			this.#toolRegistry.set(finalTool.name, finalTool);
+		}
+
+		const currentActive = this.getActiveToolNames().filter(
+			name => !name.startsWith(prefix) && this.#toolRegistry.has(name),
+		);
+		const mcpToolNames = Array.from(this.#toolRegistry.keys()).filter(name => name.startsWith(prefix));
+		const nextActive = [...currentActive];
+		for (const name of mcpToolNames) {
+			if (!nextActive.includes(name)) {
+				nextActive.push(name);
+			}
+		}
+
+		await this.setActiveToolsByName(nextActive);
+	}
+
 	/** Whether auto-compaction is currently running */
 	get isCompacting(): boolean {
 		return this.#autoCompactionAbortController !== undefined || this.#compactionAbortController !== undefined;

package/src/system-prompt.ts

@@ -4,9 +4,8 @@
 import * as os from "node:os";
 import * as path from "node:path";
 import { getSystemInfo as getNativeSystemInfo, type SystemInfo } from "@oh-my-pi/pi-natives";
-import { $env } from "@oh-my-pi/pi-utils";
+import { $env, logger } from "@oh-my-pi/pi-utils";
 import { $ } from "bun";
-import chalk from "chalk";
 import { contextFileCapability } from "./capability/context-file";
 import { systemPromptCapability } from "./capability/system-prompt";
 import { renderPromptTemplate } from "./config/prompt-templates";
@@ -355,7 +354,7 @@ export async function resolvePromptInput(input: string | undefined, description:
 		try {
 			return await file.text();
 		} catch (error) {
-			console.error(chalk.yellow(`Warning: Could not read ${description} file ${input}: ${error}`));
+			logger.warn(`Could not read ${description} file`, { path: input, error: String(error) });
 			return input;
 		}
 	}

package/src/task/executor.ts

@@ -71,47 +71,35 @@ function normalizeModelPatterns(value: string | string[] | undefined): string[]
 }
 
 function withAbortTimeout<T>(promise: Promise<T>, timeoutMs: number, signal?: AbortSignal): Promise<T> {
-	return new Promise((resolve, reject) => {
-		let settled = false;
-		const timeoutId = setTimeout(() => {
-			if (settled) return;
-			settled = true;
-			reject(new Error(`MCP tool call timed out after ${timeoutMs}ms`));
-		}, timeoutMs);
-
-		const onAbort = () => {
-			if (settled) return;
-			settled = true;
-			clearTimeout(timeoutId);
-			reject(new ToolAbortError());
-		};
+	if (signal?.aborted) {
+		return Promise.reject(new ToolAbortError());
+	}
 
-		if (signal) {
-			if (signal.aborted) {
-				clearTimeout(timeoutId);
-				reject(new ToolAbortError());
-				return;
-			}
-			signal.addEventListener("abort", onAbort, { once: true });
-		}
+	const { promise: wrappedPromise, resolve, reject } = Promise.withResolvers<T>();
+	let settled = false;
+	const timeoutId = setTimeout(() => {
+		if (settled) return;
+		settled = true;
+		reject(new Error(`MCP tool call timed out after ${timeoutMs}ms`));
+	}, timeoutMs);
 
-		promise.then(
-			value => {
-				if (settled) return;
-				settled = true;
-				clearTimeout(timeoutId);
-				if (signal) signal.removeEventListener("abort", onAbort);
-				resolve(value);
-			},
-			error => {
-				if (settled) return;
-				settled = true;
-				clearTimeout(timeoutId);
-				if (signal) signal.removeEventListener("abort", onAbort);
-				reject(error);
-			},
-		);
+	const onAbort = () => {
+		if (settled) return;
+		settled = true;
+		clearTimeout(timeoutId);
+		reject(new ToolAbortError());
+	};
+
+	if (signal) {
+		signal.addEventListener("abort", onAbort, { once: true });
+	}
+
+	promise.then(resolve, reject).finally(() => {
+		if (signal) signal.removeEventListener("abort", onAbort);
+		clearTimeout(timeoutId);
 	});
+
+	return wrappedPromise;
 }
 
 function getReportFindingKey(value: unknown): string | null {

package/src/task/worktree.ts

@@ -1,7 +1,7 @@
 import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import path from "node:path";
-import { Snowflake } from "@oh-my-pi/pi-utils";
+import { isEnoent, Snowflake } from "@oh-my-pi/pi-utils";
 import { $ } from "bun";
 
 export interface WorktreeBaseline {
@@ -88,10 +88,13 @@ export async function applyBaseline(worktreeDir: string, baseline: WorktreeBasel
 	for (const entry of baseline.untracked) {
 		const source = path.join(baseline.repoRoot, entry);
 		const destination = path.join(worktreeDir, entry);
-		const exists = await Bun.file(source).exists();
-		if (!exists) continue;
-		await fs.mkdir(path.dirname(destination), { recursive: true });
-		await fs.cp(source, destination, { recursive: true });
+		try {
+			await fs.mkdir(path.dirname(destination), { recursive: true });
+			await fs.cp(source, destination, { recursive: true });
+		} catch (err) {
+			if (isEnoent(err)) continue;
+			throw err;
+		}
 	}
 }
 

package/src/tools/bash.ts

@@ -1,8 +1,9 @@
-import type * as fs from "node:fs";
+import * as fs from "node:fs";
 import * as path from "node:path";
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
+import { isEnoent } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
 import { renderPromptTemplate } from "../config/prompt-templates";
 import { type BashExecutorOptions, executeBash } from "../exec/bash-executor";
@@ -90,9 +91,12 @@ export class BashTool implements AgentTool<typeof bashSchema, BashToolDetails> {
 		const commandCwd = cwd ? resolveToCwd(cwd, this.session.cwd) : this.session.cwd;
 		let cwdStat: fs.Stats;
 		try {
-			cwdStat = await Bun.file(commandCwd).stat();
-		} catch {
-			throw new ToolError(`Working directory does not exist: ${commandCwd}`);
+			cwdStat = await fs.promises.stat(commandCwd);
+		} catch (err) {
+			if (isEnoent(err)) {
+				throw new ToolError(`Working directory does not exist: ${commandCwd}`);
+			}
+			throw err;
 		}
 		if (!cwdStat.isDirectory()) {
 			throw new ToolError(`Working directory is not a directory: ${commandCwd}`);

package/src/tools/browser.ts

@@ -1,4 +1,4 @@
-import { tmpdir } from "node:os";
+import * as os from "node:os";
 import * as path from "node:path";
 import { Readability } from "@mozilla/readability";
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
@@ -1127,8 +1127,11 @@ export class BrowserTool implements AgentTool<typeof browserSchema, BrowserToolD
 					const page = await this.#ensurePage(params);
 					const value = (await untilAborted(signal, () =>
 						page.evaluate((source: string) => {
-							const evaluator = new Function(`return (${source});`);
-							return evaluator();
+							try {
+								return new Function(`return (${source});`)();
+							} catch {
+								return new Function(source)();
+							}
 						}, script),
 					)) as unknown;
 					const output = formatEvaluateResult(value);
@@ -1289,7 +1292,7 @@ export class BrowserTool implements AgentTool<typeof browserSchema, BrowserToolD
 						{ maxBytes: 0.75 * 1024 * 1024 },
 					);
 					const dimensionNote = formatDimensionNote(resized);
-					const tempFile = path.join(tmpdir(), `omp-sshots-${Snowflake.next()}.png`);
+					const tempFile = path.join(os.tmpdir(), `omp-sshots-${Snowflake.next()}.png`);
 					await Bun.write(tempFile, resized.buffer);
 					details.screenshotPath = tempFile;
 					details.mimeType = resized.mimeType;

package/src/tools/grep.ts

@@ -51,15 +51,6 @@ export interface GrepToolDetails {
 	error?: string;
 }
 
-export interface GrepOperations {
-	isDirectory: (absolutePath: string) => Promise<boolean> | boolean;
-	readFile: (absolutePath: string) => Promise<string> | string;
-}
-
-export interface GrepToolOptions {
-	operations?: GrepOperations;
-}
-
 type GrepParams = Static<typeof grepSchema>;
 
 export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
@@ -68,10 +59,7 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 	readonly description: string;
 	readonly parameters = grepSchema;
 
-	constructor(
-		private readonly session: ToolSession,
-		_options?: GrepToolOptions,
-	) {
+	constructor(private readonly session: ToolSession) {
 		this.description = renderPromptTemplate(grepDescription);
 	}
 

package/src/tools/index.ts

@@ -74,7 +74,7 @@ export { type ExitPlanModeDetails, ExitPlanModeTool } from "./exit-plan-mode";
 export { FetchTool, type FetchToolDetails } from "./fetch";
 export { type FindOperations, FindTool, type FindToolDetails, type FindToolInput, type FindToolOptions } from "./find";
 export { setPreferredImageProvider } from "./gemini-image";
-export { type GrepOperations, GrepTool, type GrepToolDetails, type GrepToolInput, type GrepToolOptions } from "./grep";
+export { GrepTool, type GrepToolDetails, type GrepToolInput } from "./grep";
 export { NotebookTool, type NotebookToolDetails } from "./notebook";
 export { PythonTool, type PythonToolDetails, type PythonToolOptions } from "./python";
 export { ReadTool, type ReadToolDetails, type ReadToolInput } from "./read";

package/src/utils/event-bus.ts

@@ -1,3 +1,5 @@
+import { logger } from "@oh-my-pi/pi-utils";
+
 export class EventBus {
 	readonly #listeners = new Map<string, Set<(data: unknown) => void>>();
 
@@ -18,7 +20,7 @@ export class EventBus {
 			try {
 				await handler(data);
 			} catch (err) {
-				console.error(`Event handler error (${channel}):`, err);
+				logger.error("Event handler error", { channel, error: String(err) });
 			}
 		};
 		this.#listeners.get(channel)!.add(safeHandler);