pi-freeflow 1.4.7 → 1.4.9

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,55 +1,55 @@
-{
-	"name": "pi-freeflow",
-	"type": "module",
-	"version": "1.4.7",
-	"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",
-	"keywords": [
-		"pi-package",
-		"pi-extension",
-		"oh-my-pi",
-		"omp",
-		"free-models",
-		"opencode",
-		"kilocode",
-		"ai-models",
-		"relay"
-	],
-	"author": "trefeon",
-	"license": "MIT",
-	"repository": {
-		"type": "git",
-		"url": "git+https://github.com/trefeon/pi-freeflow.git"
-	},
-	"homepage": "https://github.com/trefeon/pi-freeflow#readme",
-	"engines": {
-		"node": ">=22.6.0"
-	},
-	"omp": {
-		"extensions": [
-			"./extensions"
-		]
-	},
-	"pi": {
-		"extensions": [
-			"./extensions"
-		]
-	},
-	"files": [
-		"extensions",
-		"src",
-		"README.md",
-		"LICENSE"
-	],
-	"scripts": {
-		"test": "node --experimental-strip-types --test test/**/*.test.ts",
-		"typecheck": "tsc --noEmit",
-		"smoke": "node --experimental-strip-types -e \"import('./extensions/index.ts').then(() => console.log('✓ Smoke test passed: extensions/index.ts loaded successfully')).catch(err => { console.error(err); process.exit(1); })\""
-	},
-	"devDependencies": {
-		"@earendil-works/pi-coding-agent": "^0.84.3",
-		"@types/node": "^22.13.9",
-		"typescript": "^5.8.2"
-	}
-}
+{
+	"name": "pi-freeflow",
+	"type": "module",
+	"version": "1.4.9",
+	"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",
+	"keywords": [
+		"pi-package",
+		"pi-extension",
+		"oh-my-pi",
+		"omp",
+		"free-models",
+		"opencode",
+		"kilocode",
+		"ai-models",
+		"relay"
+	],
+	"author": "trefeon",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/trefeon/pi-freeflow.git"
+	},
+	"homepage": "https://github.com/trefeon/pi-freeflow#readme",
+	"engines": {
+		"node": ">=22.6.0"
+	},
+	"omp": {
+		"extensions": [
+			"./extensions"
+		]
+	},
+	"pi": {
+		"extensions": [
+			"./extensions"
+		]
+	},
+	"files": [
+		"extensions",
+		"src",
+		"README.md",
+		"LICENSE"
+	],
+	"scripts": {
+		"test": "node --experimental-strip-types --test --test-concurrency=1 test/**/*.test.ts",
+		"typecheck": "tsc --noEmit",
+		"smoke": "node --experimental-strip-types -e \"import('./extensions/index.ts').then(() => console.log('✓ Smoke test passed: extensions/index.ts loaded successfully')).catch(err => { console.error(err); process.exit(1); })\""
+	},
+	"devDependencies": {
+		"@earendil-works/pi-coding-agent": "^0.84.3",
+		"@types/node": "^22.13.9",
+		"typescript": "^5.8.2"
+	}
+}

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/deploy.ts

@@ -14,18 +14,61 @@ import { log, logError } from "./logger.ts";
  */
 export const VERCEL_RELAY_WORKER = `// Only the 2 upstreams pi-freeflow talks to. Anything else = open proxy abuse.
 const ALLOWED_TARGETS = ["https://opencode.ai", "https://api.kilo.ai"];
+const resolveRelayTarget = function(target, relayPath) {
+  let targetUrl;
+  try { targetUrl = new URL(target); } catch { return { ok: false, status: 400, reason: "invalid x-relay-target" }; }
+  if (typeof relayPath !== "string" || relayPath.indexOf("@") !== -1 || relayPath.indexOf("\\") !== -1 || relayPath.charAt(0) !== "/") {
+    return { ok: false, status: 403, reason: "forbidden x-relay-path" };
+  }
+  let finalUrl;
+  try { finalUrl = new URL(relayPath, targetUrl); } catch { return { ok: false, status: 403, reason: "forbidden x-relay-path" }; }
+  if (finalUrl.hostname !== targetUrl.hostname || finalUrl.protocol !== targetUrl.protocol || finalUrl.port !== targetUrl.port || finalUrl.username || finalUrl.password) {
+    return { ok: false, status: 403, reason: "forbidden x-relay-path (host mismatch)" };
+  }
+  return { ok: true, url: finalUrl.toString() };
+};
+const isPrivateHostname = function(h) {
+  if (!h) return true
+  let host = String(h).trim().toLowerCase().replace(/^\[|\]$/g, "")
+  if (host.length > 1 && host.endsWith(".")) host = host.slice(0, -1)
+  if (!host) return true
+  if (host === "localhost" || host === "0.0.0.0" || host === "127.0.0.1" || host.endsWith(".localhost") || host.endsWith(".local") || host.endsWith(".internal")) return true
+  if (host.startsWith("::")) return true
+  const v4 = host.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/)
+  if (v4) {
+    const a = Number(v4[1])
+    const b = Number(v4[2])
+    if (a === 0 || a === 10 || a === 127) return true
+    if (a === 169 && b === 254) return true
+    if (a === 192 && b === 168) return true
+    if (a === 172 && b >= 16 && b <= 31) return true
+    if (a === 100 && b >= 64 && b <= 127) return true
+    return false
+  }
+  if (host.includes(":")) {
+    if (host.startsWith("fc") || host.startsWith("fd")) return true
+    if (/^fe[89ab]/.test(host)) return true
+    return false
+  }
+  return false
+};
 export const config = { runtime: "edge" };
 export default async function handler(req) {
   const target = req.headers.get("x-relay-target");
-  const relayPath = req.headers.get("x-relay-path") || "/";
   if (!target) return new Response(JSON.stringify({ error: "Missing x-relay-target header" }), { status: 400, headers: { "content-type": "application/json" } });
-  const cleanTarget = target.replace(/\\/$/, "");
+  let targetUrl;
+  try { targetUrl = new URL(target); } catch { return new Response(JSON.stringify({ error: "invalid x-relay-target" }), { status: 400, headers: { "content-type": "application/json" } }); }
+  if (targetUrl.protocol !== "http:" && targetUrl.protocol !== "https:") return new Response(JSON.stringify({ error: "forbidden x-relay-target protocol" }), { status: 403, headers: { "content-type": "application/json" } });
+  if (targetUrl.username || targetUrl.password) return new Response(JSON.stringify({ error: "forbidden x-relay-target (embedded credentials)" }), { status: 403, headers: { "content-type": "application/json" } });
+  if (isPrivateHostname(targetUrl.hostname)) return new Response(JSON.stringify({ error: "forbidden x-relay-target (private/loopback host)" }), { status: 403, headers: { "content-type": "application/json" } });
+  const cleanTarget = target.replace(/\/$/, "");
   if (!ALLOWED_TARGETS.includes(cleanTarget)) return new Response(JSON.stringify({ error: "Forbidden target" }), { status: 403, headers: { "content-type": "application/json" } });
-  if (!relayPath.startsWith("/")) return new Response(JSON.stringify({ error: "Bad path" }), { status: 400, headers: { "content-type": "application/json" } });
-  const targetUrl = cleanTarget + relayPath;
+  const relayPath = req.headers.get("x-relay-path") || "/";
+  const resolved = resolveRelayTarget(target, relayPath);
+  if (!resolved.ok) return new Response(JSON.stringify({ error: resolved.reason }), { status: resolved.status, headers: { "content-type": "application/json" } });
   const headers = new Headers(req.headers);
-  headers.delete("x-relay-target"); headers.delete("x-relay-path"); headers.delete("host");
-  const response = await fetch(targetUrl, { method: req.method, headers, body: req.method !== "GET" && req.method !== "HEAD" ? req.body : undefined, duplex: "half" });
+  ["host", "connection", "content-length", "keep-alive", "proxy-connection", "proxy-authenticate", "proxy-authorization", "transfer-encoding", "te", "trailer", "upgrade", "x-relay-target", "x-relay-path", "x-relay-auth"].forEach((h) => headers.delete(h));
+  const response = await fetch(resolved.url, { method: req.method, headers, body: req.method !== "GET" && req.method !== "HEAD" ? req.body : undefined, duplex: "half" });
   return new Response(response.body, { status: response.status, headers: response.headers });
 }`;
 
@@ -142,23 +185,68 @@ export type DeployPlatform = "vercel" | "cloudflare" | "deno";
 
 /**
  * Module Worker relay deployed to Cloudflare Workers.
- * Same whitelist contract as the Vercel Edge relay, without Vercel's
- * `config` export or undici-only `duplex` flag (plain body passthrough).
+ * Same whitelist contract as the Vercel Edge relay, with SSRF guard, relay-path resolver, and streaming duplex.
  */
 export const CLOUDFLARE_RELAY_WORKER = `// Only the 2 upstreams this relay talks to. Anything else = open proxy abuse.
 const ALLOWED_TARGETS = ["https://opencode.ai", "https://api.kilo.ai"];
+const resolveRelayTarget = function(target, relayPath) {
+  let targetUrl;
+  try { targetUrl = new URL(target); } catch { return { ok: false, status: 400, reason: "invalid x-relay-target" }; }
+  if (typeof relayPath !== "string" || relayPath.indexOf("@") !== -1 || relayPath.indexOf("\\") !== -1 || relayPath.charAt(0) !== "/") {
+    return { ok: false, status: 403, reason: "forbidden x-relay-path" };
+  }
+  let finalUrl;
+  try { finalUrl = new URL(relayPath, targetUrl); } catch { return { ok: false, status: 403, reason: "forbidden x-relay-path" }; }
+  if (finalUrl.hostname !== targetUrl.hostname || finalUrl.protocol !== targetUrl.protocol || finalUrl.port !== targetUrl.port || finalUrl.username || finalUrl.password) {
+    return { ok: false, status: 403, reason: "forbidden x-relay-path (host mismatch)" };
+  }
+  return { ok: true, url: finalUrl.toString() };
+};
+const isPrivateHostname = function(h) {
+  if (!h) return true
+  let host = String(h).trim().toLowerCase().replace(/^\[|\]$/g, "")
+  if (host.length > 1 && host.endsWith(".")) host = host.slice(0, -1)
+  if (!host) return true
+  if (host === "localhost" || host === "0.0.0.0" || host === "127.0.0.1" || host.endsWith(".localhost") || host.endsWith(".local") || host.endsWith(".internal")) return true
+  if (host.startsWith("::")) return true
+  const v4 = host.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/)
+  if (v4) {
+    const a = Number(v4[1])
+    const b = Number(v4[2])
+    if (a === 0 || a === 10 || a === 127) return true
+    if (a === 169 && b === 254) return true
+    if (a === 192 && b === 168) return true
+    if (a === 172 && b >= 16 && b <= 31) return true
+    if (a === 100 && b >= 64 && b <= 127) return true
+    return false
+  }
+  if (host.includes(":")) {
+    if (host.startsWith("fc") || host.startsWith("fd")) return true
+    if (/^fe[89ab]/.test(host)) return true
+    return false
+  }
+  return false
+};
 export default {
   async fetch(request) {
     const target = request.headers.get("x-relay-target");
-    const relayPath = request.headers.get("x-relay-path") || "/";
     if (!target) return new Response(JSON.stringify({ error: "Missing x-relay-target header" }), { status: 400, headers: { "content-type": "application/json" } });
-    const cleanTarget = target.replace(/\\/$/, "");
+    let targetUrl;
+    try { targetUrl = new URL(target); } catch { return new Response(JSON.stringify({ error: "invalid x-relay-target" }), { status: 400, headers: { "content-type": "application/json" } }); }
+    if (targetUrl.protocol !== "http:" && targetUrl.protocol !== "https:") return new Response(JSON.stringify({ error: "forbidden x-relay-target protocol" }), { status: 403, headers: { "content-type": "application/json" } });
+    if (targetUrl.username || targetUrl.password) return new Response(JSON.stringify({ error: "forbidden x-relay-target (embedded credentials)" }), { status: 403, headers: { "content-type": "application/json" } });
+    if (isPrivateHostname(targetUrl.hostname)) return new Response(JSON.stringify({ error: "forbidden x-relay-target (private/loopback host)" }), { status: 403, headers: { "content-type": "application/json" } });
+    const cleanTarget = target.replace(/\/$/, "");
     if (!ALLOWED_TARGETS.includes(cleanTarget)) return new Response(JSON.stringify({ error: "Forbidden target" }), { status: 403, headers: { "content-type": "application/json" } });
-    if (!relayPath.startsWith("/")) return new Response(JSON.stringify({ error: "Bad path" }), { status: 400, headers: { "content-type": "application/json" } });
+    const relayPath = request.headers.get("x-relay-path") || "/";
+    const resolved = resolveRelayTarget(target, relayPath);
+    if (!resolved.ok) return new Response(JSON.stringify({ error: resolved.reason }), { status: resolved.status, headers: { "content-type": "application/json" } });
     const headers = new Headers(request.headers);
-    headers.delete("x-relay-target"); headers.delete("x-relay-path"); headers.delete("host");
+    ["host", "connection", "content-length", "keep-alive", "proxy-connection", "proxy-authenticate", "proxy-authorization", "transfer-encoding", "te", "trailer", "upgrade", "x-relay-target", "x-relay-path", "x-relay-auth"].forEach((h) => headers.delete(h));
     try {
-      const response = await fetch(cleanTarget + relayPath, { method: request.method, headers, body: request.method !== "GET" && request.method !== "HEAD" ? request.body : undefined });
+      const init = { method: request.method, headers };
+      if (request.method !== "GET" && request.method !== "HEAD") { init.body = request.body; init.duplex = "half"; }
+      const response = await fetch(resolved.url, init);
       return new Response(response.body, { status: response.status, headers: response.headers });
     } catch (error) {
       return new Response(JSON.stringify({ error: String(error) }), { status: 502, headers: { "content-type": "application/json" } });
@@ -168,21 +256,67 @@ export default {
 
 /**
  * Relay script deployed to Deno Deploy (Deno.serve variant).
- * Same whitelist contract; plain streaming passthrough, no duplex flag.
+ * Same whitelist contract as the Vercel Edge relay, with SSRF guard and relay-path resolver.
  */
 export const DENO_RELAY_SCRIPT = `// Only the 2 upstreams this relay talks to. Anything else = open proxy abuse.
 const ALLOWED_TARGETS = ["https://opencode.ai", "https://api.kilo.ai"];
+const resolveRelayTarget = function(target, relayPath) {
+  let targetUrl;
+  try { targetUrl = new URL(target); } catch { return { ok: false, status: 400, reason: "invalid x-relay-target" }; }
+  if (typeof relayPath !== "string" || relayPath.indexOf("@") !== -1 || relayPath.indexOf("\\") !== -1 || relayPath.charAt(0) !== "/") {
+    return { ok: false, status: 403, reason: "forbidden x-relay-path" };
+  }
+  let finalUrl;
+  try { finalUrl = new URL(relayPath, targetUrl); } catch { return { ok: false, status: 403, reason: "forbidden x-relay-path" }; }
+  if (finalUrl.hostname !== targetUrl.hostname || finalUrl.protocol !== targetUrl.protocol || finalUrl.port !== targetUrl.port || finalUrl.username || finalUrl.password) {
+    return { ok: false, status: 403, reason: "forbidden x-relay-path (host mismatch)" };
+  }
+  return { ok: true, url: finalUrl.toString() };
+};
+const isPrivateHostname = function(h) {
+  if (!h) return true
+  let host = String(h).trim().toLowerCase().replace(/^\[|\]$/g, "")
+  if (host.length > 1 && host.endsWith(".")) host = host.slice(0, -1)
+  if (!host) return true
+  if (host === "localhost" || host === "0.0.0.0" || host === "127.0.0.1" || host.endsWith(".localhost") || host.endsWith(".local") || host.endsWith(".internal")) return true
+  if (host.startsWith("::")) return true
+  const v4 = host.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/)
+  if (v4) {
+    const a = Number(v4[1])
+    const b = Number(v4[2])
+    if (a === 0 || a === 10 || a === 127) return true
+    if (a === 169 && b === 254) return true
+    if (a === 192 && b === 168) return true
+    if (a === 172 && b >= 16 && b <= 31) return true
+    if (a === 100 && b >= 64 && b <= 127) return true
+    return false
+  }
+  if (host.includes(":")) {
+    if (host.startsWith("fc") || host.startsWith("fd")) return true
+    if (/^fe[89ab]/.test(host)) return true
+    return false
+  }
+  return false
+};
 Deno.serve(async (request) => {
   const target = request.headers.get("x-relay-target");
-  const relayPath = request.headers.get("x-relay-path") || "/";
   if (!target) return new Response(JSON.stringify({ error: "Missing x-relay-target header" }), { status: 400, headers: { "content-type": "application/json" } });
-  const cleanTarget = target.replace(/\\/$/, "");
+  let targetUrl;
+  try { targetUrl = new URL(target); } catch { return new Response(JSON.stringify({ error: "invalid x-relay-target" }), { status: 400, headers: { "content-type": "application/json" } }); }
+  if (targetUrl.protocol !== "http:" && targetUrl.protocol !== "https:") return new Response(JSON.stringify({ error: "forbidden x-relay-target protocol" }), { status: 403, headers: { "content-type": "application/json" } });
+  if (targetUrl.username || targetUrl.password) return new Response(JSON.stringify({ error: "forbidden x-relay-target (embedded credentials)" }), { status: 403, headers: { "content-type": "application/json" } });
+  if (isPrivateHostname(targetUrl.hostname)) return new Response(JSON.stringify({ error: "forbidden x-relay-target (private/loopback host)" }), { status: 403, headers: { "content-type": "application/json" } });
+  const cleanTarget = target.replace(/\/$/, "");
   if (!ALLOWED_TARGETS.includes(cleanTarget)) return new Response(JSON.stringify({ error: "Forbidden target" }), { status: 403, headers: { "content-type": "application/json" } });
-  if (!relayPath.startsWith("/")) return new Response(JSON.stringify({ error: "Bad path" }), { status: 400, headers: { "content-type": "application/json" } });
+  const relayPath = request.headers.get("x-relay-path") || "/";
+  const resolved = resolveRelayTarget(target, relayPath);
+  if (!resolved.ok) return new Response(JSON.stringify({ error: resolved.reason }), { status: resolved.status, headers: { "content-type": "application/json" } });
   const headers = new Headers(request.headers);
-  headers.delete("x-relay-target"); headers.delete("x-relay-path"); headers.delete("host");
+  ["host", "connection", "content-length", "keep-alive", "proxy-connection", "proxy-authenticate", "proxy-authorization", "transfer-encoding", "te", "trailer", "upgrade", "x-relay-target", "x-relay-path", "x-relay-auth"].forEach((h) => headers.delete(h));
   try {
-    const response = await fetch(cleanTarget + relayPath, { method: request.method, headers, body: request.method !== "GET" && request.method !== "HEAD" ? request.body : undefined });
+    const init = { method: request.method, headers };
+    if (request.method !== "GET" && request.method !== "HEAD") { init.body = request.body; init.duplex = "half"; }
+    const response = await fetch(resolved.url, init);
     return new Response(response.body, { status: response.status, headers: response.headers });
   } catch (error) {
     return new Response(JSON.stringify({ error: String(error) }), { status: 502, headers: { "content-type": "application/json" } });

package/src/stream-pipe.ts

@@ -223,9 +223,14 @@ export function pipeUpstreamStream(
 					// is not at fault; still give the host a terminal event.
 					ensureTerminalEvent(false, "stream interrupted by client", false);
 				} else {
-					// Upstream socket died mid-stream with no error event:
-					// genuine upstream truncation — penalize the relay.
-					ensureTerminalEvent(true, "stream closed prematurely");
+					// Upstream socket died mid-stream with no error event.
+					// For muse-spark large payloads: raxtant 514KB failed but feoni 802KB
+					// succeeded with same 2.6MB in — so this is edge-specific, not pure
+					// provider token limit. Keep penalize=true to rotate failing relay,
+					// but inject incomplete (not failed) for substantial to avoid alarming
+					// stream_error. Small premature (<50 chunks) stays failed+penalize.
+					const isSubstantial = totalChunks > 50 && totalBytes > 100 * 1024;
+					ensureTerminalEvent(!isSubstantial, "stream closed prematurely", true);
 				}
 			}
 			if (!res.writableEnded) res.end();

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
+	}
+}