pi-freeflow 1.11.0 → 1.11.2

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## 1.11.2
+
+### Patch Changes
+
+- 549b66e: Oversized requests no longer fail at the relay hop: when a relay answers 413 payload limit, the proxy transparently tries the next relay and then the direct route, keeping the stream alive. Long sessions that outgrow the relay payload cap now complete instead of surfacing a function payload error.
+
+## 1.11.1
+
+### Patch Changes
+
+- Apologies for the daemon disconnect bug introduced in v1.11.0: in multi-agent workflows or when subagents, evaluations, and background tasks completed, the extension prematurely detached from the local proxy daemon, causing the proxy to shut down while your main session remained active. The heartbeat connection now persists throughout your active terminal session.
+- Increased local health check and liveness probe timeouts from 800ms and 500ms to 2500ms and 1500ms, with an automatic probe retry to avoid false-alarm daemon restarts during heavy concurrent streaming.
+- Added unhandled error logging inside the daemon to prevent silent process exits.
+- Fresh installs now log full HTTP lifecycle debug output by default so diagnostic reports contain complete request context; turn it off anytime with `/freeflow debug off`.
+
 ## 1.11.0
 
 ### Minor Changes

package/README.md

@@ -250,7 +250,7 @@ cat ~/.pi/agent/pi-freeflow.log | tail -n 20
 /freeflow logs
 cat ~/.pi/agent/pi-freeflow.log | tail -n 50
 
-# debug toggle
+# debug toggle (full debug is on by default for complete error reports; `off` restores info)
 /freeflow debug on
 ```
 

package/package.json

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

@@ -349,6 +349,14 @@ export async function watchdogCheck(port: number): Promise<void> {
 	} catch {
 		return;
 	}
+	if (health === null) {
+		await new Promise<void>((r) => setTimeout(r, 200));
+		try {
+			health = await getDaemonHealth(port);
+		} catch {
+			return;
+		}
+	}
 	if (health && (health.activeRequests ?? 0) > 0) {
 		trackBusyEdge(health.activeRequests ?? 0, health.lastBytesAt ?? 0);
 	} else {
@@ -566,6 +574,15 @@ export function getClientId(): string {
 	return CLIENT_ID;
 }
 
+export function hasFallbackServer(): boolean {
+	return fallbackServer !== null;
+}
+
+/** Test seam: true when client heartbeat timer is active. */
+export function isHeartbeatActive(): boolean {
+	return heartbeatTimer !== null;
+}
+
 export function _resetClientForTest(): void {
 	stopHeartbeatInternal();
 	heartbeatPort = 0;

package/src/daemon.ts

@@ -98,6 +98,12 @@ export async function runDaemon(): Promise<void> {
 	};
 	process.on("SIGTERM", () => retire("SIGTERM"));
 	process.on("SIGINT", () => retire("SIGINT"));
+	process.on("uncaughtException", (err) => {
+		log("error", "daemon uncaughtException", { error: String(err), stack: (err as Error)?.stack });
+	});
+	process.on("unhandledRejection", (reason) => {
+		log("error", "daemon unhandledRejection", { error: String(reason) });
+	});
 	setShutdownShouldExit(true);
 	try {
 		const r = await startProxy();

package/src/index.ts

@@ -16,7 +16,7 @@ import {
 	refreshCatalog,
 	setAliveCatalog,
 } from "./catalog.ts";
-import { ensureDaemon as ensureClientDaemon, getClientPort, stopHeartbeat } from "./client.ts";
+import { ensureDaemon as ensureClientDaemon, getClientPort, hasFallbackServer, stopHeartbeat } from "./client.ts";
 import { createCommandSpec, stopLogsFollow, updateStatusBar } from "./commands.ts";
 import { HOST, ONBOARDED_FLAG_FILE, PORT } from "./config.ts";
 import { logInfo, logWarn } from "./logger.ts";
@@ -328,7 +328,14 @@ export default async function (pi: ExtensionAPI): Promise<void> {
 		}
 	});
 	pi.on?.("session_shutdown", () => {
-		stopHeartbeat();
 		stopLogsFollow();
+		if (hasFallbackServer()) {
+			stopHeartbeat();
+		}
+	});
+	process.once("exit", () => {
+		try {
+			stopHeartbeat();
+		} catch {}
 	});
 }

package/src/lease.ts

@@ -1,116 +1,116 @@
-/**
- * Client lease registry for the detached pi-freeflow proxy daemon.
- *
- * Each OMP/Pi session is a client that registers a lease and renews it with a
- * heartbeat while alive. The daemon drops expired leases and retires itself
- * once NO client holds a live lease: the empty state must persist for the
- * grace window (a fresh spawn's clients re-attach within seconds) with
- * nothing in flight. Request-idleness alone NEVER retires the daemon.
- *
- * The request-touch (`lastActivityAt`) is still recorded and surfaced in
- * /_health for observability, but it no longer gates retirement.
- */
-
-export interface LeaseOptions {
-	/** Lease lifetime (ms); a client that misses ~3 beats is dropped. */
-	ttlMs: number;
-	/** GC sweep interval (ms). */
-	gcMs: number;
-	/** Zero-lease persistence window (ms): how long leases must stay empty before a lease-less daemon exits. */
-	graceMs: number;
-	/** Current in-flight proxied requests — daemon never exits mid-stream. */
-	getActiveRequests: () => number;
-	/** Called once when the daemon should retire (close server + exit). */
-	onIdle: () => void;
-}
-
-const leases = new Map<string, number>();
-let lastActivityAt = Date.now();
-let gcTimer: ReturnType<typeof setInterval> | null = null;
-/** First sweep timestamp at which leases were observed empty; null while any lease exists. */
-let emptySince: number | null = null;
-
-/** Register or refresh a client lease. */
-export function registerClient(clientId: string): void {
-	leases.set(clientId, Date.now());
-}
-
-/** Renew an existing client lease. Returns false when the id is unknown (daemon restarted). */
-export function renewClient(clientId: string): boolean {
-	if (leases.has(clientId)) {
-		leases.set(clientId, Date.now());
-		return true;
-	}
-	return false;
-}
-
-/** Remove a client lease (graceful detach on session end). */
-export function unregisterClient(clientId: string): void {
-	leases.delete(clientId);
-}
-
-/** Number of clients holding a live lease. */
-export function getLeaseCount(): number {
-	return leases.size;
-}
-
-/** Snapshot of live client leases (id -> lastSeenAt) for health/debugging. */
-export function getLeaseSnapshot(): Record<string, number> {
-	return Object.fromEntries(leases);
-}
-
-/** Record proxy activity — any proxied request counts as a live user. */
-export function touchActivity(): void {
-	lastActivityAt = Date.now();
-}
-
-/** Timestamp of the last proxied request (0 = never; daemon inits at bind). */
-export function getLastActivityAt(): number {
-	return lastActivityAt;
-}
-
-/**
- * Start the lease GC sweep. Prunes expired leases and, when no client holds a
- * lease, nothing is in flight, and the lease-less state has persisted for the
- * grace window, invokes `onIdle` (the daemon retires). Idempotent — a second
- * call is a no-op.
- */
-export function startLeaseGC(opts: LeaseOptions): void {
-	if (gcTimer !== null) return;
-	gcTimer = setInterval(() => {
-		const now = Date.now();
-		for (const [id, seenAt] of leases) {
-			if (now - seenAt > opts.ttlMs) {
-				leases.delete(id);
-			}
-		}
-		if (leases.size > 0) {
-			emptySince = null;
-			return;
-		}
-		if (emptySince === null) {
-			emptySince = now;
-			return;
-		}
-		if (opts.getActiveRequests() === 0 && now - emptySince >= opts.graceMs) {
-			stopLeaseGC();
-			opts.onIdle();
-		}
-	}, opts.gcMs);
-}
-
-/** Stop the GC sweep (test teardown / daemon shutdown). */
-export function stopLeaseGC(): void {
-	if (gcTimer !== null) {
-		clearInterval(gcTimer);
-		gcTimer = null;
-	}
-}
-
-/** Test-only: reset all lease state. */
-export function _resetLeaseStateForTest(): void {
-	leases.clear();
-	lastActivityAt = Date.now();
-	emptySince = null;
-	stopLeaseGC();
-}
+/**
+ * Client lease registry for the detached pi-freeflow proxy daemon.
+ *
+ * Each OMP/Pi session is a client that registers a lease and renews it with a
+ * heartbeat while alive. The daemon drops expired leases and retires itself
+ * once NO client holds a live lease: the empty state must persist for the
+ * grace window (a fresh spawn's clients re-attach within seconds) with
+ * nothing in flight. Request-idleness alone NEVER retires the daemon.
+ *
+ * The request-touch (`lastActivityAt`) is still recorded and surfaced in
+ * /_health for observability, but it no longer gates retirement.
+ */
+
+export interface LeaseOptions {
+	/** Lease lifetime (ms); a client that misses ~3 beats is dropped. */
+	ttlMs: number;
+	/** GC sweep interval (ms). */
+	gcMs: number;
+	/** Zero-lease persistence window (ms): how long leases must stay empty before a lease-less daemon exits. */
+	graceMs: number;
+	/** Current in-flight proxied requests — daemon never exits mid-stream. */
+	getActiveRequests: () => number;
+	/** Called once when the daemon should retire (close server + exit). */
+	onIdle: () => void;
+}
+
+const leases = new Map<string, number>();
+let lastActivityAt = 0;
+let gcTimer: ReturnType<typeof setInterval> | null = null;
+/** First sweep timestamp at which leases were observed empty; null while any lease exists. */
+let emptySince: number | null = null;
+
+/** Register or refresh a client lease. */
+export function registerClient(clientId: string): void {
+	leases.set(clientId, Date.now());
+}
+
+/** Renew an existing client lease. Returns false when the id is unknown (daemon restarted). */
+export function renewClient(clientId: string): boolean {
+	if (leases.has(clientId)) {
+		leases.set(clientId, Date.now());
+		return true;
+	}
+	return false;
+}
+
+/** Remove a client lease (graceful detach on session end). */
+export function unregisterClient(clientId: string): void {
+	leases.delete(clientId);
+}
+
+/** Number of clients holding a live lease. */
+export function getLeaseCount(): number {
+	return leases.size;
+}
+
+/** Snapshot of live client leases (id -> lastSeenAt) for health/debugging. */
+export function getLeaseSnapshot(): Record<string, number> {
+	return Object.fromEntries(leases);
+}
+
+/** Record proxy activity — any proxied request counts as a live user. */
+export function touchActivity(): void {
+	lastActivityAt = Date.now();
+}
+
+/** Timestamp of the last proxied request (0 = never; daemon inits at bind). */
+export function getLastActivityAt(): number {
+	return lastActivityAt;
+}
+
+/**
+ * Start the lease GC sweep. Prunes expired leases and, when no client holds a
+ * lease, nothing is in flight, and the lease-less state has persisted for the
+ * grace window, invokes `onIdle` (the daemon retires). Idempotent — a second
+ * call is a no-op.
+ */
+export function startLeaseGC(opts: LeaseOptions): void {
+	if (gcTimer !== null) return;
+	gcTimer = setInterval(() => {
+		const now = Date.now();
+		for (const [id, seenAt] of leases) {
+			if (now - seenAt > opts.ttlMs) {
+				leases.delete(id);
+			}
+		}
+		if (leases.size > 0) {
+			emptySince = null;
+			return;
+		}
+		if (emptySince === null) {
+			emptySince = now;
+			return;
+		}
+		if (opts.getActiveRequests() === 0 && now - emptySince >= opts.graceMs) {
+			stopLeaseGC();
+			opts.onIdle();
+		}
+	}, opts.gcMs);
+}
+
+/** Stop the GC sweep (test teardown / daemon shutdown). */
+export function stopLeaseGC(): void {
+	if (gcTimer !== null) {
+		clearInterval(gcTimer);
+		gcTimer = null;
+	}
+}
+
+/** Test-only: reset all lease state. */
+export function _resetLeaseStateForTest(): void {
+	leases.clear();
+	lastActivityAt = 0;
+	emptySince = null;
+	stopLeaseGC();
+}

package/src/logger.ts

@@ -128,7 +128,8 @@ export function getMinLogLevel(): number {
 		return LOG_LEVEL_ORDER[dbg.level];
 	}
 
-	const raw = (process.env.FREEFLOW_LOG_LEVEL || "info").toLowerCase();
+	const rawEnv = process.env.FREEFLOW_LOG_LEVEL;
+	const raw = (typeof rawEnv === "string" ? rawEnv : "").toLowerCase();
 
 	if (isEmittedLogLevel(raw)) {
 		return LOG_LEVEL_ORDER[raw as LogLevel];
@@ -142,7 +143,14 @@ export function getMinLogLevel(): number {
 		return LOG_LEVEL_ORDER.debug;
 	}
 
-	return LOG_LEVEL_ORDER.info;
+	// Fresh installs default to full debug so users can attach complete
+	// request lifecycles when reporting errors (10MB rotation bounds volume).
+	// An explicit persisted off state or env level above still wins, so
+	// /freeflow debug off keeps working on every platform.
+	if (dbg !== null) {
+		return LOG_LEVEL_ORDER.info;
+	}
+	return LOG_LEVEL_ORDER.debug;
 }
 
 export function shouldLog(level: LogLevel): boolean {

package/src/proxy.ts

@@ -147,7 +147,7 @@ export async function isProxyAlive(port: number): Promise<boolean> {
 	if (!Number.isInteger(port) || port < 1 || port > 65535) return false;
 	try {
 		const res = await fetch(`http://${HOST}:${port}/v1/models`, {
-			signal: AbortSignal.timeout(500),
+			signal: AbortSignal.timeout(1500),
 		});
 		const ct = res.headers.get("content-type") || "";
 		return res.ok && ct.includes("application/json");
@@ -182,7 +182,7 @@ export async function getDaemonHealth(
 	if (!Number.isInteger(port) || port < 1 || port > 65535) return null;
 	try {
 		const res = await fetch(`http://${HOST}:${port}/_health`, {
-			signal: AbortSignal.timeout(800),
+			signal: AbortSignal.timeout(2500),
 		});
 		if (!res.ok) return null;
 		const data: unknown = await res.json();

package/src/relay.ts

@@ -155,6 +155,28 @@ export async function relayFetch(
 				}
 				break;
 			}
+			// Relay payload cap hit (413: request exceeds host payload limit):
+			// Not a relay health signal, so no failure marking — try the next
+			// relay (a different host may accept it), else the direct fallback.
+			if (res.status === 413) {
+				lastResponse?.body?.cancel().catch(() => {});
+				lastResponse = res;
+				log(
+					"warn",
+					`relay ${targetUrl} hit HTTP 413 payload limit in ${elapsed}s — trying next path`,
+					{ upstream: url, sizeKB: bodySizeKB },
+					rid,
+				);
+				const now = Date.now();
+				if (now - lastRollNotify > ROLL_NOTIFY_MS) {
+					lastRollNotify = now;
+					const ui = getStatusUi();
+					if (ui?.notify) {
+						ui.notify(`relay ${shortRelayLabel(targetUrl)} hit payload limit — trying next path`, "warning");
+					}
+				}
+				continue;
+			}
 
 			// Relay host infrastructure 404 (e.g. Vercel DEPLOYMENT_NOT_FOUND or non-JSON 404):
 			// When a relay URL is deleted, misconfigured, or has no deployment, Vercel/Cloudflare