pi-freeflow 1.4.12 → 1.6.0

package/src/commands.ts

@@ -4,17 +4,15 @@
  * log viewing, debug level configuration, and live catalog refreshing.
  */
 
-import { spawn } from "node:child_process";
-import { readFileSync } from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { refreshCatalog, setAliveCatalog } from "./catalog.ts";
-import { DEBUG_STATE_FILE, DEFAULT_RELAY_URL, LOG_FILE } from "./config.ts";
-import {
-	compareVersions,
-	fetchLatestVersion,
-	getCachedUpdate,
-	isLinkedInstall,
+import { spawn } from "node:child_process";
+import { refreshCatalog, setAliveCatalog } from "./catalog.ts";
+import { DEBUG_STATE_FILE, LOG_FILE, RELAY_STATE_FILE } from "./config.ts";
+import {
+	compareVersions,
+	fetchLatestVersion,
+	getCachedUpdate,
+	isLinkedInstall,
+	getLocalVersion,
 } from "./update-checker.ts";
 import {
 	deployCloudflareWorker,
@@ -30,18 +28,21 @@ import {
 	readRecentLogs,
 	saveDebugState,
 } from "./logger.ts";
+import { probeRelay } from "./probe.ts";
 import {
 	ensureRelay,
 	findRelay,
 	getActiveRelayState,
 	getRelayHealth,
-	isRelayHealthy,
 	removeRelay,
-	saveRelayState,
 	setActiveRelayState,
 	setRelayLabel,
 	setStatusUi,
 	shortRelayLabel,
+	withRelayState,
+	formatRelayFlash,
+	formatRelayPickerItem,
+	formatRelayStatusLabel,
 } from "./relay-state.ts";
 import type {
 	ExtensionAPI,
@@ -59,81 +60,98 @@ import type {
  */
 export function updateStatusBar(ui?: ExtensionUIContext): void {
 	if (!ui) return;
-	const relayState = getActiveRelayState();
-	if (relayState.enabled && relayState.relays.length > 0) {
-		const label = shortRelayLabel(relayState.url);
-		const idx = Math.max(
-			1,
-			relayState.relays.findIndex((r) => r.url === relayState.url) + 1,
-		);
-		const total = relayState.relays.length;
-		const modeLabel = relayState.mode === "on" ? "ON" : "AUTO (ON)";
-		ui.setStatus("freeflow", `relay: ${modeLabel} | ${label} ${idx}/${total}`);
-	} else if (relayState.mode === "off" || !relayState.enabled) {
-		ui.setStatus("freeflow", "relay: OFF (direct)");
-	} else {
-		ui.setStatus("freeflow", undefined);
+	ui.setStatus("freeflow", formatRelayStatusLabel(getActiveRelayState()) ?? undefined);
+}
+
+function spawnWithProgress(
+	cmd: string,
+	args: string[],
+	ctx: ExtensionContext,
+): Promise<number> {
+	return new Promise((resolve) => {
+		try {
+			const child = spawn(cmd, args, {
+				shell: process.platform === "win32",
+				stdio: "pipe",
+			});
+			child.stdout?.on("data", (d: Buffer) => {
+				const s = String(d).trim();
+				if (s) ctx.ui.notify(s, "info");
+			});
+			child.stderr?.on("data", (d: Buffer) => {
+				const s = String(d).trim();
+				if (s) ctx.ui.notify(s, "info");
+			});
+			child.on("error", (err: Error) => {
+				ctx.ui.notify(`spawn ${cmd} failed: ${err.message}`, "warning");
+				resolve(1);
+			});
+			child.on("close", (code: number | null) => resolve(code ?? 0));
+		} catch (e) {
+			ctx.ui.notify(`spawn ${cmd} failed: ${(e as Error).message}`, "warning");
+			resolve(1);
+		}
+	});
+}
+
+/**
+ * Follow-mode log poller: tracks the count of matched lines already printed
+ * and notifies only lines beyond it, so repeated ticks never re-notify the
+ * same tail. One poller at a time — a re-run clears the previous interval.
+ */
+let logsFollowTimer: NodeJS.Timeout | null = null;
+function startLogsFollow(
+	ctx: ExtensionContext,
+	filterLevel: LogLevel | null,
+	filterReqId: string | null,
+	count: number,
+	filterText: string | null,
+	baselineMatched: number,
+): void {
+	if (logsFollowTimer) {
+		clearInterval(logsFollowTimer);
+		logsFollowTimer = null;
 	}
+	let lastPrinted = baselineMatched;
+	logsFollowTimer = setInterval(() => {
+		try {
+			const tail = readRecentLogs(filterLevel, filterReqId, count, filterText);
+			if (tail.totalMatched < lastPrinted) {
+				// Log rotated/rewritten below the baseline — re-baseline silently.
+				lastPrinted = tail.totalMatched;
+				return;
+			}
+			const newCount = tail.totalMatched - lastPrinted;
+			if (newCount <= 0) return;
+			const newLines = tail.lines.slice(
+				tail.lines.length - Math.min(newCount, tail.lines.length),
+			);
+			if (newLines.length > 0) {
+				ctx.ui.notify(newLines.join("\n"), "info");
+			}
+			lastPrinted = tail.totalMatched;
+		} catch {}
+	}, 1000);
+	// @ts-ignore allow unref to not block process exit in CLI
+	logsFollowTimer.unref?.();
 }
 
-function getLocalVersion(): string {
-	try {
-		const thisDir = path.dirname(fileURLToPath(import.meta.url));
-		const pkgPath = path.join(thisDir, "..", "package.json");
-		const raw = readFileSync(pkgPath, "utf8");
-		const pkg = JSON.parse(raw) as { version?: string };
-		if (typeof pkg.version === "string" && pkg.version.trim().length > 0) {
-			return pkg.version.trim();
-		}
-		return "0.0.0";
-	} catch {
-		return "0.0.0";
-	}
-}
-
-function spawnWithProgress(
-	cmd: string,
-	args: string[],
-	ctx: ExtensionContext,
-): Promise<number> {
-	return new Promise((resolve) => {
-		try {
-			const child = spawn(cmd, args, {
-				shell: process.platform === "win32",
-				stdio: "pipe",
-			});
-			child.stdout?.on("data", (d: Buffer) => {
-				const s = String(d).trim();
-				if (s) ctx.ui.notify(s, "info");
-			});
-			child.stderr?.on("data", (d: Buffer) => {
-				const s = String(d).trim();
-				if (s) ctx.ui.notify(s, "info");
-			});
-			child.on("error", (err: Error) => {
-				ctx.ui.notify(`spawn ${cmd} failed: ${err.message}`, "warning");
-				resolve(1);
-			});
-			child.on("close", (code: number | null) => resolve(code ?? 0));
-		} catch (e) {
-			ctx.ui.notify(`spawn ${cmd} failed: ${(e as Error).message}`, "warning");
-			resolve(1);
-		}
-	});
-}
-
 export function createCommandSpec(
 	_pi: ExtensionAPI,
 	onCatalogRefreshed?: (models: RegisteredModel[]) => void,
 ): Omit<RegisteredCommand, "name"> {
 	return {
 		description:
-			"Relay egress: auto | on | off | status | add <URL> [name] | list | use <URL|name|index> [name] | label <target> <name> | remove <target> | logs [level] [n] | debug on|off | refresh | update | deploy vercel | deploy cloudflare | deploy deno",
+			"Relay egress: auto | on | off | hide | show | widget hide/show | status | add <URL> [name] | list | use <URL|name|index> [name] | label <target> <name> | remove <target> | test <target> | logs [level] [n] | debug on|off | refresh | update | deploy vercel | deploy cloudflare | deploy deno",
 		getArgumentCompletions: (prefix: string) =>
 			[
 				"auto",
 				"on",
 				"off",
+				"hide",
+				"show",
+				"widget hide",
+				"widget show",
 				"status",
 				"add",
 				"list",
@@ -141,6 +159,7 @@ export function createCommandSpec(
 				"label",
 				"rename",
 				"remove",
+				"test",
 				"url",
 				"deploy",
 				"deploy vercel",
@@ -160,39 +179,40 @@ export function createCommandSpec(
 				.split(/\s+/);
 			const sub = parts[0] || "";
 			const rest = parts.slice(1).join(" ");
-			const relayState = getActiveRelayState();
+			let relayState = getActiveRelayState();
 
 			const flash = () => {
-				const activeLabel = shortRelayLabel(relayState.url, relayState.relays);
-				const activeIdx = Math.max(
-					1,
-					relayState.relays.findIndex((r) => r.url === relayState.url) + 1,
-				);
-				const total = relayState.relays.length || 1;
-				const modeStr = (relayState.mode || "auto").toUpperCase();
-				ctx.ui.notify(
-					`Relay mode: ${modeStr} (${relayState.enabled ? "ON" : "OFF"})${relayState.enabled ? ` → ${activeLabel} (${activeIdx}/${total})` : " (direct)"} | saved=${relayState.relays.length} (auto-fallback rolling)`,
-					"info",
-				);
+				ctx.ui.notify(formatRelayFlash(relayState), "info");
 			};
 
+			// UI refresh only — every disk write flows through CAS
+			// (withRelayState) so the operation is re-applied to the freshest
+			// on-disk state at write time instead of a stale snapshot.
 			const persist = () => {
-				setActiveRelayState(relayState, true);
 				setStatusUi(ctx.ui);
 				updateStatusBar(ctx.ui);
 			};
+			/** Re-apply an operation to the freshest on-disk state and persist it. */
+			const applyRelayState = (
+				updater: (s: RelayState) => RelayState,
+			): RelayState => {
+				relayState = withRelayState(updater);
+				return relayState;
+			};
 			const setRelay = (
 				enabled: boolean,
 				url: string,
 				addLabel?: string,
 			) => {
-				relayState.enabled = enabled;
-				const cleanUrl = (url || "").trim() || DEFAULT_RELAY_URL;
-				relayState.url = cleanUrl;
-				if (cleanUrl) {
-					ensureRelay(relayState, cleanUrl, addLabel);
-				}
-				setActiveRelayState(relayState);
+				applyRelayState((s) => {
+					s.enabled = enabled;
+					const cleanUrl = (url || "").trim() || "";
+					s.url = cleanUrl;
+					if (cleanUrl) {
+						ensureRelay(s, cleanUrl, addLabel);
+					}
+					return s;
+				});
 			};
 
 			const addRelayInteractive = async () => {
@@ -214,12 +234,16 @@ export function createCommandSpec(
 					)
 				)?.trim() || defaultLabel;
 
-				const added = ensureRelay(relayState, inputUrl, inputLabel);
-				setRelay(true, added.url, added.label);
+				applyRelayState((s) => {
+					const added = ensureRelay(s, inputUrl, inputLabel);
+					s.enabled = true;
+					s.url = added.url;
+					return s;
+				});
 				persist();
 				flash();
 				ctx.ui.notify(
-					`✓ Added & activated relay [${added.label || shortRelayLabel(added.url)}]: ${added.url}`,
+					`✓ Added & activated relay [${shortRelayLabel(relayState.url, relayState.relays)}]: ${relayState.url}`,
 					"info",
 				);
 			};
@@ -248,7 +272,10 @@ export function createCommandSpec(
 					ctx.ui.notify("Cancelled — short name not changed", "warning");
 					return;
 				}
-				setRelayLabel(relayState, match.url, newLabel);
+				applyRelayState((s) => {
+					setRelayLabel(s, match.url, newLabel);
+					return s;
+				});
 				persist();
 				flash();
 				ctx.ui.notify(
@@ -257,6 +284,12 @@ export function createCommandSpec(
 				);
 			};
 
+			const DEPLOY_OPTIONS: Record<string, DeployPlatform> = {
+				"Vercel (1M req/mo — recommended)": "vercel",
+				"Cloudflare (100k req/day)": "cloudflare",
+				"Deno Deploy (100k req/day)": "deno",
+			};
+
 			const parseDeployPlatform = (raw?: string): DeployPlatform | null => {
 				const v = (raw || "").trim().toLowerCase();
 				if (!v || v === "vercel") return "vercel";
@@ -273,6 +306,13 @@ export function createCommandSpec(
 						: platform === "deno"
 							? "Deno Deploy"
 							: "Vercel";
+				const tokenHint =
+					platform === "cloudflare"
+						? "Cloudflare relay — token: dash.cloudflare.com → API Tokens (Workers Scripts: Edit)"
+						: platform === "deno"
+							? "Deno Deploy relay — token: dash.deno.com → Access Tokens"
+							: "Vercel relay — token: vercel.com/account/tokens";
+				ctx.ui.notify(tokenHint, "info");
 				const token = (
 					await ctx.ui.input(`${label} API token:`, "")
 				)?.trim();
@@ -288,6 +328,17 @@ export function createCommandSpec(
 						)
 					)?.trim() || defaultName;
 
+				if (typeof ctx.ui.confirm === "function") {
+					const ok = await ctx.ui.confirm(
+						"Deploy relay",
+						`Deploy ${label} relay '${name}' using token ending ${token.slice(-4)}?`,
+					);
+					if (!ok) {
+						ctx.ui.notify("Deploy cancelled", "warning");
+						return;
+					}
+				}
+
 				ctx.ui.setStatus("freeflow", `deploying ${platform} relay…`);
 				try {
 					const deployer =
@@ -296,12 +347,26 @@ export function createCommandSpec(
 							: platform === "deno"
 								? deployDenoRelay
 								: deployVercelRelay;
-					const url = await deployer(token, name, (m) =>
+					const { url, auth } = await deployer(token, name, (m) =>
 						ctx.ui.notify(m, "info"),
 					);
 					setRelay(true, url, `deployed ${name}`);
+					// Persist the per-deployment shared secret with the relay entry
+					// (setRelay wrote without it; this save must include it).
+					const deployed = relayState.relays.find((r) => r.url === url);
+					if (deployed) deployed.auth = auth;
+					setActiveRelayState(relayState);
 					persist();
-					ctx.ui.notify(`✓ Deployed & active: ${url}`, "info");
+					let probeNote = "";
+					try {
+						const probe = await probeRelay(url, auth);
+						probeNote = probe.ok
+							? ` ✓ reachable (HTTP ${probe.status}, ${probe.latencyMs}ms)`
+							: ` ⚠ deployed but unreachable (${probe.error || `HTTP ${probe.status}`}) — verify with /freeflow test`;
+					} catch {
+						// probeRelay never throws, but keep the notify safe regardless
+					}
+					ctx.ui.notify(`✓ Deployed & active: ${url}${probeNote}`, "info");
 				} catch (e) {
 					updateStatusBar(ctx.ui);
 					ctx.ui.notify(
@@ -316,17 +381,19 @@ export function createCommandSpec(
 					ctx.ui.notify("No saved relays yet", "warning");
 					return;
 				}
-				const fmt = (r: KnownRelay, idx: number) => {
-					const isAct = r.url === relayState.url ? "★ " : "  ";
-					const lbl = r.label ? `[${r.label}] ` : `[${shortRelayLabel(r.url, relayState.relays)}] `;
-					return `${isAct}[${idx + 1}] ${lbl}→ ${r.url}`;
-				};
+				const fmt = (r: KnownRelay, idx: number) => formatRelayPickerItem(r, idx, relayState.url);
 				const opts = relayState.relays.map(fmt);
 				const choice = await ctx.ui.select("Switch active relay", opts);
 				if (!choice) return;
 				const match = relayState.relays.find((r, idx) => fmt(r, idx) === choice);
 				if (!match) return;
-				setRelay(true, match.url, match.label);
+				applyRelayState((s) => {
+					const fresh = s.relays.find((r) => r.url === match.url);
+					if (!fresh) return s;
+					s.enabled = true;
+					s.url = fresh.url;
+					return s;
+				});
 				persist();
 				flash();
 			};
@@ -345,8 +412,13 @@ export function createCommandSpec(
 					const remainingSec = isCooling ? Math.ceil((health.cooldownUntil - Date.now()) / 1000) : 0;
 					const healthBadge = isCooling
 						? ` ⚠️ [cooling ${remainingSec}s: ${health.lastStatus ? `HTTP ${health.lastStatus}` : "error"}]`
-						: " ✓";
-					return `${star} [${idx + 1}] ${paddedName} → ${r.url}${healthBadge}`;
+						: health?.lastLatencyMs != null && Number.isFinite(health.lastLatencyMs)
+							? ` ✓ [${health.lastLatencyMs}ms]`
+							: " ✓";
+					const counterText = health && (health.successCount != null || health.failureCount != null)
+						? ` ${health.successCount ?? 0} ok / ${health.failureCount ?? 0} fail`
+						: "";
+					return `${star} [${idx + 1}] ${paddedName} → ${r.url}${healthBadge}${counterText}`;
 				});
 				const activeLabel = shortRelayLabel(relayState.url, relayState.relays);
 				const activeIdx = Math.max(
@@ -369,10 +441,7 @@ export function createCommandSpec(
 					);
 					return;
 				}
-				const fmt = (r: KnownRelay, idx: number) => {
-					const lbl = r.label ? `[${r.label}] ` : `[${shortRelayLabel(r.url, relayState.relays)}] `;
-					return `[${idx + 1}] ${lbl}→ ${r.url}`;
-				};
+				const fmt = (r: KnownRelay, idx: number) => formatRelayPickerItem(r, idx);
 				const choice = await ctx.ui.select(
 					"Remove relay",
 					removable.map(fmt),
@@ -380,95 +449,137 @@ export function createCommandSpec(
 				if (!choice) return;
 				const match = removable.find((r, idx) => fmt(r, idx) === choice);
 				if (!match) return;
-				removeRelay(relayState, match.url);
+				applyRelayState((s) => {
+					removeRelay(s, match.url);
+					return s;
+				});
 				persist();
 				ctx.ui.notify(`Removed: [${shortRelayLabel(match.url, relayState.relays)}] ${match.url}`, "info");
 			};
 
 			if (sub === "auto") {
-				relayState.mode = "auto";
-				relayState.enabled = true;
-				setRelay(true, relayState.url || DEFAULT_RELAY_URL);
+				applyRelayState((s) => {
+					s.mode = "auto";
+					s.enabled = true;
+					s.url = s.url || "";
+					if (s.url) {
+						ensureRelay(s, s.url);
+					}
+					return s;
+				});
 				persist();
 				flash();
 			} else if (sub === "on") {
-				relayState.mode = "on";
-				setRelay(true, relayState.url || DEFAULT_RELAY_URL);
+				applyRelayState((s) => {
+					s.mode = "on";
+					s.enabled = true;
+					s.url = s.url || "";
+					if (s.url) {
+						ensureRelay(s, s.url);
+					}
+					return s;
+				});
 				persist();
 				flash();
 			} else if (sub === "off") {
-				relayState.mode = "off";
-				relayState.enabled = false;
-				setActiveRelayState(relayState);
+				applyRelayState((s) => {
+					s.mode = "off";
+					s.enabled = false;
+					return s;
+				});
+				persist();
+				flash();
+			} else if (sub === "hide" || (sub === "widget" && rest === "hide")) {
+				applyRelayState((s) => ({ ...s, hideWidget: true }));
+				persist();
+				updateStatusBar(ctx.ui);
+				ctx.ui.notify("Widget hidden — use /freeflow show or /freeflow widget show to restore", "info");
+			} else if (sub === "show" || (sub === "widget" && rest === "show")) {
+				applyRelayState((s) => ({ ...s, hideWidget: false }));
 				persist();
 				flash();
-			} else if (sub === "status") {
-				flash();
-				try {
-					const local = getLocalVersion();
-					let latest: string | null = null;
-					const cached = getCachedUpdate();
-					if (cached && typeof cached.latest === "string") {
-						latest = cached.latest;
-					}
-					if (latest && compareVersions(latest, local) > 0) {
-						ctx.ui.notify(
-							`Update available: ${local} -> ${latest} - run /freeflow update`,
-							"info",
-						);
-					}
-				} catch {
-					// swallow — status banner is best-effort
-				}
-			} else if (sub === "update") {
-				if (isLinkedInstall()) {
-					ctx.ui.notify(
-						"LINK install (D:/github_repo/pi-freeflow) is live - just omp restart, no npm update needed.",
-						"info",
-					);
-				} else {
-					try {
-						ctx.ui.notify("Checking for updates…", "info");
-						let latest: string | null = null;
-						try {
-							latest = await fetchLatestVersion();
-						} catch {
-							latest = null;
-						}
-						if (!latest) {
-							const cached = getCachedUpdate();
-							if (cached && typeof cached.latest === "string") {
-								latest = cached.latest;
-							}
-						}
-						if (!latest) {
-							ctx.ui.notify("Could not check latest version (offline?)", "warning");
-						} else {
-							const local = getLocalVersion();
-							const cmp = compareVersions(latest, local);
-							if (cmp <= 0) {
-								ctx.ui.notify(`Already on latest (v${local})`, "info");
-							} else {
-								ctx.ui.notify(`Update available: v${local} → v${latest} — updating…`, "info");
-								let code = await spawnWithProgress("omp", ["plugin", "update", "pi-freeflow"], ctx);
-								if (code !== 0) {
-									ctx.ui.notify(`omp update exited ${code}, trying npm…`, "info");
-									code = await spawnWithProgress("npm", ["i", "-g", "pi-freeflow@latest"], ctx);
-								}
-								if (code === 0) {
-									ctx.ui.notify(`Updated to ${latest}, restart OMP`, "info");
-								} else {
-									ctx.ui.notify(
-										`Update failed (exit ${code}) — try manually: npm i -g pi-freeflow@latest`,
-										"warning",
-									);
-								}
-							}
-						}
-					} catch (e) {
-						ctx.ui.notify(`Update failed: ${(e as Error).message} — try manually: npm i -g pi-freeflow@latest`, "warning");
-					}
-				}
+				ctx.ui.notify("Widget shown", "info");
+			} else if (sub === "status") {
+				flash();
+				try {
+					const local = getLocalVersion();
+					let latest: string | null = null;
+					const cached = getCachedUpdate();
+					if (cached && typeof cached.latest === "string") {
+						latest = cached.latest;
+					}
+					if (latest && compareVersions(latest, local) > 0) {
+						ctx.ui.notify(
+							`Update available: ${local} -> ${latest} - run /freeflow update`,
+							"info",
+						);
+					}
+				} catch {
+					// swallow — status banner is best-effort
+				}
+
+				const modeLine =
+					relayState.mode === "off"
+						? "Mode: off (always direct)"
+						: relayState.mode === "on"
+							? "Mode: on (always relay)"
+							: "Mode: auto (enabled on session, auto-rolls on 429/5xx)";
+				const poolLine = `${relayState.relays.length} relay(s)${
+					relayState.relays.length > 0
+						? ` | active: ${shortRelayLabel(relayState.url, relayState.relays)}`
+						: ""
+				}`;
+				const stateFileLine = `State file: ${RELAY_STATE_FILE}`;
+				ctx.ui.notify(`${modeLine} | ${poolLine}\n${stateFileLine}`, "info");
+			} else if (sub === "update") {
+				if (isLinkedInstall()) {
+					ctx.ui.notify(
+						"Linked install detected — restart your host app to pick up changes (no update needed).",
+						"info",
+					);
+				} else {
+					try {
+						ctx.ui.notify("Checking for updates…", "info");
+						let latest: string | null = null;
+						try {
+							latest = await fetchLatestVersion();
+						} catch {
+							latest = null;
+						}
+						if (!latest) {
+							const cached = getCachedUpdate();
+							if (cached && typeof cached.latest === "string") {
+								latest = cached.latest;
+							}
+						}
+						if (!latest) {
+							ctx.ui.notify("Could not check latest version (offline?)", "warning");
+						} else {
+							const local = getLocalVersion();
+							const cmp = compareVersions(latest, local);
+							if (cmp <= 0) {
+								ctx.ui.notify(`Already on latest (v${local})`, "info");
+							} else {
+								ctx.ui.notify(`Update available: v${local} → v${latest} — updating…`, "info");
+								let code = await spawnWithProgress("omp", ["plugin", "update", "pi-freeflow"], ctx);
+								if (code !== 0) {
+									ctx.ui.notify(`omp update exited ${code}, trying npm…`, "info");
+									code = await spawnWithProgress("npm", ["i", "-g", "pi-freeflow@latest"], ctx);
+								}
+								if (code === 0) {
+									ctx.ui.notify(`Updated to ${latest}, restart OMP`, "info");
+								} else {
+									ctx.ui.notify(
+										`Update failed (exit ${code}) — try manually: npm i -g pi-freeflow@latest`,
+										"warning",
+									);
+								}
+							}
+						}
+					} catch (e) {
+						ctx.ui.notify(`Update failed: ${(e as Error).message} — try manually: npm i -g pi-freeflow@latest`, "warning");
+					}
+				}
 			} else if (sub === "list") {
 				showList();
 			} else if (sub === "add") {
@@ -478,12 +589,16 @@ export function createCommandSpec(
 					const tokens = rest.trim().split(/\s+/);
 					const targetUrl = tokens[0];
 					const customLabel = tokens.slice(1).join(" ").trim() || undefined;
-					const added = ensureRelay(relayState, targetUrl, customLabel);
-					setRelay(true, added.url, added.label);
+					applyRelayState((s) => {
+						const added = ensureRelay(s, targetUrl, customLabel);
+						s.enabled = true;
+						s.url = added.url;
+						return s;
+					});
 					persist();
 					flash();
 					ctx.ui.notify(
-						`✓ Added & activated relay [${added.label || shortRelayLabel(added.url)}]: ${added.url}`,
+						`✓ Added & activated relay [${shortRelayLabel(relayState.url, relayState.relays)}]: ${relayState.url}`,
 						"info",
 					);
 				}
@@ -496,10 +611,16 @@ export function createCommandSpec(
 					const customLabel = tokens.slice(1).join(" ").trim() || undefined;
 					const matched = findRelay(relayState, targetToken);
 					if (matched) {
-						if (customLabel) {
-							matched.label = customLabel;
-						}
-						setRelay(true, matched.url, matched.label);
+						applyRelayState((s) => {
+							const fresh = s.relays.find((r) => r.url === matched.url);
+							if (!fresh) return s;
+							s.enabled = true;
+							s.url = fresh.url;
+							if (customLabel) {
+								fresh.label = customLabel;
+							}
+							return s;
+						});
 						persist();
 						flash();
 					} else {
@@ -511,8 +632,12 @@ export function createCommandSpec(
 						} catch {}
 						const looksLikeUrl = parsedUrl && (parsedUrl.protocol === "http:" || parsedUrl.protocol === "https:");
 						if (looksLikeUrl) {
-							const added = ensureRelay(relayState, targetToken, customLabel);
-							setRelay(true, added.url, added.label);
+							applyRelayState((s) => {
+								const added = ensureRelay(s, targetToken, customLabel);
+								s.enabled = true;
+								s.url = added.url;
+								return s;
+							});
 							persist();
 							flash();
 						} else {
@@ -541,7 +666,10 @@ export function createCommandSpec(
 							)
 						)?.trim() || "";
 					}
-					setRelayLabel(relayState, matched.url, finalLabel);
+					applyRelayState((s) => {
+						setRelayLabel(s, matched.url, finalLabel);
+						return s;
+					});
 					persist();
 					flash();
 					ctx.ui.notify(
@@ -610,14 +738,27 @@ export function createCommandSpec(
 					const rawRest = rest.trim();
 					let filterLevel: LogLevel | null = null;
 					let filterReqId: string | null = null;
+					let filterText: string | null = null;
+					let expectRelay = false;
 					let count = 25;
+					const rawTokens = rawRest ? rawRest.split(/\s+/) : [];
+					const isFollow = rawTokens.includes("--follow") || rawTokens.includes("-f");
 
 					if (sub === "trace" && rawRest) {
-						filterReqId = rawRest.split(/\s+/)[0];
+						filterReqId = rawTokens.filter((t) => t !== "--follow" && t !== "-f")[0] || null;
 					} else if (rawRest) {
-						const tokens = rawRest.split(/\s+/);
-						for (const t of tokens) {
+						for (const t of rawTokens) {
+							if (t === "--follow" || t === "-f") continue;
 							const lower = t.toLowerCase();
+							if (expectRelay) {
+								filterText = t;
+								expectRelay = false;
+								continue;
+							}
+							if (t === "relay") {
+								expectRelay = true;
+								continue;
+							}
 							if (lower in LOG_LEVEL_ORDER) {
 								filterLevel = lower as LogLevel;
 							} else if (/^\d+$/.test(t)) {
@@ -633,7 +774,9 @@ export function createCommandSpec(
 							} else if (lower === "trace" || lower === "req") {
 								continue;
 							} else {
-								filterReqId = t;
+								// Unrecognized token: an invalid level must default to info,
+								// not silently become a request-id filter.
+								filterLevel = filterLevel ?? "info";
 							}
 						}
 					}
@@ -642,6 +785,7 @@ export function createCommandSpec(
 						filterLevel,
 						filterReqId,
 						count,
+						filterText,
 					);
 					if (result.lines.length === 0) {
 						if (result.totalLines === 0) {
@@ -651,18 +795,38 @@ export function createCommandSpec(
 							);
 						} else {
 							ctx.ui.notify(
-								`No logs matched (level=${filterLevel || "any"} reqId=${filterReqId || "any"} count=${count})`,
+								`No logs matched (level=${filterLevel || "any"} reqId=${filterReqId || "any"} text=${filterText || "any"} count=${count})`,
 								"warning",
 							);
 						}
+						if (isFollow) {
+							startLogsFollow(
+								ctx,
+								filterLevel,
+								filterReqId,
+								count,
+								filterText,
+								result.totalMatched,
+							);
+						}
 						return;
 					}
 
-					const header = `pi-freeflow logs (last ${result.lines.length}/${result.totalMatched} matched, total ${result.totalLines} lines, file: ${LOG_FILE}${filterLevel ? ` level=${filterLevel}` : ""}${filterReqId ? ` req=${filterReqId}` : ""}):`;
+					const header = `pi-freeflow logs (last ${result.lines.length}/${result.totalMatched} matched, total ${result.totalLines} lines, file: ${LOG_FILE}${filterLevel ? ` level=${filterLevel}` : ""}${filterReqId ? ` req=${filterReqId}` : ""}${filterText ? ` text=${filterText}` : ""}):`;
 					ctx.ui.notify(
 						`${header}\n\n${result.lines.join("\n")}`,
 						"info",
 					);
+					if (isFollow) {
+						startLogsFollow(
+							ctx,
+							filterLevel,
+							filterReqId,
+							count,
+							filterText,
+							result.totalMatched,
+						);
+					}
 				} catch (e) {
 					ctx.ui.notify(
 						`Could not read log file: ${(e as Error).message}`,
@@ -703,34 +867,61 @@ export function createCommandSpec(
 						);
 						return;
 					}
-					removeRelay(relayState, matched.url);
+					applyRelayState((s) => {
+						removeRelay(s, matched.url);
+						return s;
+					});
 					persist();
 					ctx.ui.notify(`Removed: [${shortRelayLabel(matched.url, relayState.relays)}] ${matched.url}`, "info");
 				}
+			} else if (sub === "test") {
+				const target = rest.trim();
+				const matched = findRelay(relayState, target);
+				if (!matched) {
+					ctx.ui.notify(`Relay '${target}' not in saved list`, "warning");
+					return;
+				}
+				ctx.ui.notify(`Testing ${matched.url}…`, "info");
+				const probe = await probeRelay(matched.url, matched.auth);
+				if (probe.ok) {
+					ctx.ui.notify(`✓ ${shortRelayLabel(matched.url, relayState.relays)} ok (HTTP ${probe.status}, ${probe.latencyMs}ms)`, "info");
+				} else {
+					ctx.ui.notify(`✗ ${shortRelayLabel(matched.url, relayState.relays)} failed: ${probe.error || `HTTP ${probe.status}`}`, "error");
+				}
 			} else if (sub === "url") {
 				const input =
 					rest ||
 					(await ctx.ui.input(
 						"Relay URL (empty = default):",
-						relayState.url || DEFAULT_RELAY_URL,
+						relayState.url || "",
 					));
-				const cleanInput = (input || "").trim() || DEFAULT_RELAY_URL;
-				setRelay(
-					relayState.enabled,
-					cleanInput,
-					shortRelayLabel(cleanInput, relayState.relays),
-				);
+				const cleanInput = (input || "").trim() || "";
+				applyRelayState((s) => {
+					s.url = cleanInput;
+					if (cleanInput) {
+						ensureRelay(s, cleanInput, shortRelayLabel(cleanInput, s.relays));
+					}
+					return s;
+				});
 				persist();
 				flash();
 			} else if (sub === "deploy") {
-				const pf = parseDeployPlatform(rest);
-				if (!pf) {
-					ctx.ui.notify(
-						"Unknown platform. Use: vercel | cloudflare | deno",
-						"warning",
+				if (!rest.trim()) {
+					const choice = await ctx.ui.select(
+						"Deploy relay on",
+						Object.keys(DEPLOY_OPTIONS),
 					);
+					if (choice) await doDeploy(DEPLOY_OPTIONS[choice]);
 				} else {
-					await doDeploy(pf);
+					const pf = parseDeployPlatform(rest);
+					if (!pf) {
+						ctx.ui.notify(
+							"Unknown platform. Use: vercel | cloudflare | deno",
+							"warning",
+						);
+					} else {
+						await doDeploy(pf);
+					}
 				}
 			} else {
 				const currentMode = (relayState.mode || "auto").toUpperCase();
@@ -768,20 +959,35 @@ export function createCommandSpec(
 				} else if (choice === "Deploy Deno relay…") {
 					await doDeploy("deno");
 				} else if (choice === "Mode: AUTO (auto-detect on model select)") {
-					relayState.mode = "auto";
-					relayState.enabled = true;
-					setRelay(true, relayState.url || DEFAULT_RELAY_URL);
+					applyRelayState((s) => {
+						s.mode = "auto";
+						s.enabled = true;
+						s.url = s.url || "";
+						if (s.url) {
+							ensureRelay(s, s.url);
+						}
+						return s;
+					});
 					persist();
 					flash();
 				} else if (choice === "Mode: ON (always relay)") {
-					relayState.mode = "on";
-					setRelay(true, relayState.url || DEFAULT_RELAY_URL);
+					applyRelayState((s) => {
+						s.mode = "on";
+						s.enabled = true;
+						s.url = s.url || "";
+						if (s.url) {
+							ensureRelay(s, s.url);
+						}
+						return s;
+					});
 					persist();
 					flash();
 				} else if (choice === "Mode: OFF (always direct)") {
-					relayState.mode = "off";
-					relayState.enabled = false;
-					setActiveRelayState(relayState);
+					applyRelayState((s) => {
+						s.mode = "off";
+						s.enabled = false;
+						return s;
+					});
 					persist();
 					flash();
 				}