@estebanforge/pi-antigravity-bridge 1.5.2 → 1.5.3

package/CHANGELOG.md

@@ -2,7 +2,13 @@
 
 All notable changes to this project will be documented in this file.
 
-## [1.5.2] - 2026-09-15
+## [1.5.3] - 2026-09-10
+
+### Fixed
+
+- **Parallel agy tool approvals no longer clobber each other.** The shadow-tool `GatePolicy` asked through pi's `ui.confirm`, but pi's TUI shows ONE extension dialog at a time and an overlapping call replaces the live dialog without settling it: with several agy bash/write/edit calls in flight, approvals were silently lost (the park timeout eventually resolved them as declines). The confirm now holds the same shared cross-extension dialog lock as the pi-*-me gates (`withDialogLock`, `Symbol.for("pi-me.dialog-lock")`), so approvals queue and render in turn; the park timeout still bounds each dialog and is held inside the lock. New `src/dialog-lock.ts` module plus contract tests (FIFO order, throw-release, shared key).
+
+## [1.5.2] - 2026-09-09
 
 ### Fixed
 

package/extensions/index.ts

@@ -88,6 +88,7 @@ import {
 import { mapAgyToolToNative } from "../src/native-tools.js";
 import { Type } from "typebox";
 import { patchStatus, restorePatch } from "../src/patch-cleanup.js";
+import { withDialogLock } from "../src/dialog-lock.js";
 
 // Last UI seen (session_start / /agy commands). The ACP login URL arrives
 // via the driver log sink, which has no command context; the stash lets that
@@ -808,7 +809,14 @@ export default async function (pi: ExtensionAPI): Promise<void> {
 								: typeof params.path === "string"
 									? params.path
 									: JSON.stringify(stripMarkerFields(params)).slice(0, 200);
-						const ok = await extCtx.ui.confirm(`agy ${tool}?`, what, { timeout: APPROVAL_PARK_MS });
+						// Dialog lock: parallel agy tool approvals queue up instead of
+						// clobbering the live dialog (which silently loses the approval).
+						// Capture the narrowed method: TS drops the guard's narrowing
+						// inside the deferred closure.
+						const uiConfirm = extCtx.ui.confirm.bind(extCtx.ui);
+						const ok = await withDialogLock(() =>
+							uiConfirm(`agy ${tool}?`, what, { timeout: APPROVAL_PARK_MS }),
+						);
 						return ok ? { allow: true } : { allow: false, reason: `declined in pi (agy ${tool})` };
 					};
 					const handle = r.handle;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@estebanforge/pi-antigravity-bridge",
-  "version": "1.5.2",
+  "version": "1.5.3",
   "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",

package/src/dialog-lock.ts

@@ -0,0 +1,48 @@
+// Process-wide FIFO lock for human-facing dialogs (confirm/editor/select).
+//
+// pi's interactive UI shows ONE extension dialog at a time; an overlapping
+// ctx.ui.* dialog call REPLACES the live dialog and the replaced promise
+// never settles, so parallel gated tool calls hang forever (or silently lose
+// their prompt). Holding this lock around each dialog serializes them: the
+// first renders, the rest appear in turn as each is answered.
+//
+// The lock is keyed via Symbol.for because ALL pi-* extensions run in the
+// SAME pi process and must share one queue: a per-module lock would still let
+// a dialog from one extension clobber a dialog from another in the same
+// parallel tool-call batch.
+const DIALOG_LOCK: unique symbol = Symbol.for("pi-me.dialog-lock");
+
+interface DialogQueue {
+  tail: Promise<void>;
+}
+
+function dialogQueue(): DialogQueue {
+  const host = globalThis as typeof globalThis & Record<symbol, unknown>;
+  const existing = host[DIALOG_LOCK] as DialogQueue | undefined;
+  if (existing) return existing;
+  const created: DialogQueue = { tail: Promise.resolve() };
+  host[DIALOG_LOCK] = created;
+  return created;
+}
+
+/**
+ * Run `run` while holding the cross-extension dialog lock. FIFO: each caller
+ * chains onto the queue tail synchronously (before its first await), so call
+ * order is the order the dialogs appear. Released in a finally block, so one
+ * throwing dialog can never wedge the queue for the callers behind it.
+ * NOT reentrant: calling it inside a held `run` self-deadlocks.
+ */
+export async function withDialogLock<T>(run: () => Promise<T>): Promise<T> {
+  const queue = dialogQueue();
+  const prev = queue.tail;
+  let release!: () => void;
+  queue.tail = new Promise<void>((resolve) => {
+    release = resolve;
+  });
+  await prev;
+  try {
+    return await run();
+  } finally {
+    release();
+  }
+}