@cmetech/otto 1.0.7 → 1.0.9

package/packages/pi-coding-agent/src/core/extensions/runner.ts

@@ -2,6 +2,7 @@
  * Extension runner - executes extensions and manages their lifecycle.
  */
 
+import { AsyncLocalStorage } from "node:async_hooks";
 import type { AgentMessage } from "@otto/pi-agent-core";
 import type { ImageContent, Model } from "@otto/pi-ai";
 import type { KeyId } from "@otto/pi-tui";
@@ -222,6 +223,49 @@ const noOpUIContext: ExtensionUIContext = {
 	setToolsExpanded: () => {},
 };
 
+// Async context flag: true when the current async stack originates inside a
+// quiet extension's handler invocation. Read by the patched console methods to
+// decide whether to suppress output. Empty store = normal logging behaviour.
+const quietExtensionContext = new AsyncLocalStorage<boolean>();
+
+let quietConsolePatchInstalled = false;
+
+/**
+ * Patch `console.log/warn/error/info` to no-op when the current async context
+ * is flagged as "quiet". Installed once on first `setQuietExtensions(non-empty)`
+ * call so users who never configure quietExtensions pay zero overhead.
+ *
+ * The check is `quietExtensionContext.getStore() === true` — for any code path
+ * that wasn't dispatched inside `quietExtensionContext.run(true, …)` the store
+ * is undefined and console behaves exactly as before. This isolates the
+ * suppression to the quiet handler's own async work without affecting
+ * concurrent non-quiet handlers.
+ */
+function installQuietConsolePatch(): void {
+	if (quietConsolePatchInstalled) return;
+	quietConsolePatchInstalled = true;
+	const realLog = console.log.bind(console);
+	const realWarn = console.warn.bind(console);
+	const realError = console.error.bind(console);
+	const realInfo = console.info.bind(console);
+	console.log = (...args: unknown[]): void => {
+		if (quietExtensionContext.getStore() === true) return;
+		realLog(...args);
+	};
+	console.warn = (...args: unknown[]): void => {
+		if (quietExtensionContext.getStore() === true) return;
+		realWarn(...args);
+	};
+	console.error = (...args: unknown[]): void => {
+		if (quietExtensionContext.getStore() === true) return;
+		realError(...args);
+	};
+	console.info = (...args: unknown[]): void => {
+		if (quietExtensionContext.getStore() === true) return;
+		realInfo(...args);
+	};
+}
+
 export class ExtensionRunner {
 	private extensions: Extension[];
 	private runtime: ExtensionRuntime;
@@ -257,6 +301,8 @@ export class ExtensionRunner {
 	private shutdownHandler: ShutdownHandler = () => {};
 	private shortcutDiagnostics: ResourceDiagnostic[] = [];
 	private commandDiagnostics: ResourceDiagnostic[] = [];
+	/** Case-insensitive substring patterns matched against ext.path. ui.notify is dropped for matches. */
+	private quietExtensionPatterns: string[] = [];
 
 	constructor(
 		extensions: Extension[],
@@ -734,6 +780,41 @@ export class ExtensionRunner {
 		return eventType === "agent_end" || eventType === "stop" || eventType === "session_end";
 	}
 
+	/**
+	 * Replace the quiet-extensions allowlist. Each entry is a case-insensitive
+	 * substring matched against the extension's filesystem path. Matching
+	 * extensions have their `ui.notify` calls silently dropped AND their
+	 * `console.log/warn/error/info` calls silently dropped while the handler
+	 * is on the stack — useful for muting noisy session_start banners
+	 * (piolium uses ui.notify; pi-notion uses console.log).
+	 *
+	 * Console filtering uses AsyncLocalStorage so other extensions running
+	 * concurrently are unaffected — output is only suppressed when the call
+	 * originates inside a quiet extension's handler async context.
+	 */
+	setQuietExtensions(patterns: readonly string[]): void {
+		this.quietExtensionPatterns = patterns.map((p) => p.toLowerCase()).filter((p) => p.length > 0);
+		if (this.quietExtensionPatterns.length > 0) {
+			installQuietConsolePatch();
+		}
+	}
+
+	private isQuietExtension(ext: Extension): boolean {
+		if (this.quietExtensionPatterns.length === 0) return false;
+		const path = ext.path.toLowerCase();
+		return this.quietExtensionPatterns.some((p) => path.includes(p));
+	}
+
+	private withSilencedNotify(base: ExtensionContext): ExtensionContext {
+		// Wraps the shared ui context so notify() is a no-op while every other
+		// method (select/confirm/input/setStatus/setWidget/…) keeps working.
+		const silencedUi: ExtensionUIContext = {
+			...base.ui,
+			notify: () => undefined,
+		};
+		return { ...base, ui: silencedUi };
+	}
+
 	createCommandContext(): ExtensionCommandContext {
 		return {
 			...this.createContext(),
@@ -782,10 +863,18 @@ export class ExtensionRunner {
 			const handlers = ext.handlers.get(eventType);
 			if (!handlers || handlers.length === 0) continue;
 
+			const isQuiet = this.isQuietExtension(ext);
+			const extCtx = isQuiet ? this.withSilencedNotify(ctx) : ctx;
+
 			for (const handler of handlers) {
 				try {
 					const event = getEvent();
-					const handlerResult = await handler(event, ctx);
+					// Run quiet extensions inside an AsyncLocalStorage scope so
+					// the patched console methods can suppress their output
+					// without affecting non-quiet extensions running concurrently.
+					const handlerResult = isQuiet
+						? await quietExtensionContext.run(true, () => handler(event, extCtx))
+						: await handler(event, extCtx);
 					const action = processResult(handlerResult, ext.path);
 					if (action.done) return;
 				} catch (err) {

package/packages/pi-coding-agent/src/core/package-manager.ts

@@ -807,12 +807,13 @@ export class DefaultPackageManager implements PackageManager {
 		const parsed = this.parseSource(source);
 		const scope: SourceScope = options?.local ? "project" : "user";
 		await this.withProgress("install", source, `Installing ${source}...`, async () => {
+			// Explicit user-initiated install — stream npm/git progress to the terminal.
 			if (parsed.type === "npm") {
-				await this.installNpm(parsed, scope, false);
+				await this.installNpm(parsed, scope, false, true);
 				return;
 			}
 			if (parsed.type === "git") {
-				await this.installGit(parsed, scope);
+				await this.installGit(parsed, scope, true);
 				return;
 			}
 			if (parsed.type === "local") {
@@ -831,7 +832,7 @@ export class DefaultPackageManager implements PackageManager {
 		const scope: SourceScope = options?.local ? "project" : "user";
 		await this.withProgress("remove", source, `Removing ${source}...`, async () => {
 			if (parsed.type === "npm") {
-				await this.uninstallNpm(parsed, scope);
+				await this.uninstallNpm(parsed, scope, true);
 				return;
 			}
 			if (parsed.type === "git") {
@@ -869,15 +870,16 @@ export class DefaultPackageManager implements PackageManager {
 		const parsed = this.parseSource(source);
 		if (parsed.type === "npm") {
 			if (parsed.pinned) return;
+			// Explicit `pi package update` — stream npm progress to terminal.
 			await this.withProgress("update", source, `Updating ${source}...`, async () => {
-				await this.installNpm(parsed, scope, false);
+				await this.installNpm(parsed, scope, false, true);
 			});
 			return;
 		}
 		if (parsed.type === "git") {
 			if (parsed.pinned) return;
 			await this.withProgress("update", source, `Updating ${source}...`, async () => {
-				await this.updateGit(parsed, scope);
+				await this.updateGit(parsed, scope, true);
 			});
 			return;
 		}
@@ -890,54 +892,75 @@ export class DefaultPackageManager implements PackageManager {
 	): Promise<void> {
 		for (const { pkg, scope } of sources) {
 			const sourceStr = typeof pkg === "string" ? pkg : pkg.source;
-			const filter = typeof pkg === "object" ? pkg : undefined;
-			const parsed = this.parseSource(sourceStr);
-			const metadata: PathMetadata = { source: sourceStr, scope, origin: "package" };
-
-			if (parsed.type === "local") {
-				const baseDir = this.getBaseDirForScope(scope);
-				this.resolveLocalExtensionSource(parsed, accumulator, filter, metadata, baseDir);
-				continue;
+			try {
+				await this.resolveOnePackageSource(pkg, scope, accumulator, onMissing);
+			} catch (error) {
+				// One bad source (typo, 404, network glitch, unreachable git host)
+				// must not abort startup or block resolution of the remaining
+				// packages. Warn loudly so the user knows, then continue.
+				const message = error instanceof Error ? error.message : String(error);
+				process.stderr.write(
+					`[pi] Skipping package "${sourceStr}" — ${message}. ` +
+						`Run \`pi remove ${sourceStr}\` if you want to drop it permanently.\n`,
+				);
 			}
+		}
+	}
 
-			const installMissing = async (): Promise<boolean> => {
-				if (isOfflineModeEnabled()) {
-					return false;
-				}
-				if (!onMissing) {
-					await this.installParsedSource(parsed, scope);
-					return true;
-				}
-				const action = await onMissing(sourceStr);
-				if (action === "skip") return false;
-				if (action === "error") throw new Error(`Missing source: ${sourceStr}`);
+	private async resolveOnePackageSource(
+		pkg: PackageSource,
+		scope: SourceScope,
+		accumulator: ResourceAccumulator,
+		onMissing?: (source: string) => Promise<MissingSourceAction>,
+	): Promise<void> {
+		const sourceStr = typeof pkg === "string" ? pkg : pkg.source;
+		const filter = typeof pkg === "object" ? pkg : undefined;
+		const parsed = this.parseSource(sourceStr);
+		const metadata: PathMetadata = { source: sourceStr, scope, origin: "package" };
+
+		if (parsed.type === "local") {
+			const baseDir = this.getBaseDirForScope(scope);
+			this.resolveLocalExtensionSource(parsed, accumulator, filter, metadata, baseDir);
+			return;
+		}
+
+		const installMissing = async (): Promise<boolean> => {
+			if (isOfflineModeEnabled()) {
+				return false;
+			}
+			if (!onMissing) {
 				await this.installParsedSource(parsed, scope);
 				return true;
-			};
+			}
+			const action = await onMissing(sourceStr);
+			if (action === "skip") return false;
+			if (action === "error") throw new Error(`Missing source: ${sourceStr}`);
+			await this.installParsedSource(parsed, scope);
+			return true;
+		};
 
-			if (parsed.type === "npm") {
-				const installedPath = this.getNpmInstallPath(parsed, scope);
-				const needsInstall = !existsSync(installedPath) || (await this.npmNeedsUpdate(parsed, installedPath));
-				if (needsInstall) {
-					const installed = await installMissing();
-					if (!installed) continue;
-				}
-				metadata.baseDir = installedPath;
-				this.collectPackageResources(installedPath, accumulator, filter, metadata);
-				continue;
+		if (parsed.type === "npm") {
+			const installedPath = this.getNpmInstallPath(parsed, scope);
+			const needsInstall = !existsSync(installedPath) || (await this.npmNeedsUpdate(parsed, installedPath));
+			if (needsInstall) {
+				const installed = await installMissing();
+				if (!installed) return;
 			}
+			metadata.baseDir = installedPath;
+			this.collectPackageResources(installedPath, accumulator, filter, metadata);
+			return;
+		}
 
-			if (parsed.type === "git") {
-				const installedPath = this.getGitInstallPath(parsed, scope);
-				if (!existsSync(installedPath)) {
-					const installed = await installMissing();
-					if (!installed) continue;
-				} else if (scope === "temporary" && !parsed.pinned && !isOfflineModeEnabled()) {
-					await this.refreshTemporaryGitSource(parsed, sourceStr);
-				}
-				metadata.baseDir = installedPath;
-				this.collectPackageResources(installedPath, accumulator, filter, metadata);
+		if (parsed.type === "git") {
+			const installedPath = this.getGitInstallPath(parsed, scope);
+			if (!existsSync(installedPath)) {
+				const installed = await installMissing();
+				if (!installed) return;
+			} else if (scope === "temporary" && !parsed.pinned && !isOfflineModeEnabled()) {
+				await this.refreshTemporaryGitSource(parsed, sourceStr);
 			}
+			metadata.baseDir = installedPath;
+			this.collectPackageResources(installedPath, accumulator, filter, metadata);
 		}
 	}
 
@@ -1169,21 +1192,34 @@ export class DefaultPackageManager implements PackageManager {
 		return { name, version };
 	}
 
-	private async installNpm(source: NpmSource, scope: SourceScope, temporary: boolean): Promise<void> {
+	private async installNpm(
+		source: NpmSource,
+		scope: SourceScope,
+		temporary: boolean,
+		interactive: boolean = false,
+	): Promise<void> {
 		const installRoot = this.getNpmInstallRoot(scope, temporary);
 		this.ensureNpmProject(installRoot);
-		await this.runCommand("npm", ["install", source.spec, "--prefix", installRoot]);
+		await this.runCommand("npm", ["install", source.spec, "--prefix", installRoot], { interactive });
 	}
 
-	private async uninstallNpm(source: NpmSource, scope: SourceScope): Promise<void> {
+	private async uninstallNpm(
+		source: NpmSource,
+		scope: SourceScope,
+		interactive: boolean = false,
+	): Promise<void> {
 		const installRoot = this.getNpmInstallRoot(scope, false);
 		if (!existsSync(installRoot)) {
 			return;
 		}
-		await this.runCommand("npm", ["uninstall", source.name, "--prefix", installRoot]);
+		await this.runCommand("npm", ["uninstall", source.name, "--prefix", installRoot], { interactive });
 	}
 
-	private async installGit(source: GitSource, scope: SourceScope): Promise<void> {
+	private async installGit(
+		source: GitSource,
+		scope: SourceScope,
+		interactive: boolean = false,
+	): Promise<void> {
 		const targetDir = this.getGitInstallPath(source, scope);
 		if (existsSync(targetDir)) {
 			return;
@@ -1194,40 +1230,44 @@ export class DefaultPackageManager implements PackageManager {
 		}
 		mkdirSync(dirname(targetDir), { recursive: true });
 
-		await this.runCommand("git", ["clone", source.repo, targetDir]);
+		await this.runCommand("git", ["clone", source.repo, targetDir], { interactive });
 		if (source.ref) {
-			await this.runCommand("git", ["checkout", source.ref], { cwd: targetDir });
+			await this.runCommand("git", ["checkout", source.ref], { cwd: targetDir, interactive });
 		}
 		const packageJsonPath = join(targetDir, "package.json");
 		if (existsSync(packageJsonPath)) {
-			await this.runCommand("npm", ["install"], { cwd: targetDir });
+			await this.runCommand("npm", ["install"], { cwd: targetDir, interactive });
 		}
 	}
 
-	private async updateGit(source: GitSource, scope: SourceScope): Promise<void> {
+	private async updateGit(
+		source: GitSource,
+		scope: SourceScope,
+		interactive: boolean = false,
+	): Promise<void> {
 		const targetDir = this.getGitInstallPath(source, scope);
 		if (!existsSync(targetDir)) {
-			await this.installGit(source, scope);
+			await this.installGit(source, scope, interactive);
 			return;
 		}
 
 		// Fetch latest from remote (handles force-push by getting new history)
-		await this.runCommand("git", ["fetch", "--prune", "origin"], { cwd: targetDir });
+		await this.runCommand("git", ["fetch", "--prune", "origin"], { cwd: targetDir, interactive });
 
 		// Reset to tracking branch. Fall back to origin/HEAD when no upstream is configured.
 		try {
-			await this.runCommand("git", ["reset", "--hard", "@{upstream}"], { cwd: targetDir });
+			await this.runCommand("git", ["reset", "--hard", "@{upstream}"], { cwd: targetDir, interactive });
 		} catch {
-			await this.runCommand("git", ["remote", "set-head", "origin", "-a"], { cwd: targetDir }).catch(() => {});
-			await this.runCommand("git", ["reset", "--hard", "origin/HEAD"], { cwd: targetDir });
+			await this.runCommand("git", ["remote", "set-head", "origin", "-a"], { cwd: targetDir, interactive }).catch(() => {});
+			await this.runCommand("git", ["reset", "--hard", "origin/HEAD"], { cwd: targetDir, interactive });
 		}
 
 		// Clean untracked files (extensions should be pristine)
-		await this.runCommand("git", ["clean", "-fdx"], { cwd: targetDir });
+		await this.runCommand("git", ["clean", "-fdx"], { cwd: targetDir, interactive });
 
 		const packageJsonPath = join(targetDir, "package.json");
 		if (existsSync(packageJsonPath)) {
-			await this.runCommand("npm", ["install"], { cwd: targetDir });
+			await this.runCommand("npm", ["install"], { cwd: targetDir, interactive });
 		}
 	}
 
@@ -1819,19 +1859,46 @@ export class DefaultPackageManager implements PackageManager {
 		};
 	}
 
-	private runCommand(command: string, args: string[], options?: { cwd?: string }): Promise<void> {
+	/**
+	 * Run a child process. When `interactive` is true (the explicit user-facing
+	 * install/update path), stdio is inherited so npm/git progress shows in the
+	 * terminal. When false (the default — auto-resolve during launch), stdout
+	 * and stderr are captured. The captured stderr is appended to the failure
+	 * error so callers can surface the underlying cause without polluting the
+	 * TUI during startup.
+	 */
+	private runCommand(
+		command: string,
+		args: string[],
+		options?: { cwd?: string; interactive?: boolean },
+	): Promise<void> {
+		const interactive = options?.interactive === true;
 		return new Promise((resolvePromise, reject) => {
 			const child = spawn(command, args, {
 				cwd: options?.cwd,
-				stdio: "inherit",
+				stdio: interactive ? "inherit" : ["ignore", "pipe", "pipe"],
 				shell: process.platform === "win32",
 			});
+
+			let stderr = "";
+			if (!interactive) {
+				child.stdout?.on("data", () => { /* drop — progress goes through withProgress */ });
+				child.stderr?.on("data", (chunk: Buffer | string) => {
+					stderr += typeof chunk === "string" ? chunk : chunk.toString("utf-8");
+					// Cap to avoid unbounded growth on chatty failures.
+					if (stderr.length > 4_000) stderr = stderr.slice(-4_000);
+				});
+			}
+
 			child.on("error", reject);
 			child.on("exit", (code) => {
 				if (code === 0) {
 					resolvePromise();
 				} else {
-					reject(new Error(`${command} ${args.join(" ")} failed with code ${code}`));
+					const detail = !interactive && stderr.trim().length > 0
+						? `: ${stderr.trim().split("\n").slice(-3).join(" ").slice(0, 500)}`
+						: "";
+					reject(new Error(`${command} ${args.join(" ")} failed with code ${code}${detail}`));
 				}
 			});
 		});

package/packages/pi-coding-agent/src/core/resolve-config-value.ts

@@ -24,6 +24,20 @@ export const SAFE_COMMAND_PREFIXES = [
 	"lpass",
 ];
 
+/**
+ * Whether to emit the per-blocked-command stderr warning. Off by default —
+ * extensions (e.g. piolium's anthropic-vertex registration) intentionally
+ * register !sh-style apiKey expressions that will never resolve on most user
+ * machines; the warning is noise. Opt back in by setting OTTO_LOG_BLOCKED_COMMANDS=1
+ * (or any truthy value) when actively debugging credential resolution.
+ */
+function shouldLogBlockedCommands(): boolean {
+	const v = process.env.OTTO_LOG_BLOCKED_COMMANDS;
+	if (!v) return false;
+	const lv = v.toLowerCase();
+	return lv === "1" || lv === "true" || lv === "yes";
+}
+
 /**
  * Active command prefix allowlist. Defaults to SAFE_COMMAND_PREFIXES but can be
  * overridden via setAllowedCommandPrefixes() (called from settings or env var).
@@ -70,13 +84,17 @@ function executeCommand(commandConfig: string): string | undefined {
 	const tokens = command.split(/\s+/).filter(Boolean);
 	const firstToken = tokens[0];
 	if (!activeCommandPrefixes.includes(firstToken)) {
-		process.stderr.write(`[resolve-config-value] Blocked disallowed command: "${firstToken}". Allowed: ${activeCommandPrefixes.join(", ")}\n`);
+		if (shouldLogBlockedCommands()) {
+			process.stderr.write(`[resolve-config-value] Blocked disallowed command: "${firstToken}". Allowed: ${activeCommandPrefixes.join(", ")}\n`);
+		}
 		commandResultCache.set(commandConfig, undefined);
 		return undefined;
 	}
 
 	if (SHELL_OPERATORS.test(command)) {
-		process.stderr.write(`[resolve-config-value] Blocked shell operators in command: "${command}"\n`);
+		if (shouldLogBlockedCommands()) {
+			process.stderr.write(`[resolve-config-value] Blocked shell operators in command: "${command}"\n`);
+		}
 		commandResultCache.set(commandConfig, undefined);
 		return undefined;
 	}

package/packages/pi-coding-agent/src/core/settings-manager.ts

@@ -220,6 +220,11 @@ export interface Settings {
 	allowedCommandPrefixes?: string[]; // Override built-in SAFE_COMMAND_PREFIXES for !command resolution (global-only — ignored in project settings)
 	fetchAllowedUrls?: string[]; // Hostnames exempted from SSRF blocklist in fetch_page (global-only — ignored in project settings)
 	hooks?: HooksSettings; // Layer 0 shell-command hooks. Project-scoped hooks require explicit trust (.pi/hooks.trusted).
+	seedDefaultsOnLaunch?: boolean; // When true, ship-with-OTTO default packages are added to `packages` on launch
+	seededDefaults?: string[]; // Sources already attempted to seed — prevents re-adding after the user removes one
+	enabledDefaultPackages?: string[]; // Subset of default sources the user opted into during onboarding. undefined = "all" (back-compat)
+	quietExtensions?: string[]; // Substring patterns matched against extension.path — ui.notify calls from matching extensions are silently dropped
+	seededQuietPatterns?: string[]; // Quiet patterns already attempted to seed — zombie-resurrection guard, mirrors seededDefaults
 }
 
 /** Settings keys that are only respected from global config — project settings cannot override these. */
@@ -938,6 +943,57 @@ export class SettingsManager {
 		this.setProjectSetting("packages", packages);
 	}
 
+	getSeedDefaultsOnLaunch(): boolean | undefined {
+		return this.settings.seedDefaultsOnLaunch;
+	}
+
+	setSeedDefaultsOnLaunch(enabled: boolean): void {
+		this.setGlobalSetting("seedDefaultsOnLaunch", enabled);
+	}
+
+	getSeededDefaults(): string[] {
+		return [...(this.settings.seededDefaults ?? [])];
+	}
+
+	setSeededDefaults(sources: string[]): void {
+		this.setGlobalSetting("seededDefaults", sources);
+	}
+
+	/**
+	 * Returns undefined when the user has expressed no preference (back-compat:
+	 * the seeder treats this as "install every default"). Returns a (possibly
+	 * empty) array when the user has explicitly chosen a subset.
+	 */
+	getEnabledDefaultPackages(): string[] | undefined {
+		const value = this.settings.enabledDefaultPackages;
+		return value === undefined ? undefined : [...value];
+	}
+
+	setEnabledDefaultPackages(sources: string[]): void {
+		this.setGlobalSetting("enabledDefaultPackages", sources);
+	}
+
+	/**
+	 * Returns substring patterns matched (case-insensitive) against an extension's
+	 * filesystem path. ui.notify calls from matching extensions are silently
+	 * dropped at runtime — useful for muting noisy session_start banners.
+	 */
+	getQuietExtensions(): string[] {
+		return [...(this.settings.quietExtensions ?? [])];
+	}
+
+	setQuietExtensions(patterns: string[]): void {
+		this.setGlobalSetting("quietExtensions", patterns);
+	}
+
+	getSeededQuietPatterns(): string[] {
+		return [...(this.settings.seededQuietPatterns ?? [])];
+	}
+
+	setSeededQuietPatterns(patterns: string[]): void {
+		this.setGlobalSetting("seededQuietPatterns", patterns);
+	}
+
 	getExtensionPaths(): string[] {
 		return [...(this.settings.extensions ?? [])];
 	}