pi-straw-boss 0.41.0 → 0.41.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-straw-boss",
-  "version": "0.41.0",
+  "version": "0.41.1",
   "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/agent/sidecar.ts

@@ -4,7 +4,7 @@ import { pathToFileURL } from "node:url";
 import { createDigest } from "../digest.ts";
 import { createElection } from "../election.ts";
 import { createGuard, GUARD_MS } from "../guard.ts";
-import { herdrApi, herdrCall, herdrRun, herdrWorld, isSub, place, socketReads, worldOf, panes, workspaces } from "../herdr.ts";
+import { herdrApi, herdrCall, herdrRun, herdrWorld, isSub, place, socketRun, worldOf, panes, workspaces } from "../herdr.ts";
 import type { Briefing } from "../briefing.ts";
 import { createMembership } from "../membership.ts";
 import { createPresence } from "../presence.ts";
@@ -57,7 +57,7 @@ const piOwn = (key: string) => /^PI_(INTERCOM|SUBAGENT)_/.test(key) || key === "
 
 /** The configuration of a pi session, with what only the GUI and the tower's host use left unavailable. */
 function agentConfig(d: AgentDeps, env: NodeJS.ProcessEnv): Config {
-	const call = d.call ?? herdrCall(), run = d.run ?? socketReads(herdrRun, call);
+	const call = d.call ?? herdrCall(), run = d.run ?? socketRun(herdrRun, call);
 	return {
 		run, world: d.world ?? (d.run ? worldOf(run) : herdrWorld(call)), api: d.api ?? herdrApi(), call, env, stateDir: d.stateDir,
 		sleep: d.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms))), now: d.now ?? Date.now,

package/src/herdr.ts

@@ -118,13 +118,37 @@ function listing(args: string[]): { method: string; params: Record<string, unkno
 	return undefined;
 }
 
+/** `pane current` as the CLI asks it, for the pane the process runs in; without HERDR_PANE_ID the CLI's own answer is left to it. */
+function current(args: string[], pane: string | undefined): { method: string; params: Record<string, unknown> } | undefined {
+	return args.length === 2 && args[0] === "pane" && args[1] === "current" && pane ? { method: "pane.current", params: { caller_pane_id: pane } } : undefined;
+}
+
+/** `<pane|workspace> report-metadata <id> --source S [--ttl-ms N] [--token k=v]... [--clear-token k]...` as its socket request; anything else is left to the CLI. */
+function metadata(args: string[]): { method: string; params: Record<string, unknown> } | undefined {
+	const [kind, cmd, id, ...flags] = args;
+	if ((kind !== "pane" && kind !== "workspace") || cmd !== "report-metadata" || !id || flags.length % 2) return undefined;
+	const tokens: Record<string, string | null> = {};
+	let source: string | undefined, ttl: number | undefined;
+	for (let i = 0; i < flags.length; i += 2) {
+		const [flag, value] = [flags[i]!, flags[i + 1]!], at = value.indexOf("=");
+		if (flag === "--source") source = value;
+		else if (flag === "--ttl-ms" && /^\d+$/.test(value)) ttl = Number(value);
+		else if (flag === "--token" && at > 0) tokens[value.slice(0, at)] = value.slice(at + 1);
+		else if (flag === "--clear-token") tokens[value] = null;
+		else return undefined;
+	}
+	if (!source) return undefined;
+	return { method: `${kind}.report_metadata`, params: { [kind === "pane" ? "pane_id" : "workspace_id"]: id, source, tokens, ...(ttl === undefined ? {} : { ttl_ms: ttl }) } };
+}
+
 /**
- * `run` with Herdr's listings (`pane list`, `workspace list`, `tab list --workspace`) answered over the socket instead of by a spawned CLI:
- * the same `{result}` text, so every reader works unchanged. Every other command, the writes included, still goes to `run`.
- * A listing that fails rejects with Herdr's own error (a HerdrError with its code); nothing falls back to the CLI.
+ * `run` with Herdr's listings (`pane list`, `workspace list`, `tab list --workspace`), `pane current`, and `report-metadata` answered over the socket
+ * instead of by a spawned CLI: the same `{result}` text, so every caller works unchanged. A spawned CLI costs a process start on every call, which a
+ * loaded machine turns into seconds, and these are the calls every session makes as it starts and on its timers. Every other command still goes to `run`.
+ * A request that fails rejects with Herdr's own error (a HerdrError with its code); nothing falls back to the CLI.
  */
-export const socketReads = (run: HerdrRun, call: HerdrCall): HerdrRun => async (args, timeoutMs) => {
-	const request = listing(args);
+export const socketRun = (run: HerdrRun, call: HerdrCall, pane = process.env.HERDR_PANE_ID): HerdrRun => async (args, timeoutMs) => {
+	const request = listing(args) ?? current(args, pane) ?? metadata(args);
 	return request ? JSON.stringify({ result: await call(request.method, request.params, timeoutMs) }) : run(args, timeoutMs);
 };
 

package/src/index.ts

@@ -13,7 +13,7 @@ import { openBrowser, VERSION } from "./gui.ts";
 import { ownerGone } from "./handover.ts";
 import { copyText } from "./pairing.ts";
 import { createHost } from "./host.ts";
-import { herdrApi, herdrCall, herdrRun, herdrWorld, socketReads, worldOf } from "./herdr.ts";
+import { herdrApi, herdrCall, herdrRun, herdrWorld, socketRun, worldOf } from "./herdr.ts";
 import { createMembership } from "./membership.ts";
 import { createPresence } from "./presence.ts";
 import { createReach } from "./reach.ts";
@@ -34,7 +34,7 @@ const ADOPT_MS = 2_000;
 // The composition root: the concerns live in their own modules (state.ts says what they share), and this wires them for one pi session.
 export function createStrawBoss({ run: given, world: reading, 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, version = VERSION, guardMs = GUARD_MS, couple = true, events = herdrEvents(), detectMs = DETECT_MS, now = Date.now, later = afterExit, gone = ownerGone(), adoptMs = ADOPT_MS }: Deps = {}) {
 	// A run that is not injected is the real CLI, with its listings over the socket; an injected one answers everything itself, listings included.
-	const run = given ?? socketReads(herdrRun, call), world = reading ?? (given ? worldOf(given) : herdrWorld(call));
+	const run = given ?? socketRun(herdrRun, call), world = reading ?? (given ? worldOf(given) : herdrWorld(call));
 	const cfg: Config = { run, world, api, call, tailscale: ts, copy, env, sleep, promptDir, bundle, openUrl, watch, stateDir, autoTower, nudgeMs, version, guardMs, couple, events, detectMs, now, later, gone, adoptMs };
 	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

package/src/session.ts

@@ -13,6 +13,7 @@ import { ENTRY, type Kit } from "./state.ts";
 
 const KID_MARK_MS = [3_000, 15_000];
 const SUBAGENT_TOOLS = ["subagent", "subagent_resume"];
+const CHECKING = "Straw Boss is still asking Herdr whether this is a sub workspace; try again in a moment";
 
 /** What the session does at its start, around each run, and at its end. */
 export function registerSession(kit: Kit, { briefing, presence, membership, guard, host, reach, digest, control, startTower }: { briefing: Briefing; presence: Presence; membership: Membership; guard: Guard; host: ReturnType<typeof createHost>; reach: Reach; digest: Digest; control: Control; startTower(): Promise<void> }) {
@@ -42,6 +43,8 @@ export function registerSession(kit: Kit, { briefing, presence, membership, guar
 	};
 	// A tab the tower opened for a request starts its pi with this role: it promotes itself as soon as it has joined (opener.ts).
 	const opensAsMain = env.STRAW_BOSS_ROLE === "main";
+	// The session start in progress, and its answer to whether this session may join (true) once Herdr has said what workspace it is in.
+	let started: object | undefined, checked: Promise<boolean> = Promise.resolve(false);
 	// STRAW_BOSS_ROLE=main stays in the new tab's shell, so a later pi started there would self-promote. The tower's one-time pane token is what
 	// authorises it: this pi consumes the token and keeps the opener's marker (sb_opened_by) fresh, which the tower counts to enforce its limits.
 	const claimOpened = async () => {
@@ -55,6 +58,7 @@ export function registerSession(kit: Kit, { briefing, presence, membership, guar
 	};
 
 	pi.on("session_start", async (event, ctx) => {
+		const start = (started = {});
 		s.stopped = false;
 		s.ui = ctx.ui;
 		s.hasUI = ctx.hasUI;
@@ -73,24 +77,29 @@ export function registerSession(kit: Kit, { briefing, presence, membership, guar
 			unwatch = cfg.watch(presence.restore);
 			starting = startTower();
 		} else {
-			const bar = await barReason();
-			s.barred = bar?.text;
-			if (bar) {
-				tell(bar.text, bar.level);
-			} else {
+			// Asking Herdr whether this is a sub workspace waits in the background too: on a loaded machine a Herdr call takes seconds, and pi-intercom
+			// connects only after this handler returns. Until the answer comes the session counts as barred, so nothing joins (membership.ts) or promotes early.
+			s.barred = CHECKING;
+			checked = barReason().then((bar) => {
+				if (start !== started) return false; // a /new or /resume started another session meanwhile, which asks again
+				s.barred = bar?.text;
+				if (bar) tell(bar.text, bar.level);
+				return !bar;
+			});
+			starting = checked.then(async (joinable) => {
+				if (!joinable) return;
 				if (!s.stopped) unwatch = cfg.watch(presence.restore); // a shutdown that came while Herdr was asked about the workspace has stopped nothing yet
-				starting = membership.joinNet().then(async () => {
-					note(`${who()} joined tab ${s.info.tab}`);
-					const claimed = await claimOpened();
-					if (!claimed && event.reason !== "startup" && s.saved.openedBy && s.saved.openedPane === s.at.paneId) s.openedBy = s.saved.openedBy; // only the same pi in the tower's pane (/reload, /fork): `pi --session` anywhere is the boss's main
-					if (s.openedBy) {
-						control.register(); // the tower that opened this main may ask it to close (closemain.ts), also after a reload
-						await presence.publish(); // sb_opened_by was cleared at shutdown
-					}
-					const taken = claimed && (await membership.promote(false));
-					if (taken && !taken.promoted) tell(taken.text, "warning");
-				});
-			}
+				await membership.joinNet();
+				note(`${who()} joined tab ${s.info.tab}`);
+				const claimed = await claimOpened();
+				if (!claimed && event.reason !== "startup" && s.saved.openedBy && s.saved.openedPane === s.at.paneId) s.openedBy = s.saved.openedBy; // only the same pi in the tower's pane (/reload, /fork): `pi --session` anywhere is the boss's main
+				if (s.openedBy) {
+					control.register(); // the tower that opened this main may ask it to close (closemain.ts), also after a reload
+					await presence.publish(); // sb_opened_by was cleared at shutdown
+				}
+				const taken = claimed && (await membership.promote(false));
+				if (taken && !taken.promoted) tell(taken.text, "warning");
+			});
 		}
 		starting?.catch((error: Error) => tell(`Straw Boss: ${error.message}`, "error"));
 		// The GUI this process ran before a /reload, /new, or /resume starts again on its URL, and a session newer than the running server
@@ -117,7 +126,9 @@ export function registerSession(kit: Kit, { briefing, presence, membership, guar
 	// A member that dispatches or resumes a subagent without promoting is promoted here, before the subagent starts, unless the tab already has a main.
 	// A tower only coordinates: it dispatches no subagent (one would outlive it with no one to take its result), and opens a main for the work instead.
 	pi.on("tool_call", async (event) => {
-		if (!SUBAGENT_TOOLS.includes(event.toolName) || s.barred) return;
+		if (!SUBAGENT_TOOLS.includes(event.toolName)) return;
+		await checked; // a subagent launched while session start still asks Herdr about the workspace waits for the answer
+		if (s.barred) return;
 		if (s.isTower) return { block: true, reason: "A tower dispatches no subagents. Open a main for this work with boss_open_main, or route it to the main that owns it." };
 		try {
 			await membership.joinNet();

package/src/state.ts

@@ -28,7 +28,7 @@ export interface Saved { tower?: boolean; openedBy?: string | null; openedPane?:
 export type Role = "tower" | "main" | "member";
 export type Scope = "tab" | "workspace" | "towers" | "all";
 /**
- * `run` is the CLI for every command; left out, Herdr's listings go over the socket instead (`socketReads`) and `world` is one `session.snapshot`. `world` is the dashboard's and the GUI's reading of panes and workspaces.
+ * `run` is the CLI for every command; left out, Herdr's listings, `pane current`, and `report-metadata` go over the socket instead (`socketRun`) and `world` is one `session.snapshot`. `world` is the dashboard's and the GUI's reading of panes and workspaces.
  * `gone` says whether the process that recorded a GUI server has ended for good (handover.ts `ownerGone`), which a survivor needs before it takes the server over; `adoptMs` is how often a session looks.
  */
 export interface Deps { run?: HerdrRun; world?: HerdrWorld; 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; version?: string; guardMs?: number; couple?: boolean; events?: HerdrEvents; detectMs?: number; now?: () => number; later?: (pid: number, args: string[]) => void; gone?: (record: GuiRecord, wrote: number) => boolean; adoptMs?: number }