@zhuxixi/pi-agent-board 0.5.2 → 0.6.1

package/src/ui/dashboard-decisions.mjs

@@ -0,0 +1,55 @@
+/**
+ * Dashboard decision helpers for host prewarm and attach prelude (issue #70 A14).
+ *
+ * Pure functions extracted from src/ui/dashboard.ts so the branching contract is
+ * node-testable without pi's TS loader (same pattern as commands/attach-decision.mjs).
+ * `hostActive` covers starting/alive/stopping claims from store.loadRow — pending
+ * claims count as an already-registered launch, so prewarm never re-spawns them.
+ */
+
+/**
+ * Prewarm decision for the selected row.
+ * - "mark-only": the row has an active host claim — mark it prewarmed WITHOUT
+ *   calling prewarmHost (a pending/starting claim is already a launch; the old
+ *   hostAlive guard re-checked it on every debounce tick).
+ * - "skip": busy row without a host claim — no prewarm, no mark.
+ * - "prewarm": no claim — call service.prewarmHost once; the caller marks only on ok.
+ * @param {{ hostActive?: boolean, agentBusy?: boolean }} row
+ * @returns {{ action: "mark-only" | "skip" | "prewarm" }}
+ */
+export function planPrewarm({ hostActive, agentBusy }) {
+	if (hostActive) return { action: "mark-only" };
+	if (agentBusy) return { action: "skip" };
+	return { action: "prewarm" };
+}
+
+/**
+ * Attach prelude for a dashboard row. A hostActive row attaches directly — the
+ * async resolver owns starting/stopping wait, so no interrupt confirmation is
+ * offered even when the row is busy. A busy row WITHOUT a host claim keeps the
+ * existing stopFirst confirm; everything else attaches directly.
+ * @param {{ hostActive?: boolean, agentBusy?: boolean }} row
+ * @returns {{ plan: "attach" | "confirm-stop-first" }}
+ */
+export function planDashboardAttach({ hostActive, agentBusy }) {
+	if (!hostActive && agentBusy) return { plan: "confirm-stop-first" };
+	return { plan: "attach" };
+}
+
+/**
+ * Map a service reply() result to the dashboard notice (issue #70: queued and
+ * sent are different outcomes — a queued reply is durable, not yet delivered).
+ * Result shapes from service.reply(): {ok:false,error} | {ok:true,queued:true}
+ * | {ok:true,sent:true} | {ok:true,hostMode,fallbackReason?}.
+ * @param {{ ok?: boolean, error?: string, queued?: boolean, sent?: boolean, hostMode?: string|null, fallbackReason?: string }} res
+ * @returns {{ level: "info" | "warn" | "error", text: string }}
+ */
+export function replyNotice(res) {
+	if (!res?.ok) return { level: "error", text: res?.error ?? "Reply failed" };
+	if (res.queued) return { level: "info", text: "Reply queued — will deliver when the host is ready" };
+	if (res.sent) return { level: "info", text: "Reply sent" };
+	if (res.hostMode === "json-runner") {
+		return { level: "warn", text: `Reply sent with non-live fallback: ${res.fallbackReason ?? "PTY unavailable"}` };
+	}
+	return { level: "info", text: "Reply sent" };
+}

package/src/ui/dashboard.ts

@@ -18,12 +18,14 @@ import {
 	clampThinkingLevel,
 	listDirectorySuggestions,
 	existingCwdCandidates,
+	modelRefAvailable,
 	nextCwdPickerState,
 	resolveDirectoryValue,
 	resolveLaunchContext,
 	supportedThinkingLevels,
 } from "../core/launch-options.mjs";
 import { createPrewarmScheduler } from "../core/prewarm-schedule.mjs";
+import { planDashboardAttach, planPrewarm, replyNotice } from "./dashboard-decisions.mjs";
 import { ensureCwdStatsSeeded, rankedCwdCandidates, recordCwdLaunch } from "../core/cwd-stats.mjs";
 import { filterRows, groupRowsByFolder, rowState, stateGlyph } from "../core/rows.mjs";
 import { loadSessionView } from "../core/session-view.mjs";
@@ -142,6 +144,15 @@ export class DashboardComponent implements Component {
 	private inputNotice: InputNotice | null = null;
 	private launch: LaunchState | null = null;
 	private lastLaunchPrefs: { cwd: string | null; model: string | null; thinkingLevel: ThinkingLevel | null } | null = null;
+	/** First frame after mount must clear the screen: pi-tui's first render
+	 *  "assumes clean screen" (fullRender(false)) and overlays never get
+	 *  clearOnShrink — crash output / dirty bottoms would persist (issue #88). */
+	private needsFullClear = true;
+	/** Content line count of the previous frame BEFORE spacer/padding fill
+	 *  (padding always fills the terminal height, so padded counts never
+	 *  shrink — shrink detection must run on pre-fill counts). */
+	private lastContentLineCount: number | null = null;
+	private frameContentLineCount = 0;
 	private readonly editor: CustomEditor;
 
 	constructor(
@@ -266,7 +277,16 @@ export class DashboardComponent implements Component {
 		const id = this.selectedId;
 		if (!id || id === this.prewarmedId) return;
 		const row = this.selectedRow();
-		if (!row || row.hostAlive || isAgentBusy(row)) return;
+		if (!row) return;
+		// hostActive claims (starting/alive/stopping) already have a launch — mark
+		// them prewarmed without another service call; a pending claim is not a
+		// failure to retry on every debounce tick (issue #70 A14).
+		const decision = planPrewarm({ hostActive: row.hostActive, agentBusy: isAgentBusy(row) });
+		if (decision.action === "skip") return;
+		if (decision.action === "mark-only") {
+			this.prewarmedId = id;
+			return;
+		}
 		const res = this.deps.service.prewarmHost?.(id);
 		if (res?.ok) this.prewarmedId = id;
 	}
@@ -792,7 +812,8 @@ export class DashboardComponent implements Component {
 			case "rename":
 				return this.submitRename();
 			case "reply":
-				return this.submitReply();
+				void this.submitReply();
+				return;
 			case "list":
 			case "dispatch":
 				return this.input.trim() ? this.openLaunchDialog() : this.attachSelected();
@@ -866,7 +887,7 @@ export class DashboardComponent implements Component {
 		this.refresh();
 	}
 
-	private submitReply(): void {
+	private async submitReply(): Promise<void> {
 		const text = this.input.trim();
 		const row = this.selectedRow();
 		if (!text || !row) {
@@ -874,10 +895,11 @@ export class DashboardComponent implements Component {
 			this.setInput("");
 			return;
 		}
-		const res = this.deps.service.reply(row.meta.id, text);
-		if (!res.ok) this.notice(res.error ?? "Reply failed", "error");
-		else if (res.hostMode === "json-runner") this.notice(`Reply sent with non-live fallback: ${res.fallbackReason ?? "PTY unavailable"}`, "warn");
-		else this.notice("Reply sent", "info");
+		// reply() is async since issue #70 A13 (ack-gated host delivery); the
+		// result (sent vs queued) only shapes the notice.
+		const res = await this.deps.service.reply(row.meta.id, text);
+		const notice = replyNotice(res);
+		this.notice(notice.text, notice.level);
 		this.setInput("");
 		this.mode = "peek";
 		this.inputNotice = null;
@@ -1116,17 +1138,19 @@ export class DashboardComponent implements Component {
 	}
 
 	private requestAttach(row: Row): void {
-		if (row.hostAlive) {
-			this.done({ action: "attach", viewId: row.meta.id, stopFirst: false });
-		} else if (isAgentBusy(row)) {
+		// hostActive rows (starting/alive/stopping) attach directly — the async
+		// resolver owns the starting/stopping wait, so no interrupt confirm even
+		// when the row is busy (issue #70 A14).
+		const plan = planDashboardAttach({ hostActive: row.hostActive, agentBusy: isAgentBusy(row) });
+		if (plan.plan === "confirm-stop-first") {
 			this.pending = {
 				prompt: `"${row.meta.name}" is running. Interrupt and attach? (y/N)`,
 				onYes: () => this.done({ action: "attach", viewId: row.meta.id, stopFirst: true }),
 			};
 			this.mode = "confirm";
-		} else {
-			this.done({ action: "attach", viewId: row.meta.id, stopFirst: false });
+			return;
 		}
+		this.done({ action: "attach", viewId: row.meta.id, stopFirst: false });
 	}
 
 	// ---- rendering ----------------------------------------------------------
@@ -1141,6 +1165,28 @@ export class DashboardComponent implements Component {
 	}
 
 	render(width: number): string[] {
+		const lines = this.renderLines(width);
+		// Self-heal frames (issue #88): pi-tui disables clearOnShrink while an
+		// overlay is active ("overlays need the padding"), so a content shrink
+		// under the dashboard overlay would leave stale rows forever. Force a
+		// full clear on the first frame and on any content-line shrink.
+		// The force MUST be deferred past the active doRender pass: calling
+		// requestRender(true) synchronously here resets pi-tui's diff state
+		// mid-frame (previousLines=[], previousWidth=-1), making the CURRENT frame
+		// take the first-render no-clear branch, after which the deferred re-render
+		// diffs identical content — nothing is ever cleared (issue #88 CR r1).
+		// Deferred to nextTick, the reset lands between frames: the next doRender
+		// sees previousWidth=-1 ≠ width → widthChanged → fullRender(true), a real
+		// clear wrapped in DECSET 2026 synchronized output by pi-tui itself.
+		if (this.needsFullClear || (this.lastContentLineCount != null && this.frameContentLineCount < this.lastContentLineCount)) {
+			this.needsFullClear = false;
+			process.nextTick(() => this.tui.requestRender(true));
+		}
+		this.lastContentLineCount = this.frameContentLineCount;
+		return lines;
+	}
+
+	private renderLines(width: number): string[] {
 		const allRows = this.deps.service.rows();
 		const needs = allRows.filter((r) => r.state?.semanticState === "needs_input").length;
 		const working = allRows.filter((r) => r.state?.semanticState === "working").length;
@@ -1170,6 +1216,12 @@ export class DashboardComponent implements Component {
 		const body = this.renderRows(width);
 		const windowed = this.windowBody(body, capacity);
 		lines.push(...windowed.lines);
+		// Shrink-detection count: recorded BEFORE the spacer fill — the spacer
+		// pads the frame back out to the terminal height, so the padded (or
+		// pre-fitToHeight-padding) total never shrinks and would mask row
+		// removals, the exact ghosting trigger (issue #88). Non-list modes
+		// return earlier and intentionally don't record.
+		this.frameContentLineCount = lines.length;
 		// Keep the compose box visually docked to the bottom instead of glued to the
 		// final session row. This matches the Claude-style layout: list at top,
 		// large calm workspace, input/footer at bottom.
@@ -1724,7 +1776,9 @@ function filterLaunchChoices(choices: LaunchChoice[], query: string): LaunchChoi
 function findLaunchModelByRef(models: LaunchModel[], ref: string): LaunchModel | null {
 	const target = String(ref || "").trim().toLowerCase();
 	if (!target) return null;
-	return models.find((model) => `${model.provider}/${model.id}`.toLowerCase() === target) ?? null;
+	// Single source of truth with the service-side stale-model guard (issue #90):
+	// same case-insensitive exact "provider/id" rule.
+	return models.find((model) => modelRefAvailable(target, [model])) ?? null;
 }
 
 function stripBracketedPaste(data: string): string {

package/src/ui/pty-attach.ts

@@ -244,6 +244,16 @@ export class PtyAttachComponent implements Component {
 			this.send({ type: "input", data });
 			return;
 		}
+		if (matchesKey(data, Key.ctrl("left"))) {
+			// Explicit detach chord (issue #89): single ← is gated on editor state
+			// (it doubles as cursor-left inside a non-empty draft), so a user with
+			// a draft had no way out short of Ctrl+C/D, which kills the child Pi.
+			// Ctrl+← is unambiguous intent — detach unconditionally, regardless of
+			// editor state or socket liveness (same always-exitable guarantee as
+			// the disconnected-← escape, issue #48).
+			this.detach();
+			return;
+		}
 		if (matchesKey(data, Key.left)) {
 			// While the socket is down the key can never reach the child, so
 			// escape unconditionally — the view must always be exitable, even
@@ -279,7 +289,7 @@ export class PtyAttachComponent implements Component {
 		}
 		const header =
 			this.theme.fg("accent", this.theme.bold(` ${this.opts.title} `)) +
-			this.theme.fg("muted", `${this.status} · click opens links · dblclick/drag selects+copies · ← detach`);
+			this.theme.fg("muted", `${this.status} · click opens links · dblclick/drag selects+copies · ←/Ctrl+← detach`);
 		return [clip(header, width), ...body.map((l) => clipTerminalLine(l, width)), this.theme.fg("dim", "─".repeat(width))];
 	}
 
@@ -295,7 +305,7 @@ export class PtyAttachComponent implements Component {
 		out.push(center(this.theme.fg("accent", this.theme.bold(title)), width));
 		out.push(center(this.theme.fg("muted", detail), width));
 		out.push("");
-		out.push(center(this.theme.fg("dim", "← to detach"), width));
+		out.push(center(this.theme.fg("dim", "←/Ctrl+← to detach"), width));
 		while (out.length < height) out.push("");
 		return out.slice(0, height);
 	}
@@ -1150,16 +1160,24 @@ function asciiCellsForBufferLine(line: BufferLineLike, reusable: BufferCellLike)
 function openExternalTarget(target: string): boolean {
 	const sanitized = sanitizeOscPayload(target).trim();
 	if (!sanitized) return false;
+	// Opening the target is best-effort: an async spawn failure (e.g. xdg-open
+	// missing on a minimal server) must be swallowed, not crash the host (issue #86).
 	try {
 		if (process.platform === "darwin") {
-			spawn("open", [sanitized], { detached: true, stdio: "ignore" }).unref();
+			const child = spawn("open", [sanitized], { detached: true, stdio: "ignore" });
+			child.on("error", () => {});
+			child.unref();
 			return true;
 		}
 		if (process.platform === "win32") {
-			spawn("cmd", ["/c", "start", "", sanitized], { detached: true, stdio: "ignore" }).unref();
+			const child = spawn("cmd", ["/c", "start", "", sanitized], { detached: true, stdio: "ignore" });
+			child.on("error", () => {});
+			child.unref();
 			return true;
 		}
-		spawn("xdg-open", [sanitized], { detached: true, stdio: "ignore" }).unref();
+		const child = spawn("xdg-open", [sanitized], { detached: true, stdio: "ignore" });
+		child.on("error", () => {});
+		child.unref();
 		return true;
 	} catch {
 		return false;