@huseynsnmz/pi-board 0.14.0 → 0.15.3

package/src/ui/double-left.ts

@@ -1,36 +1,30 @@
-/** Left arrow twice on an empty prompt opens the board. */
+/** Left arrow twice on an empty prompt puts this session on the board and opens it. */
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { isKeyRelease, Key, matchesKey } from "@earendil-works/pi-tui";
 import { createDoublePress } from "../core/double-press.mjs";
-
-const WIDGET = "agent-board-double-left";
-
-type Editorish = { getExpandedText?: () => string };
+import { watchFocus } from "./focus.ts";
 
 export function watchDoubleLeft(ctx: ExtensionContext): () => void {
-	// Only a widget is handed the TUI, and only the TUI knows what has focus: without this check,
-	// the Enter below could answer a dialog that's on screen.
-	let focused: () => unknown = () => null;
-	ctx.ui.setWidget(WIDGET, (tui) => {
-		// Newer than some versions of Pi this may load in. Without it, double left does nothing.
-		focused = () => (tui as unknown as { getFocusedComponent?: () => unknown }).getFocusedComponent?.();
-		return { render: () => [], invalidate() {} };
-	});
+	const focus = watchFocus(ctx, "agent-board-double-left");
 	const presses = createDoublePress();
 	const stop = ctx.ui.onTerminalInput((data) => {
 		if (isKeyRelease(data)) return undefined;
-		const editor = focused() as Editorish | null | undefined;
-		if (!matchesKey(data, Key.left) || editor?.getExpandedText?.() !== "") {
+		// Checked first: the Enter below could otherwise answer a dialog that's on screen.
+		if (!matchesKey(data, Key.left) || focus.promptText() !== "") {
 			presses.reset();
 			return undefined;
 		}
 		if (!presses.press()) return undefined;
 		// A command runs with more than a key handler is given, so this goes the way a typed one does.
-		ctx.ui.setEditorText("/agent-board");
+		ctx.ui.setEditorText("/bg");
 		return { data: "\r" };
 	});
 	return () => {
-		stop();
-		ctx.ui.setWidget(WIDGET, undefined);
+		try {
+			stop();
+		} catch {
+			/* see focus.stop */
+		}
+		focus.stop();
 	};
 }

package/src/ui/external-editor.ts

@@ -0,0 +1,25 @@
+/** Ctrl+G: write the task in $VISUAL or $EDITOR. */
+import { spawn } from "node:child_process";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+/** The edited text, or undefined if no editor is set or it didn't finish cleanly. */
+export async function editExternally(text: string, env = process.env): Promise<string | undefined> {
+	const command = env.VISUAL || env.EDITOR;
+	if (!command) return undefined;
+	const dir = mkdtempSync(join(tmpdir(), "pi-board-editor-"));
+	const file = join(dir, "task.md");
+	try {
+		writeFileSync(file, text);
+		const [program, ...args] = command.split(" ");
+		const code = await new Promise<number | null>((resolve) => {
+			const child = spawn(program!, [...args, file], { stdio: "inherit" });
+			child.on("error", () => resolve(null));
+			child.on("close", (exit) => resolve(exit));
+		});
+		return code === 0 ? readFileSync(file, "utf8").replace(/\n$/, "") : undefined;
+	} finally {
+		rmSync(dir, { recursive: true, force: true });
+	}
+}

package/src/ui/focus.ts

@@ -0,0 +1,32 @@
+/** What has the keyboard, which only the TUI knows, and only a widget is handed the TUI. */
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+type Editorish = { getExpandedText?: () => string };
+
+export interface Focus {
+	/** The prompt's text if it has the keyboard, or undefined if something else does. */
+	promptText(): string | undefined;
+	/** Whether anything is known about what has the keyboard, on this version of Pi. */
+	known(): boolean;
+	stop(): void;
+}
+
+export function watchFocus(ctx: ExtensionContext, widget: string): Focus {
+	let focused: (() => unknown) | null = null;
+	ctx.ui.setWidget(widget, (tui) => {
+		const reader = tui as unknown as { getFocusedComponent?: () => unknown };
+		if (reader.getFocusedComponent) focused = () => reader.getFocusedComponent?.();
+		return { render: () => [], invalidate() {} };
+	});
+	return {
+		promptText: () => (focused?.() as Editorish | null | undefined)?.getExpandedText?.(),
+		known: () => focused !== null,
+		stop: () => {
+			try {
+				ctx.ui.setWidget(widget, undefined);
+			} catch {
+				/* the session it belonged to has already gone, and its widget with it */
+			}
+		},
+	};
+}

package/src/ui/waiting.ts

@@ -0,0 +1,30 @@
+/**
+ * Tells the board when a session is waiting on you. A permission prompt or any other dialog takes
+ * the keyboard from the prompt while a run is under way, whichever extension opened it.
+ */
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { watchFocus } from "./focus.ts";
+
+const CHECK_MS = 500;
+
+export function watchWaiting(ctx: ExtensionContext, changed: (waiting: boolean) => void): () => void {
+	const focus = watchFocus(ctx, "agent-board-waiting");
+	let waiting = false;
+	const timer = setInterval(() => {
+		try {
+			const now = focus.known() && !ctx.isIdle() && focus.promptText() === undefined;
+			if (now === waiting) return;
+			waiting = now;
+			// If the run has ended too, its own end has already said so, and this would undo that.
+			if (now || !ctx.isIdle()) changed(now);
+		} catch {
+			// The session was replaced before this could be stopped. An error here would end Pi.
+			clearInterval(timer);
+		}
+	}, CHECK_MS);
+	timer.unref?.();
+	return () => {
+		clearInterval(timer);
+		focus.stop();
+	};
+}

package/scripts/patch-vulns.mjs

@@ -1,59 +0,0 @@
-#!/usr/bin/env node
-/**
- * postinstall: patch vulnerable transitive dependencies that are locked behind
- * @earendil-works/pi-coding-agent's npm-shrinkwrap.json (which prevents npm
- * "overrides" from taking effect).
- *
- * Vulnerabilities patched:
- * - brace-expansion <=5.0.7 → 5.0.8 (GHSA-3jxr-9vmj-r5cp, GHSA-mh99-v99m-4gvg)
- * - protobufjs 7.5.0–7.6.4 → 7.6.5 (GHSA-j3f2-48v5-ccww)
- */
-import { execSync } from "node:child_process";
-import { existsSync, rmSync, mkdirSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const root = join(dirname(fileURLToPath(import.meta.url)), "..");
-const nested = join(
-  root,
-  "node_modules",
-  "@earendil-works",
-  "pi-coding-agent",
-  "node_modules",
-);
-
-const patches = [
-  { name: "brace-expansion", version: "5.0.8" },
-  { name: "protobufjs", version: "7.6.5" },
-];
-
-for (const { name, version } of patches) {
-  const target = join(nested, name);
-  if (!existsSync(target)) {
-    console.log(`[patch-vulns] ${name} not found nested, skipping`);
-    continue;
-  }
-
-  console.log(`[patch-vulns] patching ${name} → ${version}`);
-  rmSync(target, { recursive: true, force: true });
-  mkdirSync(target, { recursive: true });
-
-  // Install the patched version into a temp dir, then move it into place
-  const tmp = join(root, `.patch-tmp-${name}`);
-  rmSync(tmp, { recursive: true, force: true });
-  mkdirSync(tmp, { recursive: true });
-
-  try {
-    execSync(`npm install ${name}@${version} --prefix "${tmp}" --ignore-scripts`, {
-      stdio: "pipe",
-      cwd: root,
-    });
-    const installed = join(tmp, "node_modules", name);
-    rmSync(target, { recursive: true, force: true });
-    execSync(`mv "${installed}" "${target}"`);
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
-}
-
-console.log("[patch-vulns] done");