@yusukeshib/pi-babysit 0.6.5 → 0.6.7

package/README.md

@@ -80,8 +80,14 @@ backgrounding (`… &`, `nohup`, `setsid`, `disown`). Set
 
 A widget below the editor separates session **kind** from task **state** at a glance:
 summary counts use `RUNNING` / `IDLE`, and every row is labeled
-`PROCESS RUNNING`, `AGENT RUNNING`, or `AGENT IDLE`. The displayed `age`
-is total session age, not time spent in the current state. Transcript details
+`PROCESS RUNNING`, `AGENT RUNNING`, or `AGENT IDLE`. In fullscreen mode, the
+`SESSIONS(n) < 1/4 >` list combines running, idle, finished, and failed sessions
+(newest first, five per page); the fraction shows the current/total page. Click the arrows to page or anywhere else on the header to collapse
+and expand the list. Click a row to toggle between its latest line and latest 20
+available output lines. A session with no available output shows an explicit
+placeholder when expanded. Mouse clicks require fullscreen mode; `/babysit`
+works in regular mode. The displayed `age` is total session age, not time spent
+in the current state. Transcript details
 from tool results, snapshots, and completion notifications collapse or expand
 with Pi's tool-output toggle (`Ctrl+O` by default).
 

package/index.ts

@@ -43,7 +43,7 @@ import type {
 	ToolDefinition,
 } from "@earendil-works/pi-coding-agent";
 import { getMarkdownTheme } from "@earendil-works/pi-coding-agent";
-import { Box, Markdown, Text, truncateToWidth } from "@earendil-works/pi-tui";
+import { Box, Markdown, Text, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import { Type, type TSchema } from "typebox";
 import { StringEnum } from "@earendil-works/pi-ai";
 import { type AgentConfig, type AgentScope, discoverAgents } from "./agents";
@@ -1229,16 +1229,18 @@ async function selectedProcessOutput(
 	return tail ? `\n\nSelected tail (${lines} lines max):\n${clip(tail, maxBytes)}` : "";
 }
 
+function escapeCommandForDisplay(command: string): string {
+	return command
+		.replace(/\r/g, "\\r")
+		.replace(/\n/g, "\\n")
+		.replace(/\t/g, "\\t")
+		.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x9F]/g, (char) =>
+			`\\x${char.charCodeAt(0).toString(16).toUpperCase().padStart(2, "0")}`,
+		);
+}
+
 export function summarizeNotificationCommand(command: string | undefined): string {
-	const preview =
-		(command ?? "?")
-			.trim()
-			.replace(/\r/g, "\\r")
-			.replace(/\n/g, "\\n")
-			.replace(/\t/g, "\\t")
-			.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x9F]/g, (char) =>
-				`\\x${char.charCodeAt(0).toString(16).toUpperCase().padStart(2, "0")}`,
-			) || "?";
+	const preview = escapeCommandForDisplay((command ?? "?").trim()) || "?";
 	const bytes = Buffer.from(preview, "utf8");
 	if (bytes.length <= NOTIFY_COMMAND_MAX_BYTES) return preview;
 	if (NOTIFY_COMMAND_MAX_BYTES === 0) return "";
@@ -2287,14 +2289,23 @@ async function spawnSubagent(
 }
 
 // ---------------------------------------------------------------------------
-// widget (live counts)
+// widget (live counts and browsable sessions)
 // ---------------------------------------------------------------------------
 
+export function widgetSessionGroups(sessions: BsSession[], startedAt: (id: string) => number) {
+	const active = sessions.filter((session) => session.state === "running");
+	const started = new Map(sessions.map((session) => [session.id, startedAt(session.id)]));
+	const newestFirst = (a: BsSession, b: BsSession) =>
+		(started.get(b.id) ?? 0) - (started.get(a.id) ?? 0) || b.id.localeCompare(a.id);
+	const finished = sessions.filter((session) => session.state !== "running").sort(newestFirst);
+	return { active, finished, all: [...sessions].sort(newestFirst) };
+}
+
 // A subagent whose task is done stays alive as an idle RPC worker (for
 // follow-ups), so "running" in babysit does NOT mean "working" — count
 // processes / busy subagents / idle subagents separately.
 export type WidgetSessionKind = "process" | "agent";
-export type WidgetSessionState = "running" | "idle";
+export type WidgetSessionState = "running" | "idle" | "finished" | "failed";
 
 export function widgetSummaryText(procs: number, busy: number, idle: number): string {
 	const sections: string[] = [];
@@ -2312,7 +2323,7 @@ export function widgetSessionHeader(
 	state: WidgetSessionState,
 	elapsed?: string,
 ): string {
-	const icon = state === "running" ? "▶" : "○";
+	const icon = state === "running" ? "▶" : state === "failed" ? "✗" : "○";
 	return `  ${icon} ${id} ${kind.toUpperCase()} ${state.toUpperCase()}${elapsed ? ` age ${elapsed}` : ""}`;
 }
 
@@ -2338,17 +2349,23 @@ function renderWidgetSessionHeader(
 	elapsed: string,
 	theme: Theme,
 ): string {
-	const running = state === "running";
-	const icon = theme.fg(running ? "success" : "muted", running ? "▶" : "○");
+	const color = state === "running" ? "success" : state === "failed" ? "error" : "muted";
+	const icon = theme.fg(color, state === "running" ? "▶" : state === "failed" ? "✗" : "○");
 	const kindLabel = theme.fg(kind === "process" ? "accent" : "warning", theme.bold(kind.toUpperCase()));
-	const stateLabel = theme.fg(running ? "success" : "muted", theme.bold(state.toUpperCase()));
+	const stateLabel = theme.fg(color, theme.bold(state.toUpperCase()));
 	return `  ${icon} ${id} ${kindLabel} ${stateLabel}${elapsed ? theme.fg("dim", ` age ${elapsed}`) : ""}`;
 }
 
-// How many trailing output lines to show per running session in the widget.
+// How many trailing output lines to show per session in the widget.
 const WIDGET_COLLAPSED_TAIL_LINES = 1;
 const WIDGET_EXPANDED_TAIL_LINES = 20;
 const WIDGET_TAIL_WIDTH = 100;
+const WIDGET_SESSION_PAGE_SIZE = 5;
+
+export interface WidgetSessionListState {
+	open: boolean;
+	page: number;
+}
 
 export interface WidgetSessionDisplay {
 	id: string;
@@ -2361,6 +2378,7 @@ interface WidgetMouseEvent {
 	type: string;
 	button: string;
 	y: number;
+	x?: number;
 }
 
 /**
@@ -2371,45 +2389,96 @@ interface WidgetMouseEvent {
 export function createWidgetComponent(
 	summaryLines: string[],
 	sessions: WidgetSessionDisplay[],
-	expandedProcessIds: Set<string>,
+	expandedSessionIds: Set<string>,
+	listState?: WidgetSessionListState,
 ) {
-	let processIdByLine: Array<string | undefined> = [];
+	type Target = { type: "session"; id: string } | { type: "sessions"; endX: number; prevX?: number; nextX?: number };
+	let targetByLine: Array<Target | undefined> = [];
 
 	return {
 		render(width: number): string[] {
 			const lines: string[] = [];
-			processIdByLine = [];
-			const push = (text: string, processId?: string) => {
+			targetByLine = [];
+			const push = (text: string, target?: Target) => {
 				lines.push(truncateToWidth(text, Math.max(0, width), ""));
-				processIdByLine.push(processId);
+				targetByLine.push(target);
 			};
-
-			for (const line of summaryLines) push(line);
-			for (const session of sessions) {
-				const expanded = session.expandable && expandedProcessIds.has(session.id);
+			const pushSession = (session: WidgetSessionDisplay) => {
+				const expanded = session.expandable && expandedSessionIds.has(session.id);
 				const tail = session.tail.slice(
 					expanded ? -WIDGET_EXPANDED_TAIL_LINES : -WIDGET_COLLAPSED_TAIL_LINES,
 				);
-				const processId = session.expandable ? session.id : undefined;
+				const target = session.expandable ? { type: "session" as const, id: session.id } : undefined;
 				if (!expanded && tail.length === 1) {
-					push(`${session.header} ${tail[0]}`, processId);
+					push(`${session.header} ${tail[0]}`, target);
 				} else {
-					push(session.header, processId);
-					for (const line of tail) push(`      ${line}`, processId);
+					push(session.header, target);
+					for (const line of tail) push(`      ${line}`, target);
+					if (expanded && tail.length === 0) push("      (no output available)", target);
 				}
+			};
+
+			for (const line of summaryLines.slice(0, -1)) push(line);
+			const summary = summaryLines.at(-1);
+			if (listState && sessions.length) {
+				const pageCount = Math.ceil(sessions.length / WIDGET_SESSION_PAGE_SIZE);
+				listState.page = Math.min(Math.max(0, listState.page), pageCount - 1);
+				const label = ` SESSIONS(${sessions.length})`;
+				const showArrows = listState.open && pageCount > 1;
+				const suffix = `${label}${showArrows ? ` < ${listState.page + 1}/${pageCount} >` : ""}`;
+				// Keep the count clickable on narrow terminals by moving it to its own row.
+				const inline = summary !== undefined && visibleWidth(summary) + visibleWidth(suffix) <= width;
+				if (summary !== undefined && !inline) {
+					push(summary, { type: "sessions", endX: Math.min(visibleWidth(summary), Math.max(0, width)) });
+				}
+				const prefix = inline ? summary ?? "" : "";
+				const prefixWidth = visibleWidth(prefix);
+				push(`${prefix}${suffix}`, {
+					type: "sessions",
+					endX: Math.min(prefixWidth + visibleWidth(suffix), Math.max(0, width)),
+					prevX: showArrows ? prefixWidth + suffix.indexOf("<") : undefined,
+					nextX: showArrows ? prefixWidth + suffix.indexOf(">") : undefined,
+				});
+				if (listState.open) {
+					const start = listState.page * WIDGET_SESSION_PAGE_SIZE;
+					for (const session of sessions.slice(start, start + WIDGET_SESSION_PAGE_SIZE)) {
+						pushSession(session);
+					}
+				}
+			} else {
+				if (summary !== undefined) push(summary);
+				for (const session of sessions) pushSession(session);
 			}
 			return lines;
 		},
 		handleMouse(event: WidgetMouseEvent) {
-			if (event.type !== "click" || event.button !== "left") return undefined;
-			const id = processIdByLine[event.y];
-			if (!id) return undefined;
-			if (expandedProcessIds.has(id)) expandedProcessIds.delete(id);
-			else expandedProcessIds.add(id);
-			return { handled: true, render: true };
+			if (event.button !== "left") return undefined;
+			const target = targetByLine[event.y];
+			if (!target) return undefined;
+			if (target.type === "sessions" && (event.x === undefined || event.x < 0 || event.x >= target.endX)) return undefined;
+			// Toggle on press so a terminal that omits release still works.
+			if (event.type === "press") {
+				if (target.type === "session") {
+					if (expandedSessionIds.has(target.id)) expandedSessionIds.delete(target.id);
+					else expandedSessionIds.add(target.id);
+				} else if (listState) {
+					const pageCount = Math.ceil(sessions.length / WIDGET_SESSION_PAGE_SIZE);
+					if (event.x === target.prevX && target.prevX !== undefined) {
+						listState.page = (listState.page - 1 + pageCount) % pageCount;
+					} else if (event.x === target.nextX && target.nextX !== undefined) {
+						listState.page = (listState.page + 1) % pageCount;
+					} else {
+						listState.open = !listState.open;
+					}
+				}
+				return { handled: true, render: true };
+			}
+			// Consume Pi's synthesized click without toggling a second time.
+			if (event.type === "click") return { handled: true, render: false };
+			return undefined;
 		},
 		invalidate() {
-			processIdByLine = [];
+			targetByLine = [];
 		},
 	};
 }
@@ -2454,21 +2523,23 @@ function readTailLines(file: string, lines: number, maxBytes = 64_000): string[]
 	}
 }
 
-// Trailing lines to show for a running session (sanitized, unprefixed).
+// Trailing lines to show for a session (sanitized, unprefixed).
 // Process tails are read directly from the bounded end of output.log, avoiding
-// one `babysit log` subprocess per active process on every poll.
-async function widgetTail(
+// one `babysit log` subprocess per visible process.
+export function widgetTail(
 	id: string,
 	isSub: boolean,
 	subagentProgress?: Progress,
 	lines = WIDGET_COLLAPSED_TAIL_LINES,
-): Promise<string[]> {
+): string[] {
 	let raw: string[];
 	if (!isSub) {
 		raw = readTailLines(logPath(id), lines);
 	} else {
 		const progress = subagentProgress ?? taskProgressOf(id).progress;
-		if (progress.finalText.trim()) {
+		if (progress.streamingText.trim()) {
+			raw = progress.streamingText.trim().split("\n");
+		} else if (progress.finalText.trim()) {
 			raw = progress.finalText.trim().split("\n");
 		} else if (progress.toolCalls.length > 0) {
 			raw = progress.toolCalls.map((tool) => tool.summary);
@@ -3365,13 +3436,13 @@ export default function (pi: ExtensionAPI) {
 		}
 	}
 
-	const expandedWidgetProcesses = new Set<string>();
+	const expandedWidgetSessions = new Set<string>();
+	const widgetListState: WidgetSessionListState = { open: true, page: 0 };
 
 	const refreshWidget = async (ctx: ExtensionContext, snapshot?: BsSession[]) => {
 		if (!ctx.hasUI) return;
-		const active = (snapshot ?? (await listSessions()).sessions).filter(
-			(session) => session.state === "running",
-		);
+		const all = snapshot ?? (await listSessions()).sessions;
+		const { active, all: ordered } = widgetSessionGroups(all, (id) => readMeta(id)?.startedAt ?? 0);
 		const subs = active.filter((session) => kindOf(session.id) === "subagent");
 		const procs = active.length - subs.length;
 		const progressById = new Map<string, Progress>();
@@ -3383,11 +3454,9 @@ export default function (pi: ExtensionAPI) {
 			}
 		}
 		const idle = subs.filter((session) => progressById.get(session.id)?.done).length;
-		const activeProcessIds = new Set(
-			active.filter((session) => kindOf(session.id) !== "subagent").map((session) => session.id),
-		);
-		for (const id of expandedWidgetProcesses) {
-			if (!activeProcessIds.has(id)) expandedWidgetProcesses.delete(id);
+		const sessionIds = new Set(all.map((session) => session.id));
+		for (const id of expandedWidgetSessions) {
+			if (!sessionIds.has(id)) expandedWidgetSessions.delete(id);
 		}
 
 		const theme = ctx.ui.theme;
@@ -3399,37 +3468,53 @@ export default function (pi: ExtensionAPI) {
 					session.id,
 					isSubagent,
 					isSubagent ? progressById.get(session.id) : undefined,
-					isSubagent ? WIDGET_COLLAPSED_TAIL_LINES : WIDGET_EXPANDED_TAIL_LINES,
+					WIDGET_EXPANDED_TAIL_LINES,
 				);
 			}),
 		);
-		const displays = active.map((session, index): WidgetSessionDisplay => {
-			const isSubagent = kindOf(session.id) === "subagent";
-			const state: WidgetSessionState = isSubagent && progressById.get(session.id)?.done
-				? "idle"
-				: "running";
+		const activeTails = new Map(active.map((session, index) => [session.id, tails[index]]));
+		const displays = ordered.map((session): WidgetSessionDisplay => {
+			const id = session.id;
+			const isSubagent = kindOf(id) === "subagent";
+			if (session.state === "running") {
+				const state: WidgetSessionState = isSubagent && progressById.get(id)?.done ? "idle" : "running";
+				return {
+					id,
+					header: renderWidgetSessionHeader(id, isSubagent ? "agent" : "process", state, elapsedOf(id), theme),
+					tail: activeTails.get(id) ?? [],
+					expandable: true,
+				};
+			}
 			return {
-				id: session.id,
+				id,
 				header: renderWidgetSessionHeader(
-					session.id,
+					id,
 					isSubagent ? "agent" : "process",
-					state,
-					elapsedOf(session.id),
+					session.state === "exited" && session.exit_code === 0 ? "finished" : "failed",
+					"",
 					theme,
 				),
-				tail: tails[index],
-				expandable: !isSubagent,
+				// Only read/parse the five visible sessions on demand.
+				get tail() {
+					try {
+						return widgetTail(id, isSubagent, undefined, WIDGET_EXPANDED_TAIL_LINES);
+					} catch {
+						return [];
+					}
+				},
+				expandable: true,
 			};
 		});
 
 		if (ctx.mode === "tui") {
 			ctx.ui.setWidget(
 				"pi-babysit",
-				() => createWidgetComponent(summaryLines, displays, expandedWidgetProcesses),
+				() => createWidgetComponent(summaryLines, displays, expandedWidgetSessions, widgetListState),
 				{ placement: "belowEditor" },
 			);
 		} else {
-			const component = createWidgetComponent(summaryLines, displays, new Set());
+			const activeIds = new Set(active.map((session) => session.id));
+			const component = createWidgetComponent(summaryLines, displays.filter((session) => activeIds.has(session.id)), new Set());
 			ctx.ui.setWidget("pi-babysit", component.render(10_000), {
 				placement: "belowEditor",
 			});
@@ -4147,7 +4232,7 @@ export default function (pi: ExtensionAPI) {
 			const title = theme.bold(`babysit_run ${kind}`);
 			const detail =
 				typeof payload === "string" && payload.length > 0
-					? `  ${summarizeNotificationCommand(payload)}`
+					? `  ${escapeCommandForDisplay(payload)}`
 					: "";
 			return new Text(theme.fg("warning", `${title}${agent}${detail}`), 0, 0);
 		},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yusukeshib/pi-babysit",
-  "version": "0.6.5",
+  "version": "0.6.7",
   "description": "Run any shell command and pi subagents under babysit, with context-safe captured output.",
   "keywords": [
     "pi-package",