pi-straw-boss 0.9.0 → 0.9.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-straw-boss",
-  "version": "0.9.0",
+  "version": "0.9.2",
   "description": "Straw Boss coordination for pi in Herdr: sessions join a tab's net by choice, the first joiner is its main agent, a workspace tower opens on demand with a live monitoring dashboard, and boss_broadcast reaches the rest",
   "type": "module",
   "license": "MIT",

package/src/herdr.ts

@@ -164,14 +164,24 @@ async function open({ run, sleep, live, moveFirst, model }: TowerEnv, workspace:
 
 	// A leftover tower tab is reused: a pane already running pi only needs its token awaited, a shell prompt gets pi started.
 	// The tab is told apart by the `sb_role=tower` pane token that only Straw Boss writes; a tab merely labelled "tower"
-	// (a pi-herdr-agents subagent can be named so) is someone else's.
+	// (a pi-herdr-agents subagent can be named so) is someone else's. A tab whose token was cleared (its tower quit) is still ours when it has
+	// exactly the tower label (the glyph), one pane, and no agent in it.
 	let paneId: string;
 	let running = false;
-	const marked = (await panes(run, ws)).find((p) => p.tokens?.sb_role === "tower");
-	if (marked) {
-		paneId = marked.pane_id;
-		running = marked.agent === "pi";
-		await moveFirst(marked.tab_id);
+	const here = await panes(run, ws);
+	const marked = here.find((p) => p.tokens?.sb_role === "tower");
+	const bare = marked ? [] : (await tabs(run, ws)).filter((t) => t.label === TOWER_LABEL).flatMap((t) => {
+		const inside = here.filter((p) => p.tab_id === t.tab_id);
+		return inside.length === 1 && !inside[0]!.agent && !inside[0]!.tokens?.sb_role ? [inside[0]!] : [];
+	});
+	const reused = marked ?? bare[0];
+	if (reused) {
+		paneId = reused.pane_id;
+		running = reused.agent === "pi";
+		if (!marked) await report(run, "pane", paneId, { sb_role: "tower" });
+		await moveFirst(reused.tab_id);
+		// Other shell-only leftovers are closed; failing to close one leaves a harmless tab, so it does not stop the tower.
+		for (const extra of bare.slice(1)) await run(["tab", "close", extra.tab_id]).catch(() => {});
 	} else {
 		const dir = workspace.worktree?.checkout_path ?? cwd;
 		const created = await createTab(run, ws, dir, ["STRAW_BOSS_ROLE=tower"], TOWER_LABEL);
@@ -182,7 +192,11 @@ async function open({ run, sleep, live, moveFirst, model }: TowerEnv, workspace:
 	}
 	if (!running) {
 		// Herdr agent names are unique across workspaces and lowercase only, so the name carries the lowercased workspace id.
-		await startPi(run, sleep, `tower-${ws.toLowerCase()}`, paneId, ["--name", `tower · ${workspace.label}`, ...(model ? ["--model", model] : [])]);
+		// An adopted shell that turns out busy (the user runs something there) gives the token back, so the next open does not count it as the tower.
+		await startPi(run, sleep, `tower-${ws.toLowerCase()}`, paneId, ["--name", `tower · ${workspace.label}`, ...(model ? ["--model", model] : [])]).catch(async (error: unknown) => {
+			if (reused && !marked) await report(run, "pane", paneId, { sb_role: null }).catch(() => {});
+			throw error;
+		});
 	}
 	const id = await waitFor(sleep, held, TOWER_WAIT_MS, 1000);
 	if (!id) throw new Error(`The tower of ${workspace.label} did not publish its token within ${TOWER_WAIT_MS / 1000} s (pane ${paneId})`);

package/src/index.ts

@@ -15,6 +15,7 @@ import { opener } from "./opener.ts";
 import { orphans } from "./orphan.ts";
 import { copyText, pairingKeys, showLines } from "./pairing.ts";
 import { type Run, switchRemote, tailscale } from "./remote.ts";
+import { type HerdrWatch, herdrWatch } from "./server-watch.ts";
 import { ensureTower, headOf, towerModel, herdrApi, type HerdrApi, herdrCall, type HerdrCall, herdrRun, type HerdrRun, isSub, type Pane, panes, parentOf, place, type Place, report, type Session, type Sleep, waitFor, workspaces, type Workspace } from "./herdr.ts";
 
 // pi-intercom's extension API as constants and minimal types: intercom is a runtime requirement, not an import.
@@ -43,7 +44,7 @@ interface Saved { tower?: boolean }
 type Role = "tower" | "main" | "member";
 type Scope = "tab" | "workspace" | "towers" | "all";
 type Member = ReturnType<typeof netMembers>[number];
-export interface Deps { run?: HerdrRun; api?: HerdrApi; call?: HerdrCall; tailscale?: Run; copy?: (text: string) => Promise<void>; env?: NodeJS.ProcessEnv; sleep?: Sleep; promptDir?: string; bundle?: string; openUrl?: (url: string) => Promise<void>; stateDir?: string; autoTower?: boolean; nudgeMs?: number }
+export interface Deps { run?: HerdrRun; api?: HerdrApi; call?: HerdrCall; tailscale?: Run; copy?: (text: string) => Promise<void>; env?: NodeJS.ProcessEnv; sleep?: Sleep; promptDir?: string; bundle?: string; openUrl?: (url: string) => Promise<void>; watch?: HerdrWatch; stateDir?: string; autoTower?: boolean; nudgeMs?: number }
 
 /** Live sessions whose pane carries an `sb_role` token: the sessions that joined the net, and towers. */
 function netMembers(sessions: Session[], ps: Pane[]) {
@@ -55,7 +56,7 @@ function netMembers(sessions: Session[], ps: Pane[]) {
 }
 const nameOf = (s?: Session) => (s ? (s.name ?? s.id) : "");
 
-export function createStrawBoss({ run = herdrRun, api = herdrApi(), call = herdrCall(), tailscale: ts = tailscale, copy = copyText, env = process.env, sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)), promptDir = fileURLToPath(new URL("../prompts", import.meta.url)), bundle, openUrl = openBrowser, stateDir, autoTower = true, nudgeMs = NUDGE_MS }: Deps = {}) {
+export function createStrawBoss({ run = herdrRun, api = herdrApi(), call = herdrCall(), tailscale: ts = tailscale, copy = copyText, env = process.env, sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)), promptDir = fileURLToPath(new URL("../prompts", import.meta.url)), bundle, openUrl = openBrowser, watch = herdrWatch(), stateDir, autoTower = true, nudgeMs = NUDGE_MS }: Deps = {}) {
 	return function strawBoss(pi: ExtensionAPI): void {
 		// Outside Herdr there is no tab to coordinate. Every session in Herdr relays its dialogs to the GUI (bridge.ts), subagents too: they ask
 		// questions as well. A pi-herdr-agents worker never joins: its parent represents it.
@@ -76,7 +77,7 @@ export function createStrawBoss({ run = herdrRun, api = herdrApi(), call = herdr
 		let prompts: Record<string, string> = {}, info: Record<string, string> = {}, saved: Saved = {};
 		let gui: Gui | undefined, viewer: Channel | undefined, opening: Promise<string> | undefined;
 		let c!: Channel, at!: Place, ui: ExtensionContext["ui"] | undefined, timer: ReturnType<typeof setInterval> | undefined;
-		let queue: Promise<void> = Promise.resolve();
+		let queue: Promise<void> = Promise.resolve(), unwatch: (() => void) | undefined;
 		// This session's intercom name, which the subagents it launched show as their launcher, and the subagent panes it has marked.
 		let ownName = "", openedBy: string | undefined, kids = new Set<string>();
 		// Watches for subagents this session launched whose result can no longer reach it (orphan.ts).
@@ -125,6 +126,16 @@ export function createStrawBoss({ run = herdrRun, api = herdrApi(), call = herdr
 			if (holdsTower && !stopped) await report(run, "workspace", at.workspaceId, { tower: me() }).catch(() => {});
 		};
 		const publish = (known?: Session[]) => (publishing = publishing.then(() => publishOnce(known)).catch(() => {}));
+		// A new Herdr server (an update handoff, or a stop and start) starts without the tokens of the one before. Writing them waits for no refresh:
+		// the tower's marks go first, because they are how another session finds the tower, and the rest follows. Nothing is written by a session that has not joined.
+		const restore = () => {
+			if (stopped || !at || !(joined || holdsTower)) return;
+			publishing = publishing.then(async () => {
+				if (stopped) return;
+				if (holdsTower) await Promise.all([report(run, "workspace", at.workspaceId, { tower: me() }), report(run, "pane", at.paneId, { sb_role: "tower" })]).catch(() => {});
+				await publishOnce();
+			}).catch(() => {});
+		};
 		const keepFresh = () => {
 			timer ??= setInterval(() => void publish(), REFRESH_MS);
 			timer.unref();
@@ -397,11 +408,14 @@ export function createStrawBoss({ run = herdrRun, api = herdrApi(), call = herdr
 			const log = ctx.sessionManager;
 			clearInterval(nudgeTimer);
 			nudges?.stop();
+			unwatch?.();
+			unwatch = undefined;
 			nudges = orphans({ run, file: () => log.getSessionFile(), entries: () => log.getEntries(), sessions, send, type: ENTRY, remember: (key) => pi.appendEntry(ENTRY, { nudged: key }), me, tell });
 			nudgeTimer = setInterval(() => void nudges?.poll().catch(() => {}), nudgeMs).unref();
 			// Starting runs in the background: pi awaits session_start handlers in turn, and pi-intercom connects in its own, after this one.
 			let starting: Promise<void> | undefined;
 			if (isTower) {
+				unwatch = watch(restore);
 				starting = startTower();
 			} else {
 				const bar = await barReason();
@@ -409,6 +423,7 @@ export function createStrawBoss({ run = herdrRun, api = herdrApi(), call = herdr
 				if (bar) {
 					tell(bar.text, bar.level);
 				} else {
+					if (!stopped) unwatch = watch(restore); // a shutdown that came while Herdr was asked about the workspace has stopped nothing yet
 					starting = joinNet().then(async () => {
 						const taken = (await claimOpened()) && (await promote(false));
 						if (taken && !taken.promoted) tell(taken.text, "warning");
@@ -441,7 +456,7 @@ export function createStrawBoss({ run = herdrRun, api = herdrApi(), call = herdr
 			if (["subagent", "subagent_resume"].includes(event.toolName) && !isTower && !barred && role()) for (const ms of KID_MARK_MS) setTimeout(() => void publish(), ms).unref();
 		});
 
-		pi.on("session_shutdown", async () => {
+		pi.on("session_shutdown", async (event) => {
 			if (gui) await switchRemote(gui, false, guiDir, ts).catch(() => {});
 			await gui?.stop();
 			gui = undefined;
@@ -451,6 +466,8 @@ export function createStrawBoss({ run = herdrRun, api = herdrApi(), call = herdr
 			timer = undefined;
 			clearInterval(nudgeTimer);
 			nudges?.stop();
+			unwatch?.();
+			unwatch = undefined;
 			stopped = true; // a refresh still in flight must not write tokens after they are cleared
 			await publishing;
 			const held = holdsTower;
@@ -459,6 +476,12 @@ export function createStrawBoss({ run = herdrRun, api = herdrApi(), call = herdr
 			await report(run, "pane", at.paneId, { sb_role: null, sb_opened_by: null, sb_order: null, sb_mark: null, sb_indent: null, sb_tab: null }).catch(() => {});
 			await clearOrder(run, [...kids]);
 			if (held) await report(run, "workspace", at.workspaceId, { tower: null }).catch(() => {});
+			// A tower that quits leaves its tab as a plain shell: close the tab, but only when this pane is all it holds. A reload, /new, resume or fork keeps the tab.
+			if (isTower && event.reason === "quit") {
+				const all = await panes(run, at.workspaceId).catch(() => []);
+				const tab = all.find((p) => p.pane_id === at.paneId)?.tab_id;
+				if (tab && all.every((p) => p.tab_id !== tab || p.pane_id === at.paneId)) await run(["tab", "close", tab]).catch(() => {});
+			}
 		});
 
 		// /boss gui is a read-only viewer: any session may open it, and it joins nothing and writes no token. A session outside the net

package/src/server-watch.ts

@@ -0,0 +1,58 @@
+import { createConnection, type Socket } from "node:net";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { StringDecoder } from "node:string_decoder";
+
+/** Starts watching the Herdr server; `onTakeover` runs each time a server answers again after the one watched went away. Returns the stop function. */
+export type HerdrWatch = (onTakeover: () => void) => () => void;
+
+const RETRY_MS = [250, 500, 1000, 2000];
+const ACK_MS = 5000;
+
+/**
+ * One `events.subscribe` connection kept open on Herdr's socket, for what its closing says: the server it was open to has stopped, and the
+ * tokens it held in memory are gone. The subscription asks for `workspace.renamed`, which almost never happens, so the open connection carries
+ * no traffic. When it closes (or the first attempt finds no server) the watch reconnects after 0.25 s, 0.5 s, 1 s, then every 2 s, and when a server
+ * acknowledges the subscription it calls `onTakeover` once. The first connection of a watch, which finds the server the session started in, does not.
+ * The socket and the retry timer never keep pi alive; `stop` ends both.
+ */
+export const herdrWatch = (socketPath = process.env.HERDR_SOCKET_PATH || join(homedir(), ".config", "herdr", "herdr.sock"), retryMs = RETRY_MS): HerdrWatch => (onTakeover) => {
+	let socket: Socket | undefined, timer: ReturnType<typeof setTimeout> | undefined, stopped = false, initial = true, retries = 0;
+	const attempt = () => {
+		const first = initial, text = new StringDecoder("utf8");
+		let acked = false, ended = false, head = "";
+		initial = false;
+		const end = () => {
+			if (ended) return;
+			ended = true;
+			current.destroy();
+			if (!stopped) timer = setTimeout(attempt, retryMs[Math.min(retries++, retryMs.length - 1)]).unref();
+		};
+		const current = (socket = createConnection(socketPath).setTimeout(ACK_MS));
+		current.unref();
+		current.on("connect", () => current.write(`${JSON.stringify({ id: `straw-boss-watch-${Date.now()}`, method: "events.subscribe", params: { subscriptions: [{ type: "workspace.renamed" }] } })}\n`));
+		current.on("data", (chunk) => {
+			if (acked || ended) return; // events after the acknowledgement are not wanted: read them off the socket and drop them
+			head += text.write(chunk);
+			if (!head.includes("\n")) return;
+			try {
+				if ((JSON.parse(head.split("\n")[0]!) as { result?: { type?: string } }).result?.type !== "subscription_started") return end();
+			} catch {
+				return end();
+			}
+			acked = true;
+			retries = 0;
+			current.setTimeout(0);
+			if (!first) onTakeover();
+		});
+		current.on("timeout", end);
+		current.on("error", end);
+		current.on("close", end);
+	};
+	attempt();
+	return () => {
+		stopped = true;
+		clearTimeout(timer);
+		socket?.destroy();
+	};
+};