@estebanforge/pi-ask-antigravity 1.2.0 → 1.2.1

package/extensions/index.ts

@@ -500,13 +500,124 @@ function snapshotConversations(dir: string): Set<string> {
 	return out;
 }
 
-/** Find the single new conversation id created since `before`. Returns null if
- *  none, or if several appeared (can't safely pick which one is ours). */
-function newConversationId(dir: string, before: Set<string>): string | null {
+/** Resolve which of the `candidates` DB ids is held open by the process tree
+ *  rooted at `rootPid`. Used to disambiguate concurrent agy runs. Returns the
+ *  single matching id, or null when none/several are open or /proc is
+ *  unavailable. Ported from pi-antigravity-bridge src/discovery.ts; keep in
+ *  sync. */
+type OpenDbResolver = (
+	rootPid: number,
+	dir: string,
+	candidates: Set<string>,
+) => string | null;
+
+function readProcStat(pid: number): { pid: number; ppid: number } | null {
+	let raw: string;
+	try {
+		raw = fs.readFileSync(`/proc/${pid}/stat`, "utf8");
+	} catch {
+		return null;
+	}
+	const closeParen = raw.lastIndexOf(")");
+	if (closeParen < 0) return null;
+	const fields = raw.slice(closeParen + 2).trim().split(/\s+/);
+	const ppid = Number(fields[1]);
+	if (!Number.isFinite(ppid)) return null;
+	return { pid, ppid };
+}
+
+function collectDescendants(rootPid: number): Set<number> {
+	const out = new Set<number>([rootPid]);
+	let entries: string[];
+	try {
+		entries = fs.readdirSync("/proc");
+	} catch {
+		return out;
+	}
+	const ppidOf = new Map<number, number>();
+	for (const e of entries) {
+		if (!/^\d+$/.test(e)) continue;
+		const s = readProcStat(Number(e));
+		if (s) ppidOf.set(s.pid, s.ppid);
+	}
+	let changed = true;
+	while (changed) {
+		changed = false;
+		for (const [pid, ppid] of ppidOf) {
+			if (out.has(pid)) continue;
+			if (out.has(ppid)) {
+				out.add(pid);
+				changed = true;
+			}
+		}
+	}
+	return out;
+}
+
+function safeRealpath(p: string): string | null {
+	try {
+		return fs.realpathSync(p);
+	} catch {
+		return null;
+	}
+}
+
+const procTreeOpenDbResolver: OpenDbResolver = (rootPid, dir, candidates) => {
+	if (candidates.size <= 1) return null;
+	if (process.platform !== "linux") return null;
+	const dirResolved = safeRealpath(dir);
+	const tree = collectDescendants(rootPid);
+	const found = new Set<string>();
+	for (const pid of tree) {
+		let fds: string[];
+		try {
+			fds = fs.readdirSync(`/proc/${pid}/fd`);
+		} catch {
+			continue;
+		}
+		for (const fd of fds) {
+			let target: string;
+			try {
+				target = fs.readlinkSync(`/proc/${pid}/fd/${fd}`);
+			} catch {
+				continue;
+		}
+			const base = path.basename(target);
+			if (!base.endsWith(".db")) continue;
+			if (dirResolved && safeRealpath(path.dirname(target)) !== dirResolved) continue;
+			const id = base.slice(0, -3);
+			if (candidates.has(id)) found.add(id);
+		}
+	}
+	if (found.size === 1) return [...found][0] ?? null;
+	return null;
+};
+
+interface BindOptions {
+	pid?: number;
+	resolveOpenDb?: OpenDbResolver;
+}
+
+/** Find the conversation id created since `before`. Returns null when none
+ *  appeared, or when several appeared and we cannot tie one to our process.
+ *  Pass `opts.pid` (the spawned agy) to enable concurrent-run disambiguation
+ *  via the process-tree FD scan. */
+function newConversationId(
+	dir: string,
+	before: Set<string>,
+	opts: BindOptions = {},
+): string | null {
 	const created = [...snapshotConversations(dir)].filter((id) => !before.has(id));
 	if (created.length === 0) return null;
-	if (created.length > 1) return null; // ambiguous; refuse to bind
-	return created[0] ?? null;
+	if (created.length === 1) return created[0] ?? null;
+	// Ambiguous: try to authoritatively identify ours via the spawned
+	// process's open files. Fail safe to null when we can't pick exactly one.
+	if (opts.pid !== undefined) {
+		const resolve = opts.resolveOpenDb ?? procTreeOpenDbResolver;
+		const hit = resolve(opts.pid, dir, new Set(created));
+		if (hit && created.includes(hit)) return hit;
+	}
+	return null;
 }
 
 // --- Extension -------------------------------------------------------------
@@ -859,6 +970,11 @@ export default async function (pi: ExtensionAPI) {
 				: null;
 
 			try {
+				// Bind the conversation id DURING the run (agy is alive then) so the
+				// pid-based /proc FD resolver can disambiguate when a concurrent agy
+				// also drops a new .db. Awaited after the run; the post-exit loop
+				// below is the fallback for runs that exit before the poll binds.
+				let bindDuringRun: Promise<void> = Promise.resolve();
 				const outcome = await new Promise<{
 					exitCode: number;
 					aborted: boolean;
@@ -886,6 +1002,28 @@ export default async function (pi: ExtensionAPI) {
 						details.stderr += d;
 					});
 
+					// Concurrent bind: poll for the new id while agy is alive. The FD
+					// resolver needs a live process tree, so this stops (and the
+					// post-exit fallback below takes over) once agy has exited.
+					if (!isContinuation && snapshot && proc.pid) {
+						bindDuringRun = (async () => {
+							for (let attempt = 0; attempt < DISCOVERY_POLL_ATTEMPTS; attempt++) {
+								if (details.conversationId) return;
+								if (proc.exitCode !== null) return; // agy gone: scan useless now
+								const found = newConversationId(CONVERSATIONS_DIR, snapshot, {
+									pid: proc.pid,
+								});
+								if (found) {
+									details.conversationId = found;
+									return;
+								}
+								await sleep(DISCOVERY_POLL_MS);
+							}
+						})().catch(() => {
+							/* best-effort: a bind error must never fail an otherwise-OK turn */
+						});
+					}
+
 					let sigkillTimer: ReturnType<typeof setTimeout> | undefined;
 					let watchdog: ReturnType<typeof setTimeout> | undefined;
 					let settled = false;
@@ -952,6 +1090,10 @@ export default async function (pi: ExtensionAPI) {
 
 				if (statusInterval) clearInterval(statusInterval);
 
+				// Let the during-run bind poll finish (it bails immediately once agy
+				// has exited, so this rarely blocks).
+				await bindDuringRun;
+
 				details.exitCode = outcome.exitCode;
 				details.aborted = outcome.aborted;
 				details.timedOut = outcome.timedOut;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@estebanforge/pi-ask-antigravity",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "Pi tool that delegates a self-contained sub-task to Google Antigravity's agy CLI (the CLI for Gemini). Friendly model aliases (flash/pro/gemini), configurable default model + thinking, and the AskAntigravity delegation tool.",
   "keywords": [
     "pi-package",
@@ -22,7 +22,15 @@
     "type": "git",
     "url": "git+https://github.com/EstebanForge/pi-ask-antigravity.git"
   },
+  "publishConfig": {
+    "access": "public"
+  },
   "type": "module",
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "prepublishOnly": "npm run typecheck && npm test"
+  },
   "files": [
     "extensions",
     "README.md"
@@ -41,11 +49,12 @@
     }
   },
   "devDependencies": {
-    "@earendil-works/pi-coding-agent": "^0.80.2",
-    "@earendil-works/pi-ai": "^0.80.2",
-    "@earendil-works/pi-tui": "^0.80.2",
+    "@earendil-works/pi-coding-agent": "^0.84.0",
+    "@earendil-works/pi-ai": "^0.84.0",
+    "@earendil-works/pi-tui": "^0.84.0",
     "@types/node": "^22.0.0",
     "typebox": "^1.1.38",
-    "typescript": "^5.8.0"
+    "typescript": "^5.8.0",
+    "vitest": "^4.1.7"
   }
 }