@zhuxixi/pi-agent-board 0.5.2 → 0.6.0

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

@@ -24,6 +24,7 @@ import {
 	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";
@@ -266,7 +267,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 +802,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 +877,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 +885,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 +1128,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 ----------------------------------------------------------