codehost 0.10.0 → 0.11.1

package/.claude/scheduled_tasks.lock

@@ -0,0 +1 @@
+{"sessionId":"f8e4e571-944e-43d7-bbfa-267a5251e41c","pid":87968,"procStart":"Mon Jun  8 09:46:02 2026","acquiredAt":1780974562147}

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [0.11.1](https://github.com/snomiao/codehost/compare/v0.11.0...v0.11.1) (2026-06-09)
+
+
+### Bug Fixes
+
+* **signaling:** harden reconnect backoff + log close code/duration ([a0aa1ce](https://github.com/snomiao/codehost/commit/a0aa1ce7aeae49815fc51dd272a8e08852ed55b2))
+
+# [0.11.0](https://github.com/snomiao/codehost/compare/v0.10.0...v0.11.0) (2026-06-09)
+
+
+### Features
+
+* **web:** update URL on Connect + Back returns to the list ([7258a16](https://github.com/snomiao/codehost/commit/7258a168a0bcc1d476aab8a7f3fcd81f35ccfcb5))
+
 # [0.10.0](https://github.com/snomiao/codehost/compare/v0.9.1...v0.10.0) (2026-06-09)
 
 

package/package.json

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

package/src/cli/run-server.ts

@@ -50,7 +50,13 @@ export async function runServer(opts: RunServerOptions): Promise<never> {
     peerId,
     meta: opts.meta,
     onOpen: () => console.log(`[codehost] registered as "${opts.meta.name}" (${peerId.slice(0, 8)})`),
-    onClose: () => console.log("[codehost] disconnected from signaling, reconnecting…"),
+    onClose: (info) => {
+      // Surface the close code + how long the socket lived: a near-instant drop
+      // (low ms) points at a middlebox killing the WebSocket after the upgrade,
+      // not the signaling server. Helps triage field reconnect storms.
+      const detail = info ? ` (code ${info.code}${info.reason ? ` "${info.reason}"` : ""}, up ${info.ms}ms)` : "";
+      console.log(`[codehost] disconnected from signaling${detail}, reconnecting…`);
+    },
     onSignal: (from, data) => rtc.handleSignal(from, data),
   });
 

package/src/shared/signaling-client.ts

@@ -17,9 +17,26 @@ export interface SignalingClientOptions {
   onPeers?: (peers: PeerInfo[]) => void;
   onSignal?: (from: string, data: unknown) => void;
   onOpen?: () => void;
-  onClose?: () => void;
+  /** Called on every socket close. `info` carries the WebSocket close code,
+   *  reason, and how long the socket stayed open (ms) — for diagnosing networks
+   *  that complete the upgrade then drop the connection. */
+  onClose?: (info?: CloseInfo) => void;
 }
 
+export interface CloseInfo {
+  code: number;
+  reason: string;
+  /** Milliseconds the socket was open before it closed. */
+  ms: number;
+}
+
+/** Reset the reconnect backoff only after a socket has stayed open this long. A
+ *  connection that completes the handshake then drops within seconds (a
+ *  middlebox that accepts the WebSocket upgrade but kills the socket, seen on
+ *  some field networks) must keep backing off — otherwise every reset-to-1s
+ *  open/close cycle becomes a sub-second reconnect storm. */
+const STABLE_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
@@ -31,6 +48,10 @@ export class SignalingClient {
   private closed = false;
   private reconnectDelay = 1000;
   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;
+  /** Wall-clock ms when the current socket opened (0 if never/closed). */
+  private openedAt = 0;
 
   constructor(private opts: SignalingClientOptions) {
     this.peerId = opts.peerId ?? newPeerId();
@@ -51,7 +72,14 @@ export class SignalingClient {
     this.ws = ws;
 
     ws.onopen = () => {
-      this.reconnectDelay = 1000;
+      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
+      // its backoff keeps growing instead of hammering at 1s.
+      this.clearStableTimer();
+      this.stableTimer = setTimeout(() => {
+        this.reconnectDelay = 1000;
+      }, STABLE_MS);
       const hello: ClientMessage = {
         type: "hello",
         role: this.opts.role,
@@ -74,9 +102,12 @@ export class SignalingClient {
       else if (msg.type === "signal") this.opts.onSignal?.(msg.from, msg.data);
     };
 
-    ws.onclose = () => {
+    ws.onclose = (ev) => {
+      this.clearStableTimer();
       this.stopHeartbeat();
-      this.opts.onClose?.();
+      const ms = this.openedAt ? Date.now() - this.openedAt : 0;
+      this.openedAt = 0;
+      this.opts.onClose?.({ code: ev?.code ?? 0, reason: ev?.reason ?? "", ms });
       if (!this.closed) this.scheduleReconnect();
     };
 
@@ -110,6 +141,13 @@ export class SignalingClient {
     }
   }
 
+  private clearStableTimer(): void {
+    if (this.stableTimer != null) {
+      clearTimeout(this.stableTimer);
+      this.stableTimer = null;
+    }
+  }
+
   private scheduleReconnect(): void {
     const delay = this.reconnectDelay;
     this.reconnectDelay = Math.min(delay * 2, 15000);
@@ -126,6 +164,7 @@ export class SignalingClient {
   close(): void {
     this.closed = true;
     this.stopHeartbeat();
+    this.clearStableTimer();
     try {
       this.ws?.close();
     } catch {

package/src/web/discovery.tsx

@@ -176,6 +176,11 @@ export function Discovery() {
   const activePeerRef = useRef<string | null>(null);
   const activeRoomRef = useRef<string | null>(null);
   const sendersRef = useRef<Map<string, (to: string, data: unknown) => void>>(new Map());
+  // Whether the live connection pushed a history entry (so Disconnect/Back can
+  // pop it), and whether we're currently *viewing* a workspace (so popstate only
+  // tears down from the iframe view, not during a mid-connect URL revert).
+  const pushedRef = useRef(false);
+  const viewingRef = useRef(false);
 
   // Deep-link resolution (/gh/<owner>/<repo>/... or /dev/<path>): parse once,
   // auto-connect when a matching server appears, remember the opened folder.
@@ -213,6 +218,13 @@ export function Discovery() {
       const folder = activeFolderRef.current;
       setTimeout(() => setIframeSrc(`/vs/${peerId}/${folderQuery(folder)}`), 400);
     });
+    // Back / Cmd+Left from a workspace returns to the list: the browser restores
+    // the previous URL and we drop the connection. Only when actually viewing —
+    // a mid-connect URL revert (failed dial) must leave the list state untouched.
+    const onPopState = () => {
+      if (viewingRef.current) teardownConn();
+    };
+    window.addEventListener("popstate", onPopState);
     // A valid token in the URL fragment (#t=<token>) joins the room and turns on
     // single-server auto-connect for it; consume it from the address bar after,
     // so the secret isn't left visible or re-applied on a manual reload.
@@ -242,6 +254,8 @@ export function Discovery() {
         }
       }
     }
+
+    return () => window.removeEventListener("popstate", onPopState);
   }, []);
 
   // Auto-connect once discovery turns up a match: a deep-link target across any
@@ -291,8 +305,19 @@ export function Discovery() {
     setActivePeerId(server.peerId);
     activePeerRef.current = server.peerId;
     activeRoomRef.current = room;
+    viewingRef.current = false;
     setConnState("connecting");
 
+    // Update the address bar the instant Connect is clicked (don't wait for the
+    // WebRTC handshake) and push a history entry, so Back / Cmd+Left returns to
+    // the list. Reverted if the connection fails.
+    const openFolder = folder ?? server.meta?.cwd;
+    const targetPath = shareablePathFor(server, openFolder);
+    const pushed = !!targetPath && targetPath !== window.location.pathname;
+    if (pushed) history.pushState(null, "", targetPath);
+    pushedRef.current = pushed;
+    sharePathRef.current = targetPath ?? window.location.pathname;
+
     // The broker decides whether this tab owns the connection. `establish` is
     // only invoked when we're the owner (or get promoted on failover); other
     // tabs reuse the owner's channel via a proxy, so they never open WebRTC.
@@ -326,29 +351,31 @@ export function Discovery() {
       await connBroker.connect(server.peerId, establish);
       setConnState("connected");
       // The daemon no longer sets a default folder (current VS Code serve-web
-      // dropped that flag), so open the served workspace from here: an explicit
+      // dropped that flag), so open the served workspace from here: the
       // deep-link folder if we have one, else the server's reported cwd.
-      const openFolder = folder ?? server.meta?.cwd;
       activeFolderRef.current = openFolder;
       setIframeSrc(`/vs/${server.peerId}/${folderQuery(openFolder)}`);
       setResolving(null);
       recordConnect(server, room, openFolder);
-      updateAddressBar(server, openFolder);
+      viewingRef.current = true;
     } catch {
       setConnState("failed");
+      // Undo the optimistic history entry / URL change. We never started
+      // viewing, so the popstate handler leaves the "failed" card in place.
+      if (pushed) {
+        pushedRef.current = false;
+        history.back();
+      }
     }
   }
 
-  // Reflect the live connection in the address bar as a clean, shareable deep
-  // link (no token — Share adds that). If we arrived via a deep link, keep its
-  // pathname; otherwise derive one from the server's repo identity or folder.
-  function updateAddressBar(server: PeerInfo, folder?: string) {
-    const path = deepLinkRef.current
+  // Shareable deep-link pathname for a server+folder, with no side effects (no
+  // token — Share adds that). Keeps an existing deep-link path as-is; otherwise
+  // derives /gh|/git|/dev from the server's repo identity or opened folder.
+  function shareablePathFor(server: PeerInfo, folder?: string): string | null {
+    return deepLinkRef.current
       ? window.location.pathname
       : shareableDeepLink({ repo: server.meta?.repo, branch: server.meta?.branch, folder });
-    if (!path) return;
-    sharePathRef.current = path;
-    if (path !== window.location.pathname) history.replaceState(null, "", path);
   }
 
   async function shareLink() {
@@ -408,7 +435,10 @@ export function Discovery() {
     if (dl?.type === "repo") recordConnection(repoKey(dl.target), { ...base, folder });
   }
 
-  function disconnect() {
+  // Tear down the active connection and return to the workspace list. Does NOT
+  // touch history — the caller (Disconnect → history.back, or a popstate from
+  // Cmd+Left) owns the URL.
+  function teardownConn() {
     rtcRef.current?.close();
     rtcRef.current = null;
     if (activePeerRef.current) connBroker.disconnect(activePeerRef.current);
@@ -418,6 +448,18 @@ export function Discovery() {
     activeRoomRef.current = null;
     setConnState("idle");
     sharePathRef.current = null;
+    pushedRef.current = false;
+    viewingRef.current = false;
+  }
+
+  function disconnect() {
+    // Mirror Cmd+Left: if connecting pushed a history entry, pop it — the
+    // browser restores the previous URL and our popstate handler tears down.
+    if (pushedRef.current) {
+      history.back();
+      return;
+    }
+    teardownConn();
     if (window.location.pathname !== "/") history.replaceState(null, "", "/");
   }