pi-freeflow 1.4.7 → 1.4.8

package/extensions/index.ts

@@ -4,5 +4,20 @@
  * Lightweight bridge re-exporting the modular codebase rooted in src/
  */
 
-export { default } from "../src/index.ts";
+import { checkForUpdateInBackground } from "../src/update-checker.ts";
+import originalDefault from "../src/index.ts";
+import type { ExtensionAPI } from "../src/types.ts";
+
+export default async function (pi: ExtensionAPI): Promise<void> {
+	try {
+		const r = checkForUpdateInBackground() as unknown as Promise<void> | void;
+		if (r && typeof (r as Promise<void>).catch === "function") {
+			(r as Promise<void>).catch(() => {});
+		}
+	} catch {
+		// swallow — never block activation
+	}
+	return originalDefault(pi);
+}
+
 export * from "../src/index.ts";

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "pi-freeflow",
 	"type": "module",
-	"version": "1.4.7",
+	"version": "1.4.8",
 	"description": "Thin provider for OMP/Pi — model list + dumb relay proxy + log; host pi-ai owns thinking/normalization",
 	"main": "extensions/index.ts",
 	"types": "src/index.ts",

package/src/commands.ts

@@ -4,8 +4,18 @@
  * 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 { 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,
+} from "./update-checker.ts";
 import {
 	deployCloudflareWorker,
 	deployDenoRelay,
@@ -66,13 +76,59 @@ export function updateStatusBar(ui?: ExtensionUIContext): void {
 	}
 }
 
+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 | deploy vercel | deploy cloudflare | deploy deno",
+			"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",
 		getArgumentCompletions: (prefix: string) =>
 			[
 				"auto",
@@ -346,8 +402,73 @@ export function createCommandSpec(
 				setActiveRelayState(relayState);
 				persist();
 				flash();
-			} else if (sub === "status") {
-				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");
+					}
+				}
 			} else if (sub === "list") {
 				showList();
 			} else if (sub === "add") {

package/src/config.ts

@@ -138,7 +138,21 @@ export function resolveDebugStatePath(): string {
 	}
 }
 
+export function resolveUpdateCachePath(): string {
+	try {
+		return path.join(homedir(), ".pi", "agent", "pi-freeflow-update.json");
+	} catch {
+		return path.join(
+			path.dirname(fileURLToPath(import.meta.url)),
+			"..",
+			".update-cache.json",
+		);
+	}
+}
+
 export const RELAY_STATE_FILE = resolveRelayStatePath();
 export const LOG_FILE = resolveLogFilePath();
 export const CATALOG_CACHE_FILE = resolveCatalogCachePath();
 export const DEBUG_STATE_FILE = resolveDebugStatePath();
+export const UPDATE_CACHE_FILE = resolveUpdateCachePath();
+export const UPDATE_CHECK_TTL_MS = 86_400_000;

package/src/update-checker.ts

@@ -0,0 +1,156 @@
+/**
+ * Update checker for pi-freeflow — background npm registry poll with 24h cache.
+ *
+ * LINK-skip: when the extension entry is a symlink (developer `omp plugin link`),
+ * the checker is disabled entirely.
+ */
+
+import { existsSync, lstatSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { UPDATE_CACHE_FILE, UPDATE_CHECK_TTL_MS } from "./config.ts";
+import { logInfo } from "./logger.ts";
+
+const REGISTRY_URL = "https://registry.npmjs.org/pi-freeflow/latest";
+
+export interface UpdateCacheData {
+	latest: string;
+	checkedAt: number;
+}
+
+/**
+ * Detect a LINK install by checking whether the published extension entry is a
+ * symlink. `omp plugin link <path>` creates a symlink at extensions/index.ts
+ * pointing at the dev checkout — when that link exists we skip the update check.
+ */
+export function isLinkedInstall(): boolean {
+	try {
+		const thisDir = path.dirname(fileURLToPath(import.meta.url));
+		const entry = path.join(thisDir, "..", "extensions", "index.ts");
+		return lstatSync(entry).isSymbolicLink();
+	} catch {
+		return false;
+	}
+}
+
+export function getCachedUpdate(): UpdateCacheData | null {
+	try {
+		if (!existsSync(UPDATE_CACHE_FILE)) return null;
+		const raw = readFileSync(UPDATE_CACHE_FILE, "utf8");
+		const data = JSON.parse(raw) as UpdateCacheData;
+		if (!data || typeof data.latest !== "string" || typeof data.checkedAt !== "number") {
+			return null;
+		}
+		return data;
+	} catch {
+		return null;
+	}
+}
+
+export function setCachedUpdate(latest: string): void {
+	try {
+		const dir = path.dirname(UPDATE_CACHE_FILE);
+		mkdirSync(dir, { recursive: true });
+		const data: UpdateCacheData = { latest, checkedAt: Date.now() };
+		writeFileSync(UPDATE_CACHE_FILE, JSON.stringify(data, null, 2), "utf8");
+	} catch {
+		// swallow — cache is best-effort
+	}
+}
+
+export async function fetchLatestVersion(): Promise<string | null> {
+	try {
+		const res = await fetch(REGISTRY_URL, {
+			signal: AbortSignal.timeout(3000),
+			headers: { Accept: "application/json" },
+		});
+		if (!res.ok) return null;
+		const json = (await res.json()) as { version?: string };
+		const v = json?.version;
+		if (typeof v === "string" && v.trim().length > 0) return v.trim();
+		return null;
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Simple semver compare: split on '.' and compare numeric segments.
+ * Returns >0 if a > b, <0 if a < b, 0 if equal.
+ */
+export function compareVersions(a: string, b: string): number {
+	try {
+		const pa = a.split(".").map((s) => Number(s) || 0);
+		const pb = b.split(".").map((s) => Number(s) || 0);
+		const len = Math.max(pa.length, pb.length);
+		for (let i = 0; i < len; i++) {
+			const da = pa[i] ?? 0;
+			const db = pb[i] ?? 0;
+			if (da !== db) return da - db;
+		}
+		return 0;
+	} catch {
+		return 0;
+	}
+}
+
+function getLocalVersion(): string | null {
+	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 null;
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Non-blocking background update check. Safe to call during extension
+ * activation without awaiting — it never throws and never blocks the caller.
+ *
+ * Flow: LINK-skip → cache TTL (24h) skip → fetchLatestVersion in background
+ * → cache result → log if latest > local.
+ */
+export function checkForUpdateInBackground(): void {
+	try {
+		if (isLinkedInstall()) return;
+
+		const cached = getCachedUpdate();
+		if (
+			cached &&
+			typeof cached.checkedAt === "number" &&
+			Date.now() - cached.checkedAt < UPDATE_CHECK_TTL_MS
+		) {
+			return;
+		}
+
+		void fetchLatestVersion()
+			.then((latest) => {
+				if (!latest) return;
+				try {
+					setCachedUpdate(latest);
+				} catch {
+					// swallow
+				}
+				try {
+					const local = getLocalVersion();
+					if (local && compareVersions(latest, local) > 0) {
+						logInfo(`pi-freeflow update available: ${local} -> ${latest} (run /freeflow update)`);
+					}
+				} catch {
+					// swallow
+				}
+			})
+			.catch(() => {
+				// swallow — offline / transient network error
+			});
+	} catch {
+		// swallow — never throw from background check
+	}
+}