codehost 0.18.0 → 0.18.2

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [0.18.2](https://github.com/snomiao/codehost/compare/v0.18.1...v0.18.2) (2026-06-11)
+
+
+### Bug Fixes
+
+* **signaling:** recover instantly when a throttled tab wakes (visibility/focus/online) ([d459132](https://github.com/snomiao/codehost/commit/d45913267f053ee1fee062bae550cfe60a193207))
+
+## [0.18.1](https://github.com/snomiao/codehost/compare/v0.18.0...v0.18.1) (2026-06-11)
+
+
+### Bug Fixes
+
+* **signaling:** abort connect attempts stuck in CONNECTING; guard tunnel stream enqueue ([b3ae0d1](https://github.com/snomiao/codehost/commit/b3ae0d11299a195b8d09e42355cd14a3b09b8d2f))
+
 # [0.18.0](https://github.com/snomiao/codehost/compare/v0.17.0...v0.18.0) (2026-06-11)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codehost",
-  "version": "0.18.0",
+  "version": "0.18.2",
   "type": "module",
   "repository": {
     "type": "git",

package/src/shared/signaling-client.ts

@@ -37,6 +37,12 @@ export interface CloseInfo {
  *  open/close cycle becomes a sub-second reconnect storm. */
 const STABLE_MS = 10_000;
 
+/** Abort a connect attempt that hasn't opened by this deadline. Observed in the
+ *  field (Chrome, page-load burst): a socket can sit in CONNECTING for minutes
+ *  and never fire close — so without this, no retry ever runs, even though a
+ *  freshly-created socket to the same room opens instantly. */
+const CONNECT_TIMEOUT_MS = 10_000;
+
 /**
  * Thin WebSocket client for the signaling room. Runs unchanged in the browser
  * and in Bun (both expose a global `WebSocket`). Auto-reconnects with backoff
@@ -47,6 +53,7 @@ export class SignalingClient {
   private ws: WebSocket | null = null;
   private closed = false;
   private reconnectDelay = 1000;
+  private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
   private heartbeat: ReturnType<typeof setInterval> | null = null;
   /** Fires STABLE_MS after a socket opens; only then is the backoff reset. */
   private stableTimer: ReturnType<typeof setTimeout> | null = null;
@@ -59,9 +66,53 @@ export class SignalingClient {
 
   connect(): void {
     this.closed = false;
+    this.attachWakeListeners();
     this.open();
   }
 
+  // ---- background-tab recovery -------------------------------------------
+  // Chrome throttles timers in hidden tabs to minutes, so the backoff retry
+  // (and the connect-timeout abort) may be arbitrarily far away even though a
+  // fresh socket would connect in milliseconds. When the tab becomes visible /
+  // focused / back online, recover NOW instead of waiting for a timer.
+
+  private onWake = (): void => {
+    if (this.closed) return;
+    const state = this.ws?.readyState;
+    if (state === 1 /* OPEN */) return;
+    if (state === 0 /* CONNECTING */) {
+      // Stuck handshake: abort — onclose reschedules, and timers run normally
+      // now that the tab is active.
+      try {
+        this.ws?.close();
+      } catch {
+        // ignore
+      }
+      return;
+    }
+    // Closed and waiting out the (throttled) backoff: skip the wait.
+    if (this.reconnectTimer != null) {
+      this.clearReconnectTimer();
+      this.open();
+    }
+  };
+
+  private attachWakeListeners(): void {
+    const doc = (globalThis as { document?: EventTarget }).document;
+    doc?.addEventListener("visibilitychange", this.onWake);
+    const win = (globalThis as { window?: EventTarget }).window;
+    win?.addEventListener("focus", this.onWake);
+    win?.addEventListener("online", this.onWake);
+  }
+
+  private detachWakeListeners(): void {
+    const doc = (globalThis as { document?: EventTarget }).document;
+    doc?.removeEventListener("visibilitychange", this.onWake);
+    const win = (globalThis as { window?: EventTarget }).window;
+    win?.removeEventListener("focus", this.onWake);
+    win?.removeEventListener("online", this.onWake);
+  }
+
   private roomUrl(): string {
     const base = this.opts.url.replace(/\/+$/, "");
     return `${base}/room/${encodeURIComponent(this.opts.token)}`;
@@ -71,7 +122,21 @@ export class SignalingClient {
     const ws = new WebSocket(this.roomUrl());
     this.ws = ws;
 
+    // A stuck CONNECTING socket never fires close on its own — abort it so the
+    // normal onclose -> backoff -> retry path takes over.
+    const connectTimer = setTimeout(() => {
+      if (ws.readyState === 0 /* CONNECTING */) {
+        try {
+          ws.close();
+        } catch {
+          // closing an unopened socket may throw in some runtimes — the
+          // onerror/onclose path still runs
+        }
+      }
+    }, CONNECT_TIMEOUT_MS);
+
     ws.onopen = () => {
+      clearTimeout(connectTimer);
       this.openedAt = Date.now();
       // Don't reset the backoff yet — only once the socket proves stable (see
       // STABLE_MS). A handshake-then-drop network never reaches this timer, so
@@ -103,6 +168,7 @@ export class SignalingClient {
     };
 
     ws.onclose = (ev) => {
+      clearTimeout(connectTimer);
       this.clearStableTimer();
       this.stopHeartbeat();
       const ms = this.openedAt ? Date.now() - this.openedAt : 0;
@@ -151,11 +217,20 @@ export class SignalingClient {
   private scheduleReconnect(): void {
     const delay = this.reconnectDelay;
     this.reconnectDelay = Math.min(delay * 2, 15000);
-    setTimeout(() => {
+    this.clearReconnectTimer();
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
       if (!this.closed) this.open();
     }, delay);
   }
 
+  private clearReconnectTimer(): void {
+    if (this.reconnectTimer != null) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+
   sendSignal(to: string, data: unknown): void {
     const msg: ClientMessage = { type: "signal", to, data };
     this.ws?.send(JSON.stringify(msg));
@@ -173,6 +248,8 @@ export class SignalingClient {
 
   close(): void {
     this.closed = true;
+    this.detachWakeListeners();
+    this.clearReconnectTimer();
     this.stopHeartbeat();
     this.clearStableTimer();
     try {

package/src/web/tunnel-client.ts

@@ -129,7 +129,13 @@ export class TunnelClient {
             }),
           );
         },
-        onBody: (b) => controller?.enqueue(b),
+        onBody: (b) => {
+          try {
+            controller?.enqueue(b);
+          } catch {
+            // stream already closed/cancelled (consumer went away mid-body)
+          }
+        },
         onEnd: () => {
           try {
             controller?.close();