@estebanforge/pi-antigravity-bridge 1.9.3 → 1.10.0

package/src/acp/home.ts

@@ -0,0 +1,95 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { isPidAlive } from "../mcp-server.js";
+
+function record(value: unknown, label: string): Record<string, unknown> {
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`${label} must contain a JSON object`);
+	return value as Record<string, unknown>;
+}
+
+function linkDirectory(source: string, target: string): void {
+	fs.symlinkSync(source, target, "junction");
+}
+
+export function acpHomeStagingDir(): string {
+	return path.join(os.homedir(), ".pi", "agent", "antigravity-bridge", "acp-homes");
+}
+
+/** Isolate native ACP from per-pid bridge entries in the global MCP config. */
+export function stageAcpHome(opts: { geminiHome?: string; parentDir?: string } = {}): string {
+	const geminiHome = opts.geminiHome ?? path.join(os.homedir(), ".gemini");
+	const globalConfigDir = path.join(geminiHome, "config");
+	const globalMcpPath = path.join(globalConfigDir, "mcp_config.json");
+	let config: Record<string, unknown> = { mcpServers: {} };
+	try {
+		config = record(JSON.parse(fs.readFileSync(globalMcpPath, "utf8")), globalMcpPath);
+	} catch (err) {
+		if ((err as NodeJS.ErrnoException).code !== "ENOENT") {
+			throw new Error(`Cannot isolate inherited MCP config ${globalMcpPath}: ${err instanceof Error ? err.message : String(err)}`);
+		}
+	}
+	const servers = record(config.mcpServers ?? {}, `${globalMcpPath} mcpServers`);
+	const filtered = Object.fromEntries(Object.entries(servers).filter(([name]) => !/^pi-bridge(?:-\d+)?$/.test(name)));
+
+	const parentDir = opts.parentDir ?? acpHomeStagingDir();
+	fs.mkdirSync(parentDir, { recursive: true, mode: 0o700 });
+	const staged = fs.mkdtempSync(path.join(parentDir, `acp-home-${process.pid}-`));
+	try {
+		fs.mkdirSync(path.join(staged, "config"), { mode: 0o700 });
+		fs.writeFileSync(path.join(staged, "config", "mcp_config.json"), JSON.stringify({ ...config, mcpServers: filtered }), { mode: 0o600 });
+
+		const appData = path.join(geminiHome, "antigravity-cli");
+		if (fs.existsSync(appData)) linkDirectory(appData, path.join(staged, "antigravity-cli"));
+		const instructions = path.join(geminiHome, "GEMINI.md");
+		if (fs.existsSync(instructions)) fs.copyFileSync(instructions, path.join(staged, "GEMINI.md"));
+		if (fs.existsSync(globalConfigDir)) {
+			for (const entry of fs.readdirSync(globalConfigDir, { withFileTypes: true })) {
+				if (entry.name === "mcp_config.json") continue;
+				const source = path.join(globalConfigDir, entry.name);
+				const target = path.join(staged, "config", entry.name);
+				let stat: fs.Stats | fs.Dirent = entry;
+				if (entry.isSymbolicLink()) {
+					try {
+						stat = fs.statSync(source);
+					} catch (err) {
+						if ((err as NodeJS.ErrnoException).code === "ENOENT") continue;
+						throw err;
+					}
+				}
+				if (stat.isDirectory()) linkDirectory(source, target);
+				else if (stat.isFile()) fs.copyFileSync(source, target);
+			}
+		}
+		return staged;
+	} catch (err) {
+		fs.rmSync(staged, { recursive: true, force: true });
+		throw err;
+	}
+}
+
+export function sweepStaleAcpHomes(baseDir: string = acpHomeStagingDir(), alive: (pid: number) => boolean = isPidAlive): void {
+	let entries: string[];
+	try {
+		entries = fs.readdirSync(baseDir);
+	} catch {
+		return;
+	}
+	for (const name of entries) {
+		const match = /^acp-home-(\d+)-/.exec(name);
+		if (!match) continue;
+		const pid = Number(match[1]);
+		if (pid === process.pid || alive(pid)) continue;
+		removeStagedAcpHome(path.join(baseDir, name));
+	}
+}
+
+export function removeStagedAcpHome(staged: string): void {
+	if (!path.basename(staged).startsWith("acp-home-")) return;
+	try {
+		if (!fs.lstatSync(staged).isDirectory()) return;
+		fs.rmSync(staged, { recursive: true, force: true });
+	} catch {
+		// Connection teardown is best-effort; startup sweeps crash leftovers.
+	}
+}

package/src/acp/jsonrpc.ts

@@ -4,7 +4,7 @@
 // serialized frame + newline to the child's stdin) and feeds incoming bytes to
 // `feed()`. Everything ACP-specific lives in connection.ts.
 //
-// Semantics verified live against agy_acp_server (20260818_01_RC01):
+// Semantics verified live against agy 1.5.3 ACP:
 //   - requests are correlated by numeric id; responses reject the pending
 //     promise on JSON-RPC `error` results;
 //   - server-to-client REQUESTS (session/request_permission, fs/*, terminal/*)
@@ -197,6 +197,11 @@ export class JsonRpcSession {
 		});
 	}
 
+	notify(method: string, params?: unknown): void {
+		if (this.#aborted) return;
+		this.#send(JSON.stringify({ jsonrpc: "2.0", method, params: params ?? {} }));
+	}
+
 	/** Reject every pending request (Gate D teardown). The transport is going
 	 *  away; nothing will ever be written again. */
 	abortAll(reason: string): void {

package/src/acp/setup.ts

@@ -1,473 +1,107 @@
-// ACP engine self-service setup: binary install from the official registry
-// and auth bootstrap. Everything is automatic when possible; the caller
-// surfaces `manual` only when a step fails. Instructions-as-first-resort is
-// gone: /agy engine acp and session_start self-heal silently when ready.
-//
-// Sources: docs/ACP-ADOPTION-PLAN.md §2.1 (registry entry), §12 (pinned
-// install layout: ~/.local/opt/agy-acp/<build>/ + current symlink, zip
-// sha256 recorded at install time), docs/ACP-PROTOCOL-REFERENCE.md
-// (settings.json auth shapes; the server opens the oauth browser itself).
-// Credential rule: this module never reads or writes credential VALUES —
-// acp_token.json is only stat()ed, gemini-api-key is read by the server
-// from the environment.
-
-import { spawn } from "node:child_process";
-import { createHash } from "node:crypto";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { ensureQueuedMessagesInFile, QUEUED_MESSAGES_SEND_IMMEDIATELY } from "../queued-messages.js";
-
-export const REGISTRY_URL =
-	"https://raw.githubusercontent.com/agentclientprotocol/registry/main/antigravity-acp/agent.json";
-
-const INSTALL_TIMEOUT_MS = 30 * 60_000;
-
-export interface SetupOptions {
-	/** Registry agent.json URL. Overridable for tests. */
-	registryUrl?: string;
-	/** Install root. Default ~/.local/opt/agy-acp. */
-	installRoot?: string;
-	/** Server settings dir. Default ~/.gemini/antigravity-acp. */
-	geminiDir?: string;
-	/** Bridge-side verified-sign-in marker file. Default
-	 *  ~/.pi/agent/antigravity-bridge/acp-auth-verified.json (tests point this
-	 *  at a fixture to stay hermetic). */
-	authVerifiedFile?: string;
-	/** acp.bin from config (second resolution priority after AGY_ACP_BIN). */
-	configBin?: string;
-	/** Environment. Default process.env (test injection). */
-	env?: NodeJS.ProcessEnv;
-	/** Progress messages for the user (throttled by the caller's UI). */
-	onProgress?: (msg: string) => void;
-	fetchImpl?: typeof fetch;
-	/** Archive unpacker. Default: `unzip` subprocess (tests inject a copier). */
-	unpack?: (archive: string, dest: string) => Promise<void>;
-	/** Download when the binary is missing. Default true. */
-	install?: boolean;
-}
-
-export type AcpSetupStatus =
-	| {
-			ok: true;
-			bin: string;
-			binarySource: "env" | "config" | "installed" | "existing";
-			/** Registry argv for the managed binary; empty for env/config overrides. */
-			args: string[];
-			auth: string;
-			/** True when auth was just set to oauth-personal: /agy auth opens
-			 *  the Google login in the browser. */
-			needsLogin: boolean;
-			/** Human-readable actions taken (empty when everything was ready). */
-			actions: string[];
-	  }
-	| { ok: false; stage: "install" | "auth"; error: string; manual: string };
 
-export const MANUAL_SETUP = [
-	"For some unknown reason, Google ships its ACP server as a separate",
-	"binary from the Agy CLI. So, as with any other part of its Antigravity",
-	"suite (Agy Desktop, Agy Editor, Agy CLI), you need to log in to",
-	"this one as well. Separately ¯\\_(ツ)_/¯",
-	"ACP manual setup:",
-	"1. Download the server zip for your platform from the antigravity-acp",
-	"   registry entry (github.com/agentclientprotocol/registry, folder",
-	"   antigravity-acp/agent.json) and unzip it, e.g. to",
-	"   ~/.local/opt/agy-acp/<build>/; chmod +x agy_acp_server.par.",
-	"2. Point AGY_ACP_BIN or /agy config acp.bin at the binary",
-	"   (~/.local/opt/agy-acp/current/agy_acp_server.par works; 'current' is a",
-	"   symlink to the build dir).",
-	'3. Log in: put {"auth":{"type":"oauth-personal"}} in',
-	"   ~/.gemini/antigravity-acp/settings.json and run /agy auth, then complete",
-	"   the Google login that opens in your browser. That login IS your",
-	"   Antigravity subscription (Google AI Plus/Pro/Ultra).",
-	"Details: /agy auth-manual",
-].join("\n");
-
-export function platformKey(): string {
-	const goos = process.platform === "darwin" ? "darwin" : process.platform === "win32" ? "windows" : "linux";
-	const goarch = process.arch === "arm64" ? "aarch64" : "x86_64";
-	return `${goos}-${goarch}`;
-}
-
-/** Build id from a registry archive URL:
- *  …/agy-acp-server-<build>-<platform>-<arch>.zip. */
-export function buildIdFromArchive(url: string): string {
-	const base = path.posix.basename(url, ".zip");
-	const m = base.match(/^agy-acp-server-(.+)-(darwin|linux|windows)-(?:arm64|x86_64)$/);
-	if (!m) throw new Error(`unrecognized registry archive name: ${base}`);
-	return m[1];
+export interface AcpCleanupResult {
+	removedBuilds: string[];
+	rootRemoved: boolean;
 }
 
-function defaultInstallRoot(): string {
+export function defaultManagedAcpRoot(): string {
 	return path.join(os.homedir(), ".local", "opt", "agy-acp");
 }
 
-function defaultGeminiDir(opts: SetupOptions): string {
-	return opts.geminiDir ?? path.join(os.homedir(), ".gemini", "antigravity-acp");
-}
-
-/** Expand a leading ~ (spawn does not). Mirrors resolveAcpBinary. */
-function expandTilde(p: string): string {
-	return p === "~" || p.startsWith("~/") ? path.join(os.homedir(), p.slice(1)) : p;
-}
-
-export function executableFile(p: string): boolean {
+function regularFile(file: string): boolean {
 	try {
-		fs.accessSync(p, fs.constants.X_OK);
-		return fs.statSync(p).isFile();
+		return fs.lstatSync(file).isFile();
 	} catch {
 		return false;
 	}
 }
 
-interface RegistryBinary {
-	archive: string;
-	cmd?: string;
-	/** Platform-specific argv the server needs to boot (e.g. linux `--uid=`).
-	 *  Untrusted registry data: validated as a string array before use. */
-	args?: unknown;
-}
-
-/** Registry args are untrusted; accept only a flat string array. */
-function normalizeRegistryArgs(raw: unknown): string[] {
-	if (!Array.isArray(raw)) return [];
-	return raw.filter((a): a is string => typeof a === "string");
-}
-
-async function fetchRegistryBinary(opts: SetupOptions, key: string): Promise<RegistryBinary> {
-	const fetchImpl = opts.fetchImpl ?? fetch;
-	const res = await fetchImpl(opts.registryUrl ?? REGISTRY_URL, { signal: AbortSignal.timeout(15_000) });
-	if (!res.ok) throw new Error(`registry fetch failed: HTTP ${res.status}`);
-	const json = (await res.json()) as { distribution?: { binary?: Record<string, RegistryBinary> } };
-	const entry = json.distribution?.binary?.[key];
-	if (!entry?.archive) throw new Error(`registry has no ${key} binary`);
-	return entry;
-}
-
-function defaultUnpack(archive: string, dest: string): Promise<void> {
-	return new Promise((resolve, reject) => {
-		const child = spawn("unzip", ["-o", "-q", archive, "-d", dest], { stdio: "ignore" });
-		child.on("error", (err) => reject(new Error(`unzip is not available: ${err.message}`)));
-		child.on("exit", (code) => (code === 0 ? resolve() : reject(new Error(`unzip exited with ${code}`))));
-	});
-}
-
-async function downloadTo(
-	url: string,
-	dest: string,
-	fetchImpl: typeof fetch,
-	onProgress?: (msg: string) => void,
-): Promise<string> {
-	const res = await fetchImpl(url, { signal: AbortSignal.timeout(INSTALL_TIMEOUT_MS) });
-	if (!res.ok || !res.body) throw new Error(`download failed: HTTP ${res.status}`);
-	const hash = createHash("sha256");
-	const total = Number(res.headers.get("content-length") ?? 0);
-	const out = fs.createWriteStream(dest);
-	let done = 0;
-	let lastPct = -1;
-	for await (const chunk of res.body) {
-		const buf = Buffer.from(chunk as unknown as Uint8Array);
-		hash.update(buf);
-		done += buf.length;
-		if (total > 0) {
-			const pct = Math.floor((done / total) * 100);
-			if (pct >= lastPct + 10) {
-				lastPct = pct;
-				onProgress?.(`downloading ACP server: ${pct}%`);
-			}
-		}
-		if (!out.write(buf)) await new Promise<void>((r) => out.once("drain", r));
-	}
-	await new Promise<void>((resolve, reject) => {
-		out.on("finish", () => resolve());
-		out.on("error", reject);
-		out.end();
-	});
-	return hash.digest("hex");
-}
-
-export interface InstallResult {
-	bin: string;
-	build: string;
-	sha256: string;
-	downloaded: boolean;
-	/** Registry-declared argv for the managed binary (may be empty). */
-	args: string[];
-}
-
-/** Fetch the pinned registry build for this platform and install it under
- *  <root>/<build>/ with a `current` symlink (plan §12). No-op when the
- *  build is already installed. Registry publishes no checksums; the zip
- *  sha256 is recorded at install time for drift detection. */
-export async function installAcpBinary(opts: SetupOptions = {}): Promise<InstallResult> {
-	const root = opts.installRoot ?? defaultInstallRoot();
-	const entry = await fetchRegistryBinary(opts, platformKey());
-	const build = buildIdFromArchive(entry.archive);
-	const cmd = (entry.cmd ?? "./agy_acp_server.par").replace(/^\.\//, "");
-	const dir = path.join(root, build);
-	const bin = path.join(dir, cmd);
-	const args = normalizeRegistryArgs(entry.args);
-	if (executableFile(bin)) {
-		// Already installed: recover any recorded args so the early-return
-		// path does not silently drop them.
-		return { bin, build, sha256: readRecordedSha(dir), downloaded: false, args: readRecordedArgs(dir) };
-	}
-
-	fs.mkdirSync(root, { recursive: true });
-	fs.mkdirSync(dir, { recursive: true });
-	const tmpZip = path.join(root, `.download-${build}.zip`);
-	opts.onProgress?.(`downloading ACP server (build ${build})…`);
-	const sha = await downloadTo(entry.archive, tmpZip, opts.fetchImpl ?? fetch, opts.onProgress);
-	opts.onProgress?.("unpacking ACP server…");
-	const unpack = opts.unpack ?? defaultUnpack;
-	await unpack(tmpZip, dir);
-	fs.rmSync(tmpZip, { force: true });
-	if (!executableFile(bin)) throw new Error(`${cmd} not found in the archive after unpacking`);
-	fs.chmodSync(bin, 0o755);
-	fs.writeFileSync(path.join(dir, "zip.sha256"), `${sha}  ${path.basename(entry.archive)}\n`);
-	if (args.length > 0) fs.writeFileSync(path.join(dir, "args.json"), JSON.stringify(args));
-
-	// Re-point `current` at the new build. The link is ours (managed layout).
-	const link = path.join(root, "current");
-	fs.rmSync(link, { force: true });
-	fs.symlinkSync(build, link);
-	opts.onProgress?.("ACP server installed.");
-	return { bin, build, sha256: sha, downloaded: true, args };
-}
-
-function readRecordedSha(dir: string): string {
+function realDirectory(file: string): boolean {
 	try {
-		return fs.readFileSync(path.join(dir, "zip.sha256"), "utf8").split(/\s+/)[0] ?? "";
-	} catch {
-		return "";
-	}
-}
-
-function readRecordedArgs(dir: string): string[] {
-	try {
-		return normalizeRegistryArgs(JSON.parse(fs.readFileSync(path.join(dir, "args.json"), "utf8")));
-	} catch {
-		return [];
-	}
-}
-
-export interface AuthState {
-	configured: boolean;
-	/** settings.json auth.type, "token" (acp_token.json present), or undefined. */
-	type?: string;
-}
-
-/** Token presence WITHOUT reading any credential value: acp_token.json is
- *  stat()ed, never opened. The token only exists after the browser login
- *  round-trip, so this is the real proof of a completed login. */
-function tokenPresent(target: string): boolean {
-	try {
-		fs.statSync(path.join(target, "acp_token.json"));
-		return true;
+		const stat = fs.lstatSync(file);
+		return stat.isDirectory() && !stat.isSymbolicLink();
 	} catch {
 		return false;
 	}
 }
 
-/** Whether a login token exists (default dir, or an explicit one). */
-export function hasAcpToken(dir?: string): boolean {
-	return tokenPresent(dir ?? path.join(os.homedir(), ".gemini", "antigravity-acp"));
+function enoent(err: unknown): boolean {
+	return (err as NodeJS.ErrnoException).code === "ENOENT";
 }
 
-/** Bridge-side record that the ACP server proved its own credentials in a
- *  verified sign-in (runAcpAuth). Needed because servers may authenticate
- *  from artifacts this module cannot see: 1.1.1 honors legacy ~/.gemini
- *  credential files (e.g. jetski-standalone-oauth-token) and never writes
- *  acp_token.json, so the file check alone would nag login-pending forever
- *  on a working setup. Cleared the moment the server reports an auth error
- *  (-32000), so a stale marker never masks a real logout. Never holds a
- *  credential value: a boolean and a timestamp. */
-export function defaultAcpAuthVerifiedPath(): string {
-	return path.join(os.homedir(), ".pi", "agent", "antigravity-bridge", "acp-auth-verified.json");
-}
-
-export function readAcpAuthVerified(file: string = defaultAcpAuthVerifiedPath()): boolean {
-	try {
-		const raw = JSON.parse(fs.readFileSync(file, "utf8")) as { verified?: unknown };
-		return raw.verified === true;
-	} catch {
-		return false;
-	}
-}
-
-export function writeAcpAuthVerified(file: string = defaultAcpAuthVerifiedPath()): void {
-	fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
-	fs.writeFileSync(file, `${JSON.stringify({ verified: true, at: new Date().toISOString() }, null, 2)}\n`, { mode: 0o600 });
-}
-
-export function clearAcpAuthVerified(file: string = defaultAcpAuthVerifiedPath()): void {
+/** Remove only artifacts carrying the old installer's layout markers. */
+export function cleanupManagedAcpInstall(root: string = defaultManagedAcpRoot()): AcpCleanupResult {
+	let rootStat: fs.Stats;
 	try {
-		fs.rmSync(file, { force: true });
-	} catch {
-		/* best effort: a leftover marker only over-reports readiness, and the
-		   next auth error clears it again. */
+		rootStat = fs.lstatSync(root);
+	} catch (err) {
+		if (enoent(err)) return { removedBuilds: [], rootRemoved: false };
+		throw err;
 	}
-}
-
-/** Auth state WITHOUT reading any credential value: settings.json carries
- *  only auth.type (+ non-secret gcp placement), acp_token.json is stat()ed. */
-export function readAuthState(dir?: string): AuthState {
-	const target = dir ?? path.join(os.homedir(), ".gemini", "antigravity-acp");
-	try {
-		const raw = JSON.parse(fs.readFileSync(path.join(target, "settings.json"), "utf8")) as {
-			auth?: { type?: unknown };
-		};
-		const type = typeof raw.auth?.type === "string" ? raw.auth.type : undefined;
-		if (type) return { configured: true, type };
-	} catch {
-		/* absent or garbage = unconfigured */
-	}
-	return tokenPresent(target) ? { configured: true, type: "token" } : { configured: false };
-}
-
-/** Write a minimal auth block into settings.json. The server reads this file
- *  at STARTUP, so this must happen before the first server spawn. */
-export function writeAuthType(type: "gemini-api-key" | "oauth-personal", dir?: string): void {
-	const target = dir ?? path.join(os.homedir(), ".gemini", "antigravity-acp");
-	fs.mkdirSync(target, { recursive: true, mode: 0o700 });
-	const file = path.join(target, "settings.json");
-	let settings: Record<string, unknown> = {};
-	try {
-		settings = JSON.parse(fs.readFileSync(file, "utf8")) as Record<string, unknown>;
-	} catch {
-		/* fresh file */
-	}
-	const prevAuth = (typeof settings.auth === "object" && settings.auth !== null ? settings.auth : {}) as Record<string, unknown>;
-	const nextSettings: Record<string, unknown> = { ...settings, auth: { ...prevAuth, type } };
-	if (typeof nextSettings.queuedMessages !== "string" || !nextSettings.queuedMessages.trim()) {
-		nextSettings.queuedMessages = QUEUED_MESSAGES_SEND_IMMEDIATELY;
-	}
-	fs.writeFileSync(file, `${JSON.stringify(nextSettings, null, 2)}\n`, { mode: 0o600 });
-}
-
-export interface BinaryResolution {
-	bin: string | null;
-	source: "env" | "config" | "existing" | "installed" | null;
-}
-
-/** Read-only binary resolution: AGY_ACP_BIN > acp.bin > installed `current`
- *  layout. Does NOT install and does NOT fall back to the bare PATH name. */
-export function resolveInstalledBinary(opts: SetupOptions = {}): BinaryResolution {
-	const env = opts.env ?? process.env;
-	const root = opts.installRoot ?? defaultInstallRoot();
-	const candidates: Array<[string, BinaryResolution["source"]]> = [
-		[env.AGY_ACP_BIN?.trim() ?? "", "env"],
-		[opts.configBin?.trim() ?? "", "config"],
-		[path.join(root, "current", "agy_acp_server.par"), "existing"],
-	];
-	for (const [raw, source] of candidates) {
-		if (!raw) continue;
-		const bin = expandTilde(raw);
-		if (executableFile(bin)) return { bin, source };
-	}
-	return { bin: null, source: null };
-}
-
-/** Registry argv for the managed install only. Env/config overrides (a user
- *  shim like `agy acp`, or AGY_ACP_BIN) own their argv, so they get none.
- *  Identity is by PATH, not by which candidate won: setup persists the managed
- *  path into acp.bin, so after install the config candidate resolves to the
- *  managed binary too. Compare realpaths against `<root>/current/...` (the
- *  symlink target carries the args.json sidecar). Empty when not managed. */
-export function resolveInstalledArgs(opts: SetupOptions = {}): string[] {
-	const binary = resolveInstalledBinary(opts);
-	if (!binary.bin) return [];
-	const root = opts.installRoot ?? defaultInstallRoot();
-	const managed = path.join(root, "current", "agy_acp_server.par");
-	try {
-		if (fs.realpathSync(binary.bin) !== fs.realpathSync(managed)) return [];
-	} catch {
-		return [];
+	if (!rootStat.isDirectory() || rootStat.isSymbolicLink()) return { removedBuilds: [], rootRemoved: false };
+
+	const entries = fs.readdirSync(root, { withFileTypes: true });
+	const interrupted = new Set<string>();
+	for (const entry of entries) {
+		const match = /^\.download-(.+)\.zip$/.exec(entry.name);
+		if (!match || !regularFile(path.join(root, entry.name))) continue;
+		interrupted.add(match[1]!);
+		try {
+			fs.unlinkSync(path.join(root, entry.name));
+		} catch (err) {
+			if (!enoent(err)) throw err;
+		}
 	}
-	return readRecordedArgs(path.dirname(fs.realpathSync(managed)));
-}
 
-/** Read-only setup state (for /agy doctor): no installs, no writes. */
-export function inspectAcpSetup(opts: SetupOptions = {}): { bin: string | null; source: string | null; auth: string | null } {
-	const binary = resolveInstalledBinary(opts);
-	const gdir = defaultGeminiDir(opts);
-	const auth = readAuthState(gdir);
-	if (!auth.configured) return { bin: binary.bin, source: binary.source, auth: null };
-	const type = auth.type ?? "token";
-	// Surface the verified-marker state so a setup that authenticates without
-	// a token file (1.1.1 legacy artifacts) reads as healthy in doctor.
-	const verified = type !== "gemini-api-key" && !tokenPresent(gdir) && readAcpAuthVerified(opts.authVerifiedFile);
-	return { bin: binary.bin, source: binary.source, auth: verified ? `${type} (verified, no token file)` : type };
-}
-
-/** Orchestrate everything the ACP engine needs, in order: binary (install
- *  from the registry when missing), then auth (oauth-personal: the user's
- *  own Antigravity subscription - the same Google account and plan as the
- *  agy CLI login; the server opens the browser itself on the first message).
- *  Every step is skipped when already satisfied; failures return `manual`
- *  text for the caller to surface. */
-export async function ensureAcpReady(opts: SetupOptions = {}): Promise<AcpSetupStatus> {
-	const actions: string[] = [];
-
-	// 1. Binary.
-	let binary = resolveInstalledBinary(opts);
-	let args = resolveInstalledArgs(opts);
-	if (!binary.bin) {
-		if (opts.install === false) {
-			return { ok: false, stage: "install", error: "no ACP server binary found", manual: MANUAL_SETUP };
+	const removedBuilds: string[] = [];
+	for (const entry of entries) {
+		if (!entry.isDirectory() || entry.isSymbolicLink()) continue;
+		const dir = path.join(root, entry.name);
+		if (!regularFile(path.join(dir, "agy_acp_server.par"))) {
+			if (interrupted.has(entry.name)) {
+				try {
+					if (fs.readdirSync(dir).length === 0) fs.rmdirSync(dir);
+				} catch (err) {
+					if (!enoent(err)) throw err;
+				}
+			}
+			continue;
 		}
+		const marked =
+			regularFile(path.join(dir, "zip.sha256")) ||
+			realDirectory(path.join(dir, "localharness_external")) ||
+			interrupted.has(entry.name);
+		if (!marked) continue;
 		try {
-			const installed = await installAcpBinary(opts);
-			binary = { bin: installed.bin, source: "installed" };
-			args = installed.args;
-			actions.push(installed.downloaded ? `installed ACP server build ${installed.build}` : `found installed ACP server build ${installed.build}`);
+			fs.rmSync(dir, { recursive: true, force: true });
+			removedBuilds.push(entry.name);
 		} catch (err) {
-			return {
-				ok: false,
-				stage: "install",
-				error: err instanceof Error ? err.message : String(err),
-				manual: MANUAL_SETUP,
-			};
+			if (!enoent(err)) throw err;
 		}
 	}
 
-	// 2. Auth. settings.json is read at server STARTUP; setup always runs
-	// before the first spawn, so a fresh write takes effect. oauth-personal is
-	// THE default: it is the Antigravity subscription (same Google account and
-	// plan as the agy CLI login). gemini-api-key (metered paid API) stays a
-	// manual option for headless boxes (/agy auth-manual); never the default.
-	const gdir = defaultGeminiDir(opts);
-	ensureQueuedMessagesInFile(path.join(gdir, "settings.json"));
-	const auth = readAuthState(gdir);
-	if (!auth.configured) {
-		try {
-			writeAuthType("oauth-personal", gdir);
-			actions.push("configured oauth-personal auth (your Antigravity subscription login)");
-			return { ok: true, bin: binary.bin!, binarySource: binary.source!, args, auth: "oauth-personal", needsLogin: true, actions };
-		} catch (err) {
-			return {
-				ok: false,
-				stage: "auth",
-				error: err instanceof Error ? err.message : String(err),
-				manual: MANUAL_SETUP,
-			};
+	const current = path.join(root, "current");
+	try {
+		if (fs.lstatSync(current).isSymbolicLink()) {
+			const target = path.resolve(root, fs.readlinkSync(current));
+			if (path.dirname(target) === root && removedBuilds.includes(path.basename(target))) fs.unlinkSync(current);
+		}
+	} catch (err) {
+		if (!enoent(err)) throw err;
+	}
+
+	let rootRemoved = false;
+	try {
+		if (fs.readdirSync(root).length === 0) {
+			fs.rmdirSync(root);
+			rootRemoved = true;
 		}
+	} catch (err) {
+		if (enoent(err)) rootRemoved = true;
+		else throw err;
 	}
-	// settings.json alone proves nothing: setup writes it before the login,
-	// the token file only appears after the browser round-trip. oauth-personal
-	// without a token is login-pending UNLESS a verified sign-in recorded that
-	// this server authenticates from artifacts the bridge cannot see (1.1.1
-	// legacy ~/.gemini credentials; marker written by runAcpAuth, cleared on
-	// any -32000). gemini-api-key has no browser login; a present token file
-	// means done.
-	const needsLogin = auth.type !== "gemini-api-key" && !tokenPresent(gdir) && !readAcpAuthVerified(opts.authVerifiedFile);
-	return {
-		ok: true,
-		bin: binary.bin!,
-		binarySource: binary.source!,
-		args,
-		auth: auth.type ?? "token",
-		needsLogin,
-		actions,
-	};
+	return { removedBuilds, rootRemoved };
 }

package/src/agents.ts

@@ -8,7 +8,7 @@
 //
 // A picked name rides the turn request as `--agent` (same flag our web
 // tools already pass for their throwaway agents). ACP has no agent slot in
-// the protocol (RC01), so selection is refused at the command level there.
+// per-turn agent selection, so the bridge refuses it at the command level.
 
 import { spawnAgyRaw } from "./models.js";