@oh-my-pi/pi-coding-agent 14.5.12 → 14.5.14

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

@@ -1,7 +1,7 @@
 import * as os from "node:os";
 import * as path from "node:path";
 
-import { getOAuthProviders } from "@oh-my-pi/pi-ai";
+import { getOAuthProviders } from "@oh-my-pi/pi-ai/utils/oauth";
 import { getConfigDirName } from "@oh-my-pi/pi-utils";
 import { invalidate as invalidateFsCache } from "../capability/fs";
 import type { SettingPath, SettingValue } from "../config/settings";

package/src/system-prompt.ts

@@ -2,10 +2,9 @@
  * System prompt construction and project context loading
  */
 
-import * as fs from "node:fs";
 import * as os from "node:os";
-import * as path from "node:path";
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import { FileType, glob } from "@oh-my-pi/pi-natives";
 import { $env, getGpuCachePath, getProjectDir, hasFsCode, isEnoent, logger, prompt } from "@oh-my-pi/pi-utils";
 import { $ } from "bun";
 import { contextFileCapability } from "./capability/context-file";
@@ -89,81 +88,44 @@ const AGENTS_MD_LIMIT = 200;
 const SYSTEM_PROMPT_PREP_TIMEOUT_MS = 5000;
 const AGENTS_MD_EXCLUDED_DIRS = new Set(["node_modules", ".git"]);
 
-interface AgentsMdSearch {
+export interface AgentsMdSearch {
 	scopePath: string;
 	limit: number;
 	pattern: string;
 	files: string[];
 }
 
-function normalizePath(value: string): string {
-	return value.replace(/\\/g, "/");
-}
-
-function shouldSkipAgentsDir(name: string): boolean {
-	if (AGENTS_MD_EXCLUDED_DIRS.has(name)) return true;
-	return name.startsWith(".");
-}
-
-async function collectAgentsMdFiles(
-	root: string,
-	dir: string,
-	depth: number,
-	limit: number,
-	discovered: Set<string>,
-): Promise<void> {
-	if (depth > AGENTS_MD_MAX_DEPTH || discovered.size >= limit) {
-		return;
-	}
-
-	let entries: fs.Dirent[];
-	try {
-		entries = await fs.promises.readdir(dir, { withFileTypes: true });
-	} catch {
-		return;
-	}
-
-	if (depth >= AGENTS_MD_MIN_DEPTH) {
-		const hasAgentsMd = entries.some(entry => entry.isFile() && entry.name === "AGENTS.md");
-		if (hasAgentsMd) {
-			const relPath = normalizePath(path.relative(root, path.join(dir, "AGENTS.md")));
-			if (relPath.length > 0) {
-				discovered.add(relPath);
-			}
-			if (discovered.size >= limit) {
-				return;
-			}
-		}
-	}
-
-	if (depth === AGENTS_MD_MAX_DEPTH) {
-		return;
-	}
-
-	const childDirs = entries
-		.filter(entry => entry.isDirectory() && !shouldSkipAgentsDir(entry.name))
-		.map(entry => entry.name)
-		.sort();
-
-	await Promise.all(
-		childDirs.map(async child => {
-			if (discovered.size >= limit) return;
-			await collectAgentsMdFiles(root, path.join(dir, child), depth + 1, limit, discovered);
-		}),
-	);
-}
-
 async function listAgentsMdFiles(root: string, limit: number): Promise<string[]> {
 	try {
-		const discovered = new Set<string>();
-		await collectAgentsMdFiles(root, root, 0, limit, discovered);
-		return Array.from(discovered).sort().slice(0, limit);
+		const result = await glob({
+			pattern: "**/AGENTS.md",
+			path: root,
+			fileType: FileType.File,
+			recursive: true,
+			hidden: false,
+			gitignore: true,
+			maxResults: limit * 4,
+			cache: true,
+		});
+		const files: string[] = [];
+		for (const m of result.matches) {
+			const rel = m.path.replace(/\\/g, "/");
+			if (!rel?.endsWith("AGENTS.md")) continue;
+			const segments = rel.split("/");
+			const depth = segments.length - 1;
+			if (depth < AGENTS_MD_MIN_DEPTH || depth > AGENTS_MD_MAX_DEPTH) continue;
+			const dirSegments = segments.slice(0, -1);
+			if (dirSegments.some(seg => AGENTS_MD_EXCLUDED_DIRS.has(seg) || seg.startsWith("."))) continue;
+			files.push(rel);
+			if (files.length >= limit) break;
+		}
+		return Array.from(new Set(files)).sort().slice(0, limit);
 	} catch {
 		return [];
 	}
 }
 
-async function buildAgentsMdSearch(cwd: string): Promise<AgentsMdSearch> {
+export async function buildAgentsMdSearch(cwd: string): Promise<AgentsMdSearch> {
 	const files = await listAgentsMdFiles(cwd, AGENTS_MD_LIMIT);
 	return {
 		scopePath: ".",
@@ -445,6 +407,8 @@ export interface BuildSystemPromptOptions {
 	alwaysApplyRules?: AlwaysApplyRule[];
 	/** Whether secret obfuscation is active. When true, explains the redaction format in the prompt. */
 	secretsEnabled?: boolean;
+	/** Pre-loaded AGENTS.md search (skips discovery if provided). May be a Promise to allow early kick-off. */
+	agentsMdSearch?: AgentsMdSearch | Promise<AgentsMdSearch>;
 }
 
 /** Build the system prompt with tools, guidelines, and context */
@@ -470,6 +434,7 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		mcpDiscoveryServerSummaries = [],
 		eagerTasks = false,
 		secretsEnabled = false,
+		agentsMdSearch: providedAgentsMdSearch,
 	} = options;
 	const resolvedCwd = cwd ?? getProjectDir();
 
@@ -480,7 +445,10 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		const contextFilesPromise = providedContextFiles
 			? Promise.resolve(providedContextFiles)
 			: logger.time("loadProjectContextFiles", loadProjectContextFiles, { cwd: resolvedCwd });
-		const agentsMdSearchPromise = logger.time("buildAgentsMdSearch", buildAgentsMdSearch, resolvedCwd);
+		const agentsMdSearchPromise =
+			providedAgentsMdSearch !== undefined
+				? Promise.resolve(providedAgentsMdSearch)
+				: logger.time("buildAgentsMdSearch", buildAgentsMdSearch, resolvedCwd);
 		const skillsPromise: Promise<Skill[]> =
 			providedSkills !== undefined
 				? Promise.resolve(providedSkills)
@@ -572,7 +540,7 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 			toolNames = Array.from(tools.keys());
 		} else {
 			// Use defaults
-			toolNames = ["read", "bash", "python", "edit", "write"]; // TODO: Why?
+			toolNames = ["read", "bash", "eval", "edit", "write"]; // TODO: Why?
 		}
 	}
 

package/src/task/agents.ts

@@ -69,10 +69,7 @@ const EMBEDDED_AGENT_DEFS: EmbeddedAgentDef[] = [
 	},
 ];
 
-const EMBEDDED_AGENTS: { name: string; content: string }[] = EMBEDDED_AGENT_DEFS.map(def => ({
-	name: def.fileName,
-	content: buildAgentContent(def),
-}));
+// Computed lazily on first loadBundledAgents() call to avoid eager prompt.render at module load.
 
 export class AgentParsingError extends Error {
 	constructor(
@@ -133,7 +130,9 @@ export function loadBundledAgents(): AgentDefinition[] {
 	if (bundledAgentsCache !== null) {
 		return bundledAgentsCache;
 	}
-	bundledAgentsCache = EMBEDDED_AGENTS.map(({ name, content }) => parseAgent(`embedded:${name}`, content, "bundled"));
+	bundledAgentsCache = EMBEDDED_AGENT_DEFS.map(def =>
+		parseAgent(`embedded:${def.fileName}`, buildAgentContent(def), "bundled"),
+	);
 	return bundledAgentsCache;
 }
 

package/src/task/executor.ts

@@ -532,16 +532,12 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 	if (atMaxDepth && toolNames?.includes("task")) {
 		toolNames = toolNames.filter(name => name !== "task");
 	}
-	const pythonToolMode = settings.get("python.toolMode") ?? "both";
 	if (toolNames?.includes("exec")) {
+		const allowEvalPy = settings.get("eval.py") ?? true;
+		const allowEvalJs = settings.get("eval.js") ?? true;
 		const expanded = toolNames.filter(name => name !== "exec");
-		if (pythonToolMode === "bash-only") {
-			expanded.push("bash");
-		} else if (pythonToolMode === "ipy-only") {
-			expanded.push("python");
-		} else {
-			expanded.push("python", "bash");
-		}
+		if (allowEvalPy || allowEvalJs) expanded.push("eval");
+		expanded.push("bash");
 		toolNames = Array.from(new Set(expanded));
 	}
 
@@ -557,7 +553,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 
 	const lspEnabled = enableLsp ?? true;
 	const ircEnabled = subagentSettings.get("irc.enabled") === true;
-	const skipPythonPreflight = Array.isArray(toolNames) && !toolNames.includes("python");
+	const skipPythonPreflight = Array.isArray(toolNames) && !toolNames.includes("eval");
 
 	const outputChunks: string[] = [];
 	const finalOutputChunks: string[] = [];

package/src/tools/archive-reader.ts

@@ -1,6 +1,11 @@
-import { unzipSync } from "fflate";
 import { ToolError } from "./tool-errors";
 
+let fflateModulePromise: Promise<typeof import("fflate")> | undefined;
+async function loadFflate(): Promise<typeof import("fflate")> {
+	if (!fflateModulePromise) fflateModulePromise = import("fflate");
+	return fflateModulePromise;
+}
+
 export type ArchiveFormat = "zip" | "tar" | "tar.gz";
 
 export interface ArchivePathCandidate {
@@ -150,7 +155,8 @@ async function readTarEntries(bytes: Uint8Array): Promise<ArchiveIndexEntry[]> {
 	return entries;
 }
 
-function readZipEntries(bytes: Uint8Array): ArchiveIndexEntry[] {
+async function readZipEntries(bytes: Uint8Array): Promise<ArchiveIndexEntry[]> {
+	const { unzipSync } = await loadFflate();
 	let files: Record<string, Uint8Array>;
 	try {
 		files = unzipSync(bytes);
@@ -310,6 +316,6 @@ export async function openArchive(filePath: string): Promise<ArchiveReader> {
 	}
 
 	const bytes = await Bun.file(filePath).bytes();
-	const entries = format === "zip" ? readZipEntries(bytes) : await readTarEntries(bytes);
+	const entries = format === "zip" ? await readZipEntries(bytes) : await readTarEntries(bytes);
 	return new ArchiveReader(format, entries);
 }

package/src/tools/browser/launch.ts

@@ -22,6 +22,14 @@ import stealthWorkerScript from "../puppeteer/13_stealth_worker.txt" with { type
 import { ToolError } from "../tool-errors";
 
 export const DEFAULT_VIEWPORT = { width: 1365, height: 768, deviceScaleFactor: 1.25 };
+
+/**
+ * Per-CDP-message timeout applied to every puppeteer launch/connect. Set above
+ * `TOOL_TIMEOUTS.browser.max` (30s) so the agent-side wall-clock is the canonical
+ * limit; this constant only catches genuinely stuck CDP sockets (renderer wedged,
+ * connection dropped, etc.).
+ */
+export const BROWSER_PROTOCOL_TIMEOUT_MS = 60_000;
 export const STEALTH_IGNORE_DEFAULT_ARGS = [
 	"--disable-extensions",
 	"--disable-default-apps",
@@ -55,6 +63,19 @@ export async function loadPuppeteer(): Promise<typeof Puppeteer> {
 	}
 }
 
+let puppeteerModuleWorker: typeof Puppeteer | undefined;
+export async function loadPuppeteerInWorker(safeDir: string): Promise<typeof Puppeteer> {
+	if (puppeteerModuleWorker) return puppeteerModuleWorker;
+	const orig = process.cwd;
+	Object.defineProperty(process, "cwd", { value: () => safeDir, configurable: true });
+	try {
+		puppeteerModuleWorker = (await import("puppeteer-core")).default;
+		return puppeteerModuleWorker;
+	} finally {
+		Object.defineProperty(process, "cwd", { value: orig, configurable: true });
+	}
+}
+
 /**
  * Lazily download Chromium on first browser launch via @puppeteer/browsers.
  * Skipped when a system Chromium (NixOS) or PUPPETEER_EXECUTABLE_PATH is set.
@@ -243,6 +264,7 @@ export async function launchHeadlessBrowser(opts: LaunchHeadlessOptions): Promis
 		executablePath: await ensureChromiumExecutable(),
 		args: launchArgs,
 		ignoreDefaultArgs: [...STEALTH_IGNORE_DEFAULT_ARGS],
+		protocolTimeout: BROWSER_PROTOCOL_TIMEOUT_MS,
 	});
 }
 

package/src/tools/browser/readable.ts

@@ -26,13 +26,17 @@ function normalize(text: string | null | undefined): string | undefined {
  * CSS selector chain over the same pre-parsed DOM. Returns null if neither
  * path yields usable content.
  */
-export function extractReadableFromHtml(html: string, url: string, format: ReadableFormat): ReadableResult | null {
+export async function extractReadableFromHtml(
+	html: string,
+	url: string,
+	format: ReadableFormat,
+): Promise<ReadableResult | null> {
 	const { document } = parseHTML(html);
 
 	// --- Primary: Readability article extraction ---
 	const article = new Readability(document).parse();
 	if (article) {
-		const result = toReadableResult(url, format, article.textContent, article.content, {
+		const result = await toReadableResult(url, format, article.textContent, article.content, {
 			title: article.title,
 			byline: article.byline,
 			excerpt: article.excerpt,
@@ -55,7 +59,7 @@ export function extractReadableFromHtml(html: string, url: string, format: Reada
 		const innerHTML = el.innerHTML?.trim();
 		const textContent = el.textContent?.trim();
 		if (!innerHTML || !textContent) continue;
-		const result = toReadableResult(url, format, textContent, innerHTML, {
+		const result = await toReadableResult(url, format, textContent, innerHTML, {
 			title: document.title,
 			excerpt: textContent.slice(0, 240),
 			length: textContent.length,
@@ -67,15 +71,16 @@ export function extractReadableFromHtml(html: string, url: string, format: Reada
 }
 
 /** Shared builder for both extraction paths. */
-function toReadableResult(
+async function toReadableResult(
 	url: string,
 	format: ReadableFormat,
 	textContent: string | null | undefined,
 	htmlContent: string | null | undefined,
 	meta: { title?: string | null; byline?: string | null; excerpt?: string | null; length?: number | null },
-): ReadableResult | null {
+): Promise<ReadableResult | null> {
 	const text = normalize(textContent);
-	const markdown = format === "markdown" ? (normalize(htmlToBasicMarkdown(htmlContent ?? "")) ?? text) : undefined;
+	const markdown =
+		format === "markdown" ? (normalize(await htmlToBasicMarkdown(htmlContent ?? "")) ?? text) : undefined;
 	const normalizedText = format === "text" ? text : undefined;
 	if (!normalizedText && !markdown) return null;
 	return {