@estebanforge/pi-antigravity-bridge 1.2.6 → 1.3.0

package/src/mcp-server.ts

@@ -15,16 +15,14 @@
 //     the loopback server. Combined with 127.0.0.1 binding.
 //   - Request body size cap.
 //
-// CAPABILITY GATE: pi.invokeTool is NOT upstream pi (local patch, see
-// docs/PI-INVOKETOOL-PATCH.md). If absent, startMcpServer returns { ok:false }
-// and the bridge runs unchanged.
+// The bridge routes calls through the provider's toolUse round-trip; it
+// needs no privileged pi API.
 
 import http from "node:http";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import crypto from "node:crypto";
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import {
@@ -54,9 +52,20 @@ export interface McpStartResult {
 	reason?: string;
 }
 
-/** True only if the running pi exposes the local invokeTool patch. */
-export function hasInvokeTool(pi: ExtensionAPI): boolean {
-	return typeof (pi as unknown as { invokeTool?: unknown }).invokeTool === "function";
+/** Provider-owned bridge surface. The provider builds the tool catalog
+ *  (config-filtered: none|mcp|all + skills) and owns the toolUse round-trip:
+ *  onToolCall parks the call, ends the pi assistant message with stopReason
+ *  "toolUse" for the REAL pi tool, and resolves when pi hands back the
+ *  toolResult on the next stream call. Fail-closed: the provider enforces a
+ *  480s timeout and rejects when no agy turn is active. */
+export interface McpBridgeDeps {
+	listTools(): Array<{ name: string; description: string; inputSchema: object }>;
+	onToolCall(
+		callId: string,
+		name: string,
+		args: Record<string, unknown>,
+		signal: AbortSignal,
+	): Promise<{ content: Array<{ type: string; text?: string }>; isError: boolean }>;
 }
 
 /** Clamp an unsupported MCP-Protocol-Version header down to the SDK's LATEST.
@@ -83,18 +92,6 @@ function clampProtocolVersionHeader(req: http.IncomingMessage): void {
 	}
 }
 
-interface PiToolMeta {
-	name: string;
-	description?: string;
-	parameters?: object;
-	sourceInfo?: { source?: string };
-}
-
-interface InvokeResult {
-	content?: Array<{ type: string; text?: string }>;
-	isError?: boolean;
-}
-
 const BRIDGE_BASE = path.join(os.homedir(), ".pi", "agent", "antigravity-bridge");
 
 /** Per-process config dir. Each pi session owns its own file, so concurrent
@@ -240,52 +237,35 @@ export function registerExitCleanup(
 }
 
 export async function startMcpServer(
-	pi: ExtensionAPI,
+	deps: McpBridgeDeps,
 	opts: { preferredPort?: number; log?: (s: string, d?: unknown) => void } = {},
 ): Promise<McpStartResult> {
 	const log = opts.log ?? (() => {});
 
-	if (!hasInvokeTool(pi)) {
-		const reason =
-			"pi.invokeTool unavailable (needs the local pi patch). MCP tool bridge disabled; provider and AskAntigravity tool run unchanged.";
-		log("capability-missing", reason);
-		return { ok: false, reason };
-	}
-
-	const getAll = (pi as unknown as { getAllTools: () => PiToolMeta[] }).getAllTools.bind(pi);
-	const invoke =
-		(pi as unknown as { invokeTool: (n: string, a?: unknown, o?: { signal?: AbortSignal }) => Promise<InvokeResult> }).invokeTool.bind(pi);
-
 	const listHandler = async () => {
-		const all = getAll();
-		const tools = all
-			.filter((t) => t.sourceInfo?.source !== "builtin")
-			.filter((t) => !SKIP_CIRCULAR.has(t.name))
-			.map((t) => {
-				let inputSchema: object | undefined;
-				try {
-					inputSchema = t.parameters ? JSON.parse(JSON.stringify(t.parameters)) : undefined;
-				} catch {
-					inputSchema = { type: "object", properties: {}, additionalProperties: true };
-				}
-				return { name: t.name, description: t.description ?? t.name, inputSchema };
-			});
+		const tools = deps.listTools();
 		log("list-tools", { count: tools.length });
 		return { tools };
 	};
 
 	const callHandler = async (request: { params: { name: string; arguments?: unknown } }, signal?: AbortSignal) => {
 		const { name, arguments: args } = request.params;
-		log("call-tool", { name });
+		const callId = crypto.randomUUID();
+		log("call-tool", { name, callId });
 		try {
-			const r = await invoke(name, args ?? {}, { signal });
+			const r = await deps.onToolCall(
+				callId,
+				name,
+				(args && typeof args === "object" ? args : {}) as Record<string, unknown>,
+				signal ?? new AbortController().signal,
+			);
 			const content =
 				r.content && r.content.length > 0 ? r.content : [{ type: "text", text: JSON.stringify(r) }];
-			log("call-tool-ok", { name });
+			log("call-tool-ok", { name, callId });
 			return { content, isError: r.isError ?? false };
 		} catch (e) {
 			const msg = e instanceof Error ? e.message : String(e);
-			log("call-tool-fail", { name, msg });
+			log("call-tool-fail", { name, callId, msg });
 			return { content: [{ type: "text", text: `Error: ${msg}` }], isError: true };
 		}
 	};

package/src/native-tools.ts

@@ -0,0 +1,104 @@
+// Native re-execution mapping - agy read-only tools whose work pi can redo
+// cheaply and safely with its own builtins. The provider emits these as native
+// pi toolCalls (real builtin name, pi-schema args); pi executes the real
+// builtin, so cards render with pi's own renderers.
+//
+// Mutating tools (commands, edits, writes) and agy-specialty tools are never
+// re-executed - they replay through the display-only `antigravity` wrapper
+// tool. Ported from tianzuo/pi-antigravity lib/native-tools.ts (MIT).
+
+export interface NativeToolCall {
+	/** pi builtin tool name (`read`, `ls`, `grep`, `find`). */
+	tool: string;
+	/** Arguments conforming to the builtin's schema. */
+	args: Record<string, unknown>;
+}
+
+function str(input: Record<string, unknown>, keys: string[]): string | undefined {
+	for (const key of keys) {
+		const value = input[key];
+		if (typeof value === "string" && value.trim()) return value;
+	}
+	return undefined;
+}
+
+function num(input: Record<string, unknown>, keys: string[]): number | undefined {
+	for (const key of keys) {
+		const value = input[key];
+		if (typeof value === "number" && Number.isInteger(value) && value > 0) return value;
+	}
+	return undefined;
+}
+
+function onlyKeys(input: Record<string, unknown>, allowed: readonly string[]): boolean {
+	const accepted = new Set(allowed);
+	return Object.entries(input).every(
+		([key, value]) => value === undefined || value === null || accepted.has(key),
+	);
+}
+
+const VIEW_PATH_KEYS = [
+	"path",
+	"Path",
+	"AbsolutePath",
+	"absolute_path",
+	"TargetFile",
+	"target_file",
+	"FilePath",
+	"file_path",
+] as const;
+const START_LINE_KEYS = ["StartLine", "start_line", "startLine"] as const;
+const END_LINE_KEYS = ["EndLine", "end_line", "endLine"] as const;
+
+/** Map an agy tool step to a native pi toolCall when re-execution is safe.
+ *  Returns undefined for everything that must stay on the replay wrapper. */
+export function mapAgyToolToNative(
+	tool: string,
+	args: Record<string, unknown>,
+): NativeToolCall | undefined {
+	switch (tool) {
+		case "view_file": {
+			if (!onlyKeys(args, [...VIEW_PATH_KEYS, ...START_LINE_KEYS, ...END_LINE_KEYS])) {
+				return undefined;
+			}
+			const path = str(args, [...VIEW_PATH_KEYS]);
+			const start = num(args, [...START_LINE_KEYS]);
+			const end = num(args, [...END_LINE_KEYS]);
+			if (!path || (end !== undefined && start === undefined) || (start && end && end < start)) {
+				return undefined;
+			}
+			return {
+				tool: "read",
+				args: {
+					path,
+					...(start === undefined ? {} : { offset: start }),
+					...(start === undefined || end === undefined ? {} : { limit: end - start + 1 }),
+				},
+			};
+		}
+		case "list_dir": {
+			const keys = ["path", "Path", "DirectoryPath", "directory", "Directory"];
+			if (!onlyKeys(args, keys)) return undefined;
+			const path = str(args, keys);
+			return path ? { tool: "ls", args: { path } } : undefined;
+		}
+		case "grep_search": {
+			const patternKeys = ["query", "Query", "pattern", "Pattern"];
+			const pathKeys = ["search_path", "SearchPath", "path", "Path"];
+			if (!onlyKeys(args, [...patternKeys, ...pathKeys])) return undefined;
+			const pattern = str(args, patternKeys);
+			const path = str(args, pathKeys);
+			return pattern ? { tool: "grep", args: path ? { pattern, path } : { pattern } } : undefined;
+		}
+		case "find_by_name": {
+			const patternKeys = ["pattern", "Pattern", "glob", "name"];
+			const pathKeys = ["search_directory", "SearchDirectory", "path", "Path", "directory"];
+			if (!onlyKeys(args, [...patternKeys, ...pathKeys])) return undefined;
+			const pattern = str(args, patternKeys);
+			const path = str(args, pathKeys);
+			return pattern ? { tool: "find", args: path ? { pattern, path } : { pattern } } : undefined;
+		}
+		default:
+			return undefined;
+	}
+}

package/src/{patcher.ts → patch-cleanup.ts}

@@ -1,4 +1,15 @@
-// Self-applier for the pi.invokeTool local patch (docs/PI-INVOKETOOL-PATCH.md).
+// Cleanup for the LEGACY pi.invokeTool local patch (removed in 1.3.0).
+//
+// Users who ran the old consent-gated patcher still carry pi.invokeTool in
+// their installed pi dist/. It is inert (nothing calls it) and a pi
+// update/reinstall wipes it, but it is a silent vendor modification. This
+// module detects it and restores the original files from the versioned
+// backup the patcher left behind - only on an explicit /agy patch-cleanup
+// command. It never writes to the pi install on its own.
+//
+// Everything below (site table, sentinels, findPiRoot, version-guarded
+// restore) is carried over verbatim from the deleted patcher so detection
+// and restore stay byte-compatible with what users actually have on disk.
 //
 // Adds pi.invokeTool() at 6 sites in 4 compiled files under pi's dist/, plus
 // (pi 0.84.3+) an entry redirect that swaps the bundled dist/bundle/cli.js
@@ -365,8 +376,14 @@ function describeWriteError(err: unknown, root: string): string {
 	return err instanceof Error ? err.message : String(err);
 }
 
-/** Find the newest backup dir (by VERSION file mtime), if any. */
-function findNewestBackup(base: string): { dir: string; version: string } | null {
+/** Find the best backup dir: an exact version match when `preferVersion` is
+ *  given, else the newest by VERSION mtime. Multi-version backup dirs are
+ *  normal (the old patcher re-applied across pi upgrades), so newest-by-mtime
+ *  alone could pick a backup that cannot legally restore. */
+function findNewestBackup(
+	base: string,
+	preferVersion?: string,
+): { dir: string; version: string } | null {
 	let entries: string[];
 	try {
 		entries = fs.readdirSync(base);
@@ -381,6 +398,9 @@ function findNewestBackup(base: string): { dir: string; version: string } | null
 			const stat = fs.statSync(verFile);
 			const manifest = JSON.parse(fs.readFileSync(verFile, "utf8"));
 			if (typeof manifest.version !== "string") continue;
+			if (preferVersion && manifest.version === preferVersion) {
+				return { dir, version: manifest.version };
+			}
 			if (!best || stat.mtimeMs > best.mtime) {
 				best = { dir, version: manifest.version, mtime: stat.mtimeMs };
 			}
@@ -433,7 +453,7 @@ export function patchStatus(opts: { root?: string; backupBase?: string } = {}):
 		if (!txt.includes(ENTRY_REDIRECT.sentinel)) missing.push(ENTRY_REDIRECT.file);
 	}
 	// Absent file = pre-bundle pi: the bin already points at the modular entry.
-	const backup = findNewestBackup(backupBaseOf(opts));
+	const backup = findNewestBackup(backupBaseOf(opts), root.version);
 	return {
 		present: missing.length === 0,
 		root: root.root,
@@ -455,198 +475,6 @@ export type PatchAction =
 
 /** Decide the session_start patch action. Precedence:
  *  live > on-disk-needs-restart > declined > interactive-ask > headless-skip. */
-export function decidePatchAction(
-	live: boolean,
-	diskPresent: boolean,
-	declined: boolean,
-	hasUI: boolean,
-): PatchAction {
-	if (live) return { kind: "proceed" };
-	if (diskPresent) return { kind: "notify-restart" };
-	if (declined) return { kind: "silent" };
-	return hasUI ? { kind: "ask" } : { kind: "headless-skip" };
-}
-
-/** Apply the patch idempotently. Two-phase: validate all anchors first, write
- *  only if something is missing. Facade file is written last. */
-export function applyInvokeToolPatch(opts: PatchOpts = {}): PatchResult {
-	const log = opts.log ?? (() => {});
-	const errors: string[] = [];
-	const changedFiles: string[] = [];
-
-	const found = resolveRoot(opts);
-	if (!found) {
-		const msg =
-			"could not locate the running pi package root (tried argv, import.meta.resolve, npm root -g, and known paths, none verified). Is pi installed? For a bundled-binary pi there are no JS files to patch.";
-		log("root-not-found", msg);
-		return { present: false, patched: false, alreadyPresent: false, changedFiles, errors: [msg] };
-	}
-	const { root, version } = found;
-	log("root", { root, version });
-
-	// Phase 1: read every file, validate anchors/sentinels, build the change plan.
-	type Plan = { file: string; original: string; next: string; changed: boolean };
-	const plan: Plan[] = [];
-	for (const f of PATCH_FILES) {
-		const filePath = path.join(root, "dist", f.file);
-		let original: string;
-		try {
-			original = fs.readFileSync(filePath, "utf8");
-		} catch (e) {
-			errors.push(`cannot read ${f.file}: ${e instanceof Error ? e.message : String(e)}`);
-			return { present: false, patched: false, alreadyPresent: false, changedFiles, errors, root, version };
-		}
-		let next = original;
-		let changed = false;
-		for (const site of f.sites) {
-			if (!siteMissing(original, site)) continue; // already patched at this site
-			if (!original.includes(site.anchor)) {
-				// Version drift: the code pi ships moved/renamed. Abort cleanly.
-				const msg =
-					`anchor not found in ${f.file} (pi ${version}). pi's structure changed; ` +
-					`the patch needs updating for this version. No files were written. ` +
-					`See docs/PI-INVOKETOOL-PATCH.md.`;
-				errors.push(msg);
-				log("anchor-missing", { file: f.file, version });
-				return { present: false, patched: false, alreadyPresent: false, changedFiles, errors, root, version };
-			}
-			next = next.replace(site.anchor, site.anchor + site.insertion);
-			changed = true;
-		}
-		plan.push({ file: f.file, original, next, changed });
-	}
-
-	// Phase 1b: entry redirect. An absent file means pre-bundle pi; skip.
-	// Compute the previous backup now: the copy-forward in phase 2 needs it,
-	// and the already-redirected warning below needs to know whether any
-	// backup still holds the original entry bytes.
-	const prevBackup = findNewestBackup(backupBaseOf(opts));
-	let entry: { original: string } | null = null;
-	const entryPath = path.join(root, "dist", ENTRY_REDIRECT.file);
-	if (fs.existsSync(entryPath)) {
-		const original = fs.readFileSync(entryPath, "utf8");
-		if (!original.includes(ENTRY_REDIRECT.sentinel)) {
-			if (!original.includes(ENTRY_REDIRECT.probe)) {
-				const msg =
-					`unexpected content in ${ENTRY_REDIRECT.file} (pi ${version}); it does not look like ` +
-					`pi's bundled entry. No files were written. See docs/PI-INVOKETOOL-PATCH.md.`;
-				errors.push(msg);
-				log("entry-unexpected", { file: ENTRY_REDIRECT.file, version });
-				return { present: false, patched: false, alreadyPresent: false, changedFiles, errors, root, version };
-			}
-			if (!fs.existsSync(path.join(root, "dist", "cli.js"))) {
-				const msg =
-					`modular dist/cli.js not found (pi ${version}); the bundled entry has nowhere to ` +
-					`redirect to. No files were written.`;
-				errors.push(msg);
-				log("entry-target-missing", { version });
-				return { present: false, patched: false, alreadyPresent: false, changedFiles, errors, root, version };
-			}
-			entry = { original };
-		} else if (!prevBackup || !fs.existsSync(path.join(prevBackup.dir, ENTRY_REDIRECT.file))) {
-			// Already redirected, but no backup holds the original entry. Repair
-			// still proceeds (core sites matter); only the entry becomes unrestorable.
-			const msg =
-				`entry redirect already applied but no backup holds the original ${ENTRY_REDIRECT.file}; ` +
-				`/agy patch restore cannot revert it. Reinstall pi to fully revert.`;
-			errors.push(msg);
-			log("entry-original-missing", { file: ENTRY_REDIRECT.file });
-		}
-	}
-	// Absent entry file: pre-bundle pi, the bin already points at the modular entry.
-
-	const anyChange = plan.some((p) => p.changed) || entry !== null;
-	if (!anyChange) {
-		log("already-present", { root, version });
-		return { present: true, patched: false, alreadyPresent: true, changedFiles, errors, root, version };
-	}
-
-	// Phase 2: back up originals (one VERSION-stamped dir), then write facade-last.
-	const stamp = `${version}-${Date.now()}-${process.pid}`;
-	const backupDir = path.join(backupBaseOf(opts), stamp);
-	try {
-		fs.mkdirSync(backupDir, { recursive: true });
-		fs.writeFileSync(
-			path.join(backupDir, "VERSION"),
-			`${JSON.stringify({ version, root, createdAt: new Date().toISOString() }, null, 2)}\n`,
-		);
-		// Copy-forward: seed the new backup with the previous SAME-version backup
-		// so it stays complete even when this run changes only some files (a
-		// repair run after a partial patch). Without this, a repair that does not
-		// touch the entry would create a backup lacking it, and a later restore
-		// would silently skip the entry redirect.
-		if (prevBackup && prevBackup.version === version) {
-			for (const rel of [...PATCH_FILES.map((f) => f.file), ENTRY_REDIRECT.file]) {
-				const src = path.join(prevBackup.dir, rel);
-				if (!fs.existsSync(src)) continue;
-				const dst = path.join(backupDir, rel);
-				fs.mkdirSync(path.dirname(dst), { recursive: true });
-				fs.copyFileSync(src, dst);
-			}
-		}
-		// Overlay the pre-change bytes ONLY for files this run is about to write,
-		// so already-patched files keep their pristine bytes from the older backup
-		// instead of capturing current (patched) bytes.
-		for (const p of plan) if (p.changed) backupOriginal(p.file, p.original, backupDir);
-		if (entry) backupOriginal(ENTRY_REDIRECT.file, entry.original, backupDir);
-		log("backup-written", { backupDir });
-	} catch (e) {
-		const msg = `backup failed (${e instanceof Error ? e.message : String(e)}); aborting before any write.`;
-		errors.push(msg);
-		return { present: false, patched: false, alreadyPresent: false, changedFiles, errors, root, version };
-	}
-
-	// Write in declared order (facade/loader.js is last in PATCH_FILES).
-	for (const p of plan) {
-		if (!p.changed) continue;
-		const filePath = path.join(root, "dist", p.file);
-		try {
-			atomicWrite(filePath, p.next);
-			changedFiles.push(p.file);
-			log("file-patched", { file: p.file });
-		} catch (e) {
-			const msg = describeWriteError(e, root);
-			errors.push(`failed writing ${p.file}: ${msg}`);
-			log("write-failed", { file: p.file, code: (e as NodeJS.ErrnoException)?.code });
-			// Stop here; earlier files in this run are already patched and backed
-			// up, so a retry (or restore) recovers cleanly. hasInvokeTool() stays
-			// false unless the facade (last file) already succeeded.
-			break;
-		}
-	}
-
-	// The entry redirect goes LAST: it is the activator. Until it lands, the
-	// patched core stays inert (the bundle still runs), so a partial run fails
-	// closed exactly like a facade-only failure. Never written after any write
-	// error: activating the modular runtime is the accepted tradeoff of a
-	// SUCCESSFUL patch, not of a failed one.
-	if (entry && errors.length === 0) {
-		try {
-			atomicWrite(entryPath, ENTRY_REDIRECT.content);
-			changedFiles.push(ENTRY_REDIRECT.file);
-			log("entry-redirected", { file: ENTRY_REDIRECT.file });
-		} catch (e) {
-			const msg = describeWriteError(e, root);
-			errors.push(`failed writing ${ENTRY_REDIRECT.file}: ${msg}`);
-			log("write-failed", { file: ENTRY_REDIRECT.file, code: (e as NodeJS.ErrnoException)?.code });
-		}
-	}
-
-	const status = patchStatus({ root, backupBase: opts.backupBase });
-	return {
-		present: status.present,
-		patched: changedFiles.length > 0,
-		alreadyPresent: false,
-		changedFiles,
-		backupDir,
-		errors,
-		root,
-		version,
-	};
-}
-
-/** Restore the most recent backup. Refuses if the installed pi version differs
- *  from the backup's version (prevents silently downgrading shipped core). */
 export function restorePatch(opts: PatchOpts = {}): RestoreResult {
 	const log = opts.log ?? (() => {});
 	const found = resolveRoot(opts);
@@ -654,7 +482,7 @@ export function restorePatch(opts: PatchOpts = {}): RestoreResult {
 		return { ok: false, restoredFiles: [], reason: "could not locate the running pi package root to restore into." };
 	}
 	const { root, version } = found;
-	const backup = findNewestBackup(backupBaseOf(opts));
+	const backup = findNewestBackup(backupBaseOf(opts), found.version);
 	if (!backup) {
 		return { ok: false, restoredFiles: [], reason: "no backup found; nothing to restore." };
 	}