pi-freeflow 1.2.0 → 1.2.1

package/src/commands.ts

@@ -0,0 +1,448 @@
+/**
+ * Interactive CLI slash commands and status bar manager for pi-freeflow
+ *
+ * log viewing, debug level configuration, and live catalog refreshing.
+ */
+
+import { refreshCatalog, setAliveCatalog } from "./catalog.ts";
+import { DEBUG_STATE_FILE, DEFAULT_RELAY_URL, LOG_FILE } from "./config.ts";
+import { deployVercelRelay } from "./deploy.ts";
+import {
+	LOG_LEVEL_ORDER,
+	getMinLogLevel,
+	isDebugEnabled,
+	loadDebugState,
+	readRecentLogs,
+	saveDebugState,
+} from "./logger.ts";
+import {
+	ensureRelay,
+	getActiveRelayState,
+	removeRelay,
+	saveRelayState,
+	setActiveRelayState,
+	setStatusUi,
+	shortRelayLabel,
+} from "./relay-state.ts";
+import type {
+	ExtensionAPI,
+	ExtensionContext,
+	ExtensionUIContext,
+	KnownRelay,
+	LogLevel,
+	RegisteredCommand,
+	RegisteredModel,
+	RelayState,
+} from "./types.ts";
+
+/**
+ * Update the TUI status bar widget with active relay state.
+ */
+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;
+		ui.setStatus("freeflow", `relay: ON | ${label} ${idx}/${total}`);
+	} else {
+		ui.setStatus("freeflow", undefined);
+	}
+}
+
+export function createCommandSpec(
+	_pi: ExtensionAPI,
+	onCatalogRefreshed?: (models: RegisteredModel[]) => void,
+): Omit<RegisteredCommand, "name"> {
+	return {
+		description:
+			"Relay egress: on | off | status | logs [level] [n] | debug on|off|status | url [URL] | deploy | list | use <URL> | remove <URL> | refresh",
+		getArgumentCompletions: (prefix: string) =>
+			[
+				"on",
+				"off",
+				"status",
+				"url",
+				"deploy",
+				"list",
+				"use",
+				"remove",
+				"refresh",
+				"models",
+				"logs",
+				"debug",
+				"trace",
+			]
+				.filter((s) => s.startsWith(prefix))
+				.map((s) => ({ value: s, label: s })),
+		handler: async (args: string, ctx: ExtensionContext) => {
+			const parts = String(args || "")
+				.trim()
+				.split(/\s+/);
+			const sub = parts[0] || "";
+			const rest = parts.slice(1).join(" ");
+			const relayState = getActiveRelayState();
+
+			const flash = () => {
+				const activeLabel = shortRelayLabel(relayState.url);
+				const activeIdx = Math.max(
+					1,
+					relayState.relays.findIndex((r) => r.url === relayState.url) + 1,
+				);
+				const total = relayState.relays.length || 1;
+				ctx.ui.notify(
+					`Relay ${relayState.enabled ? "ON" : "OFF"}${relayState.enabled ? ` → ${activeLabel} (${activeIdx}/${total})` : " (direct)"} | saved=${relayState.relays.length} (auto-fallback rolling)`,
+					"info",
+				);
+			};
+
+			const persist = () => {
+				saveRelayState(relayState);
+				setStatusUi(ctx.ui);
+				updateStatusBar(ctx.ui);
+			};
+
+			const setRelay = (
+				enabled: boolean,
+				url: string,
+				addLabel?: string,
+			) => {
+				relayState.enabled = enabled;
+				relayState.url = (url || "").trim() || DEFAULT_RELAY_URL;
+				if (relayState.url) {
+					ensureRelay(relayState, relayState.url, addLabel);
+				}
+				setActiveRelayState(relayState);
+			};
+
+			const doDeploy = async () => {
+				const defaultName = `relay-${Date.now().toString(36)}`;
+				const token = (
+					await ctx.ui.input("Vercel API token (vercel-…):", "")
+				)?.trim();
+				if (!token) {
+					ctx.ui.notify("Deploy cancelled — no token", "warning");
+					return;
+				}
+				const name =
+					(
+						await ctx.ui.input(
+							"Project name (empty = auto):",
+							defaultName,
+						)
+					)?.trim() || defaultName;
+
+				ctx.ui.setStatus("freeflow", "deploying relay…");
+				try {
+					const url = await deployVercelRelay(token, name, (m) =>
+						ctx.ui.notify(m, "info"),
+					);
+					setRelay(true, url, `deployed ${name}`);
+					persist();
+					ctx.ui.notify(`✓ Deployed & active: ${url}`, "info");
+				} catch (e) {
+					updateStatusBar(ctx.ui);
+					ctx.ui.notify(
+						`Deploy failed: ${(e as Error).message}`,
+						"error",
+					);
+				}
+			};
+
+			const switchRelay = async () => {
+				if (!relayState.relays.length) {
+					ctx.ui.notify("No saved relays yet", "warning");
+					return;
+				}
+				const fmt = (r: KnownRelay) =>
+					`${r.url === relayState.url ? "★ " : "  "}${r.url}${r.label ? `  (${r.label})` : ""}`;
+				const opts = relayState.relays.map(fmt);
+				const choice = await ctx.ui.select("Switch relay", opts);
+				if (!choice) return;
+				const match = relayState.relays.find((r) => fmt(r) === choice);
+				if (!match) return;
+				setRelay(true, match.url);
+				persist();
+				flash();
+			};
+
+			const showList = () => {
+				if (!relayState.relays.length) {
+					ctx.ui.notify("No saved relays", "info");
+					return;
+				}
+				const lines = relayState.relays.map(
+					(r) =>
+						`${r.url === relayState.url ? "★" : " "} ${r.url}${r.label ? `  [${r.label}]` : ""}`,
+				);
+				ctx.ui.notify(
+					`Saved relays (${relayState.relays.length}):\n${lines.join("\n")}`,
+					"info",
+				);
+			};
+
+			const removeRelayMenu = async () => {
+				const removable = relayState.relays.filter(
+					(r) => r.url !== relayState.url,
+				);
+				if (!removable.length) {
+					ctx.ui.notify(
+						"Nothing to remove — the active relay cannot be removed (switch first)",
+						"warning",
+					);
+					return;
+				}
+				const fmt = (r: KnownRelay) =>
+					`${r.url}${r.label ? `  (${r.label})` : ""}`;
+				const choice = await ctx.ui.select(
+					"Remove relay",
+					removable.map(fmt),
+				);
+				if (!choice) return;
+				const match = removable.find((r) => fmt(r) === choice);
+				if (!match) return;
+				removeRelay(relayState, match.url);
+				persist();
+				ctx.ui.notify(`Removed: ${match.url}`, "info");
+			};
+
+			if (sub === "on") {
+				setRelay(true, relayState.url || DEFAULT_RELAY_URL);
+				persist();
+				flash();
+			} else if (sub === "off") {
+				relayState.enabled = false;
+				setActiveRelayState(relayState);
+				persist();
+				flash();
+			} else if (sub === "status") {
+				flash();
+			} else if (sub === "list") {
+				showList();
+			} else if (sub === "use") {
+				const url = (
+					rest ||
+					(await ctx.ui.input("Relay URL to activate:", "")) ||
+					""
+				).trim();
+				if (!url) {
+					ctx.ui.notify("No URL given", "warning");
+					return;
+				}
+				setRelay(true, url, "manual");
+				persist();
+				flash();
+			} else if (sub === "debug") {
+				const arg = rest.trim().toLowerCase();
+				if (arg === "on" || arg === "enable" || arg === "true") {
+					saveDebugState({ debug: true });
+					ctx.ui.notify(
+						"🔍 Debug ON — verbose trace enabled (level=debug). Logs now include request IDs, thinking sniffing, and payload normalize details.",
+						"info",
+					);
+				} else if (
+					arg === "off" ||
+					arg === "disable" ||
+					arg === "false"
+				) {
+					saveDebugState({ debug: false });
+					ctx.ui.notify(
+						`🔇 Debug OFF — level restored to info. File: ${DEBUG_STATE_FILE}`,
+						"info",
+					);
+				} else if (arg.startsWith("level")) {
+					const lvl = arg.split(/\s+/)[1] as LogLevel | undefined;
+					if (lvl && lvl in LOG_LEVEL_ORDER) {
+						saveDebugState({ debug: false, level: lvl });
+						ctx.ui.notify(
+							`Log level set to ${lvl} (persisted to ${DEBUG_STATE_FILE})`,
+							"info",
+						);
+					} else {
+						ctx.ui.notify(
+							`Unknown level: ${lvl} (use debug/info/warn/error)`,
+							"warning",
+						);
+					}
+				} else {
+					const st = loadDebugState();
+					const cur = st?.debug
+						? "debug (ON)"
+						: st?.level ||
+							process.env.FREEFLOW_LOG_LEVEL ||
+							"info";
+					ctx.ui.notify(
+						`Debug status: ${cur}\nFile: ${DEBUG_STATE_FILE}\nMinLevel: ${getMinLogLevel()} | isDebug=${isDebugEnabled()}\nUsage: /freeflow debug on|off | /freeflow debug level debug`,
+						"info",
+					);
+				}
+			} else if (sub === "logs" || sub === "log" || sub === "trace") {
+				try {
+					const rawRest = rest.trim();
+					let filterLevel: LogLevel | null = null;
+					let filterReqId: string | null = null;
+					let count = 25;
+
+					if (sub === "trace" && rawRest) {
+						filterReqId = rawRest.split(/\s+/)[0];
+					} else if (rawRest) {
+						const tokens = rawRest.split(/\s+/);
+						for (const t of tokens) {
+							const lower = t.toLowerCase();
+							if (lower in LOG_LEVEL_ORDER) {
+								filterLevel = lower as LogLevel;
+							} else if (/^\d+$/.test(t)) {
+								count = Math.min(
+									200,
+									Math.max(5, Number.parseInt(t, 10)),
+								);
+							} else if (
+								/^[a-f0-9]{6,8}$/i.test(t) ||
+								t.startsWith("req=")
+							) {
+								filterReqId = t.replace(/^req=/, "");
+							} else if (lower === "trace" || lower === "req") {
+								continue;
+							} else {
+								filterReqId = t;
+							}
+						}
+					}
+
+					const result = readRecentLogs(
+						filterLevel,
+						filterReqId,
+						count,
+					);
+					if (result.lines.length === 0) {
+						if (result.totalLines === 0) {
+							ctx.ui.notify(
+								"Log file is empty (no logs yet)",
+								"info",
+							);
+						} else {
+							ctx.ui.notify(
+								`No logs matched (level=${filterLevel || "any"} reqId=${filterReqId || "any"} count=${count})`,
+								"warning",
+							);
+						}
+						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}` : ""}):`;
+					ctx.ui.notify(
+						`${header}\n\n${result.lines.join("\n")}`,
+						"info",
+					);
+				} catch (e) {
+					ctx.ui.notify(
+						`Could not read log file: ${(e as Error).message}`,
+						"error",
+					);
+				}
+			} else if (
+				sub === "refresh" ||
+				sub === "reload" ||
+				sub === "models"
+			) {
+				ctx.ui.notify(
+					"Refreshing model catalog from live upstreams…",
+					"info",
+				);
+				const updated = await refreshCatalog(true);
+				setAliveCatalog(updated);
+				persist();
+				onCatalogRefreshed?.(updated);
+				ctx.ui.notify(
+					`✓ Refreshed ${updated.length} models with full-spec metadata!`,
+					"info",
+				);
+			} else if (sub === "remove") {
+				const url = (
+					rest ||
+					(await ctx.ui.input("Relay URL to remove:", "")) ||
+					""
+				).trim();
+				if (!url) {
+					ctx.ui.notify("No URL given", "warning");
+					return;
+				}
+				if (url === relayState.url) {
+					ctx.ui.notify(
+						"Cannot remove the active relay — switch first",
+						"warning",
+					);
+					return;
+				}
+				if (!relayState.relays.some((r) => r.url === url)) {
+					ctx.ui.notify("Not in saved list", "warning");
+					return;
+				}
+				removeRelay(relayState, url);
+				persist();
+				ctx.ui.notify(`Removed: ${url}`, "info");
+			} else if (sub === "url") {
+				const input =
+					rest ||
+					(await ctx.ui.input(
+						"Relay URL (empty = default):",
+						relayState.url || DEFAULT_RELAY_URL,
+					));
+				setRelay(
+					relayState.enabled,
+					(input || "").trim() || DEFAULT_RELAY_URL,
+					"manual",
+				);
+				persist();
+				flash();
+			} else if (sub === "deploy") {
+				await doDeploy();
+			} else {
+				const choice = await ctx.ui.select("freeflow relay", [
+					`Relay: ${relayState.enabled ? "ON" : "OFF"} → ${relayState.url || "direct"}`,
+					"Turn ON",
+					"Turn OFF",
+					"Switch relay…",
+					"Remove relay…",
+					"Set URL",
+					"Deploy Vercel relay…",
+					"List saved relays",
+				]);
+				if (choice === "Turn ON") {
+					setRelay(true, relayState.url || DEFAULT_RELAY_URL);
+					persist();
+					flash();
+				} else if (choice === "Turn OFF") {
+					relayState.enabled = false;
+					setActiveRelayState(relayState);
+					persist();
+					flash();
+				} else if (choice === "Switch relay…") {
+					await switchRelay();
+				} else if (choice === "Remove relay…") {
+					await removeRelayMenu();
+				} else if (choice === "Set URL") {
+					const input = await ctx.ui.input(
+						"Relay URL (empty = default):",
+						relayState.url || DEFAULT_RELAY_URL,
+					);
+					setRelay(
+						relayState.enabled,
+						(input || "").trim() || DEFAULT_RELAY_URL,
+						"manual",
+					);
+					persist();
+					flash();
+				} else if (choice === "Deploy Vercel relay…") {
+					await doDeploy();
+				} else if (choice === "List saved relays") {
+					showList();
+				}
+			}
+		},
+	};
+}

package/src/config.ts

@@ -0,0 +1,145 @@
+/**
+ * Configuration and path resolution for pi-freeflow
+ */
+
+import { randomUUID } from "node:crypto";
+import { homedir } from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import type { Upstream } from "./types.ts";
+
+// ── Upstream endpoints ──────────────────────────────────────────────
+export const UPSTREAM_OPENCODE = "https://opencode.ai/zen";
+export const KILO_CHAT_URL = "https://api.kilo.ai/api/gateway/chat/completions";
+export const OPENCODE_API_URL = `${UPSTREAM_OPENCODE}/v1`;
+
+// ── Network & Server defaults ───────────────────────────────────────
+export const DEFAULT_PORT = 18080;
+export const HOST = "127.0.0.1";
+export const DEFAULT_HOST = "127.0.0.1";
+
+export function resolvePort(): number {
+	const envPort = process.env.FREEFLOW_PORT;
+	if (envPort) {
+		const parsed = Number(envPort);
+		if (Number.isFinite(parsed) && parsed > 0 && parsed <= 65535) {
+			return parsed;
+		}
+	}
+	return DEFAULT_PORT;
+}
+
+export const PORT = resolvePort();
+
+// ── OpenCode client headers ─────────────────────────────────────────
+export const OPENCODE_USER_AGENT = "opencode/latest/1.14.50/cli";
+export const OPENCODE_CLIENT = "cli";
+export const OPENCODE_PROJECT = "default";
+export const OPENCODE_SESSION = randomUUID();
+
+export function opencodeHeaders(): Record<string, string> {
+	return {
+		"User-Agent": OPENCODE_USER_AGENT,
+		"x-opencode-client": OPENCODE_CLIENT,
+		"x-opencode-project": OPENCODE_PROJECT,
+		"x-opencode-session": OPENCODE_SESSION,
+		"x-opencode-request": randomUUID(),
+	};
+}
+
+// ── Relay and Deployment constants ──────────────────────────────────
+export const DEFAULT_RELAY_URL = "";
+export const VERCEL_API = "https://api.vercel.com";
+export const RELAY_MAX_TOKENS = 131_072;
+
+// ── Catalog & Logging constants ─────────────────────────────────────
+export const CATALOG_CACHE_TTL_MS = 3_600_000; // 1 hour
+export const LOG_MAX_BYTES = 5 * 1024 * 1024; // 5MB
+export const LOG_MAX_FILES = 3;
+
+// ── Rate Limit Maxima ───────────────────────────────────────────────
+export const RATE_LIMIT_MAX: Record<Upstream, number> = {
+	opencode: 200, // public free quota: requests per UTC day per IP
+	kilo: 200, // documented gateway quota: requests per 1-hour window per IP
+};
+
+// ── Whitelists & Security ───────────────────────────────────────────
+export const ALLOWED_PATH_PATTERN = /^\/v1\/[a-zA-Z0-9/_.,\-?&=]*$/;
+export const PATH_TRAVERSAL_PATTERN = /\.\./;
+export const ALLOWED_METHODS = new Set(["GET", "POST", "OPTIONS", "HEAD"]);
+
+export const STRIP_HEADERS = new Set([
+	"authorization",
+	"host",
+	"content-length",
+	"x-forwarded-for",
+	"x-forwarded-host",
+	"x-forwarded-proto",
+	"x-real-ip",
+	"x-client-ip",
+	"x-originate-ip",
+	"cookie",
+	"set-cookie",
+	"proxy-connection",
+	"proxy-authorization",
+]);
+
+// ── File Path Resolvers ─────────────────────────────────────────────
+
+export function resolveRelayStatePath(): string {
+	try {
+		return path.join(homedir(), ".pi", "agent", "pi-freeflow-relay-state.json");
+	} catch {
+		return path.join(
+			path.dirname(fileURLToPath(import.meta.url)),
+			"..",
+			".relay-state.json",
+		);
+	}
+}
+
+export function resolveLogFilePath(): string {
+	try {
+		return path.join(homedir(), ".pi", "agent", "pi-freeflow.log");
+	} catch {
+		return path.join(
+			path.dirname(fileURLToPath(import.meta.url)),
+			"..",
+			"pi-freeflow.log",
+		);
+	}
+}
+
+export function resolveCatalogCachePath(): string {
+	try {
+		return path.join(
+			homedir(),
+			".pi",
+			"agent",
+			"pi-freeflow-catalog-cache.json",
+		);
+	} catch {
+		return path.join(
+			path.dirname(fileURLToPath(import.meta.url)),
+			"..",
+			".catalog-cache.json",
+		);
+	}
+}
+
+export function resolveDebugStatePath(): string {
+	try {
+		return path.join(homedir(), ".pi", "agent", "pi-freeflow-debug.json");
+	} catch {
+		return path.join(
+			path.dirname(fileURLToPath(import.meta.url)),
+			"..",
+			".debug-state.json",
+		);
+	}
+}
+
+export const RELAY_STATE_FILE = resolveRelayStatePath();
+export const LOG_FILE = resolveLogFilePath();
+export const CATALOG_CACHE_FILE = resolveCatalogCachePath();
+export const DEBUG_STATE_FILE = resolveDebugStatePath();