pi-freeflow 1.4.1 → 1.4.3

package/src/relay-state.ts

@@ -41,6 +41,32 @@ export function loadRelayState(): RelayState {
 	}
 }
 
+/** Block synchronously for ms without burning CPU. */
+function sleepSync(ms: number): void {
+	Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, Date.now() + ms);
+}
+
+/**
+ * Rename with bounded retry: Windows briefly locks the target when another
+ * process holds the state file open, surfacing as EPERM/EACCES/EBUSY.
+ * Three attempts with a fixed 50ms backoff; any other error fails immediately.
+ */
+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);
+		}
+	}
+}
+
 /**
  * Atomically save relay state to disk using a temporary file and rename.
  */
@@ -52,7 +78,7 @@ export function saveRelayState(s: RelayState): void {
 		}
 		const tmpPath = `${RELAY_STATE_FILE}.${randomUUID()}.tmp`;
 		fs.writeFileSync(tmpPath, JSON.stringify(s, null, 2), "utf8");
-		fs.renameSync(tmpPath, RELAY_STATE_FILE);
+		renameWithRetry(tmpPath, RELAY_STATE_FILE);
 	} catch (e) {
 		logWarn("Could not persist relay state", { error: String(e) });
 	}
@@ -212,10 +238,13 @@ export function markRelayFailure(url: string, status?: number, error?: string):
 		cooldownMs = 45_000; // 45s for 5xx errors
 	}
 
+	// Escalate with consecutive failures so chronic offenders back off up to
+	// 4x their base cooldown instead of re-hammering at a fixed interval.
+	const multiplier = Math.min(4, consecutive);
 	relayHealthMap.set(clean, {
 		consecutiveFailures: consecutive,
 		lastFailureTime: now,
-		cooldownUntil: now + cooldownMs,
+		cooldownUntil: now + cooldownMs * multiplier,
 		lastStatus: status,
 		lastError: error,
 	});
@@ -370,9 +399,9 @@ export function getOrderedRelayUrls(): string[] {
 		const cooling = rawOrdered.filter((u) => !isRelayHealthy(u));
 		const ordered = [...healthy, ...cooling];
 
-		return ordered.length > 0 ? ordered : [DEFAULT_RELAY_URL];
+		return ordered;
 	}
-	return [DEFAULT_RELAY_URL];
+	return [];
 }
 
 /**

package/src/relay.ts

@@ -1,201 +1,213 @@
-/**
- * High-resiliency multi-cloud relay client and failover dispatcher for pi-freeflow
- *
- * Implements sticky preference, rolling failover across distributed egress relays,
- * 25-second fast fallback for Vercel 504 timeouts, and automatic direct upstream execution.
- */
-
-import { randomUUID } from "node:crypto";
-import { Buffer } from "node:buffer";
-import { isDebugEnabled, log } from "./logger.ts";
-import {
-	getActiveRelayState,
-	getOrderedRelayUrls,
-	markRelayFailure,
-	markRelaySuccess,
-	saveRelayState,
-	setActiveRelayState,
-	shortRelayLabel,
-	updateRelayStatusUi,
-} from "./relay-state.ts";
-
-/**
- * Determine if an HTTP status code indicates a temporary relay or upstream error
- * that warrants rolling to the next relay candidate.
- */
-export function isRetriableStatus(status: number): boolean {
-	return (
-		status === 429 ||
-		status === 408 ||
-		status === 500 ||
-		status === 502 ||
-		status === 503 ||
-		status === 504 ||
-		(status >= 520 && status <= 530)
-	);
-}
-
-/**
- * Fetch a target URL through the active relay pool with rolling failover and direct fallback.
- *
- * @param url Full upstream destination URL (e.g. https://opencode.ai/zen/v1/chat/completions)
- * @param opts Standard fetch RequestInit options
- * @param reqId Optional correlation request ID for end-to-end tracing
- */
-export async function relayFetch(
-	url: string,
-	opts: RequestInit = {},
-	reqId?: string,
-): Promise<Response> {
-	const rid = reqId || randomUUID().slice(0, 8);
-	const relayState = getActiveRelayState();
-
-	if (!relayState.enabled) {
-		log("debug", `relayFetch: direct (relay disabled) -> ${url}`, undefined, rid);
-		return fetch(url, opts);
-	}
-
-	const candidates = getOrderedRelayUrls();
-	let lastResponse: Response | null = null;
-	let lastError: unknown = null;
-	const u = new URL(url);
-	const relayTarget = `${u.protocol}//${u.host}`;
-	const relayPath = `${u.pathname}${u.search}`;
-
-	const bodySizeKB =
-		typeof opts.body === "string"
-			? (opts.body.length / 1024).toFixed(1)
-			: Buffer.isBuffer(opts.body)
-				? (opts.body.length / 1024).toFixed(1)
-				: "0";
-
-	log("info", `request starting (${bodySizeKB}KB payload) -> ${url}`, undefined, rid);
-	if (isDebugEnabled()) {
-		try {
-			const bodyPreview = typeof opts.body === "string" ? opts.body.slice(0, 1200) : "";
-			const modelMatch = bodyPreview.match(/"model"\s*:\s*"([^"]+)"/);
-			const streamMatch = bodyPreview.match(/"stream"\s*:\s*(true|false)/);
-			log("debug", "request detail", {
-				model: modelMatch?.[1],
-				stream: streamMatch?.[1],
-				sizeKB: bodySizeKB,
-				relayTarget,
-				relayPath,
-				candidates: candidates.length,
-			}, rid);
-		} catch {}
-	}
-
-	for (let i = 0; i < candidates.length; i++) {
-		const targetUrl = candidates[i];
-		const attemptStart = Date.now();
-		try {
-			let targetHost = "opencode.ai";
-			try {
-				if (targetUrl) targetHost = new URL(targetUrl).host;
-			} catch {}
-
-			const headers = new Headers(opts.headers);
-			headers.set("x-relay-target", relayTarget);
-			headers.set("x-relay-path", relayPath);
-			headers.set("host", targetHost);
-			headers.set("x-request-id", rid);
-
-			const signal = opts.signal || AbortSignal.timeout(300_000);
-			const res = await fetch(targetUrl, { ...opts, headers, signal });
-			const elapsed = ((Date.now() - attemptStart) / 1000).toFixed(1);
-
-			// Vercel 504 Gateway Timeout on heavy prompts (>50KB or >25s):
-			// Fast fallback directly to upstream instead of cycling through multiple 25s timeouts.
-			if (res.status === 504) {
-				markRelayFailure(targetUrl, 504, "Gateway Timeout (25s exceeded)");
-				log(
-					"warn",
-					`relay ${targetUrl} hit HTTP 504 Gateway Timeout in ${elapsed}s (prompt evaluation exceeded Vercel 25s limit) — fast fallback to direct upstream`,
-					{ upstream: url, sizeKB: bodySizeKB },
-					rid,
-				);
-				break;
-			}
-
-			if (isRetriableStatus(res.status)) {
-				markRelayFailure(targetUrl, res.status);
-				lastResponse = res;
-				log(
-					"warn",
-					`relay ${targetUrl} returned HTTP ${res.status} in ${elapsed}s — rolling to next relay`,
-					{ upstream: url, status: res.status },
-					rid,
-				);
-				continue;
-			}
-
-			markRelaySuccess(targetUrl);
-
-			// SUCCESS or non-retriable client error (e.g. 200, 404):
-			// If we switched to a different relay because previous failed, update sticky active relay!
-			if (relayState.url !== targetUrl) {
-				log("info", `active relay auto-switched to ${targetUrl}`, {
-					previous: relayState.url,
-				}, rid);
-				relayState.url = targetUrl;
-				saveRelayState(relayState);
-				setActiveRelayState(relayState, false);
-			}
-
-			log("info", `relay ${targetUrl} succeeded (HTTP ${res.status} in ${elapsed}s)`, undefined, rid);
-			if (isDebugEnabled()) {
-				log("debug", "relay headers", {
-					status: res.status,
-					contentType: res.headers.get("content-type"),
-					via: res.headers.get("via") || res.headers.get("x-vercel-id") || "direct",
-				}, rid);
-			}
-
-			updateRelayStatusUi(targetUrl);
-			return res;
-		} catch (err) {
-			const elapsed = ((Date.now() - attemptStart) / 1000).toFixed(1);
-			lastError = err;
-			const errMsg = (err as Error)?.message || String(err);
-			markRelayFailure(targetUrl, 0, errMsg);
-			log(
-				"warn",
-				`relay ${targetUrl} fetch error in ${elapsed}s — rolling to next relay`,
-				{ upstream: url, error: errMsg },
-				rid,
-			);
-			continue;
-		}
-	}
-
-	// Full fallback: attempt direct fetch to upstream
-	const directStart = Date.now();
-	try {
-		log("warn", "relays bypassed/exhausted — attempting direct fetch to upstream", {
-			upstream: url,
-			sizeKB: bodySizeKB,
-		}, rid);
-
-		const directHeaders = new Headers(opts.headers);
-		directHeaders.delete("x-relay-target");
-		directHeaders.delete("x-relay-path");
-		directHeaders.set("host", u.host);
-		directHeaders.set("x-request-id", rid);
-
-		const directRes = await fetch(url, { ...opts, headers: directHeaders });
-		const directElapsed = ((Date.now() - directStart) / 1000).toFixed(1);
-		log("info", `direct fetch returned HTTP ${directRes.status} in ${directElapsed}s`, undefined, rid);
-		return directRes;
-	} catch (directErr) {
-		const directElapsed = ((Date.now() - directStart) / 1000).toFixed(1);
-		log("error", `direct fallback also failed in ${directElapsed}s`, {
-			upstream: url,
-			error: String(directErr),
-		}, rid);
-		if (lastResponse) {
-			return lastResponse;
-		}
-		throw directErr || lastError;
-	}
-}
+/**
+ * High-resiliency multi-cloud relay client and failover dispatcher for pi-freeflow
+ *
+ * Implements sticky preference, rolling failover across distributed egress relays,
+ * 25-second fast fallback for Vercel 504 timeouts, and automatic direct upstream execution.
+ */
+
+import { randomUUID } from "node:crypto";
+import { Buffer } from "node:buffer";
+import { isDebugEnabled, log } from "./logger.ts";
+import {
+	getActiveRelayState,
+	getOrderedRelayUrls,
+	markRelayFailure,
+	markRelaySuccess,
+	saveRelayState,
+	setActiveRelayState,
+	shortRelayLabel,
+	updateRelayStatusUi,
+} from "./relay-state.ts";
+
+/**
+ * Determine if an HTTP status code indicates a temporary relay or upstream error
+ * that warrants rolling to the next relay candidate.
+ */
+export function isRetriableStatus(status: number): boolean {
+	return (
+		status === 429 ||
+		status === 408 ||
+		status === 502 ||
+		status === 503 ||
+		status === 504 ||
+		(status >= 520 && status <= 530)
+	);
+}
+
+/**
+ * Fetch a target URL through the active relay pool with rolling failover and direct fallback.
+ *
+ * @param url Full upstream destination URL (e.g. https://opencode.ai/zen/v1/chat/completions)
+ * @param opts Standard fetch RequestInit options
+ * @param reqId Optional correlation request ID for end-to-end tracing
+ */
+export async function relayFetch(
+	url: string,
+	opts: RequestInit = {},
+	reqId?: string,
+): Promise<Response> {
+	const rid = reqId || randomUUID().slice(0, 8);
+	const relayState = getActiveRelayState();
+
+	if (!relayState.enabled) {
+		log("debug", `relayFetch: direct (relay disabled) -> ${url}`, undefined, rid);
+		return fetch(url, opts);
+	}
+
+	const candidates = getOrderedRelayUrls();
+
+	if (candidates.length === 0) {
+		// Empty pool: skip straight to upstream instead of logging a misleading
+		// "relays bypassed/exhausted" WARN on every request.
+		log("debug", `relayFetch: direct (empty relay pool) -> ${url}`, undefined, rid);
+		return fetch(url, opts);
+	}
+
+	let lastResponse: Response | null = null;
+	let lastError: unknown = null;
+	const u = new URL(url);
+	const relayTarget = `${u.protocol}//${u.host}`;
+	const relayPath = `${u.pathname}${u.search}`;
+
+	const bodySizeKB =
+		typeof opts.body === "string"
+			? (opts.body.length / 1024).toFixed(1)
+			: Buffer.isBuffer(opts.body)
+				? (opts.body.length / 1024).toFixed(1)
+				: "0";
+
+	log("info", `request starting (${bodySizeKB}KB payload) -> ${url}`, undefined, rid);
+	if (isDebugEnabled()) {
+		try {
+			const bodyPreview = typeof opts.body === "string" ? opts.body.slice(0, 1200) : "";
+			const modelMatch = bodyPreview.match(/"model"\s*:\s*"([^"]+)"/);
+			const streamMatch = bodyPreview.match(/"stream"\s*:\s*(true|false)/);
+			log("debug", "request detail", {
+				model: modelMatch?.[1],
+				stream: streamMatch?.[1],
+				sizeKB: bodySizeKB,
+				relayTarget,
+				relayPath,
+				candidates: candidates.length,
+			}, rid);
+		} catch {}
+	}
+
+	for (let i = 0; i < candidates.length; i++) {
+		const targetUrl = candidates[i];
+		const attemptStart = Date.now();
+		try {
+			let targetHost = "opencode.ai";
+			try {
+				if (targetUrl) targetHost = new URL(targetUrl).host;
+			} catch {}
+
+			const headers = new Headers(opts.headers);
+			headers.set("x-relay-target", relayTarget);
+			headers.set("x-relay-path", relayPath);
+			headers.set("host", targetHost);
+			headers.set("x-request-id", rid);
+
+			const signal = opts.signal || AbortSignal.timeout(300_000);
+			const res = await fetch(targetUrl, { ...opts, headers, signal });
+			const elapsed = ((Date.now() - attemptStart) / 1000).toFixed(1);
+
+			// Vercel 504 Gateway Timeout on heavy prompts (>50KB or >25s):
+			// Fast fallback directly to upstream instead of cycling through multiple 25s timeouts.
+			if (res.status === 504) {
+				markRelayFailure(targetUrl, 504, "Gateway Timeout (25s exceeded)");
+				res.body?.cancel().catch(() => {});
+				log(
+					"warn",
+					`relay ${targetUrl} hit HTTP 504 Gateway Timeout in ${elapsed}s (prompt evaluation exceeded Vercel 25s limit) — fast fallback to direct upstream`,
+					{ upstream: url, sizeKB: bodySizeKB },
+					rid,
+				);
+				break;
+			}
+
+			if (isRetriableStatus(res.status)) {
+				markRelayFailure(targetUrl, res.status);
+				lastResponse?.body?.cancel().catch(() => {});
+				lastResponse = res;
+				log(
+					"warn",
+					`relay ${targetUrl} returned HTTP ${res.status} in ${elapsed}s — rolling to next relay`,
+					{ upstream: url, status: res.status },
+					rid,
+				);
+				continue;
+			}
+
+			markRelaySuccess(targetUrl);
+
+			// SUCCESS or non-retriable client error (e.g. 200, 404):
+			// If we switched to a different relay because previous failed, update sticky active relay!
+			if (relayState.url !== targetUrl) {
+				log("info", `active relay auto-switched to ${targetUrl}`, {
+					previous: relayState.url,
+				}, rid);
+				relayState.url = targetUrl;
+				saveRelayState(relayState);
+				setActiveRelayState(relayState, false);
+			}
+
+			log("info", `relay ${targetUrl} succeeded (HTTP ${res.status} in ${elapsed}s)`, undefined, rid);
+			if (isDebugEnabled()) {
+				log("debug", "relay headers", {
+					status: res.status,
+					contentType: res.headers.get("content-type"),
+					via: res.headers.get("via") || res.headers.get("x-vercel-id") || "direct",
+				}, rid);
+			}
+
+			updateRelayStatusUi(targetUrl);
+			return res;
+		} catch (err) {
+			const elapsed = ((Date.now() - attemptStart) / 1000).toFixed(1);
+			lastError = err;
+			const errMsg = (err as Error)?.message || String(err);
+			markRelayFailure(targetUrl, 0, errMsg);
+			log(
+				"warn",
+				`relay ${targetUrl} fetch error in ${elapsed}s — rolling to next relay`,
+				{ upstream: url, error: errMsg },
+				rid,
+			);
+			continue;
+		}
+	}
+
+	// Full fallback: attempt direct fetch to upstream
+	const directStart = Date.now();
+	try {
+		log("warn", "relays bypassed/exhausted — attempting direct fetch to upstream", {
+			upstream: url,
+			sizeKB: bodySizeKB,
+		}, rid);
+
+		const directHeaders = new Headers(opts.headers);
+		directHeaders.delete("x-relay-target");
+		directHeaders.delete("x-relay-path");
+		directHeaders.set("host", u.host);
+		directHeaders.set("x-request-id", rid);
+
+		const directRes = await fetch(url, { ...opts, headers: directHeaders });
+		const directElapsed = ((Date.now() - directStart) / 1000).toFixed(1);
+		log("info", `direct fetch returned HTTP ${directRes.status} in ${directElapsed}s`, undefined, rid);
+		// lastResponse holds an unread body that would otherwise leak its socket
+		// until GC; the salvage path below still needs it, so only cancel here.
+		lastResponse?.body?.cancel().catch(() => {});
+		return directRes;
+	} catch (directErr) {
+		const directElapsed = ((Date.now() - directStart) / 1000).toFixed(1);
+		log("error", `direct fallback also failed in ${directElapsed}s`, {
+			upstream: url,
+			error: String(directErr),
+		}, rid);
+		if (lastResponse) {
+			return lastResponse;
+		}
+		throw directErr || lastError;
+	}
+}