@oh-my-pi/pi-coding-agent 12.16.0 → 12.17.2

package/src/exec/bash-executor.ts

@@ -34,6 +34,8 @@ export interface BashResult {
 	artifactId?: string;
 }
 
+const HARD_TIMEOUT_GRACE_MS = 5_000;
+
 const shellSessions = new Map<string, Shell>();
 
 export async function executeBash(command: string, options?: BashExecutorOptions): Promise<BashResult> {
@@ -65,74 +67,106 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 		};
 	}
 
+	const sessionKey = buildSessionKey(shell, prefix, snapshotPath, shellEnv, options?.sessionKey);
+	let shellSession = shellSessions.get(sessionKey);
+	if (!shellSession) {
+		shellSession = new Shell({ sessionEnv: shellEnv, snapshotPath: snapshotPath ?? undefined });
+		shellSessions.set(sessionKey, shellSession);
+	}
+	const signal = options?.signal;
+	const abortHandler = () => {
+		shellSession.abort(signal?.reason instanceof Error ? signal.reason.message : undefined);
+	};
+	if (signal) {
+		signal.addEventListener("abort", abortHandler, { once: true });
+	}
+
+	let hardTimeoutTimer: NodeJS.Timeout | undefined;
+	const hardTimeoutDeferred = Promise.withResolvers<"hard-timeout">();
+	const baseTimeoutMs = Math.max(1_000, options?.timeout ?? 300_000);
+	const hardTimeoutMs = baseTimeoutMs + HARD_TIMEOUT_GRACE_MS;
+	hardTimeoutTimer = setTimeout(() => {
+		shellSession.abort(`Hard timeout after ${Math.round(hardTimeoutMs / 1000)}s`);
+		hardTimeoutDeferred.resolve("hard-timeout");
+	}, hardTimeoutMs);
+
+	let resetSession = false;
+
 	try {
-		const sessionKey = buildSessionKey(shell, prefix, snapshotPath, shellEnv, options?.sessionKey);
-		let shellSession = shellSessions.get(sessionKey);
-		if (!shellSession) {
-			shellSession = new Shell({ sessionEnv: shellEnv, snapshotPath: snapshotPath ?? undefined });
-			shellSessions.set(sessionKey, shellSession);
+		const runPromise = shellSession.run(
+			{
+				command: finalCommand,
+				cwd: options?.cwd,
+				env: options?.env,
+				timeoutMs: options?.timeout,
+				signal,
+			},
+			(err, chunk) => {
+				if (!err) {
+					enqueueChunk(chunk);
+				}
+			},
+		);
+
+		const winner = await Promise.race([
+			runPromise.then(result => ({ kind: "result" as const, result })),
+			hardTimeoutDeferred.promise.then(() => ({ kind: "hard-timeout" as const })),
+		]);
+
+		await pendingChunks;
+
+		if (winner.kind === "hard-timeout") {
+			resetSession = true;
+			return {
+				exitCode: undefined,
+				cancelled: true,
+				...(await sink.dump(`Command exceeded hard timeout after ${Math.round(hardTimeoutMs / 1000)} seconds`)),
+			};
 		}
 
-		const signal = options?.signal;
-		const abortHandler = () => {
-			shellSession.abort(signal?.reason instanceof Error ? signal.reason.message : undefined);
-		};
-		if (signal) {
-			signal.addEventListener("abort", abortHandler, { once: true });
+		// Handle timeout
+		if (winner.result.timedOut) {
+			const annotation = options?.timeout
+				? `Command timed out after ${Math.round(options.timeout / 1000)} seconds`
+				: "Command timed out";
+			resetSession = true;
+			return {
+				exitCode: undefined,
+				cancelled: true,
+				...(await sink.dump(annotation)),
+			};
 		}
 
-		try {
-			const result = await shellSession.run(
-				{
-					command: finalCommand,
-					cwd: options?.cwd,
-					env: options?.env,
-					timeoutMs: options?.timeout,
-					signal,
-				},
-				(err, chunk) => {
-					if (!err) {
-						enqueueChunk(chunk);
-					}
-				},
-			);
-
-			await pendingChunks;
-
-			// Handle timeout
-			if (result.timedOut) {
-				const annotation = options?.timeout
-					? `Command timed out after ${Math.round(options.timeout / 1000)} seconds`
-					: "Command timed out";
-				return {
-					exitCode: undefined,
-					cancelled: true,
-					...(await sink.dump(annotation)),
-				};
-			}
-
-			// Handle cancellation
-			if (result.cancelled) {
-				return {
-					exitCode: undefined,
-					cancelled: true,
-					...(await sink.dump("Command cancelled")),
-				};
-			}
-
-			// Normal completion
+		// Handle cancellation
+		if (winner.result.cancelled) {
+			resetSession = true;
 			return {
-				exitCode: result.exitCode,
-				cancelled: false,
-				...(await sink.dump()),
+				exitCode: undefined,
+				cancelled: true,
+				...(await sink.dump("Command cancelled")),
 			};
-		} finally {
-			if (signal) {
-				signal.removeEventListener("abort", abortHandler);
-			}
 		}
+
+		// Normal completion
+		return {
+			exitCode: winner.result.exitCode,
+			cancelled: false,
+			...(await sink.dump()),
+		};
+	} catch (err) {
+		resetSession = true;
+		throw err;
 	} finally {
+		if (hardTimeoutTimer) {
+			clearTimeout(hardTimeoutTimer);
+		}
+		if (signal) {
+			signal.removeEventListener("abort", abortHandler);
+		}
 		await pendingChunks;
+		if (resetSession) {
+			shellSessions.delete(sessionKey);
+		}
 	}
 }
 

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

@@ -182,7 +182,7 @@ export interface CustomTool<TParams extends TSchema = TSchema, TDetails = any> {
 	/** Called on session lifecycle events - use to reconstruct state or cleanup resources */
 	onSession?: (event: CustomToolSessionEvent, ctx: CustomToolContext) => void | Promise<void>;
 	/** Custom rendering for tool call display - return a Component */
-	renderCall?: (args: Static<TParams>, theme: Theme) => Component;
+	renderCall?: (args: Static<TParams>, options: RenderResultOptions, theme: Theme) => Component;
 
 	/** Custom rendering for tool result display - return a Component */
 	renderResult?: (

package/src/extensibility/extensions/types.ts

@@ -304,7 +304,7 @@ export interface ToolDefinition<TParams extends TSchema = TSchema, TDetails = un
 	onSession?: (event: ToolSessionEvent, ctx: ExtensionContext) => void | Promise<void>;
 
 	/** Custom rendering for tool call display */
-	renderCall?: (args: Static<TParams>, theme: Theme) => Component;
+	renderCall?: (args: Static<TParams>, options: ToolRenderResultOptions, theme: Theme) => Component;
 
 	/** Custom rendering for tool result display */
 	renderResult?: (

package/src/extensibility/extensions/wrapper.ts

@@ -18,7 +18,7 @@ export class RegisteredToolAdapter implements AgentTool<any, any, any> {
 	declare parameters: any;
 	declare label: string;
 
-	renderCall?: (args: any, theme: any) => any;
+	renderCall?: (args: any, options: any, theme: any) => any;
 	renderResult?: (result: any, options: any, theme: any, args?: any) => any;
 
 	constructor(
@@ -32,7 +32,8 @@ export class RegisteredToolAdapter implements AgentTool<any, any, any> {
 		// enters the custom-renderer path, gets undefined back, and silently
 		// discards tool result text (extensions without renderers show blank).
 		if (registeredTool.definition.renderCall) {
-			this.renderCall = (args: any, theme: any) => registeredTool.definition.renderCall!(args, theme as Theme);
+			this.renderCall = (args: any, options: any, theme: any) =>
+				registeredTool.definition.renderCall!(args, options, theme as Theme);
 		}
 		if (registeredTool.definition.renderResult) {
 			this.renderResult = (result: any, options: any, theme: any, args?: any) =>

package/src/lsp/render.ts

@@ -31,7 +31,7 @@ import type { LspParams, LspToolDetails } from "./types";
  * Render the LSP tool call in the TUI.
  * Shows: "lsp <operation> <file/filecount>"
  */
-export function renderCall(args: LspParams, theme: Theme): Text {
+export function renderCall(args: LspParams, _options: RenderResultOptions, theme: Theme): Text {
 	const actionLabel = (args.action ?? "request").replace(/_/g, " ");
 	const queryPreview = args.query ? truncateToWidth(args.query, TRUNCATE_LENGTHS.SHORT) : undefined;
 

package/src/mcp/config.ts

@@ -18,6 +18,8 @@ export interface LoadMCPConfigsOptions {
 	enableProjectConfig?: boolean;
 	/** Whether to filter out Exa MCP servers (default: true) */
 	filterExa?: boolean;
+	/** Whether to filter out browser MCP servers when builtin browser tool is enabled (default: false) */
+	filterBrowser?: boolean;
 }
 
 /** Result of loading MCP configs */
@@ -91,6 +93,7 @@ function convertToLegacyConfig(server: MCPServer): MCPServerConfig {
 export async function loadAllMCPConfigs(cwd: string, options?: LoadMCPConfigsOptions): Promise<LoadMCPConfigsResult> {
 	const enableProjectConfig = options?.enableProjectConfig ?? true;
 	const filterExa = options?.filterExa ?? true;
+	const filterBrowser = options?.filterBrowser ?? false;
 
 	// Load MCP servers via capability system
 	const result = await loadCapability<MCPServer>(mcpCapability.id, { cwd });
@@ -103,8 +106,8 @@ export async function loadAllMCPConfigs(cwd: string, options?: LoadMCPConfigsOpt
 	// Load user-level disabled servers list
 	const disabledServers = new Set(await readDisabledServers(getMCPConfigPath("user", cwd)));
 	// Convert to legacy format and preserve source metadata
-	const configs: Record<string, MCPServerConfig> = {};
-	const sources: Record<string, SourceMeta> = {};
+	let configs: Record<string, MCPServerConfig> = {};
+	let sources: Record<string, SourceMeta> = {};
 	for (const server of servers) {
 		const config = convertToLegacyConfig(server);
 		if (config.enabled === false || (server._source.level !== "user" && disabledServers.has(server.name))) {
@@ -114,11 +117,19 @@ export async function loadAllMCPConfigs(cwd: string, options?: LoadMCPConfigsOpt
 		sources[server.name] = server._source;
 	}
 
-	const exaApiKeys: string[] = [];
+	let exaApiKeys: string[] = [];
 
 	if (filterExa) {
-		const filterResult = filterExaMCPServers(configs, sources);
-		return { configs: filterResult.configs, exaApiKeys: filterResult.exaApiKeys, sources: filterResult.sources };
+		const exaResult = filterExaMCPServers(configs, sources);
+		configs = exaResult.configs;
+		sources = exaResult.sources;
+		exaApiKeys = exaResult.exaApiKeys;
+	}
+
+	if (filterBrowser) {
+		const browserResult = filterBrowserMCPServers(configs, sources);
+		configs = browserResult.configs;
+		sources = browserResult.sources;
 	}
 
 	return { configs, exaApiKeys, sources };
@@ -264,3 +275,89 @@ export function validateServerConfig(name: string, config: MCPServerConfig): str
 
 	return errors;
 }
+
+/** Known browser automation MCP server names (lowercase) */
+const BROWSER_MCP_NAMES = new Set([
+	"puppeteer",
+	"playwright",
+	"browserbase",
+	"browser-tools",
+	"browser-use",
+	"browser",
+]);
+
+/** Patterns matching browser MCP package names in command/args */
+const BROWSER_MCP_PKG_PATTERN =
+	// Official packages
+	// - @modelcontextprotocol/server-puppeteer
+	// - @playwright/mcp
+	// - @browserbasehq/mcp-server-browserbase
+	// - @agentdeskai/browser-tools-mcp
+	// - @agent-infra/mcp-server-browser
+	// Community packages: puppeteer-mcp-server, playwright-mcp, pptr-mcp, etc.
+	/(?:@modelcontextprotocol\/server-puppeteer|@playwright\/mcp|@browserbasehq\/mcp-server-browserbase|@agentdeskai\/browser-tools-mcp|@agent-infra\/mcp-server-browser|puppeteer-mcp|playwright-mcp|pptr-mcp|browser-use-mcp|mcp-browser-use)/i;
+
+/** URL patterns for hosted browser MCP services */
+const BROWSER_MCP_URL_PATTERN = /browserbase\.com|browser-use\.com/i;
+
+/**
+ * Check if a server config is a browser automation MCP server.
+ */
+export function isBrowserMCPServer(name: string, config: MCPServerConfig): boolean {
+	// Check by server name
+	if (BROWSER_MCP_NAMES.has(name.toLowerCase())) {
+		return true;
+	}
+
+	// Check by URL for HTTP/SSE servers
+	if (config.type === "http" || config.type === "sse") {
+		const httpConfig = config as { url?: string };
+		if (httpConfig.url && BROWSER_MCP_URL_PATTERN.test(httpConfig.url)) {
+			return true;
+		}
+	}
+
+	// Check by command/args for stdio servers
+	if (!config.type || config.type === "stdio") {
+		const stdioConfig = config as { command?: string; args?: string[] };
+		if (stdioConfig.command && BROWSER_MCP_PKG_PATTERN.test(stdioConfig.command)) {
+			return true;
+		}
+		if (stdioConfig.args?.some(arg => BROWSER_MCP_PKG_PATTERN.test(arg))) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+/** Result of filtering browser MCP servers */
+export interface BrowserFilterResult {
+	/** Configs with browser servers removed */
+	configs: Record<string, MCPServerConfig>;
+	/** Source metadata for remaining servers */
+	sources: Record<string, SourceMeta>;
+}
+
+/**
+ * Filter out browser automation MCP servers.
+ * Since we have a native browser tool, we don't need these MCP servers.
+ */
+export function filterBrowserMCPServers(
+	configs: Record<string, MCPServerConfig>,
+	sources: Record<string, SourceMeta>,
+): BrowserFilterResult {
+	const filtered: Record<string, MCPServerConfig> = {};
+	const filteredSources: Record<string, SourceMeta> = {};
+
+	for (const [name, config] of Object.entries(configs)) {
+		if (!isBrowserMCPServer(name, config)) {
+			filtered[name] = config;
+			if (sources[name]) {
+				filteredSources[name] = sources[name];
+			}
+		}
+	}
+
+	return { configs: filtered, sources: filteredSources };
+}

package/src/mcp/index.ts

@@ -8,10 +8,12 @@
 // Client
 export { callTool, connectToServer, disconnectServer, listTools, serverSupportsTools } from "./client";
 // Config
-export type { ExaFilterResult, LoadMCPConfigsOptions, LoadMCPConfigsResult } from "./config";
+export type { BrowserFilterResult, ExaFilterResult, LoadMCPConfigsOptions, LoadMCPConfigsResult } from "./config";
 export {
 	extractExaApiKey,
+	filterBrowserMCPServers,
 	filterExaMCPServers,
+	isBrowserMCPServer,
 	isExaMCPServer,
 	loadAllMCPConfigs,
 	validateServerConfig,

package/src/mcp/loader.ts

@@ -32,6 +32,8 @@ export interface MCPToolsLoadOptions {
 	enableProjectConfig?: boolean;
 	/** Whether to filter out Exa MCP servers (default: true) */
 	filterExa?: boolean;
+	/** Whether to filter out browser MCP servers when builtin browser tool is enabled (default: false) */
+	filterBrowser?: boolean;
 	/** SQLite storage for MCP tool cache (null disables cache) */
 	cacheStorage?: AgentStorage | null;
 	/** Auth storage used to resolve OAuth credentials before initial MCP connect */
@@ -69,6 +71,7 @@ export async function discoverAndLoadMCPTools(cwd: string, options?: MCPToolsLoa
 			onConnecting: options?.onConnecting,
 			enableProjectConfig: options?.enableProjectConfig,
 			filterExa: options?.filterExa,
+			filterBrowser: options?.filterBrowser,
 		});
 	} catch (error) {
 		// If discovery fails entirely, return empty result

package/src/mcp/manager.ts

@@ -68,6 +68,8 @@ export interface MCPDiscoverOptions {
 	enableProjectConfig?: boolean;
 	/** Whether to filter out Exa MCP servers (default: true) */
 	filterExa?: boolean;
+	/** Whether to filter out browser MCP servers when builtin browser tool is enabled (default: false) */
+	filterBrowser?: boolean;
 	/** Called when starting to connect to servers */
 	onConnecting?: (serverNames: string[]) => void;
 }
@@ -105,6 +107,7 @@ export class MCPManager {
 		const { configs, exaApiKeys, sources } = await loadAllMCPConfigs(this.cwd, {
 			enableProjectConfig: options?.enableProjectConfig,
 			filterExa: options?.filterExa,
+			filterBrowser: options?.filterBrowser,
 		});
 		const result = await this.connectServers(configs, sources, options?.onConnecting);
 		result.exaApiKeys = exaApiKeys;

package/src/mcp/tool-bridge.ts

@@ -198,7 +198,7 @@ export class MCPTool implements CustomTool<TSchema, MCPToolDetails> {
 		this.mcpServerName = connection.name;
 	}
 
-	renderCall(args: unknown, theme: Theme) {
+	renderCall(args: unknown, _options: RenderResultOptions, theme: Theme) {
 		return renderMCPCall((args ?? {}) as Record<string, unknown>, theme, this.label);
 	}
 
@@ -304,7 +304,7 @@ export class DeferredMCPTool implements CustomTool<TSchema, MCPToolDetails> {
 		this.#fallbackProviderName = source?.providerName;
 	}
 
-	renderCall(args: unknown, theme: Theme) {
+	renderCall(args: unknown, _options: RenderResultOptions, theme: Theme) {
 		return renderMCPCall((args ?? {}) as Record<string, unknown>, theme, this.label);
 	}
 

package/src/modes/components/tool-execution.ts

@@ -391,7 +391,7 @@ export class ToolExecutionComponent extends Container {
 			const shouldRenderCall = !this.#result || !mergeCallAndResult;
 			if (shouldRenderCall && tool.renderCall) {
 				try {
-					const callComponent = tool.renderCall(this.#getCallArgsForRender(), theme);
+					const callComponent = tool.renderCall(this.#getCallArgsForRender(), this.#renderState, theme);
 					if (callComponent) {
 						this.#contentBox.addChild(ensureInvalidate(callComponent));
 					}
@@ -453,7 +453,7 @@ export class ToolExecutionComponent extends Container {
 			if (shouldRenderCall) {
 				// Render call component
 				try {
-					const callComponent = renderer.renderCall(this.#getCallArgsForRender(), theme, this.#renderState);
+					const callComponent = renderer.renderCall(this.#getCallArgsForRender(), this.#renderState, theme);
 					if (callComponent) {
 						this.#contentBox.addChild(ensureInvalidate(callComponent));
 					}

package/src/patch/shared.ts

@@ -19,7 +19,6 @@ import {
 	ToolUIKit,
 	truncateDiffByHunk,
 } from "../tools/render-utils";
-import type { RenderCallOptions } from "../tools/renderers";
 import { Ellipsis, Hasher, type RenderCache, renderStatusLine, truncateToWidth } from "../tui";
 import type { DiffError, DiffResult, Operation } from "./types";
 
@@ -254,7 +253,7 @@ function renderDiffSection(
 export const editToolRenderer = {
 	mergeCallAndResult: true,
 
-	renderCall(args: EditRenderArgs, uiTheme: Theme, options?: RenderCallOptions): Component {
+	renderCall(args: EditRenderArgs, options: RenderResultOptions, uiTheme: Theme): Component {
 		const ui = new ToolUIKit(uiTheme);
 		const rawPath = args.file_path || args.path || "";
 		const filePath = shortenPath(rawPath);

package/src/sdk.ts

@@ -806,6 +806,8 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			enableProjectConfig: settings.get("mcp.enableProjectConfig") ?? true,
 			// Always filter Exa - we have native integration
 			filterExa: true,
+			// Filter browser MCP servers when builtin browser tool is active
+			filterBrowser: (settings.get("browser.enabled") as boolean) ?? false,
 			cacheStorage: settings.getStorage(),
 			authStorage,
 		});