@gavin-hu/my-pi-agent 0.11.2 → 0.11.4

package/extensions/wechat/status-screen.ts

@@ -3,19 +3,20 @@
  *
  * `connectionOf`, `statusView`, `statusLine`, and `statusBody` are pure, so the
  * wording, fields, and width safety are unit-tested; `StatusScreenComponent` is
- * the TUI mounted by `runPanel`. It is the control hub: every operator action
- * (login, new session, logout) is a key here, so the user never has to remember
- * a subcommand. It shows the live connection state and closes with an action so
- * the command can run it after the screen is gone and input focus is free.
+ * the TUI mounted by `runPanel`. It is the control hub: the global keys (login,
+ * new session, logout) close the screen and dispatch, while a focused peer row
+ * can be stopped, reset, or opened in `/wechat history` without leaving the
+ * screen.
  */
 
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import type { Component } from "@earendil-works/pi-tui";
+import { formatDuration, sanitizeLine } from "../../lib/format.ts";
 import { screenHint, type ScreenHint } from "../../lib/tui/chrome.ts";
 import { clip } from "../../lib/tui/columns.ts";
-import { isCloseKey } from "../../lib/tui/cursor.ts";
+import { formatRange, IdCursor, isCloseKey, navIntent } from "../../lib/tui/cursor.ts";
 import { SEPARATORS } from "../../lib/tui/glyphs.ts";
-import { keyValueRow } from "../../lib/tui/rows.ts";
+import { keyValueRow, listRow } from "../../lib/tui/rows.ts";
 import { titleRule } from "../../lib/tui/rules.ts";
 import { paint, type TuiRole } from "../../lib/tui/tokens.ts";
 import type { BridgeStatus } from "./bridge.ts";
@@ -23,10 +24,13 @@ import { peerLabel } from "./format.ts";
 import type { BotCredentials } from "./types.ts";
 
 /** User-facing connection word; the internal `BridgeState` stays running/stopped. */
-export type StatusConnection = "open" | "expired" | "closed";
+export type StatusConnection = "open" | "expired" | "paused" | "closed";
 
-/** What the status screen closed with: an action to dispatch, or `close`. */
-export type StatusAction = "close" | "login" | "new" | "logout";
+/**
+ * What the status screen closed with: a global action, a peer history request,
+ * or `close`.
+ */
+export type StatusAction = "close" | "login" | "new" | "logout" | { kind: "history"; peer: string } | { kind: "allow" };
 
 /** The facts the status screen and the one-line summary render. */
 export interface StatusView {
@@ -44,26 +48,36 @@ export interface StatusView {
 	refusedPeers: string[];
 	mediaDropped: number;
 	promptPending: boolean;
+	/** The waiting prompt's peer, title, and start time. */
+	prompt?: { peer: string; title: string; startedAt: number };
+	/** The clock the view was built with, for the prompt age. */
+	now?: number;
 }
 
 /** One peer's line in the control screen. */
 export interface PeerRow {
+	/** The raw peer id, so an action targets the right person; falls back to `label`. */
+	id?: string;
 	label: string;
 	status: "idle" | "queued" | "running";
 	queued: number;
 	runningMs?: number;
 }
 
-/** How many peer rows the screen lists before summarising the rest. */
+/** How many peer rows the screen lists before scrolling. */
 const MAX_PEER_ROWS = 5;
 
 /** The connection word for a bridge status, or `closed` when there is none. */
 export function connectionOf(status: BridgeStatus | undefined): StatusConnection {
-	return status?.open ? "open" : status?.expired ? "expired" : "closed";
+	return status?.paused ? "paused" : status?.open ? "open" : status?.expired ? "expired" : "closed";
 }
 
 /** Build the view from the stored account and the live bridge status. */
-export function statusView(account: BotCredentials | undefined, status: BridgeStatus | undefined): StatusView {
+export function statusView(
+	account: BotCredentials | undefined,
+	status: BridgeStatus | undefined,
+	now: number = Date.now(),
+): StatusView {
 	return {
 		bridge: status !== undefined,
 		account: account ? peerLabel(account.ilinkUserId) : undefined,
@@ -72,6 +86,7 @@ export function statusView(account: BotCredentials | undefined, status: BridgeSt
 		peers: status?.peerCount ?? 0,
 		queued: status?.queued ?? 0,
 		peerRows: (status?.peerStates ?? []).map((entry) => ({
+			id: entry.peer,
 			label: peerLabel(entry.peer),
 			status: entry.state.status,
 			queued: entry.state.queued,
@@ -81,6 +96,14 @@ export function statusView(account: BotCredentials | undefined, status: BridgeSt
 		refusedPeers: status?.refusedPeers ?? [],
 		mediaDropped: status?.mediaDropped ?? 0,
 		promptPending: status?.promptPending ?? false,
+		prompt: status?.prompt
+			? {
+					peer: sanitizeLine(peerLabel(status.prompt.peer)),
+					title: sanitizeLine(status.prompt.title),
+					startedAt: status.prompt.startedAt,
+				}
+			: undefined,
+		now,
 	};
 }
 
@@ -123,6 +146,8 @@ function connectionText(connection: StatusConnection): string {
 			return "open";
 		case "expired":
 			return "expired";
+		case "paused":
+			return "paused";
 		case "closed":
 			return "closed";
 	}
@@ -135,13 +160,21 @@ function connectionRole(connection: StatusConnection): TuiRole {
 			return "ok";
 		case "expired":
 			return "bad";
+		case "paused":
+			return "warn";
 		case "closed":
 			return "meta";
 	}
 }
 
+/** The peer focus passed into the body: which row is selected and which slice shows. */
+export interface PeerSelection {
+	selectedId?: string;
+	window?: { start: number; end: number };
+}
+
 /** Rows for the status screen body, each fitted to `width`. */
-export function statusBody(view: StatusView, theme: Theme, width: number): string[] {
+export function statusBody(view: StatusView, theme: Theme, width: number, selection?: PeerSelection): string[] {
 	const target = Math.max(1, width);
 	const lines = [
 		row(theme, target, "Account", view.account ?? "not logged in", view.account ? "label" : "meta"),
@@ -153,12 +186,20 @@ export function statusBody(view: StatusView, theme: Theme, width: number): strin
 		lines.push(row(theme, target, "Queued", String(view.queued), "meta"));
 		if (view.refused > 0) lines.push(row(theme, target, "Refused", refusedValue(view), "meta"));
 		if (view.mediaDropped > 0) lines.push(row(theme, target, "Media", `${view.mediaDropped} dropped`, "meta"));
-		if (view.promptPending) lines.push(row(theme, target, "Prompt", "waiting for a reply", "accent"));
-		lines.push(...peerLines(view.peerRows, theme, target));
+		if (view.prompt) {
+			const age = formatDuration(Math.max(0, (view.now ?? Date.now()) - view.prompt.startedAt));
+			lines.push(row(theme, target, "Prompt", `${view.prompt.peer} · ${view.prompt.title} · ${age}`, "accent"));
+		} else if (view.promptPending) {
+			lines.push(row(theme, target, "Prompt", "waiting for a reply", "accent"));
+		}
+		lines.push(...peerLines(view.peerRows, theme, target, selection));
 	}
 	if (view.connection === "expired") {
 		lines.push("");
 		lines.push(clip(`  ${paint(theme, "bad", "Session expired — press l to log in again.")}`, target));
+	} else if (view.connection === "paused") {
+		lines.push("");
+		lines.push(clip(`  ${paint(theme, "warn", "Paused — press p to resume polling.")}`, target));
 	} else if (view.connection === "closed" && view.account) {
 		lines.push("");
 		lines.push(clip(`  ${paint(theme, "meta", "Not connected — press l to log in again.")}`, target));
@@ -179,47 +220,100 @@ function peerValue(row: PeerRow): string {
 	return "idle";
 }
 
-/** One indented line per peer, capped, so the screen stays compact. */
-function peerLines(rows: PeerRow[], theme: Theme, width: number): string[] {
+/** One selectable line per peer, with a range row when the list is scrolled. */
+function peerLines(rows: PeerRow[], theme: Theme, width: number, selection?: PeerSelection): string[] {
 	if (rows.length === 0) return [];
-	const shown = rows.slice(0, MAX_PEER_ROWS);
-	const lines = [""];
-	for (const [index, entry] of shown.entries()) {
-		const value = peerValue(entry);
+	const start = selection?.window?.start ?? 0;
+	const end = selection?.window?.end ?? Math.min(rows.length, MAX_PEER_ROWS);
+	const shown = rows.slice(start, end);
+	const lines = ["", clip(`  ${paint(theme, "meta", "Conversations")}`, width)];
+	for (const entry of shown) {
+		const selected = selection?.selectedId !== undefined && (entry.id ?? entry.label) === selection.selectedId;
 		const role: TuiRole = entry.status === "running" ? "accent" : entry.status === "queued" ? "warn" : "meta";
-		lines.push(row(theme, width, index === 0 ? "Conversations" : "", value, role));
+		lines.push(
+			listRow(theme, width, {
+				indent: 2,
+				selected,
+				label: entry.label,
+				trailing: peerValue(entry),
+				trailingRole: role,
+			}),
+		);
 	}
-	if (rows.length > shown.length) {
+	if (selection?.window !== undefined) {
+		if (start > 0 || end < rows.length) {
+			lines.push(formatRange(theme, width, { start, end, total: rows.length }));
+		}
+	} else if (rows.length > shown.length) {
 		lines.push(clip(`  ${paint(theme, "meta", `+${rows.length - shown.length} more`)}`, width));
 	}
 	return lines;
 }
 
+/** The peer actions the screen can run without closing. */
+export interface StatusActions {
+	/** Stop the peer's running turn; returns the line to flash. */
+	stop(peer: string): string;
+	/** Start a fresh conversation for the peer; returns the line to flash. */
+	reset(peer: string): string;
+	/** Withdraw the waiting prompt; returns the line to flash. */
+	cancelPrompt(): string;
+	/** Pause or resume polling; async because it settles the poll loop first. */
+	togglePause(): string | Promise<string>;
+}
+
 export interface StatusScreenOptions {
 	theme: Theme;
 	/** Live view, re-read on every render so `r` shows the current state. */
 	view: () => StatusView;
 	/** Called once when the screen closes, with the chosen action. */
 	onClose: (action: StatusAction) => void;
+	/** In-place peer actions; absent makes `s`/`d` explain that they are unavailable. */
+	actions?: StatusActions;
 	/** Repaint after a state change. */
 	requestRender: () => void;
 }
 
 /** The `/wechat` control screen: live connection facts plus every action. */
 export class StatusScreenComponent implements Component {
+	private readonly cursor = new IdCursor();
+	private flash: string | undefined;
+
 	constructor(private readonly options: StatusScreenOptions) {}
 
-	private hints(): ScreenHint[] {
-		return [
-			"Esc close",
+	/**
+	 * The focused peer, or undefined when the list is empty. Not named `focused`:
+	 * the host duck-types focusables with `"focused" in component` and writes a
+	 * boolean there, which would shadow the method.
+	 */
+	private focusedPeer(view: StatusView): PeerRow | undefined {
+		const rows = view.peerRows;
+		if (rows.length === 0) return undefined;
+		return rows[this.cursor.indexOf(rows, (row) => row.id ?? row.label)];
+	}
+
+	private setFlash(message: string | undefined): void {
+		this.flash = message;
+		this.options.requestRender();
+	}
+
+	private hints(view: StatusView): ScreenHint[] {
+		const hints: ScreenHint[] = ["Esc close"];
+		if (view.peerRows.length > 0) {
+			hints.push("j/k move", { text: "s stop", color: "accent" }, { text: "d reset", color: "warning" }, "h history");
+		}
+		hints.push(
 			{ text: "l login", color: "accent" },
 			{ text: "n new", color: "accent" },
 			{ text: "o logout", color: "error" },
 			"r refresh",
-		];
+		);
+		return hints;
 	}
 
 	handleInput(data: string): void {
+		const view = this.options.view();
+		const peer = this.focusedPeer(view);
 		if (isCloseKey(data)) {
 			this.options.onClose("close");
 			return;
@@ -236,21 +330,118 @@ export class StatusScreenComponent implements Component {
 			this.options.onClose("logout");
 			return;
 		}
-		if (data === "r" || data === "R") this.options.requestRender();
+		if (data === "r" || data === "R") {
+			this.setFlash(undefined);
+			return;
+		}
+		if (data === "p" || data === "P") {
+			if (!view.bridge) {
+				this.setFlash("WeChat is not running.");
+				return;
+			}
+			const outcome = this.options.actions?.togglePause();
+			if (!outcome) {
+				this.setFlash("Pause is unavailable here.");
+				return;
+			}
+			if (typeof outcome === "string") {
+				this.setFlash(outcome);
+				return;
+			}
+			this.setFlash(view.connection === "paused" ? "Resuming…" : "Pausing…");
+			void outcome.then(
+				(line) => this.setFlash(line),
+				() => this.setFlash("Pause action failed."),
+			);
+			return;
+		}
+		if (data === "a" || data === "A") {
+			this.options.onClose({ kind: "allow" });
+			return;
+		}
+		if (data === "c" || data === "C") {
+			if (!view.prompt) {
+				this.setFlash("No prompt waiting.");
+				return;
+			}
+			this.setFlash(this.options.actions?.cancelPrompt() ?? "Prompt cancel is unavailable.");
+			return;
+		}
+		if (data === "s" || data === "S" || data === "d" || data === "D" || data === "h" || data === "H") {
+			if (!peer) {
+				this.setFlash("No peer conversation yet.");
+				return;
+			}
+			const id = peer.id ?? peer.label;
+			if (data === "h" || data === "H") {
+				this.options.onClose({ kind: "history", peer: id });
+				return;
+			}
+			const actions = this.options.actions;
+			if (!actions) {
+				this.setFlash("Peer actions are unavailable here.");
+				return;
+			}
+			this.setFlash(data === "s" || data === "S" ? actions.stop(id) : actions.reset(id));
+			return;
+		}
+		const rows = view.peerRows;
+		const index = this.cursor.indexOf(rows, (row) => row.id ?? row.label);
+		switch (navIntent(data)) {
+			case "up":
+				this.select(index - 1, view);
+				return;
+			case "down":
+				this.select(index + 1, view);
+				return;
+			case "pageUp":
+				this.select(index - this.cursor.visible, view);
+				return;
+			case "pageDown":
+				this.select(index + this.cursor.visible, view);
+				return;
+			case "home":
+				this.select(0, view);
+				return;
+			case "end":
+				this.select(rows.length - 1, view);
+				return;
+		}
 	}
 
-	/** Stateless: every value is read live from `view()` on render. */
+	/** Focus the row at `index` and repaint when it moves. */
+	private select(index: number, view: StatusView): void {
+		const rows = view.peerRows;
+		if (rows.length === 0) return;
+		this.cursor.select(rows, (row) => row.id ?? row.label, index);
+		this.options.requestRender();
+	}
+
+	/** The cursor is plain state and the view is live, so there is nothing to invalidate. */
 	invalidate(): void {}
 
 	render(width: number): string[] {
 		const target = Math.max(1, width);
 		const theme = this.options.theme;
-		return [
+		const view = this.options.view();
+		const rows = view.peerRows;
+		this.cursor.visible = Math.min(MAX_PEER_ROWS, Math.max(1, rows.length));
+		this.cursor.clamp(rows, (row) => row.id ?? row.label);
+		const peer = this.focusedPeer(view);
+		if (rows.length > 0) this.cursor.ensureVisible(this.cursor.indexOf(rows, (row) => row.id ?? row.label));
+		const start = this.cursor.scroll;
+		const end = Math.min(rows.length, start + this.cursor.visible);
+		const selection: PeerSelection | undefined =
+			rows.length === 0
+				? undefined
+				: { selectedId: peer ? (peer.id ?? peer.label) : undefined, window: { start, end } };
+		const lines = [
 			titleRule(theme, target, `wechat${SEPARATORS.item}control`),
 			"",
-			...statusBody(this.options.view(), theme, target),
-			"",
-			screenHint(theme, target, this.hints()),
+			...statusBody(view, theme, target, selection),
 		];
+		if (this.flash) lines.push("", clip(`  ${paint(theme, "meta", this.flash)}`, target));
+		lines.push("", screenHint(theme, target, this.hints(view)));
+		return lines;
 	}
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gavin-hu/my-pi-agent",
-  "version": "0.11.2",
+  "version": "0.11.4",
   "description": "Personal Pi customizations, packaged as a Pi package: worktree isolation and rewind snapshots, question, todo, goal, plan, subagent, job, watch, web-access, file-browse, file-open, document, memory, wechat, and bytefly.",
   "keywords": [
     "pi-package",