pi-freeflow 1.8.1 → 1.8.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pi-freeflow",
   "type": "module",
-  "version": "1.8.1",
+  "version": "1.8.2",
   "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/catalog.ts

@@ -191,7 +191,28 @@ export function readCatalogCache(): CatalogCacheData | null {
 /**
  * Atomically write catalog cache data to disk using temporary file + rename.
  * Persists etag alongside models for subsequent If-None-Match conditional requests.
+ * Note: fsync not needed — rename is atomic on same filesystem; crash leaves either old or new file intact.
  */
+function sleepSync(ms: number): void {
+	Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+
+function renameWithRetry(from: string, to: string): void {
+	const retryable: Record<string, true> = { EPERM: true, EACCES: true, EBUSY: true };
+	for (let attempt = 1; ; attempt++) {
+		try {
+			fs.renameSync(from, to);
+			return;
+		} catch (e) {
+			const code = (e as NodeJS.ErrnoException | null)?.code;
+			if (!code || !retryable[code] || attempt >= 3) {
+				throw e;
+			}
+			sleepSync(50);
+		}
+	}
+}
+
 export function writeCatalogCache(data: CatalogCacheData): void {
 	try {
 		const dir = path.dirname(CATALOG_CACHE_FILE);
@@ -200,7 +221,7 @@ export function writeCatalogCache(data: CatalogCacheData): void {
 		}
 		const tmpPath = `${CATALOG_CACHE_FILE}.${randomUUID()}.tmp`;
 		fs.writeFileSync(tmpPath, JSON.stringify(data, null, 2), "utf8");
-		fs.renameSync(tmpPath, CATALOG_CACHE_FILE);
+		renameWithRetry(tmpPath, CATALOG_CACHE_FILE);
 	} catch (err) {
 		logWarn("Could not persist catalog cache to disk", { error: String(err) });
 	}

package/src/commands.ts

@@ -350,12 +350,13 @@ export function createCommandSpec(
 					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);
+					relayState = withRelayState((s) => {
+						const r = ensureRelay(s, url, `deployed ${name}`);
+						r.auth = auth;
+						s.enabled = true;
+						s.url = url;
+						return s;
+					});
 					persist();
 					let probeNote = "";
 					try {
@@ -589,12 +590,17 @@ export function createCommandSpec(
 					const tokens = rest.trim().split(/\s+/);
 					const targetUrl = tokens[0];
 					const customLabel = tokens.slice(1).join(" ").trim() || undefined;
-					applyRelayState((s) => {
-						const added = ensureRelay(s, targetUrl, customLabel);
-						s.enabled = true;
-						s.url = added.url;
-						return s;
-					});
+					try {
+						applyRelayState((s) => {
+							const added = ensureRelay(s, targetUrl, customLabel);
+							s.enabled = true;
+							s.url = added.url;
+							return s;
+						});
+					} catch (e) {
+						ctx.ui.notify((e as Error).message, "warning");
+						return;
+					}
 					persist();
 					flash();
 					ctx.ui.notify(
@@ -632,12 +638,17 @@ export function createCommandSpec(
 						} catch {}
 						const looksLikeUrl = parsedUrl && (parsedUrl.protocol === "http:" || parsedUrl.protocol === "https:");
 						if (looksLikeUrl) {
-							applyRelayState((s) => {
-								const added = ensureRelay(s, targetToken, customLabel);
-								s.enabled = true;
-								s.url = added.url;
-								return s;
-							});
+							try {
+								applyRelayState((s) => {
+									const added = ensureRelay(s, targetToken, customLabel);
+									s.enabled = true;
+									s.url = added.url;
+									return s;
+								});
+							} catch (e) {
+								ctx.ui.notify((e as Error).message, "warning");
+								return;
+							}
 							persist();
 							flash();
 						} else {

package/src/config.ts

@@ -75,7 +75,7 @@ export const RATE_LIMIT_MAX: Record<Upstream, number> = {
 };
 
 // ── Whitelists & Security ───────────────────────────────────────────
-export const ALLOWED_PATH_PATTERN = /^\/v1\/[a-zA-Z0-9/_.,\-?&=]*$/;
+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"]);
 

package/src/deploy.ts

@@ -75,6 +75,8 @@ const timingSafeEqualStr = function(a, b) {
 // (never forwarded upstream) instead of living in the denylist.
 const DENY_HEADERS = ["host", "connection", "content-length", "keep-alive", "proxy-connection", "proxy-authenticate", "proxy-authorization", "transfer-encoding", "te", "trailer", "upgrade", "x-relay-target", "x-relay-path"];
 async function relayHandler(req) {
+  if (!["GET", "POST", "HEAD", "OPTIONS"].includes(req.method)) return new Response("Method Not Allowed", { status: 405 });
+  if (Number(req.headers.get("content-length") || 0) > 32 * 1024 * 1024) return new Response("Payload Too Large", { status: 413 });
   const target = req.headers.get("x-relay-target");
   if (!target) return new Response(JSON.stringify({ error: "Missing x-relay-target header" }), { status: 400, headers: { "content-type": "application/json" } });
   if (RELAY_AUTH && !timingSafeEqualStr(req.headers.get("x-relay-auth") || "", RELAY_AUTH)) {
@@ -159,11 +161,11 @@ export async function deployVercelRelay(
 	name: string,
 	onProgress?: (msg: string) => void,
 ): Promise<{ url: string; auth: string }> {
+	name = baseRelayName(name) || "relay-worker";
 	const auth = {
 		Authorization: `Bearer ${token}`,
 		"Content-Type": "application/json",
 	};
-
 	// 1. Create deployment (3 inline files, no git repository required)
 	onProgress?.("Uploading relay files to Vercel…");
 	log("info", `Starting Vercel deployment: ${name}`);

package/src/health.ts

@@ -55,7 +55,8 @@ export function getHealthData(portOverride?: number): HealthData {
 
 function isLoopbackIP(ip: string): boolean {
 	if (!ip) return false;
-	const clean = ip.startsWith("::ffff:") ? ip.slice(7) : ip;
+	const withoutZone = ip.split("%")[0];
+	const clean = withoutZone.startsWith("::ffff:") ? withoutZone.slice(7) : withoutZone;
 	return clean === "127.0.0.1" || clean === "::1" || clean === "localhost";
 }
 

package/src/index.ts

@@ -150,7 +150,7 @@ export function buildProviderConfig(
 						: m.source === "kilo"
 							? {
 									supportsDeveloperRole: false,
-									supportsReasoningEffort: false,
+									supportsReasoningEffort: !!m.thinkingLevelMap,
 								}
 							: {
 									supportsDeveloperRole: false,

package/src/logger.ts

@@ -197,6 +197,10 @@ export function formatLogMeta(
 	if (meta && Object.keys(meta).length > 0) {
 		const safe: Record<string, unknown> = {};
 		for (const [k, v] of Object.entries(meta)) {
+			if (/(auth|token|secret|password|bearer|api.?key|cookie|x-relay-auth)/i.test(k)) {
+				safe[k] = "[REDACTED]";
+				continue;
+			}
 			if (typeof v === "string" && v.length > 800) {
 				safe[k] = `${v.slice(0, 800)}…(${v.length})`;
 			} else if (v instanceof Error) {

package/src/proxy.ts

@@ -66,6 +66,7 @@ export function validatePath(rawUrl: string): URL | null {
 	if (PATH_TRAVERSAL_PATTERN.test(cleaned)) return null;
 	try {
 		const decoded = decodeURIComponent(cleaned);
+		if (PATH_TRAVERSAL_PATTERN.test(decoded)) return null;
 		if (decoded !== cleaned && !ALLOWED_PATH_PATTERN.test(`/${decoded}`)) {
 			return null;
 		}
@@ -171,6 +172,7 @@ export async function killPortHolder(port: number): Promise<boolean> {
 			}) as string;
 			const pid = out.trim().split(/\s+/)[0];
 			if (!pid || !/^\d+$/.test(pid)) return false;
+			if (Number(pid) === process.pid) return false; // never self-kill (Unix) — matches Windows guard at 161
 			execSync(`kill -9 ${pid}`, { timeout: 3000, stdio: "ignore" });
 			return true;
 		} catch {
@@ -522,7 +524,7 @@ export function startProxy(
 					fwd["connection"] = "keep-alive";
 
 					const controller = new AbortController();
-					const timeoutId = setTimeout(() => controller.abort(), 300_000);
+					const timeoutId = setTimeout(() => controller.abort(upstreamTimeoutError()), UPSTREAM_HEADER_TIMEOUT_MS);
 					const onClientClose = () => {
 						if (!res.writableEnded) controller.abort();
 					};
@@ -600,6 +602,7 @@ export function startProxy(
 			let settled = false;
 
 			const tryListen = async (port: number) => {
+				server.removeAllListeners("error");
 				server.once("error", async (err: NodeJS.ErrnoException) => {
 					if (settled) return;
 					if (err.code === "EADDRINUSE") {

package/src/relay-state.ts

@@ -512,7 +512,7 @@ lastKnownStateMtimeMs = currentDiskStateMtimeMs();
  */
 export function getActiveRelayState(): RelayState {
 	const currentMtime = currentDiskStateMtimeMs();
-	if (currentMtime > 0 && currentMtime > lastKnownStateMtimeMs) {
+	if (currentMtime !== lastKnownStateMtimeMs) {
 		activeRelayState = resolveRelayState();
 		lastKnownStateMtimeMs = currentMtime;
 	}