@dougbots/avenor-pi 0.3.5 → 0.3.7

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
 //#region src/index.d.ts
+declare function statusSupervisorId(requestedSupervisorId: string | undefined, spawnedSupervisorId: string): string | undefined;
 declare function export_default(pi: ExtensionAPI): Promise<void>;
 //#endregion
-export { export_default as default };
+export { export_default as default, statusSupervisorId };

package/dist/index.js

@@ -80,6 +80,9 @@ function formatRunLine(entry) {
 //#endregion
 //#region src/index.ts
 const POLL_INTERVAL_MS = 3e3;
+function statusSupervisorId(requestedSupervisorId, spawnedSupervisorId) {
+	return requestedSupervisorId ? spawnedSupervisorId : void 0;
+}
 function sleep(ms) {
 	return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -108,31 +111,79 @@ function summarizeEvent(evt) {
 async function src_default(pi) {
 	const trackedRuns = /* @__PURE__ */ new Map();
 	let pollingActive = false;
+	let pollingGeneration = 0;
+	let pollInFlight = null;
 	let sessionCtx = null;
 	async function pollRuns() {
-		let raw;
+		const liveMap = /* @__PURE__ */ new Map();
 		try {
-			raw = await statusTool({});
+			const allLive = await statusTool({});
+			const liveList = Array.isArray(allLive) ? allLive : [allLive];
+			for (const result of liveList) liveMap.set(result.run_id, result);
 		} catch (err) {
-			console.error("avenor pollRuns: statusTool failed", err);
-			return [];
+			console.error("avenor pollRuns: failed to list singleton runs", err);
 		}
-		const results = Array.isArray(raw) ? raw : [raw];
 		const entries = [];
-		for (const r of results) {
-			const run = trackedRuns.get(r.run_id);
-			if (run) run.lastStatus = r;
-			entries.push({
-				runId: r.run_id,
-				label: r.label,
-				status: r.status,
-				phase: r.phase,
-				phaseLabel: r.phase_label,
-				agent: trackedRuns.get(r.run_id)?.agent ?? "unknown",
-				pendingPermission: !!r.pending_permission,
-				permissionDescription: r.pending_permission?.description
-			});
+		for (const run of trackedRuns.values()) {
+			const live = liveMap.get(run.runId);
+			if (live) {
+				liveMap.delete(live.run_id);
+				run.lastStatus = live;
+				entries.push({
+					runId: run.runId,
+					label: run.label,
+					status: live.status,
+					phase: live.phase,
+					phaseLabel: live.phase_label,
+					agent: run.agent,
+					pendingPermission: !!live.pending_permission,
+					permissionDescription: live.pending_permission?.description
+				});
+				continue;
+			}
+			try {
+				const raw = await statusTool({
+					runId: run.runId,
+					supervisorId: run.supervisorId
+				});
+				const result = Array.isArray(raw) ? raw[0] : raw;
+				if (!result) throw new Error("status response was empty");
+				run.lastStatus = result;
+				entries.push({
+					runId: run.runId,
+					label: run.label,
+					status: result.status,
+					phase: result.phase,
+					phaseLabel: result.phase_label,
+					agent: run.agent,
+					pendingPermission: !!result.pending_permission,
+					permissionDescription: result.pending_permission?.description
+				});
+			} catch (err) {
+				console.error(`avenor pollRuns: statusTool failed for ${run.runId}`, err);
+				const previous = run.lastStatus;
+				entries.push({
+					runId: run.runId,
+					label: run.label,
+					status: previous?.status ?? "unavailable",
+					phase: previous?.phase,
+					phaseLabel: previous?.phase_label,
+					agent: run.agent,
+					pendingPermission: !!previous?.pending_permission,
+					permissionDescription: previous?.pending_permission?.description
+				});
+			}
 		}
+		for (const live of liveMap.values()) entries.push({
+			runId: live.run_id,
+			label: live.label,
+			status: live.status,
+			phase: live.phase,
+			phaseLabel: live.phase_label,
+			agent: "unknown",
+			pendingPermission: !!live.pending_permission,
+			permissionDescription: live.pending_permission?.description
+		});
 		return entries;
 	}
 	function renderStatusLines(entries) {
@@ -160,17 +211,24 @@ async function src_default(pi) {
 	function startPolling() {
 		if (pollingActive) return;
 		pollingActive = true;
+		const generation = ++pollingGeneration;
 		const tick = async () => {
+			if (!pollingActive || generation !== pollingGeneration) return;
 			const prevStatuses = /* @__PURE__ */ new Map();
 			for (const [id, run] of trackedRuns) prevStatuses.set(id, run.lastStatus?.status);
-			const entries = await pollRuns();
+			const currentPoll = pollRuns();
+			pollInFlight = currentPoll;
+			const entries = await currentPoll.finally(() => {
+				if (pollInFlight === currentPoll) pollInFlight = null;
+			});
+			if (!pollingActive || generation !== pollingGeneration) return;
 			updateWidget(entries);
 			for (const entry of entries) {
 				const run = trackedRuns.get(entry.runId);
 				if (!run) continue;
 				if (TERMINAL_STATUSES.has(entry.status)) {
 					const prevStatus = prevStatuses.get(entry.runId);
-					if (prevStatus && !TERMINAL_STATUSES.has(prevStatus)) {
+					if (!prevStatus || !TERMINAL_STATUSES.has(prevStatus)) {
 						sessionCtx?.ui.notify(`Sub-agent "${entry.label}" finished: ${entry.status}`, entry.status === "done" ? "info" : "warning");
 						if (!run.blocking) try {
 							pi.sendUserMessage(buildCompletionText({
@@ -195,20 +253,35 @@ async function src_default(pi) {
 					}
 				} else if (!entry.pendingPermission && run.permissionNotified) run.permissionNotified = false;
 			}
-			if (entries.some((e) => !TERMINAL_STATUSES.has(e.status))) setTimeout(tick, POLL_INTERVAL_MS);
+			if (entries.some((e) => !TERMINAL_STATUSES.has(e.status)) && pollingActive && generation === pollingGeneration) setTimeout(() => {
+				tick().catch((err) => {
+					pollingActive = false;
+					console.error("avenor polling loop failed", err);
+				});
+			}, POLL_INTERVAL_MS);
 			else {
 				pollingActive = false;
 				sessionCtx?.ui.setStatus("avenor", "");
 				sessionCtx?.ui.setWidget("avenor-status", void 0);
 			}
 		};
-		tick();
+		tick().catch((err) => {
+			pollingActive = false;
+			console.error("avenor polling loop failed", err);
+		});
+	}
+	async function stopPolling() {
+		pollingActive = false;
+		pollingGeneration++;
+		await pollInFlight?.catch(() => {});
+		sessionCtx?.ui.setStatus("avenor", "");
+		sessionCtx?.ui.setWidget("avenor-status", void 0);
 	}
 	pi.on("session_start", async (_event, ctx) => {
 		sessionCtx = ctx;
 	});
 	pi.on("session_shutdown", async (_event, _ctx) => {
-		pollingActive = false;
+		await stopPolling();
 		sessionCtx = null;
 	});
 	pi.on("before_agent_start", async (event, _ctx) => {
@@ -280,11 +353,13 @@ async function src_default(pi) {
 				serverUrl: params.server_url,
 				supervisorId: params.supervisor_id
 			});
+			const supervisorId = statusSupervisorId(params.supervisor_id, result.supervisor_id);
 			trackedRuns.set(result.run_id, {
 				runId: result.run_id,
 				agent: params.agent,
 				label,
-				supervisorId: result.supervisor_id,
+				supervisorId,
+				runtimeId: result.runtime_id,
 				startTime: Date.now(),
 				blocking: wait
 			});
@@ -317,7 +392,7 @@ async function src_default(pi) {
 				try {
 					raw = await statusTool({
 						runId: result.run_id,
-						supervisorId: result.supervisor_id
+						supervisorId
 					});
 				} catch (err) {
 					console.error("avenor spawn poll: statusTool failed", err);
@@ -337,7 +412,7 @@ async function src_default(pi) {
 				});
 				else {
 					let lastAction = "";
-					if (!result.supervisor_id) try {
+					if (!params.supervisor_id) try {
 						const eventsResult = await eventsTool({
 							runId: result.run_id,
 							limit: 3
@@ -537,6 +612,8 @@ async function src_default(pi) {
 			force: Type.Optional(Type.Boolean({ description: "Force shutdown instead of graceful" }))
 		}),
 		async execute(_toolCallId, params) {
+			await stopPolling();
+			trackedRuns.clear();
 			const result = await shutdownTool({
 				supervisorId: params.supervisor_id,
 				force: params.force
@@ -658,7 +735,7 @@ async function src_default(pi) {
 			if (!await ctx.ui.confirm("Cancel run", `Cancel "${label}" (${runId.slice(0, 8)})?`)) return;
 			try {
 				const { Supervisor } = await import("@dougbots/avenor-core");
-				await (await Supervisor.get()).getClient().cancel(run?.lastStatus?.runtime_id ?? runId);
+				await (await Supervisor.get()).getClient().cancel(run?.lastStatus?.runtime_id ?? run?.runtimeId ?? runId);
 				ctx.ui.notify(`Cancelled "${label}"`, "info");
 			} catch (err) {
 				ctx.ui.notify(`Failed to cancel: ${err instanceof Error ? err.message : String(err)}`, "error");
@@ -667,4 +744,4 @@ async function src_default(pi) {
 	});
 }
 //#endregion
-export { src_default as default };
+export { src_default as default, statusSupervisorId };

package/package.json

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