@oh-my-pi/pi-coding-agent 1.337.1 → 1.340.0

package/CHANGELOG.md

@@ -2,6 +2,38 @@
 
 ## [Unreleased]
 
+## [1.340.0] - 2026-01-03
+
+### Changed
+
+- Replaced vendored highlight.js and marked.js with CDN-hosted versions for smaller exports
+- Added runtime minification for HTML, CSS, and JS in session exports
+- Session share URL now uses gistpreview.github.io instead of shittycodingagent.ai
+
+## [1.339.0] - 2026-01-03
+
+### Added
+
+- MCP project config setting to disable loading `.mcp.json`/`mcp.json` from project root
+- Support for both `mcp.json` and `.mcp.json` filenames (prefers `mcp.json` if both exist)
+- Automatic Exa MCP server filtering with API key extraction for native integration
+
+## [1.338.0] - 2026-01-03
+
+### Added
+
+- Bash interceptor setting to block shell commands that have dedicated tools (disabled by default, enable via `/settings`)
+
+### Changed
+
+- Refactored settings UI to declarative definitions for easier maintenance
+- Shell detection now respects `$SHELL` environment variable before falling back to bash/sh
+- Tool binary detection now uses `Bun.which()` instead of spawning processes
+
+### Fixed
+
+- CLI help text now accurately lists all default tools
+
 ## [1.337.1] - 2026-01-02
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "1.337.1",
+	"version": "1.340.0",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"piConfig": {
@@ -33,8 +33,8 @@
 		"clean": "rm -rf dist",
 		"build": "tsgo -p tsconfig.build.json && chmod +x dist/cli.js && npm run copy-assets",
 		"build:binary": "npm run build && bun build --compile ./dist/cli.js --outfile dist/pi && npm run copy-binary-assets",
-		"copy-assets": "mkdir -p dist/modes/interactive/theme && cp src/modes/interactive/theme/*.json dist/modes/interactive/theme/ && mkdir -p dist/core/export-html/vendor && cp src/core/export-html/template.html src/core/export-html/template.css src/core/export-html/template.js dist/core/export-html/ && cp src/core/export-html/vendor/*.js dist/core/export-html/vendor/",
-		"copy-binary-assets": "cp package.json dist/ && cp README.md dist/ && cp CHANGELOG.md dist/ && mkdir -p dist/theme && cp src/modes/interactive/theme/*.json dist/theme/ && mkdir -p dist/export-html/vendor && cp src/core/export-html/template.html dist/export-html/ && cp src/core/export-html/vendor/*.js dist/export-html/vendor/ && cp -r docs dist/ && cp -r examples dist/",
+		"copy-assets": "mkdir -p dist/modes/interactive/theme && cp src/modes/interactive/theme/*.json dist/modes/interactive/theme/ && mkdir -p dist/core/export-html && cp src/core/export-html/template.html src/core/export-html/template.css src/core/export-html/template.js dist/core/export-html/",
+		"copy-binary-assets": "cp package.json dist/ && cp README.md dist/ && cp CHANGELOG.md dist/ && mkdir -p dist/theme && cp src/modes/interactive/theme/*.json dist/theme/ && mkdir -p dist/export-html && cp src/core/export-html/template.html src/core/export-html/template.css src/core/export-html/template.js dist/export-html/ && cp -r docs dist/ && cp -r examples dist/",
 		"test": "vitest --run",
 		"prepublishOnly": "npm run clean && npm run build"
 	},

package/src/cli/args.ts

@@ -234,13 +234,19 @@ ${chalk.bold("Environment Variables:")}
   ${chalk.dim("# Configuration")}
   ${ENV_AGENT_DIR.padEnd(23)} - Session storage directory (default: ~/${CONFIG_DIR_NAME}/agent)
 
-${chalk.bold("Available Tools (default: read, bash, edit, write):")}
-  read   - Read file contents
-  bash   - Execute bash commands
-  edit   - Edit files with find/replace
-  write  - Write files (creates/overwrites)
-  grep   - Search file contents (read-only, off by default)
-  find   - Find files by glob pattern (read-only, off by default)
-  ls     - List directory contents (read-only, off by default)
+${chalk.bold("Available Tools (all enabled by default):")}
+  read       - Read file contents
+  bash       - Execute bash commands
+  edit       - Edit files with find/replace
+  write      - Write files (creates/overwrites)
+  grep       - Search file contents
+  find       - Find files by glob pattern
+  ls         - List directory contents
+  lsp        - Language server protocol (code intelligence)
+  notebook   - Edit Jupyter notebooks
+  task       - Launch sub-agents for parallel tasks
+  web_fetch  - Fetch and process web pages
+  web_search - Search the web
+  ask        - Ask user questions (interactive mode only)
 `);
 }

package/src/core/export-html/index.ts

@@ -5,6 +5,34 @@ import { APP_NAME, getExportTemplateDir } from "../../config.js";
 import { getResolvedThemeColors, getThemeExportColors } from "../../modes/interactive/theme/theme.js";
 import { SessionManager } from "../session-manager.js";
 
+// Cached minified assets (populated on first use)
+let cachedTemplate: string | null = null;
+let cachedJs: string | null = null;
+
+/** Minify CSS by removing comments, unnecessary whitespace, and newlines. */
+function minifyCss(css: string): string {
+	return css
+		.replace(/\/\*[\s\S]*?\*\//g, "") // Remove comments
+		.replace(/\s+/g, " ") // Collapse whitespace
+		.replace(/\s*([{}:;,>+~])\s*/g, "$1") // Remove space around punctuation
+		.replace(/;}/g, "}") // Remove trailing semicolons
+		.trim();
+}
+
+/** Minify JS using Bun's transpiler. */
+function minifyJs(js: string): string {
+	const transpiler = new Bun.Transpiler({ loader: "js", minifyWhitespace: true });
+	return transpiler.transformSync(js);
+}
+
+/** Minify HTML by collapsing whitespace outside of tags. */
+function minifyHtml(html: string): string {
+	return html
+		.replace(/>\s+</g, "><") // Remove whitespace between tags
+		.replace(/\s{2,}/g, " ") // Collapse multiple spaces
+		.trim();
+}
+
 export interface ExportOptions {
 	outputPath?: string;
 	themeName?: string;
@@ -111,11 +139,16 @@ interface SessionData {
  */
 function generateHtml(sessionData: SessionData, themeName?: string): string {
 	const templateDir = getExportTemplateDir();
-	const template = readFileSync(join(templateDir, "template.html"), "utf-8");
+
+	// Load and minify assets on first use
+	if (!cachedTemplate) {
+		cachedTemplate = minifyHtml(readFileSync(join(templateDir, "template.html"), "utf-8"));
+	}
+	if (!cachedJs) {
+		cachedJs = minifyJs(readFileSync(join(templateDir, "template.js"), "utf-8"));
+	}
+
 	const templateCss = readFileSync(join(templateDir, "template.css"), "utf-8");
-	const templateJs = readFileSync(join(templateDir, "template.js"), "utf-8");
-	const markedJs = readFileSync(join(templateDir, "vendor", "marked.min.js"), "utf-8");
-	const hljsJs = readFileSync(join(templateDir, "vendor", "highlight.min.js"), "utf-8");
 
 	const themeVars = generateThemeVars(themeName);
 	const colors = getResolvedThemeColors(themeName);
@@ -127,19 +160,19 @@ function generateHtml(sessionData: SessionData, themeName?: string): string {
 	// Base64 encode session data to avoid escaping issues
 	const sessionDataBase64 = Buffer.from(JSON.stringify(sessionData)).toString("base64");
 
-	// Build the CSS with theme variables injected
-	const css = templateCss
-		.replace("{{THEME_VARS}}", themeVars)
-		.replace("{{BODY_BG}}", bodyBg)
-		.replace("{{CONTAINER_BG}}", containerBg)
-		.replace("{{INFO_BG}}", infoBg);
+	// Build and minify the CSS with theme variables injected
+	const css = minifyCss(
+		templateCss
+			.replace("{{THEME_VARS}}", themeVars)
+			.replace("{{BODY_BG}}", bodyBg)
+			.replace("{{CONTAINER_BG}}", containerBg)
+			.replace("{{INFO_BG}}", infoBg),
+	);
 
-	return template
+	return cachedTemplate
 		.replace("{{CSS}}", css)
-		.replace("{{JS}}", templateJs)
-		.replace("{{SESSION_DATA}}", sessionDataBase64)
-		.replace("{{MARKED_JS}}", markedJs)
-		.replace("{{HIGHLIGHT_JS}}", hljsJs);
+		.replace("{{JS}}", cachedJs)
+		.replace("{{SESSION_DATA}}", sessionDataBase64);
 }
 
 /**

package/src/core/export-html/template.html

@@ -39,16 +39,8 @@
   </div>
 
   <script id="session-data" type="application/json">{{SESSION_DATA}}</script>
-
-  <!-- Vendored libraries -->
-  <script>{{MARKED_JS}}</script>
-
-  <!-- highlight.js -->
-  <script>{{HIGHLIGHT_JS}}</script>
-
-  <!-- Main application code -->
-  <script>
-{{JS}}
-  </script>
+  <script src="https://cdnjs.cloudflare.com/ajax/libs/marked/15.0.4/marked.min.js" integrity="sha512-VmLxPVdDGeR+F0DzUHVqzHwaR4ZSSh1g/7aYXwKT1PAGVxunOEcysta+4H5Utvmpr2xExEPybZ8q+iM9F1tGdw==" crossorigin="anonymous" referrerpolicy="no-referrer"></script>
+  <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.9.0/highlight.min.js" integrity="sha512-D9gUyxqja7hBtkWpPWGt9wfbfaMGVt9gnyCvYa+jojwwPHLCzUm5i8rpk7vD7wNee9bA35eYIjobYPaQuKS1MQ==" crossorigin="anonymous" referrerpolicy="no-referrer"></script>
+  <script>{{JS}}</script>
 </body>
 </html>

package/src/core/mcp/client.ts

@@ -25,12 +25,32 @@ import type {
 /** MCP protocol version we support */
 const PROTOCOL_VERSION = "2025-03-26";
 
+/** Default connection timeout in ms */
+const CONNECTION_TIMEOUT_MS = 30_000;
+
 /** Client info sent during initialization */
 const CLIENT_INFO = {
 	name: "pi-coding-agent",
 	version: "1.0.0",
 };
 
+/** Wrap a promise with a timeout */
+function withTimeout<T>(promise: Promise<T>, ms: number, message: string): Promise<T> {
+	return new Promise((resolve, reject) => {
+		const timer = setTimeout(() => reject(new Error(message)), ms);
+		promise.then(
+			(value) => {
+				clearTimeout(timer);
+				resolve(value);
+			},
+			(error) => {
+				clearTimeout(timer);
+				reject(error);
+			},
+		);
+	});
+}
+
 /**
  * Create a transport for the given server config.
  */
@@ -73,24 +93,31 @@ async function initializeConnection(transport: MCPTransport): Promise<MCPInitial
 
 /**
  * Connect to an MCP server.
+ * Has a 30 second timeout to prevent blocking startup.
  */
 export async function connectToServer(name: string, config: MCPServerConfig): Promise<MCPServerConnection> {
-	const transport = await createTransport(config);
-
-	try {
-		const initResult = await initializeConnection(transport);
-
-		return {
-			name,
-			config,
-			transport,
-			serverInfo: initResult.serverInfo,
-			capabilities: initResult.capabilities,
-		};
-	} catch (error) {
-		await transport.close();
-		throw error;
-	}
+	const timeoutMs = config.timeout ?? CONNECTION_TIMEOUT_MS;
+
+	const connect = async (): Promise<MCPServerConnection> => {
+		const transport = await createTransport(config);
+
+		try {
+			const initResult = await initializeConnection(transport);
+
+			return {
+				name,
+				config,
+				transport,
+				serverInfo: initResult.serverInfo,
+				capabilities: initResult.capabilities,
+			};
+		} catch (error) {
+			await transport.close();
+			throw error;
+		}
+	};
+
+	return withTimeout(connect(), timeoutMs, `Connection to MCP server "${name}" timed out after ${timeoutMs}ms`);
 }
 
 /**

package/src/core/mcp/config.ts

@@ -91,11 +91,17 @@ export interface MCPConfigLocations {
  */
 export function getMCPConfigPaths(cwd: string): MCPConfigLocations {
 	const home = homedir();
+
+	// Project-level: check both mcp.json and .mcp.json (prefer mcp.json if both exist)
+	const mcpJson = join(cwd, "mcp.json");
+	const dotMcpJson = join(cwd, ".mcp.json");
+	const projectPath = existsSync(mcpJson) ? mcpJson : dotMcpJson;
+
 	return {
 		// User-level: ~/.pi/mcp.json (our standard)
 		user: join(home, ".pi", "mcp.json"),
-		// Project-level: .mcp.json at project root
-		project: join(cwd, ".mcp.json"),
+		// Project-level: mcp.json or .mcp.json at project root
+		project: projectPath,
 	};
 }
 
@@ -115,17 +121,157 @@ export function mergeMCPConfigs(...configs: (MCPConfigFile | null)[]): Record<st
 	return result;
 }
 
+/** Options for loading MCP configs */
+export interface LoadMCPConfigsOptions {
+	/** Additional environment variables for expansion */
+	extraEnv?: Record<string, string>;
+	/** Whether to load project-level config (default: true) */
+	enableProjectConfig?: boolean;
+	/** Whether to filter out Exa MCP servers (default: true) */
+	filterExa?: boolean;
+}
+
+/** Result of loading MCP configs */
+export interface LoadMCPConfigsResult {
+	/** Loaded server configs */
+	configs: Record<string, MCPServerConfig>;
+	/** Extracted Exa API keys (if any were filtered) */
+	exaApiKeys: string[];
+}
+
 /**
  * Load all MCP server configs from standard locations.
  * Returns merged config with project overriding user.
+ *
+ * @param cwd Working directory (project root)
+ * @param options Load options or extraEnv for backwards compatibility
  */
-export function loadAllMCPConfigs(cwd: string, extraEnv?: Record<string, string>): Record<string, MCPServerConfig> {
+export function loadAllMCPConfigs(
+	cwd: string,
+	options?: LoadMCPConfigsOptions | Record<string, string>,
+): LoadMCPConfigsResult {
+	// Support old signature: loadAllMCPConfigs(cwd, extraEnv)
+	const opts: LoadMCPConfigsOptions =
+		options && ("extraEnv" in options || "enableProjectConfig" in options || "filterExa" in options)
+			? (options as LoadMCPConfigsOptions)
+			: { extraEnv: options as Record<string, string> | undefined };
+
+	const enableProjectConfig = opts.enableProjectConfig ?? true;
+	const filterExa = opts.filterExa ?? true;
+
 	const paths = getMCPConfigPaths(cwd);
 
-	const userConfig = paths.user ? loadMCPConfigFile(paths.user, extraEnv) : null;
-	const projectConfig = paths.project ? loadMCPConfigFile(paths.project, extraEnv) : null;
+	const userConfig = paths.user ? loadMCPConfigFile(paths.user, opts.extraEnv) : null;
+	const projectConfig = enableProjectConfig && paths.project ? loadMCPConfigFile(paths.project, opts.extraEnv) : null;
+
+	let configs = mergeMCPConfigs(userConfig, projectConfig);
+	let exaApiKeys: string[] = [];
+
+	if (filterExa) {
+		const result = filterExaMCPServers(configs);
+		configs = result.configs;
+		exaApiKeys = result.exaApiKeys;
+	}
+
+	return { configs, exaApiKeys };
+}
+
+/** Pattern to match Exa MCP servers */
+const EXA_MCP_URL_PATTERN = /mcp\.exa\.ai/i;
+const EXA_API_KEY_PATTERN = /exaApiKey=([^&\s]+)/i;
+
+/**
+ * Check if a server config is an Exa MCP server.
+ */
+export function isExaMCPServer(name: string, config: MCPServerConfig): boolean {
+	// Check by server name
+	if (name.toLowerCase() === "exa") {
+		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 && EXA_MCP_URL_PATTERN.test(httpConfig.url)) {
+			return true;
+		}
+	}
+
+	// Check by args for stdio servers (e.g., mcp-remote to exa)
+	if (!config.type || config.type === "stdio") {
+		const stdioConfig = config as { args?: string[] };
+		if (stdioConfig.args?.some((arg) => EXA_MCP_URL_PATTERN.test(arg))) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+/**
+ * Extract Exa API key from an MCP server config.
+ */
+export function extractExaApiKey(config: MCPServerConfig): string | undefined {
+	// Check URL for HTTP/SSE servers
+	if (config.type === "http" || config.type === "sse") {
+		const httpConfig = config as { url?: string };
+		if (httpConfig.url) {
+			const match = EXA_API_KEY_PATTERN.exec(httpConfig.url);
+			if (match) return match[1];
+		}
+	}
+
+	// Check args for stdio servers
+	if (!config.type || config.type === "stdio") {
+		const stdioConfig = config as { args?: string[] };
+		if (stdioConfig.args) {
+			for (const arg of stdioConfig.args) {
+				const match = EXA_API_KEY_PATTERN.exec(arg);
+				if (match) return match[1];
+			}
+		}
+	}
+
+	// Check env vars
+	if ("env" in config && config.env) {
+		const envConfig = config as { env: Record<string, string> };
+		if (envConfig.env.EXA_API_KEY) {
+			return envConfig.env.EXA_API_KEY;
+		}
+	}
+
+	return undefined;
+}
+
+/** Result of filtering Exa MCP servers */
+export interface ExaFilterResult {
+	/** Configs with Exa servers removed */
+	configs: Record<string, MCPServerConfig>;
+	/** Extracted Exa API keys (if any) */
+	exaApiKeys: string[];
+}
+
+/**
+ * Filter out Exa MCP servers and extract their API keys.
+ * Since we have native Exa integration, we don't need the MCP server.
+ */
+export function filterExaMCPServers(configs: Record<string, MCPServerConfig>): ExaFilterResult {
+	const filtered: Record<string, MCPServerConfig> = {};
+	const exaApiKeys: string[] = [];
+
+	for (const [name, config] of Object.entries(configs)) {
+		if (isExaMCPServer(name, config)) {
+			// Extract API key before filtering
+			const apiKey = extractExaApiKey(config);
+			if (apiKey) {
+				exaApiKeys.push(apiKey);
+			}
+		} else {
+			filtered[name] = config;
+		}
+	}
 
-	return mergeMCPConfigs(userConfig, projectConfig);
+	return { configs: filtered, exaApiKeys };
 }
 
 /**

package/src/core/mcp/index.ts

@@ -9,19 +9,23 @@
 export { callTool, connectToServer, disconnectServer, listTools, serverSupportsTools } from "./client.js";
 
 // Config
+export type { ExaFilterResult, LoadMCPConfigsOptions, LoadMCPConfigsResult } from "./config.js";
 export {
 	expandEnvVars,
+	extractExaApiKey,
+	filterExaMCPServers,
 	getMCPConfigPaths,
+	isExaMCPServer,
 	loadAllMCPConfigs,
 	loadMCPConfigFile,
 	mergeMCPConfigs,
 	validateServerConfig,
 } from "./config.js";
 // Loader (for SDK integration)
-export type { MCPToolsLoadResult } from "./loader.js";
+export type { MCPToolsLoadOptions, MCPToolsLoadResult } from "./loader.js";
 export { discoverAndLoadMCPTools } from "./loader.js";
 // Manager
-export type { MCPLoadResult } from "./manager.js";
+export type { MCPDiscoverOptions, MCPLoadResult } from "./manager.js";
 export { createMCPManager, MCPManager } from "./manager.js";
 // Tool bridge
 export type { MCPToolDetails } from "./tool-bridge.js";

package/src/core/mcp/loader.ts

@@ -17,24 +17,49 @@ export interface MCPToolsLoadResult {
 	errors: Array<{ path: string; error: string }>;
 	/** Connected server names */
 	connectedServers: string[];
+	/** Extracted Exa API keys from filtered MCP servers */
+	exaApiKeys: string[];
+}
+
+/** Options for loading MCP tools */
+export interface MCPToolsLoadOptions {
+	/** Additional environment variables for expansion */
+	extraEnv?: Record<string, string>;
+	/** Called when starting to connect to servers */
+	onConnecting?: (serverNames: string[]) => void;
+	/** Whether to load project-level config (default: true) */
+	enableProjectConfig?: boolean;
+	/** Whether to filter out Exa MCP servers (default: true) */
+	filterExa?: boolean;
 }
 
 /**
  * Discover and load MCP tools from .mcp.json files.
  *
  * @param cwd Working directory (project root)
- * @param extraEnv Additional environment variables for expansion
+ * @param options Load options including extraEnv and progress callbacks
  * @returns MCP tools in LoadedCustomTool format for integration
  */
 export async function discoverAndLoadMCPTools(
 	cwd: string,
-	extraEnv?: Record<string, string>,
+	options?: MCPToolsLoadOptions | Record<string, string>,
 ): Promise<MCPToolsLoadResult> {
+	// Support old signature: discoverAndLoadMCPTools(cwd, extraEnv)
+	const opts: MCPToolsLoadOptions =
+		options && ("extraEnv" in options || "onConnecting" in options || "enableProjectConfig" in options)
+			? (options as MCPToolsLoadOptions)
+			: { extraEnv: options as Record<string, string> | undefined };
+
 	const manager = new MCPManager(cwd);
 
 	let result: MCPLoadResult;
 	try {
-		result = await manager.discoverAndConnect(extraEnv);
+		result = await manager.discoverAndConnect({
+			extraEnv: opts.extraEnv,
+			onConnecting: opts.onConnecting,
+			enableProjectConfig: opts.enableProjectConfig,
+			filterExa: opts.filterExa,
+		});
 	} catch (error) {
 		// If discovery fails entirely, return empty result
 		const message = error instanceof Error ? error.message : String(error);
@@ -43,6 +68,7 @@ export async function discoverAndLoadMCPTools(
 			tools: [],
 			errors: [{ path: ".mcp.json", error: message }],
 			connectedServers: [],
+			exaApiKeys: [],
 		};
 	}
 
@@ -64,5 +90,6 @@ export async function discoverAndLoadMCPTools(
 		tools: loadedTools,
 		errors,
 		connectedServers: result.connectedServers,
+		exaApiKeys: result.exaApiKeys,
 	};
 }

package/src/core/mcp/manager.ts

@@ -8,7 +8,7 @@
 import type { TSchema } from "@sinclair/typebox";
 import type { CustomTool } from "../custom-tools/types.js";
 import { connectToServer, disconnectServer, listTools } from "./client.js";
-import { loadAllMCPConfigs, validateServerConfig } from "./config.js";
+import { type LoadMCPConfigsOptions, loadAllMCPConfigs, validateServerConfig } from "./config.js";
 import type { MCPToolDetails } from "./tool-bridge.js";
 import { createMCPTools } from "./tool-bridge.js";
 import type { MCPServerConfig, MCPServerConnection } from "./types.js";
@@ -21,6 +21,14 @@ export interface MCPLoadResult {
 	errors: Map<string, string>;
 	/** Connected server names */
 	connectedServers: string[];
+	/** Extracted Exa API keys from filtered MCP servers */
+	exaApiKeys: string[];
+}
+
+/** Options for discovering and connecting to MCP servers */
+export interface MCPDiscoverOptions extends LoadMCPConfigsOptions {
+	/** Called when starting to connect to servers */
+	onConnecting?: (serverNames: string[]) => void;
 }
 
 /**
@@ -38,19 +46,49 @@ export class MCPManager {
 	 * Discover and connect to all MCP servers from .mcp.json files.
 	 * Returns tools and any connection errors.
 	 */
-	async discoverAndConnect(extraEnv?: Record<string, string>): Promise<MCPLoadResult> {
-		const configs = loadAllMCPConfigs(this.cwd, extraEnv);
-		return this.connectServers(configs);
+	async discoverAndConnect(
+		extraEnvOrOptions?: Record<string, string> | MCPDiscoverOptions,
+		onConnecting?: (serverNames: string[]) => void,
+	): Promise<MCPLoadResult> {
+		// Support old signature: discoverAndConnect(extraEnv, onConnecting)
+		const opts: MCPDiscoverOptions =
+			extraEnvOrOptions &&
+			("extraEnv" in extraEnvOrOptions ||
+				"enableProjectConfig" in extraEnvOrOptions ||
+				"filterExa" in extraEnvOrOptions ||
+				"onConnecting" in extraEnvOrOptions)
+				? (extraEnvOrOptions as MCPDiscoverOptions)
+				: { extraEnv: extraEnvOrOptions as Record<string, string> | undefined, onConnecting };
+
+		const { configs, exaApiKeys } = loadAllMCPConfigs(this.cwd, {
+			extraEnv: opts.extraEnv,
+			enableProjectConfig: opts.enableProjectConfig,
+			filterExa: opts.filterExa,
+		});
+		const result = await this.connectServers(configs, opts.onConnecting);
+		result.exaApiKeys = exaApiKeys;
+		return result;
 	}
 
 	/**
 	 * Connect to specific MCP servers.
+	 * Connections are made in parallel for faster startup.
 	 */
-	async connectServers(configs: Record<string, MCPServerConfig>): Promise<MCPLoadResult> {
+	async connectServers(
+		configs: Record<string, MCPServerConfig>,
+		onConnecting?: (serverNames: string[]) => void,
+	): Promise<MCPLoadResult> {
 		const errors = new Map<string, string>();
 		const connectedServers: string[] = [];
 		const allTools: CustomTool<TSchema, MCPToolDetails>[] = [];
 
+		// Prepare connection tasks
+		const connectionTasks: Array<{
+			name: string;
+			config: MCPServerConfig;
+			validationErrors: string[];
+		}> = [];
+
 		for (const [name, config] of Object.entries(configs)) {
 			// Skip if already connected
 			if (this.connections.has(name)) {
@@ -65,17 +103,37 @@ export class MCPManager {
 				continue;
 			}
 
-			try {
+			connectionTasks.push({ name, config, validationErrors });
+		}
+
+		// Notify about servers we're connecting to
+		if (connectionTasks.length > 0 && onConnecting) {
+			onConnecting(connectionTasks.map((t) => t.name));
+		}
+
+		// Connect to all servers in parallel
+		const results = await Promise.allSettled(
+			connectionTasks.map(async ({ name, config }) => {
 				const connection = await connectToServer(name, config);
+				const serverTools = await listTools(connection);
+				return { name, connection, serverTools };
+			}),
+		);
+
+		// Process results
+		for (let i = 0; i < results.length; i++) {
+			const result = results[i];
+			const { name } = connectionTasks[i];
+
+			if (result.status === "fulfilled") {
+				const { connection, serverTools } = result.value;
 				this.connections.set(name, connection);
 				connectedServers.push(name);
 
-				// Load tools from this server
-				const serverTools = await listTools(connection);
 				const customTools = createMCPTools(connection, serverTools);
 				allTools.push(...customTools);
-			} catch (error) {
-				const message = error instanceof Error ? error.message : String(error);
+			} else {
+				const message = result.reason instanceof Error ? result.reason.message : String(result.reason);
 				errors.set(name, message);
 			}
 		}
@@ -87,6 +145,7 @@ export class MCPManager {
 			tools: allTools,
 			errors,
 			connectedServers,
+			exaApiKeys: [], // Will be populated by discoverAndConnect
 		};
 	}