@fitchmultz/pi-subagents 0.0.0-stage → 0.44.5

package/src/pi-intercom/ui/session-list.ts

@@ -0,0 +1,139 @@
+import type { Component, SelectItem, TUI, TuiMouseEvent } from "@earendil-works/pi-tui";
+import { Box, Container, SelectList, Text, sliceByColumn, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { actionHints } from "../../tui/action-hints.ts";
+import type { KeybindingsManager, Theme } from "@earendil-works/pi-coding-agent";
+import type { SessionInfo } from "../types.ts";
+import { formatSessionTarget } from "../session-targets.ts";
+
+function sessionTitle(session: SessionInfo, allSessions: SessionInfo[], suffix?: string): string {
+  return `${session.name || "Unnamed session"} (${formatSessionTarget(session, allSessions)})${suffix ? ` [${suffix}]` : ""}`;
+}
+
+export class SessionListOverlay extends Container {
+  private completed = false;
+  private selectList: SelectList;
+  private allSessions: SessionInfo[];
+  private tui: TUI;
+  private theme: Theme;
+  private keybindings: KeybindingsManager;
+  private currentSession: SessionInfo;
+  private sessions: SessionInfo[];
+  private done: (result: SessionInfo | undefined) => void;
+  private hiddenSessionCount: number;
+
+  constructor(
+    tui: TUI,
+    theme: Theme,
+    keybindings: KeybindingsManager,
+    currentSession: SessionInfo,
+    sessions: SessionInfo[],
+    done: (result: SessionInfo | undefined) => void,
+    hiddenSessionCount = 0,
+    allSessions = [currentSession, ...sessions],
+  ) {
+    super();
+    this.tui = tui;
+    this.theme = theme;
+    this.keybindings = keybindings;
+    this.currentSession = currentSession;
+    this.sessions = sessions;
+    this.done = done;
+    this.hiddenSessionCount = hiddenSessionCount;
+    this.allSessions = allSessions;
+    const items: SelectItem[] = sessions.map((session) => ({
+      value: session.id,
+      label: sessionTitle(session, this.allSessions, session.cwd === currentSession.cwd ? "same native session cwd" : undefined),
+      description: `${session.topics?.filter((topic) => topic.resource && topic.ownership === "held").map((topic) => `Using ${topic.resource}`).join(" · ") || `Native session cwd: ${session.cwd}`} • ${session.model}`,
+    }));
+    this.selectList = new SelectList(items, 8, {
+      selectedPrefix: (text) => theme.fg("accent", text),
+      selectedText: (text) => theme.fg("accent", text),
+      description: (text) => theme.fg("dim", text),
+      scrollInfo: (text) => theme.fg("dim", text),
+      noMatch: (text) => theme.fg("dim", text),
+    });
+    this.selectList.onSelect = (item) => this.finish(sessions.find((session) => session.id === item.value));
+    this.selectList.onCancel = () => this.finish();
+  }
+
+  private finish(result?: SessionInfo): void {
+    if (this.completed) return;
+    this.completed = true;
+    this.done(result);
+  }
+
+  dispose(): void { this.completed = true; }
+
+  handleMouse(event: TuiMouseEvent) {
+    const width = Math.min(event.width, 88);
+    if (this.completed || event.x >= width) return;
+    return super.handleMouse({ ...event, width });
+  }
+
+  handleInput(data: string): void {
+    if (this.completed) return;
+    if (this.sessions.length === 0) {
+      if (this.keybindings.matches(data, "tui.select.cancel")) this.finish();
+    } else {
+      this.selectList.handleInput(data);
+    }
+    this.tui.requestRender();
+  }
+
+  render(width: number): string[] {
+    this.clear();
+    if (width < 3) return [truncateToWidth("Intercom", width)];
+    const innerWidth = Math.min(width, 88);
+    const contentWidth = Math.max(1, innerWidth - 2);
+    const message = [this.keybindings.getKeys("tui.select.confirm").join("/"), "Message"].filter(Boolean).join(": ");
+    const close = [this.keybindings.getKeys("tui.select.cancel").join("/"), "Close"].filter(Boolean).join(": ");
+    const border = (text: string) => this.theme.fg("accent", text);
+    const row = (text = "") => {
+      const clipped = truncateToWidth(text, contentWidth, "", true);
+      return `${border("│")}${clipped}${" ".repeat(Math.max(0, contentWidth - visibleWidth(clipped)))}${border("│")}`;
+    };
+
+    const framed = (component: Component) => {
+      const box = new Box(1, 0, (line) => row(sliceByColumn(line, 1, contentWidth)));
+      box.addChild(component);
+      return box;
+    };
+    const lines = [
+      border(`╭${"─".repeat(contentWidth)}╮`),
+      row(this.theme.bold(" Current Session")),
+      border(`├${"─".repeat(contentWidth)}┤`),
+      row(`  ${this.theme.fg("dim", sessionTitle(this.currentSession, this.allSessions, "self"))}`),
+      row(`  ${this.theme.fg("dim", `Native session cwd: ${this.currentSession.cwd} • ${this.currentSession.model}`)}`),
+      border(`├${"─".repeat(contentWidth)}┤`),
+      row(this.theme.bold(" Other Sessions")),
+    ];
+
+    this.addChild(new Text(lines.join("\n"), 0, 0));
+    if (this.sessions.length === 0) {
+      this.addChild(new Text((this.hiddenSessionCount > 0
+        ? [
+            row(this.theme.fg("dim", " No other sessions in this project")),
+            row(this.theme.fg("dim", ` ${this.hiddenSessionCount} in other project${this.hiddenSessionCount === 1 ? "" : "s"} hidden`)),
+            row(this.theme.fg("dim", " Run /intercom all to show every connected session")),
+          ]
+        : [
+            row(this.theme.fg("dim", " No other intercom-connected sessions")),
+            row(this.theme.fg("dim", " Start another session with: pi --name worker")),
+            row(this.theme.fg("dim", " Then run intercom({ action: \"list\" }) again")),
+          ]).join("\n"), 0, 0));
+    } else {
+      this.addChild(framed(this.selectList));
+      if (this.hiddenSessionCount > 0) {
+        this.addChild(new Text(row(this.theme.fg("dim", ` ${this.hiddenSessionCount} other-project session${this.hiddenSessionCount === 1 ? "" : "s"} hidden · /intercom all`)), 0, 0));
+      }
+    }
+
+    this.addChild(new Text(border(`├${"─".repeat(contentWidth)}┤`), 0, 0));
+    this.addChild(framed(actionHints([
+      " ", ...(this.sessions.length ? [{ text: message, run: () => { const item = this.selectList.getSelectedItem(); if (item) this.selectList.onSelect?.(item); } }, " • "] : []),
+      { text: close, run: () => this.finish() },
+    ], (text) => this.theme.fg("dim", text), "")));
+    this.addChild(new Text(border(`╰${"─".repeat(contentWidth)}╯`), 0, 0));
+    return super.render(innerWidth);
+  }
+}

package/src/runs/background/async-control.ts

@@ -0,0 +1,89 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { randomUUID } from "node:crypto";
+import { writeAtomicJson } from "../../shared/atomic-json.ts";
+import { readStatus } from "../../shared/utils.ts";
+import { readQuestionContract, readRunJson } from "../shared/supervisor-questions.ts";
+import { checkPidLiveness } from "./stale-run-reconciler.ts";
+import { readChildProcessIdentity, trySignalChildTree } from "../../shared/post-exit-stdio-guard.ts";
+
+interface AsyncControlRequest {
+	requestId: string;
+	runId: string;
+	action: "interrupt" | "cancel" | "extend";
+	index?: number;
+	extendMs?: number;
+}
+
+export function writeAsyncControlRequest(asyncDir: string, runId: string, action: AsyncControlRequest["action"], index?: number, extendMs?: number): void {
+	if (action === "extend" && (typeof extendMs !== "number" || !Number.isSafeInteger(extendMs) || extendMs <= 0 || index !== undefined)) throw new Error("extendMs must be a positive integer.");
+	const requestId = randomUUID();
+	const file = readStatus(asyncDir)?.controlRequestFiles === true || readRunJson<{ runtimeVersion?: number }>(path.join(asyncDir, "launch.json"))?.runtimeVersion === 2
+		? path.join(asyncDir, "control-requests", `${requestId}.json`)
+		: path.join(asyncDir, "control-request.json");
+	writeAtomicJson(file, { requestId, runId, action, ...(index !== undefined ? { index } : {}), ...(extendMs !== undefined ? { extendMs } : {}), createdAt: Date.now() });
+}
+
+export function writeAsyncInterruptRequest(asyncDir: string, runId: string, index?: number): void {
+	const status = readStatus(asyncDir);
+	if (status?.runId === runId && status.state === "running" && status.pid && checkPidLiveness(status.pid) === "dead") {
+		if (index !== undefined && (!Number.isSafeInteger(index) || index < 0 || status.steps?.[index]?.status !== "running")) {
+			throw new Error(`No running child at index ${index}. No siblings were stopped.`);
+		}
+		// Validate every target before signaling any: stale PIDs must never stop unrelated work.
+		const children = (status.steps ?? []).flatMap((step, childIndex) => {
+			if (step.status !== "running" || (index !== undefined && index !== childIndex)) return [];
+			const contract = readQuestionContract(runId, childIndex, undefined, { readConfiguration: false });
+			if (!contract?.pid || !Number.isSafeInteger(contract.pid) || contract.pid <= 0) throw new Error(`Cannot verify process ownership for child ${childIndex}.`);
+			if (checkPidLiveness(contract.pid) === "dead") return [];
+			if (!contract.processIdentity || readChildProcessIdentity(contract.pid) !== contract.processIdentity) {
+				throw new Error(`Cannot verify process ownership for child ${childIndex}. No stop was sent.`);
+			}
+			return [{ pid: contract.pid, identity: contract.processIdentity }];
+		});
+		for (const { pid, identity } of children) {
+			const child = { pid, kill: (signal?: NodeJS.Signals | number) => process.kill(pid, signal) };
+			if (!trySignalChildTree(child, "SIGTERM")) throw new Error(`Could not signal orphaned child process ${pid}. Exit is unconfirmed.`);
+			// Match normal Stop escalation, including descendants surviving their group leader.
+			setTimeout(() => {
+				if (checkPidLiveness(pid) === "dead") {
+					try { process.kill(-pid, "SIGKILL"); } catch {}
+				} else if (readChildProcessIdentity(pid) === identity) {
+					trySignalChildTree(child, "SIGKILL");
+				}
+			}, 3000).unref();
+		}
+		return;
+	}
+	writeAsyncControlRequest(asyncDir, runId, "interrupt", index);
+}
+
+export function readAsyncControlRequests(asyncDir: string, runId: string): AsyncControlRequest[] {
+	const directory = path.join(asyncDir, "control-requests");
+	const files = fs.existsSync(directory) ? fs.readdirSync(directory).filter((file) => file.endsWith(".json")).map((file) => path.join(directory, file)) : [];
+	files.push(path.join(asyncDir, "control-request.json"));
+	const requests: AsyncControlRequest[] = [];
+	for (const file of files) {
+		const claimed = `${file}.${randomUUID()}.reading`;
+		try {
+			// Claim before reading, so a legacy writer's replacement remains for the next poll.
+			fs.renameSync(file, claimed);
+		} catch (error) {
+			if ((error as NodeJS.ErrnoException).code !== "ENOENT") console.error(`Failed to claim async control request '${file}':`, error);
+			continue;
+		}
+		try {
+			if (fs.statSync(claimed).size > 64 * 1024) throw new Error("control request exceeds 64 KiB");
+			const request = JSON.parse(fs.readFileSync(claimed, "utf-8")) as Partial<AsyncControlRequest>;
+			if (!request || (request.action !== "interrupt" && request.action !== "cancel" && request.action !== "extend") || request.runId !== runId || typeof request.requestId !== "string" || !request.requestId) continue;
+			if (request.index !== undefined && (!Number.isSafeInteger(request.index) || request.index < 0)) continue;
+			if (request.action === "extend" && (typeof request.extendMs !== "number" || !Number.isSafeInteger(request.extendMs) || request.extendMs <= 0 || request.index !== undefined)) continue;
+			requests.push(request as AsyncControlRequest);
+		} catch (error) {
+			console.error(`Failed to read async control request '${file}':`, error);
+		} finally {
+			fs.rmSync(claimed, { force: true });
+		}
+	}
+	return requests;
+}