@estebanforge/pi-antigravity-bridge 1.3.3 → 1.4.1

package/extensions/index.ts

@@ -37,9 +37,12 @@ import {
 import { SessionStore } from "../src/sessions.js";
 import { ToolRoundTrips, WrapperReplay, createStreamSimple } from "../src/provider.js";
 import { AgyDriver } from "../src/driver.js";
-import { CONFIG_PATH, loadConfig, saveConfig, type AgyMode, type BridgeTools, type ThinkingTier } from "../src/config.js";
+import { AcpDriver } from "../src/acp/driver.js";
+import { ensureAcpReady, inspectAcpSetup } from "../src/acp/setup.js";
+import type { TurnDriver } from "../src/driver-types.js";
+import { CONFIG_PATH, loadConfig, saveConfig, type AgyMode, type BridgeTools, type Engine, type ThinkingTier } from "../src/config.js";
 import { registerAskAntigravityTool, toolModelsFromRaw } from "../src/ask-tool.js";
-import { startMcpServer, type McpServerHandle } from "../src/mcp-server.js";
+import { startMcpServer, TOKEN_HEADER, type McpServerHandle } from "../src/mcp-server.js";
 import {
 	ACTIVATE_SKILL_TOOL_NAME,
 	activateSkillSchema,
@@ -79,14 +82,72 @@ export default async function (pi: ExtensionAPI): Promise<void> {
 	const toolModels = toolModelsFromRaw(raw);
 	const usingFallback = discovered.length === 0;
 	const entries: AgyModelEntry[] = usingFallback ? FALLBACK_MODELS : discovered;
-	const models = entries.map(toPiModel);
+	// Engine latched at load: /agy engine takes effect on the next pi start
+	// (documented). Everything below resolves from THIS value - per-call
+	// config reads would let a mid-session flip leave ToolRoundTrips,
+	// kickIdle, and reentry pointing at the other engine (round-7 finding).
+	const engine: Engine = loadConfig().engine;
+	// Engine switching requires a restart, so the catalog-time engine read is
+	// authoritative for input advertising: image attach rides only when turns
+	// will run on the ACP engine (the legacy CLI prompt is text-only).
+	const modelInput: Array<"text" | "image"> = engine === "acp" ? ["text", "image"] : ["text"];
+	const models = entries.map((e) => toPiModel(e, modelInput));
 
 	const store = new SessionStore();
-	// Persistent stream-json engine + the no-patch pi-tool round-trip store.
-	// The MCP bridge parks calls here; the provider emits them as real pi
-	// toolUse turns and completes them from the next call's toolResult.
-	const driver = new AgyDriver();
-	const roundTrips = new ToolRoundTrips(driver);
+	// MCP bridge handle, declared early: the ACP engine reads the bridge port
+	// at session/new / session/load time.
+	let mcpHandle: McpServerHandle | null = null;
+	// ACP self-heal runs once per process (session_start re-fires on /reload;
+	// a ready setup is two file stats, so re-running is harmless anyway).
+	let acpSelfHealRan = false;
+	// Two turn engines behind one contract (plan §9): stream-json (tested
+	// default) and the official ACP server (opt-in via config.engine, off by
+	// default). Neither spawns anything until its first turn.
+	// ACP log routing: only genuine failures reach stderr. Routine lifecycle
+	// (driver-created, spawn, session-new, ...) stays in the driver's
+	// #lifecycle ring buffer, visible via /agy doctor. An unfiltered sink fired
+	// console.error at extension load ("driver-created"), before any UI exists,
+	// and leaked raw driver lines into the terminal on every startup.
+	const acpFailures = new Set([
+		"start-failed", "spawn-error", "parse-error", "write-failed",
+		"mode-apply-failed", "timeout", "stall", "auth-required",
+		"session-load-failed-creating-fresh", "connection-exited", "cancel-failed",
+		"unsupported-server-request",
+	]);
+	const legacyDriver = new AgyDriver();
+	const acpDriver = new AcpDriver({
+		// Resolved per connection: the setup flow can install the binary and
+		// update acp.bin mid-session; the next turn picks it up (no restart).
+		bin: () => loadConfig().acp.bin,
+		log: (msg, data) => {
+			if (!acpFailures.has(msg)) return;
+			console.error(`[antigravity-bridge acp] ${msg}${data !== undefined ? " " + JSON.stringify(data) : ""}`);
+		},
+		mcpServers: () => {
+			const handle = mcpHandle;
+			if (!handle) return [];
+			// The bridge 403s any request without the shared-secret header; the
+			// legacy engine carries it via mcp_config.json, ACP via headers[].
+			return [
+				{
+					name: "pi-bridge",
+					type: "http",
+					url: `http://127.0.0.1:${handle.port}/mcp`,
+					headers: [{ name: TOKEN_HEADER, value: handle.token }],
+				},
+			];
+		},
+	});
+	// The active engine is resolved from the latched load-time value.
+	const activeDriver = (): TurnDriver => (engine === "acp" ? acpDriver : legacyDriver);
+	// The provider's stream-json slot gets the LEGACY driver explicitly - never
+	// activeDriver(), or a load-time acp engine would make deps.driver and
+	// deps.acpDriver the same object and break the engine identity check.
+	const driver = legacyDriver;
+	// The no-patch pi-tool round-trip store: the MCP bridge parks calls here;
+	// the provider emits them as real pi toolUse turns and completes them from
+	// the next call's toolResult.
+	const roundTrips = new ToolRoundTrips(activeDriver);
 	const replay = new WrapperReplay();
 	// Native re-exec only emits for builtins actually active in the session;
 	// anything else (or an unknown name) falls back to the wrapper card.
@@ -99,9 +160,20 @@ export default async function (pi: ExtensionAPI): Promise<void> {
 		}
 	};
 	// A settled turn cannot answer its parked calls; the driver never sees
-	// ToolRoundTrips, so the provider bridges the two here.
-	driver.onTurnEnd = () => roundTrips.failAll("antigravity turn ended with an unresolved pi tool call");
-	const streamSimple = createStreamSimple({ entries, store, driver, roundTrips, replay, nativeActive });
+	// ToolRoundTrips, so the provider bridges the two here (both engines).
+	const onTurnEnd = () => roundTrips.failAll("antigravity turn ended with an unresolved pi tool call");
+	legacyDriver.onTurnEnd = onTurnEnd;
+	acpDriver.onTurnEnd = onTurnEnd;
+	const streamSimple = createStreamSimple({
+		entries,
+		store,
+		driver,
+		acpDriver,
+		roundTrips,
+		replay,
+		nativeActive,
+		engine,
+	});
 
 	pi.registerProvider("antigravity", {
 		name: "Antigravity (agy)",
@@ -122,7 +194,15 @@ export default async function (pi: ExtensionAPI): Promise<void> {
 		streamSimple,
 	});
 
-	registerAgyCommand(pi, { entries, store, usingFallback, driver, getMcpPort: () => mcpHandle?.port ?? null });
+	registerAgyCommand(pi, {
+		entries,
+		store,
+		usingFallback,
+		driver,
+		acpDriver,
+		engine,
+		getMcpPort: () => mcpHandle?.port ?? null,
+	});
 
 	// AskAntigravity tool: one-shot delegation to agy (ported from
 	// pi-ask-antigravity). When both extensions are installed, the bridge wins
@@ -153,7 +233,6 @@ export default async function (pi: ExtensionAPI): Promise<void> {
 	// Calls park in the provider's round-trip store and complete through pi's
 	// normal toolUse loop (native cards, permissions, hooks) - no patch, no
 	// privileged API. Started on session_start, torn down on session_shutdown.
-	let mcpHandle: McpServerHandle | null = null;
 	pi.on("session_start", async (_event, ctx) => {
 		// Legacy cleanup: users who ran the old consent-gated patcher still
 		// carry pi.invokeTool in their installed pi. Inert, but tell them once
@@ -172,29 +251,52 @@ export default async function (pi: ExtensionAPI): Promise<void> {
 		} catch {
 			/* detection is best-effort */
 		}
-		// Bridge lifecycle/error logger. Routes through ctx.ui.notify (an
-		// ephemeral toast that fades) instead of stderr: pi's TUI captures stderr
-		// and pins it above the input for the whole session, which left the
-		// startup "bridge-config-written" / "listening" lines stuck on screen all
-		// session. Headless modes (print/json, hasUI === false) have no toast, so
-		// fall back to stderr there. Per-turn success events (list-tools /
-		// call-tool) stay silent either way.
+		// ACP self-heal: engine=acp needs a server binary + auth. Silent when
+		// everything is ready; installs from the registry and bootstraps auth
+		// otherwise; manual instructions only on failure. Fire-and-forget: it
+		// must not delay session start (and nothing spawns until the first turn).
+		if (engine === "acp" && !acpSelfHealRan) {
+			acpSelfHealRan = true;
+			void ensureAcpReady({ configBin: loadConfig().acp.bin }).then((status) => {
+				if (status.ok) {
+					if (status.binarySource === "installed" || status.binarySource === "existing") {
+						saveConfig({ acp: { bin: status.bin, permissions: loadConfig().acp.permissions } });
+					}
+					if (status.needsLogin) {
+						const msg =
+							"ACP: one-time Google login pending. Your next antigravity message opens the browser; sign in with your Antigravity subscription account (the same login as the agy CLI). Tokens stay on your machine.";
+						if (ctx.hasUI) ctx.ui.notify(msg, "info");
+						else console.error(`[antigravity-bridge] ${msg}`);
+					}
+					return;
+				}
+				const msg = `ACP auto-setup failed (${status.error}).\n${status.manual}`;
+				if (ctx.hasUI) ctx.ui.notify(msg, "warning");
+				else console.error(`[antigravity-bridge] ${msg}`);
+			});
+		}
+		// Bridge failure logger. Routine lifecycle (listening,
+		// bridge-config-written/removed, closed) is normal startup/teardown
+		// traffic: toasting it every session, or pinning it via stderr in
+		// headless mode, was noise. Only genuine failures surface - as a
+		// warning toast (ctx.ui.notify, ephemeral) or stderr when headless.
+		// Per-turn success events (list-tools / call-tool) stay silent.
 		const mcpLog = (s: string, d?: unknown) => {
-			const surfaced = new Set([
-				"listening", "capability-missing", "http-error", "closed",
-				"bridge-config-written", "bridge-config-removed", "bridge-config-write-failed",
-				"call-tool-fail", "transport-error", "handleRequest-error",
-				"request-error", "request-handler-error", "unauthorized", "self-patch-error",
+			// Routine abort traffic: failAll fires on turn end / session shutdown
+			// and the bridge answers every parked call with an error. Not a fault.
+			if (s === "call-tool-fail") {
+				const detail = (d as { msg?: string } | undefined)?.msg ?? "";
+				if (detail.includes("unresolved pi tool call") || detail.includes("session shut down")) return;
+			}
+			const failures = new Set([
+				"http-error", "bridge-config-write-failed", "call-tool-fail",
+				"transport-error", "handleRequest-error", "request-error",
+				"request-handler-error", "unauthorized",
 			]);
-			if (!surfaced.has(s)) return;
+			if (!failures.has(s)) return;
 			const msg = `[antigravity-bridge mcp] ${s}${d !== undefined ? " " + JSON.stringify(d) : ""}`;
-			if (ctx.hasUI) {
-				const ok = s === "listening" || s === "bridge-config-written"
-					|| s === "bridge-config-removed" || s === "closed";
-				ctx.ui.notify(msg, ok ? "info" : "warning");
-			} else {
-				console.error(msg);
-			}
+			if (ctx.hasUI) ctx.ui.notify(msg, "warning");
+			else console.error(msg);
 		};
 		// Start the bridge unless the user turned it off. No patch gate, no
 		// consent flow: calls route through pi's normal toolUse loop.
@@ -266,7 +368,8 @@ export default async function (pi: ExtensionAPI): Promise<void> {
 		mcpHandle = null;
 		await h?.close();
 		roundTrips.failAll("antigravity session shut down");
-		await driver.close("shutdown");
+		await legacyDriver.close("shutdown");
+		await acpDriver.close("shutdown");
 	});
 }
 
@@ -276,7 +379,10 @@ interface AgyCommandCtx {
 	entries: AgyModelEntry[];
 	store: SessionStore;
 	usingFallback: boolean;
-	driver: AgyDriver;
+	driver: TurnDriver;
+	acpDriver: AcpDriver;
+	/** Engine latched at extension load (see the provider wiring note). */
+	engine: Engine;
 	getMcpPort: () => number | null;
 }
 
@@ -293,6 +399,7 @@ function statusText(ctx: AgyCommandCtx): string {
 	const perm = config.skipPermissions ? "auto-approved (DANGEROUS)" : "prompt (hangs in -p)";
 	return [
 		"Antigravity bridge",
+		`  engine:        ${config.engine}${config.engine === "acp" ? " (official server, opt-in)" : ""}`,
 		`  models:        ${ctx.entries.length} ${source}`,
 		`  mode:          ${config.mode}`,
 		`  permissions:   ${perm}`,
@@ -304,7 +411,7 @@ function statusText(ctx: AgyCommandCtx): string {
 		`  digest:        ${config.digest ? "on" : "off"}`,
 		`  system prompt: ${config.systemPrompt ? "on" : "off"}`,
 		"",
-		"Subcommands: /agy mode plan|accept-edits, /agy permissions on|off, /agy model flash|pro|gemini, /agy thinking low|medium|high, /agy digest on|off, /agy system-prompt on|off, /agy clear",
+		"Subcommands: /agy engine stream-json|acp, /agy mode plan|accept-edits, /agy permissions on|off, /agy model flash|pro|gemini, /agy thinking low|medium|high, /agy digest on|off, /agy system-prompt on|off, /agy acp-auth, /agy patch-cleanup, /agy clear",
 	].join("\n");
 }
 
@@ -312,7 +419,7 @@ function statusText(ctx: AgyCommandCtx): string {
 function registerAgyCommand(pi: ExtensionAPI, ctx: AgyCommandCtx): void {
 	pi.registerCommand("agy", {
 		description:
-			"Antigravity provider: status, doctor, mode picker, clear sessions. Usage: /agy [status|doctor|mode [plan|accept-edits]|digest on|off|system-prompt on|off|patch-cleanup|clear]",
+			"Antigravity provider: status, doctor, engine picker, mode picker, clear sessions. Usage: /agy [status|doctor|engine stream-json|acp|mode [plan|accept-edits]|permissions on|off|digest on|off|system-prompt on|off|acp-auth|patch-cleanup|clear]",
 		handler: async (args, cmdCtx: ExtensionCommandContext) => {
 			const ui = cmdCtx.ui;
 			const mode = cmdCtx.mode;
@@ -345,28 +452,112 @@ function registerAgyCommand(pi: ExtensionAPI, ctx: AgyCommandCtx): void {
 				);
 				return;
 			}
+			if (sub === "engine") {
+				if (val === "acp" || val === "stream-json") {
+					if (val === "acp" && loadConfig().mode === "plan") {
+						ui?.notify("mode is plan; the ACP engine has no plan mode. /agy mode accept-edits first.", "warning");
+						return;
+					}
+					const next = saveConfig({ engine: val });
+					if (next.engine !== "acp") {
+						ui?.notify("engine set to stream-json. Takes effect on the next pi start (or /reload).", "info");
+						return;
+					}
+					// Self-service setup: install the server from the official
+					// registry and bootstrap auth now, so the restart just works.
+					// Manual instructions only when a step fails.
+					ui?.notify("engine set to acp. Preparing the server (binary + auth)…", "info");
+					const status = await ensureAcpReady({
+						configBin: loadConfig().acp.bin,
+						onProgress: (m) => ui?.notify(m, "info"),
+					});
+					if (!status.ok) {
+						ui?.notify(`ACP auto-setup failed (${status.error}).\n${status.manual}`, "warning");
+						return;
+					}
+					saveConfig({ acp: { bin: status.bin, permissions: loadConfig().acp.permissions } });
+					ui?.notify(
+						status.needsLogin
+							? "ACP engine ready. Your first ACP message opens the Google login in your browser: sign in with the account of your Antigravity subscription (the same login as the Antigravity CLI, agy). One-time; tokens stay on your machine and this extension never sees them. Takes effect on the next pi start (or /reload)."
+							: `ACP engine ready (auth: ${status.auth}). Takes effect on the next pi start (or /reload).`,
+						"info",
+					);
+				} else {
+					ui?.notify(`current engine: ${loadConfig().engine}\nusage: /agy engine stream-json|acp`, "info");
+				}
+				return;
+			}
+			if (sub === "acp-auth") {
+				ui?.notify(
+					[
+						"ACP engine authentication (one-time; usually automatic -",
+						"/agy engine acp and session start set this up for you):",
+						"",
+						"The server is Google's official Antigravity ACP, installed from Google's",
+						"own registry. Logging in uses your Antigravity subscription: the same",
+						"Google account and plan as the Antigravity CLI (agy). It is no different",
+						"from logging into the CLI; the server just keeps its own token file on",
+						"your machine, like any Google tool. This extension never sees your",
+						"credentials.",
+						"",
+						"1. Server binary: auto-setup installs it. Manual: agy_acp_server.par from",
+						"   the antigravity-acp registry; point acp.bin or AGY_ACP_BIN at it.",
+						'2. Default: put {"auth":{"type":"oauth-personal"}} in',
+						"   ~/.gemini/antigravity-acp/settings.json, run one turn, and complete the",
+						"   Google login that opens in your browser (headless: tunnel 127.0.0.1:<port>",
+						"   over ssh, then open the URL on your machine).",
+						'   Headless alternative: GEMINI_API_KEY + {"auth":{"type":"gemini-api-key"}}',
+						"   (metered paid API - not your Antigravity plan). The key is used only",
+						"   when that type is selected; with the default oauth-personal in place,",
+						"   an exported key is ignored.",
+						"3. Run one turn; /agy doctor shows the server version when auth is OK.",
+					].join("\n"),
+					"info",
+				);
+				return;
+			}
 			if (sub === "doctor") {
 				const config = loadConfig();
-				const snap = ctx.driver.snapshot();
+				const engine = ctx.engine;
+				const snap = (engine === "acp" ? ctx.acpDriver : ctx.driver).snapshot();
 				const port = ctx.getMcpPort();
 				const lines = [
 					"Antigravity doctor (no tokens spent)",
+					`  engine:        ${engine}`,
 					`  bridge:        ${config.bridgeTools}${port ? ` (port ${port})` : " (not running)"}`,
-					`  driver:        ${snap.state}${snap.pid ? ` pid=${snap.pid}` : ""}${snap.conversationId ? ` conv=${snap.conversationId.slice(0, 8)}` : ""}`,
+					`  driver:        ${snap.state}${snap.pid ? ` pid=${snap.pid}` : ""}${snap.conversationId ? ` session=${snap.conversationId.slice(0, 8)}` : ""}`,
 					`  driver stats:  spawns=${snap.stats.spawns} turns=${snap.stats.turns} reused=${snap.stats.reused} recycles=${snap.stats.recycles}${snap.stats.lastRecycleReason ? ` (last: ${snap.stats.lastRecycleReason})` : ""}`,
 					`  sessions:      ${ctx.store.size} bound`,
 					`  models:        ${ctx.entries.length} ${ctx.usingFallback ? "FALLBACK (agy models failed)" : "discovered"}`,
 					`  config:        ${CONFIG_PATH}`,
 				];
+				if (snap.engine === "acp" && snap.acp) {
+					lines.push(
+						`  acp session:   ${snap.acp.sessionId ?? "(none)"}`,
+						`  acp server:    ${snap.acp.serverVersion ?? "unknown"}${snap.acp.agentTitle ? ` (${snap.acp.agentTitle})` : ""}`,
+						`  acp stats:     prompts=${snap.acp.prompts} created=${snap.acp.sessionsCreated} loaded=${snap.acp.sessionsLoaded} kills=${snap.acp.kills} reconnects=${snap.acp.reconnects} cancel=${snap.acp.cancelSupported === null ? "unprobed" : snap.acp.cancelSupported ? "supported" : "unsupported (kill+reload)"}`,
+					);
+				}
 				if (snap.lifecycle.length > 0) {
 					lines.push("  lifecycle (last 5):");
 					for (const entry of snap.lifecycle.slice(-5)) lines.push(`    ${entry}`);
 				}
+				if (engine === "acp") {
+					const setup = inspectAcpSetup({ configBin: config.acp.bin });
+					lines.push(
+						`  acp binary:    ${setup.bin ?? "not found (auto-setup offers install)"}${setup.source ? ` (${setup.source})` : ""}`,
+						`  acp auth:      ${setup.auth ?? "not configured (auto-setup bootstraps)"}`,
+					);
+				}
 				ui?.notify(lines.join("\n"), "info");
 				return;
 			}
 			if (sub === "mode") {
 				if (val === "plan" || val === "accept-edits") {
+					if (val === "plan" && ctx.engine === "acp") {
+						ui?.notify("the ACP engine has no plan mode (RC01). /agy engine stream-json first, or /agy mode accept-edits.", "warning");
+						return;
+					}
 					const next = saveConfig({ mode: val as AgyMode });
 					ui?.notify(`mode set to ${next.mode}`, "info");
 				} else {
@@ -531,6 +722,11 @@ async function openAgyPicker(ui: ExtensionUIContext, ctx: AgyCommandCtx): Promis
 	)
 		return;
 
+	if (pending.mode === "plan" && ctx.engine === "acp") {
+		ui.notify("the ACP engine has no plan mode (RC01). Switch /agy engine stream-json first.", "warning");
+		return;
+	}
+
 	try {
 		const next = saveConfig(pending);
 		const changed = [

package/package.json

@@ -1,14 +1,20 @@
 {
   "name": "@estebanforge/pi-antigravity-bridge",
-  "version": "1.3.3",
-  "description": "Streaming Gemini provider for pi, built on the agy CLI. Registers antigravity/* models in pi's /model picker; drives agy through its stream-json protocol (persistent process, tool round-trips, live usage).",
+  "version": "1.4.1",
+  "description": "Gemini provider for Pi on the Antigravity ACP server (official Google ACP) or the stream-json agy CLI. antigravity/* models in Pi's /model picker, no-patch MCP bridge: agy runs Pi's tools. ToS safe to use.",
   "keywords": [
     "pi-package",
     "pi-extension",
     "antigravity",
+    "antigravity-acp",
     "agy",
     "gemini",
     "google",
+    "google-acp",
+    "acp",
+    "agent-client-protocol",
+    "mcp",
+    "mcp-server",
     "provider",
     "streaming"
   ],
@@ -53,9 +59,10 @@
     }
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "^0.84.3",
-    "@earendil-works/pi-coding-agent": "^0.84.3",
-    "@earendil-works/pi-tui": "^0.84.3",
+    "@earendil-works/pi-ai": "^0.85.0",
+    "@earendil-works/pi-coding-agent": "^0.85.0",
+    "@earendil-works/pi-server": "^0.85.0",
+    "@earendil-works/pi-tui": "^0.85.0",
     "@types/node": "^22.0.0",
     "tsx": "^4.19.0",
     "typebox": "^1.1.38",