@dougbots/avenor-pi 0.8.0 → 0.8.2

package/dist/index.d.ts

@@ -15,7 +15,7 @@ interface RunStatusEntry {
   pid?: number;
   /** Backend type, used to determine whether to look for child supervisors. */
   backend?: string;
-  /** Count of active (non-terminal) runs on this run's child supervisor, if discovered. */
+  /** Count of active (non-terminal) descendants, if discovered. */
   nestedCount?: number;
 }
 //#endregion

package/dist/index.js

@@ -1,7 +1,8 @@
 import { Input, Key, Text, matchesKey, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
-import * as path from "node:path";
 import { Supervisor, answerPermissionTool, dial, eventsTool, followUpTool, inspectTool, observeRun, resultTool, shutdownTool, socketsRoot, spawnTool, statusTool } from "@dougbots/avenor-core";
+import * as fs from "node:fs";
+import * as path from "node:path";
 //#region src/watch.ts
 const ANSI_PATTERN = /[\u001B\u009B][[\]()#;?]*(?:(?:(?:[a-zA-Z\d]*(?:;[a-zA-Z\d]*)*)?\u0007)|(?:(?:\d{1,4}(?:;\d{0,4})*)?[\dA-PR-TZcf-nq-uy=><~]))/g;
 const TRANSCRIPT_SCROLL_STEP = 4;
@@ -567,6 +568,118 @@ function decideCompletion(run) {
 	return "send";
 }
 //#endregion
+//#region src/nested-count.ts
+const NESTED_DIAL_TIMEOUT_MS = 2e3;
+const MAX_NESTED_DEPTH = 99;
+const MAX_CONCURRENT_NESTED_DIALS = 16;
+var AsyncLimiter = class {
+	limit;
+	active = 0;
+	queue = [];
+	constructor(limit) {
+		this.limit = limit;
+	}
+	async run(task) {
+		if (this.active >= this.limit) await new Promise((resolve) => this.queue.push(resolve));
+		this.active++;
+		try {
+			return await task();
+		} finally {
+			this.active--;
+			this.queue.shift()?.();
+		}
+	}
+};
+const nestedDialLimiter = new AsyncLimiter(MAX_CONCURRENT_NESTED_DIALS);
+function isActiveRun(run) {
+	const status = String(run.status ?? "running").toLowerCase();
+	return status === "running" || status === "idle";
+}
+function childPiPid(run) {
+	if (String(run.backend ?? "").toLowerCase() !== "pi") return void 0;
+	if (typeof run.pid !== "number" || !Number.isInteger(run.pid) || run.pid <= 0) return void 0;
+	return run.pid;
+}
+function nestedSocketPath(pid) {
+	const requestedRoot = socketsRoot();
+	const requestedPath = path.join(requestedRoot, `avenor-mcp-${pid}.sock`);
+	if (!fs.existsSync(requestedRoot)) return requestedPath;
+	const root = fs.realpathSync(requestedRoot);
+	const parent = fs.realpathSync(path.dirname(requestedPath));
+	if (parent !== root) throw new Error("nested supervisor socket escaped sockets root");
+	return path.join(parent, path.basename(requestedPath));
+}
+/**
+* Dial a nested supervisor with a bounded connection/RPC timeout.
+* A client that resolves after the timeout loses the race and is closed.
+*/
+async function dialWithTimeout(dial, socketPath, timeoutOverride) {
+	const effectiveTimeout = timeoutOverride ?? NESTED_DIAL_TIMEOUT_MS;
+	let timedOut = false;
+	let timeout;
+	const timeoutMarker = Symbol("dial timeout");
+	const connection = dial(socketPath, { callTimeoutMs: effectiveTimeout }).then((client) => {
+		if (timedOut) client.close();
+		return client;
+	});
+	try {
+		const result = await Promise.race([connection, new Promise((resolve) => {
+			timeout = setTimeout(() => resolve(timeoutMarker), effectiveTimeout);
+		})]);
+		if (result === timeoutMarker) {
+			timedOut = true;
+			throw new Error("dial timeout");
+		}
+		return result;
+	} finally {
+		if (timeout) clearTimeout(timeout);
+	}
+}
+async function countNestedRunsAtDepth(pid, dial, seen, depth) {
+	if (!Number.isInteger(pid) || pid <= 0 || seen.has(pid) || depth >= MAX_NESTED_DEPTH) return 0;
+	seen.add(pid);
+	let socketPath;
+	try {
+		socketPath = nestedSocketPath(pid);
+	} catch (error) {
+		console.warn("avenor nested count: invalid supervisor socket path", error);
+		return 0;
+	}
+	let activeRuns;
+	try {
+		activeRuns = await nestedDialLimiter.run(async () => {
+			const client = await dialWithTimeout(dial, socketPath);
+			try {
+				return (await client.list()).filter(isActiveRun);
+			} finally {
+				client.close();
+			}
+		});
+	} catch {
+		return 0;
+	}
+	let total = 0;
+	for (const run of activeRuns) {
+		const nestedPid = childPiPid(run);
+		total += 1;
+		if (nestedPid && depth + 1 < MAX_NESTED_DEPTH) total += await countNestedRunsAtDepth(nestedPid, dial, seen, depth + 1);
+	}
+	return total;
+}
+/**
+* Count all active descendants of a spawned pi process. Each pi process owns
+* its own supervisor, so walking the tree requires dialing the supervisor for
+* every active pi run that exposes a child process PID.
+*
+* The depth guard prevents malformed acyclic data from recursing forever, and
+* the dial limiter keeps a large fan-out from opening unbounded sockets at
+* once. A traversal-wide PID set separately prevents cycles and duplicate
+* subtree walks from stale cross-branch references.
+*/
+async function countNestedRuns(pid, dial) {
+	return countNestedRunsAtDepth(pid, dial, /* @__PURE__ */ new Set(), 0);
+}
+//#endregion
 //#region src/agent-profile.ts
 const PROFILE_ENTRY_TYPE = "pi-agents:profile";
 /**
@@ -758,29 +871,6 @@ function createExtension(deps = defaultDeps) {
 				return;
 			}
 		}
-		/**
-		* Count active (non-terminal) runs on a child supervisor discovered via
-		* the spawned pi process's PID. The child pi process creates its own
-		* avenor supervisor at `avenor-mcp-<pid>.sock`; we dial it briefly to
-		* list runs and count those still active. Returns 0 on any failure
-		* (socket not yet ready, supervisor idle-shut-down, etc.).
-		*/
-		async function countNestedRuns(pid) {
-			if (!pid) return 0;
-			const socketPath = path.join(socketsRoot(), `avenor-mcp-${pid}.sock`);
-			let client;
-			try {
-				client = await Promise.race([deps.dial(socketPath, { callTimeoutMs: 2e3 }), new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error("dial timeout")), 2e3))]);
-				return (await client.list()).filter((r) => {
-					const status = String(r.status ?? "running").toLowerCase();
-					return status === "running" || status === "idle";
-				}).length;
-			} catch {
-				return 0;
-			} finally {
-				client?.close();
-			}
-		}
 		async function pollRuns() {
 			const liveMap = /* @__PURE__ */ new Map();
 			try {
@@ -861,7 +951,7 @@ function createExtension(deps = defaultDeps) {
 			});
 			const nestedPids = entries.filter((e) => e.backend === "pi" && e.pid && !isTerminalStatus(e.status)).map((e) => e.pid);
 			if (nestedPids.length > 0) {
-				const nestedCounts = await Promise.all(nestedPids.map((pid) => countNestedRuns(pid)));
+				const nestedCounts = await Promise.all(nestedPids.map((pid) => countNestedRuns(pid, deps.dial)));
 				let idx = 0;
 				for (const entry of entries) if (entry.backend === "pi" && entry.pid && !isTerminalStatus(entry.status)) entry.nestedCount = nestedCounts[idx++] ?? 0;
 			}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dougbots/avenor-pi",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "type": "module",
   "keywords": [
     "pi-package"
@@ -35,7 +35,7 @@
     "dev": "tsdown --watch"
   },
   "dependencies": {
-    "@dougbots/avenor-core": "^0.8.0"
+    "@dougbots/avenor-core": "^0.8.2"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "*",