@oh-my-pi/pi-coding-agent 14.4.3 → 14.5.0

package/src/modes/components/settings-defs.ts

@@ -348,6 +348,7 @@ const OPTION_PROVIDERS: Partial<Record<SettingPath, OptionProvider>> = {
 		{ value: "kagi", label: "Kagi", description: "Requires KAGI_API_KEY and Kagi Search API beta access" },
 		{ value: "synthetic", label: "Synthetic", description: "Requires SYNTHETIC_API_KEY" },
 		{ value: "parallel", label: "Parallel", description: "Requires PARALLEL_API_KEY" },
+		{ value: "searxng", label: "SearXNG", description: "Self-hosted metasearch; set searxng.endpoint" },
 	],
 	"providers.image": [
 		{

package/src/modes/controllers/command-controller.ts

@@ -28,6 +28,7 @@ import { buildHotkeysMarkdown } from "../../modes/utils/hotkeys-markdown";
 import { buildToolsMarkdown } from "../../modes/utils/tools-markdown";
 import type { AsyncJobSnapshotItem } from "../../session/agent-session";
 import type { AuthStorage } from "../../session/auth-storage";
+import type { NewSessionOptions } from "../../session/session-manager";
 import { outputMeta } from "../../tools/output-meta";
 import { resolveToCwd, stripOuterDoubleQuotes } from "../../tools/path-utils";
 import { replaceTabs } from "../../tools/render-utils";
@@ -573,7 +574,7 @@ export class CommandController {
 		this.ctx.showError("Usage: /memory <view|clear|reset|enqueue|rebuild>");
 	}
 
-	async handleClearCommand(): Promise<void> {
+	async #runNewSessionFlow(options?: NewSessionOptions, label: string = "New session started"): Promise<void> {
 		if (this.ctx.loadingAnimation) {
 			this.ctx.loadingAnimation.stop();
 			this.ctx.loadingAnimation = undefined;
@@ -586,7 +587,7 @@ export class CommandController {
 				await Bun.sleep(10);
 			}
 		}
-		await this.ctx.session.newSession();
+		if (!(await this.ctx.session.newSession(options))) return;
 		this.ctx.resetObserverRegistry();
 		setSessionTerminalTitle(
 			this.ctx.sessionManager.getSessionName(),
@@ -608,13 +609,23 @@ export class CommandController {
 		this.ctx.pendingTools.clear();
 
 		this.ctx.chatContainer.addChild(new Spacer(1));
-		this.ctx.chatContainer.addChild(
-			new Text(`${theme.fg("accent", `${theme.status.success} New session started`)}`, 1, 1),
-		);
+		this.ctx.chatContainer.addChild(new Text(`${theme.fg("accent", `${theme.status.success} ${label}`)}`, 1, 1));
 		await this.ctx.reloadTodos();
 		this.ctx.ui.requestRender();
 	}
 
+	async handleClearCommand(): Promise<void> {
+		await this.#runNewSessionFlow();
+	}
+
+	async handleDropCommand(): Promise<void> {
+		if (!this.ctx.sessionManager.getSessionFile()) {
+			this.ctx.showError("Nothing to drop (in-memory session)");
+			return;
+		}
+		await this.#runNewSessionFlow({ drop: true }, "Session dropped");
+	}
+
 	async handleForkCommand(): Promise<void> {
 		if (this.ctx.session.isStreaming) {
 			this.ctx.showWarning("Wait for the current response to finish or abort it before forking.");

package/src/modes/controllers/selector-controller.ts

@@ -1,14 +1,17 @@
+import * as os from "node:os";
+import * as path from "node:path";
 import { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import { getOAuthProviders, type OAuthProvider } from "@oh-my-pi/pi-ai";
-import type { Component } from "@oh-my-pi/pi-tui";
+import type { Component, OverlayHandle } from "@oh-my-pi/pi-tui";
 import { Input, Loader, Spacer, Text } from "@oh-my-pi/pi-tui";
-import { getAgentDbPath, getProjectDir } from "@oh-my-pi/pi-utils";
+import { getAgentDbPath, getConfigDirName, getProjectDir } from "@oh-my-pi/pi-utils";
+import { invalidate as invalidateFsCache } from "../../capability/fs";
 import { getRoleInfo } from "../../config/model-registry";
 import { formatModelSelectorValue } from "../../config/model-resolver";
 import { settings } from "../../config/settings";
 import { DebugSelectorComponent } from "../../debug";
 import { disableProvider, enableProvider } from "../../discovery";
-import { clearPluginRootsAndCaches, resolveActiveProjectRegistryPath } from "../../discovery/helpers";
+import { clearClaudePluginRootsCache, resolveActiveProjectRegistryPath } from "../../discovery/helpers";
 import {
 	getInstalledPluginsRegistryPath,
 	getMarketplacesCacheDir,
@@ -440,7 +443,13 @@ export class SelectorController {
 			projectInstalledRegistryPath: (await resolveActiveProjectRegistryPath(getProjectDir())) ?? undefined,
 			marketplacesCacheDir: getMarketplacesCacheDir(),
 			pluginsCacheDir: getPluginsCacheDir(),
-			clearPluginRootsCache: clearPluginRootsAndCaches,
+			clearPluginRootsCache: (extraPaths?: readonly string[]) => {
+				const home = os.homedir();
+				invalidateFsCache(path.join(home, ".claude", "plugins", "installed_plugins.json"));
+				invalidateFsCache(path.join(home, getConfigDirName(), "plugins", "installed_plugins.json"));
+				for (const p of extraPaths ?? []) invalidateFsCache(p);
+				clearClaudePluginRootsCache();
+			},
 		});
 
 		const [marketplaces, installed] = await Promise.all([mgr.listMarketplaces(), mgr.listInstalledPlugins()]);
@@ -969,25 +978,29 @@ export class SelectorController {
 
 	showSessionObserver(registry: SessionObserverRegistry): void {
 		const observeKeys = this.ctx.keybindings.getKeys("app.session.observe");
+		let cleanup: (() => void) | undefined;
+		let overlayHandle: OverlayHandle | undefined;
 
-		this.showSelector(done => {
-			let cleanup: (() => void) | undefined;
+		const done = () => {
+			cleanup?.();
+			overlayHandle?.hide();
+			this.ctx.ui.requestRender();
+		};
 
-			const selector = new SessionObserverOverlayComponent(
-				registry,
-				() => {
-					cleanup?.();
-					done();
-				},
-				observeKeys,
-			);
+		const selector = new SessionObserverOverlayComponent(registry, done, observeKeys);
 
-			cleanup = registry.onChange(() => {
-				selector.refreshFromRegistry();
-				this.ctx.ui.requestRender();
-			});
+		cleanup = registry.onChange(() => {
+			selector.refreshFromRegistry();
+			this.ctx.ui.requestRender();
+		});
 
-			return { component: selector, focus: selector };
+		overlayHandle = this.ctx.ui.showOverlay(selector, {
+			anchor: "bottom-center",
+			width: "100%",
+			maxHeight: "100%",
+			margin: 0,
 		});
+		this.ctx.ui.setFocus(selector);
+		this.ctx.ui.requestRender();
 	}
 }

package/src/modes/interactive-mode.ts

@@ -1324,13 +1324,22 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.#commandController.handleToolsCommand();
 	}
 
-	handleClearCommand(): Promise<void> {
+	#prepareSessionSwitch(): void {
 		this.#btwController.dispose();
 		this.#extensionUiController.clearExtensionTerminalInputListeners();
 		this.#planReviewContainer = undefined;
+	}
+
+	handleClearCommand(): Promise<void> {
+		this.#prepareSessionSwitch();
 		return this.#commandController.handleClearCommand();
 	}
 
+	handleDropCommand(): Promise<void> {
+		this.#prepareSessionSwitch();
+		return this.#commandController.handleDropCommand();
+	}
+
 	handleForkCommand(): Promise<void> {
 		this.#btwController.dispose();
 		return this.#commandController.handleForkCommand();

package/src/modes/types.ts

@@ -181,6 +181,7 @@ export interface InteractiveModeContext {
 	handleDumpCommand(): void;
 	handleDebugTranscriptCommand(): Promise<void>;
 	handleClearCommand(): Promise<void>;
+	handleDropCommand(): Promise<void>;
 	handleForkCommand(): Promise<void>;
 	handleBashCommand(command: string, excludeFromContext?: boolean): Promise<void>;
 	handlePythonCommand(code: string, excludeFromContext?: boolean): Promise<void>;

package/src/session/agent-session.ts

@@ -3373,7 +3373,15 @@ export class AgentSession {
 		this.#asyncJobManager?.cancelAll();
 		this.#closeAllProviderSessions("new session");
 		this.agent.reset();
-		await this.sessionManager.flush();
+		if (options?.drop && previousSessionFile) {
+			try {
+				await this.sessionManager.dropSession(previousSessionFile);
+			} catch (err) {
+				logger.error("Failed to delete session during /drop", { err });
+			}
+		} else {
+			await this.sessionManager.flush();
+		}
 		await this.sessionManager.newSession(options);
 		this.setTodoPhases([]);
 		this.agent.sessionId = this.sessionManager.getSessionId();

package/src/session/session-manager.ts

@@ -66,6 +66,8 @@ export interface SessionHeader {
 
 export interface NewSessionOptions {
 	parentSession?: string;
+	/** Skip flushing the current session and delete it instead of saving. */
+	drop?: boolean;
 }
 
 export interface SessionEntryBase {
@@ -1707,6 +1709,17 @@ export class SessionManager {
 		return this.#newSessionSync(options);
 	}
 
+	/** Delete a session file and its artifacts. Drains the persist writer first to avoid EPERM on Windows. ENOENT is treated as success. */
+	async dropSession(sessionPath: string): Promise<void> {
+		await this.#closePersistWriter();
+		try {
+			await this.storage.deleteSessionWithArtifacts(sessionPath);
+		} catch (err) {
+			if (isEnoent(err)) return;
+			throw err;
+		}
+	}
+
 	/**
 	 * Fork the current session, creating a new session file with the same entries.
 	 * Returns both the old and new session file paths for artifact copying.

package/src/session/session-storage.ts

@@ -32,6 +32,7 @@ export interface SessionStorage {
 	writeText(path: string, content: string): Promise<void>;
 	rename(path: string, nextPath: string): Promise<void>;
 	unlink(path: string): Promise<void>;
+	deleteSessionWithArtifacts(sessionPath: string): Promise<void>;
 	openWriter(path: string, options?: { flags?: "a" | "w"; onError?: (err: Error) => void }): SessionStorageWriter;
 }
 
@@ -360,6 +361,9 @@ export class MemorySessionStorage implements SessionStorage {
 		this.#files.delete(path);
 		return Promise.resolve();
 	}
+	deleteSessionWithArtifacts(_sessionPath: string): Promise<void> {
+		return Promise.resolve();
+	}
 
 	openWriter(path: string, options?: { flags?: "a" | "w"; onError?: (err: Error) => void }): SessionStorageWriter {
 		return new MemorySessionStorageWriter(this, path, options);

package/src/slash-commands/builtin-registry.ts

@@ -512,6 +512,14 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<BuiltinSlashCommandSpec> = [
 			await runtime.ctx.handleClearCommand();
 		},
 	},
+	{
+		name: "drop",
+		description: "Delete the current session and start a new one",
+		handle: async (_command, runtime) => {
+			runtime.ctx.editor.setText("");
+			await runtime.ctx.handleDropCommand();
+		},
+	},
 	{
 		name: "compact",
 		description: "Manually compact the session context",

package/src/tools/browser.ts

@@ -15,7 +15,7 @@ import type {
 	Page,
 	default as Puppeteer,
 	SerializedAXNode,
-} from "puppeteer";
+} from "puppeteer-core";
 import browserDescription from "../prompts/tools/browser.md" with { type: "text" };
 import type { ToolSession } from "../sdk";
 import { resizeImage } from "../utils/image-resize";
@@ -53,7 +53,7 @@ async function loadPuppeteer(): Promise<typeof Puppeteer> {
 	await Bun.write(path.join(safeDir, "package.json"), "{}");
 	try {
 		process.chdir(safeDir);
-		puppeteerModule = (await import("puppeteer")).default;
+		puppeteerModule = (await import("puppeteer-core")).default;
 		return puppeteerModule;
 	} finally {
 		process.chdir(prev);
@@ -61,50 +61,172 @@ async function loadPuppeteer(): Promise<typeof Puppeteer> {
 }
 
 /**
- * On NixOS, Puppeteer's bundled Chromium is a dynamically-linked FHS binary and
- * cannot run as-is. Detect the platform and resolve a system-installed Chromium
- * so `puppeteer.launch()` can use it instead of the bundled one.
+ * Lazily download Chromium on first browser launch via @puppeteer/browsers.
+ * Skipped when a system Chromium (NixOS) or PUPPETEER_EXECUTABLE_PATH is set.
+ * The browser is cached under ~/.omp/puppeteer (getPuppeteerDir).
+ */
+let chromiumExecutablePromise: Promise<string | undefined> | undefined;
+async function ensureChromiumExecutable(): Promise<string | undefined> {
+	const sysChrome = resolveSystemChromium();
+	if (sysChrome) return sysChrome;
+	const envPath = process.env.PUPPETEER_EXECUTABLE_PATH;
+	if (envPath) return envPath;
+	if (chromiumExecutablePromise) return chromiumExecutablePromise;
+
+	chromiumExecutablePromise = (async () => {
+		const [browsers, revisions] = await Promise.all([
+			import("@puppeteer/browsers"),
+			import("puppeteer-core/internal/revisions.js"),
+		]);
+		const platform = browsers.detectBrowserPlatform();
+		if (!platform) {
+			logger.warn("Could not detect browser platform; relying on puppeteer default resolution");
+			return undefined;
+		}
+		const cacheDir = getPuppeteerDir();
+		const buildId = await browsers.resolveBuildId(
+			browsers.Browser.CHROME,
+			platform,
+			revisions.PUPPETEER_REVISIONS.chrome,
+		);
+		const executablePath = browsers.computeExecutablePath({
+			browser: browsers.Browser.CHROME,
+			buildId,
+			cacheDir,
+			platform,
+		});
+		if (fs.existsSync(executablePath)) return executablePath;
+
+		logger.warn("Downloading Chromium for puppeteer (first browser use)", {
+			buildId,
+			platform,
+			cacheDir,
+		});
+		let lastReportedPercent = -1;
+		await browsers.install({
+			browser: browsers.Browser.CHROME,
+			buildId,
+			cacheDir,
+			platform,
+			downloadProgressCallback: (downloaded, total) => {
+				if (total <= 0) return;
+				const pct = Math.floor((downloaded / total) * 100);
+				if (pct >= lastReportedPercent + 10 || downloaded === total) {
+					lastReportedPercent = pct;
+					logger.debug(
+						`Chromium download: ${pct}% (${Math.round(downloaded / 1_000_000)} / ${Math.round(total / 1_000_000)} MB)`,
+					);
+				}
+			},
+		});
+		return executablePath;
+	})().catch(err => {
+		chromiumExecutablePromise = undefined;
+		throw new ToolError(
+			`Failed to install Chromium for puppeteer: ${(err as Error).message}. ` +
+				"Set PUPPETEER_EXECUTABLE_PATH to use an existing Chrome/Chromium binary, or install one manually.",
+		);
+	});
+	return chromiumExecutablePromise;
+}
+
+/**
+ * Resolve a system-installed Chrome/Chromium so `puppeteer.launch()` can reuse
+ * it instead of forcing a Chromium download. Returns `undefined` when no binary
+ * is found, which lets the caller fall back to a managed download.
  *
- * Detection order:
- *   1. `chromium` on PATH
- *   2. `chromium-browser` on PATH
- *   3. ~/.nix-profile/bin/chromium  (user profile)
- *   4. /run/current-system/sw/bin/chromium  (system profile)
+ * Detection order (per platform):
+ *   - macOS:   Google Chrome → Chromium → Microsoft Edge (system + user Applications)
+ *   - Linux:   PATH lookups (google-chrome, chromium, etc.) → common /usr/bin paths,
+ *              with NixOS-specific profile paths added when /etc/NIXOS exists
+ *   - Windows: Program Files / LocalAppData install paths for Chrome and Edge
  *
- * Returns `undefined` on non-NixOS systems or when no binary is found, which
- * causes Puppeteer to fall back to its default resolution.
+ * Honored regardless of platform: PUPPETEER_EXECUTABLE_PATH callers should bypass
+ * this entirely (handled in ensureChromiumExecutable).
  */
 let _resolvedChromium: string | null | undefined; // undefined = unchecked; null = not found
-function resolveSystemChromium(): string | undefined {
-	if (_resolvedChromium !== undefined) return _resolvedChromium ?? undefined;
+function isExecutableFile(p: string): boolean {
 	try {
-		if (!fs.existsSync("/etc/NIXOS")) {
-			_resolvedChromium = null;
-			return undefined;
-		}
+		const st = fs.statSync(p);
+		return st.isFile();
 	} catch {
-		_resolvedChromium = null;
-		return undefined;
+		return false;
 	}
-	const candidates = [
-		$which("chromium"),
-		$which("chromium-browser"),
-		path.join(os.homedir(), ".nix-profile/bin/chromium"),
-		"/run/current-system/sw/bin/chromium",
-	];
-	for (const candidate of candidates) {
-		if (candidate) {
+}
+
+function systemChromiumCandidates(): string[] {
+	const home = os.homedir();
+	const candidates: string[] = [];
+	switch (process.platform) {
+		case "darwin": {
+			for (const root of ["/Applications", path.join(home, "Applications")]) {
+				candidates.push(
+					path.join(root, "Google Chrome.app/Contents/MacOS/Google Chrome"),
+					path.join(root, "Google Chrome Beta.app/Contents/MacOS/Google Chrome Beta"),
+					path.join(root, "Google Chrome Dev.app/Contents/MacOS/Google Chrome Dev"),
+					path.join(root, "Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary"),
+					path.join(root, "Chromium.app/Contents/MacOS/Chromium"),
+					path.join(root, "Microsoft Edge.app/Contents/MacOS/Microsoft Edge"),
+				);
+			}
+			break;
+		}
+		case "linux": {
+			const names = ["google-chrome-stable", "google-chrome", "chromium", "chromium-browser", "chrome"];
+			for (const name of names) {
+				const found = $which(name);
+				if (found) candidates.push(found);
+			}
+			candidates.push(
+				"/usr/bin/google-chrome-stable",
+				"/usr/bin/google-chrome",
+				"/usr/bin/chromium",
+				"/usr/bin/chromium-browser",
+				"/snap/bin/chromium",
+				"/var/lib/flatpak/exports/bin/com.google.Chrome",
+				"/var/lib/flatpak/exports/bin/org.chromium.Chromium",
+			);
+			let onNixos = false;
 			try {
-				if (fs.existsSync(candidate)) {
-					_resolvedChromium = candidate;
-					logger.debug("NixOS: using system Chromium", { path: candidate });
-					return candidate;
-				}
+				onNixos = fs.existsSync("/etc/NIXOS");
 			} catch {}
+			if (onNixos) {
+				candidates.push(path.join(home, ".nix-profile/bin/chromium"), "/run/current-system/sw/bin/chromium");
+			}
+			break;
+		}
+		case "win32": {
+			const programFiles = process.env.ProgramFiles ?? "C:\\Program Files";
+			const programFilesX86 = process.env["ProgramFiles(x86)"] ?? "C:\\Program Files (x86)";
+			const localAppData = process.env.LOCALAPPDATA ?? path.join(home, "AppData\\Local");
+			candidates.push(
+				path.join(programFiles, "Google\\Chrome\\Application\\chrome.exe"),
+				path.join(programFilesX86, "Google\\Chrome\\Application\\chrome.exe"),
+				path.join(localAppData, "Google\\Chrome\\Application\\chrome.exe"),
+				path.join(programFiles, "Chromium\\Application\\chrome.exe"),
+				path.join(localAppData, "Chromium\\Application\\chrome.exe"),
+				path.join(programFiles, "Microsoft\\Edge\\Application\\msedge.exe"),
+				path.join(programFilesX86, "Microsoft\\Edge\\Application\\msedge.exe"),
+			);
+			break;
+		}
+	}
+	return candidates;
+}
+
+function resolveSystemChromium(): string | undefined {
+	if (_resolvedChromium !== undefined) return _resolvedChromium ?? undefined;
+	const seen = new Set<string>();
+	for (const candidate of systemChromiumCandidates()) {
+		if (!candidate || seen.has(candidate)) continue;
+		seen.add(candidate);
+		if (isExecutableFile(candidate)) {
+			_resolvedChromium = candidate;
+			logger.debug("Using system Chrome/Chromium", { path: candidate });
+			return candidate;
 		}
 	}
 	_resolvedChromium = null;
-	logger.debug("NixOS detected but no Chromium binary found; Puppeteer may fail to launch");
 	return undefined;
 }
 
@@ -674,7 +796,7 @@ export class BrowserTool implements AgentTool<typeof browserSchema, BrowserToolD
 		this.#browser = await puppeteer.launch({
 			headless: this.#currentHeadless,
 			defaultViewport: this.#currentHeadless ? initialViewport : null,
-			executablePath: resolveSystemChromium(),
+			executablePath: await ensureChromiumExecutable(),
 			args: launchArgs,
 			ignoreDefaultArgs: [...STEALTH_IGNORE_DEFAULT_ARGS],
 		});

package/src/web/search/index.ts

@@ -1,7 +1,7 @@
 /**
  * Unified Web Search Tool
  *
- * Single tool supporting Anthropic, Perplexity, Exa, Brave, Jina, Kimi, Gemini, Codex, Tavily, Kagi, Z.AI, and Synthetic
+ * Single tool supporting Anthropic, Perplexity, Exa, Brave, Jina, Kimi, Gemini, Codex, Tavily, Kagi, Z.AI, SearXNG, and Synthetic
  * providers with provider-specific parameters exposed conditionally.
  *
  */
@@ -202,7 +202,7 @@ export async function runSearchQuery(
 /**
  * Web search tool implementation.
  *
- * Supports Anthropic, Perplexity, Exa, Brave, Jina, Kimi, Gemini, Codex, Z.AI, and Synthetic providers with automatic fallback.
+ * Supports Anthropic, Perplexity, Exa, Brave, Jina, Kimi, Gemini, Codex, Z.AI, SearXNG, and Synthetic providers with automatic fallback.
  * Session is accepted for interface consistency but not used.
  */
 export class SearchTool implements AgentTool<typeof webSearchSchema, SearchRenderDetails> {

package/src/web/search/provider.ts

@@ -9,6 +9,7 @@ import { KagiProvider } from "./providers/kagi";
 import { KimiProvider } from "./providers/kimi";
 import { ParallelProvider } from "./providers/parallel";
 import { PerplexityProvider } from "./providers/perplexity";
+import { SearXNGProvider } from "./providers/searxng";
 import { SyntheticProvider } from "./providers/synthetic";
 import { TavilyProvider } from "./providers/tavily";
 import { ZaiProvider } from "./providers/zai";
@@ -31,6 +32,7 @@ const SEARCH_PROVIDERS: Record<SearchProviderId, SearchProvider> = {
 	parallel: new ParallelProvider(),
 	kagi: new KagiProvider(),
 	synthetic: new SyntheticProvider(),
+	searxng: new SearXNGProvider(),
 } as const;
 
 export const SEARCH_PROVIDER_ORDER: SearchProviderId[] = [
@@ -47,6 +49,7 @@ export const SEARCH_PROVIDER_ORDER: SearchProviderId[] = [
 	"parallel",
 	"kagi",
 	"synthetic",
+	"searxng",
 ];
 
 export function getSearchProvider(provider: SearchProviderId): SearchProvider {