codehost 0.23.0 → 0.23.2

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [0.23.2](https://github.com/snomiao/codehost/compare/v0.23.1...v0.23.2) (2026-06-16)
+
+
+### Performance Improvements
+
+* **cli:** throttle meta pushes to the signaling room ([654ee10](https://github.com/snomiao/codehost/commit/654ee1088bc88f95ca6b57545fa477ccb77b994f))
+
+## [0.23.1](https://github.com/snomiao/codehost/compare/v0.23.0...v0.23.1) (2026-06-16)
+
+
+### Performance Improvements
+
+* **signal:** exponential, unbounded backoff on the room sweep alarm ([fde1c43](https://github.com/snomiao/codehost/commit/fde1c43aa0dbc9274abb645ae43fc7cbd6712ee0))
+
 # [0.23.0](https://github.com/snomiao/codehost/compare/v0.22.1...v0.23.0) (2026-06-15)
 
 

package/package.json

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

package/src/cli/run-server.ts

@@ -56,6 +56,13 @@ export interface RunServerOptions {
 /** How often a daemon re-enumerates its workspaces (manual clones show up). */
 const META_REFRESH_MS = 60_000;
 
+/** Floor between meta pushes to the room. `serve` re-evaluates meta every ~3s so
+ *  live agent titles stay fresh, but each push is a billable DO request that
+ *  fans out to every peer — so coalesce bursts (a churning agent title) into at
+ *  most one push per this interval. The first change in a quiet period goes out
+ *  immediately; rapid follow-ups ride a single trailing push. */
+const MIN_META_PUSH_MS = 15_000;
+
 /**
  * Foreground server loop shared by `serve`, `dev`, and `expose`: register in the
  * signaling room with the given meta and bridge each client's data channel to a
@@ -113,15 +120,36 @@ export async function runServer(opts: RunServerOptions): Promise<never> {
     onSignal: (from, data) => rtc.handleSignal(from, data),
   });
 
-  // Re-advertise when the workspace set changes (provision, manual clone).
-  let lastMeta = JSON.stringify(opts.meta);
+  // Re-advertise when the workspace set changes (provision, manual clone),
+  // throttled so a burst of changes is at most one room push per MIN_META_PUSH_MS.
+  let sentMeta = JSON.stringify(opts.meta); // last meta the room actually has
+  let lastPushAt = 0; // ms of the last updateMeta send (0 = none since connect)
+  let pushTimer: ReturnType<typeof setTimeout> | null = null;
+  const sendMeta = (meta: PeerMeta) => {
+    const s = JSON.stringify(meta);
+    if (s === sentMeta) return; // nothing new since the last push
+    sentMeta = s;
+    lastPushAt = Date.now();
+    client.updateMeta(meta);
+  };
   const refreshMeta = () => {
     if (!opts.refreshMeta) return;
     const meta = opts.refreshMeta();
-    const s = JSON.stringify(meta);
-    if (s === lastMeta) return;
-    lastMeta = s;
-    client.updateMeta(meta);
+    if (JSON.stringify(meta) === sentMeta) return; // unchanged — nothing to do
+    const wait = MIN_META_PUSH_MS - (Date.now() - lastPushAt);
+    if (wait <= 0) {
+      // Cooldown elapsed: push the leading change now, dropping any pending one.
+      if (pushTimer) clearTimeout(pushTimer);
+      pushTimer = null;
+      sendMeta(meta);
+    } else if (!pushTimer) {
+      // Within the cooldown: schedule one trailing push that re-reads the
+      // freshest meta when it fires, so coalesced changes all ship at once.
+      pushTimer = setTimeout(() => {
+        pushTimer = null;
+        sendMeta(opts.refreshMeta!());
+      }, wait);
+    }
   };
   const provision: ProvisionDeps | undefined = opts.provision
     ? { ...opts.provision, onProvisioned: refreshMeta }

package/worker/room.ts

@@ -16,16 +16,33 @@ interface Attachment {
   lastSeen: number;
 }
 
-/** How often the room scans for dead sockets, and how long a socket may go
- *  silent before eviction. Clients heartbeat every ~25s (HEARTBEAT_MS in
- *  signaling-client.ts); allow ~2 misses, so a crashed peer drops out within
- *  ~65-85s. Every sweep alarm and every ping is a billable DO request, so both
- *  cadences are deliberately slow — a hidden Chrome tab's throttled timers
- *  (1/min) must still beat STALE_MS, or background tabs churn evict/reconnect
- *  cycles all day. */
-const SWEEP_MS = 20_000;
+/** How long a socket may go silent before eviction. Clients heartbeat every
+ *  ~25s (HEARTBEAT_MS in signaling-client.ts); allow ~2 misses, so a crashed
+ *  peer drops out within ~65s+. A hidden Chrome tab's throttled timers (1/min)
+ *  must still beat STALE_MS, or background tabs churn evict/reconnect all day. */
 const STALE_MS = 65_000;
 
+/** The sweep alarm scans for dead sockets, and every firing is a billable DO
+ *  request. A room with one always-on daemon never goes idle, so a fixed-cadence
+ *  sweep would wake the DO forever — the dominant signaling cost. Instead the
+ *  interval backs off exponentially with NO upper bound: it starts at
+ *  SWEEP_MIN_MS so a just-changed room evicts promptly, doubles after every no-op
+ *  sweep, and resets to the floor whenever a peer joins or a stale socket is
+ *  evicted. So a long-stable room's sweep cost trends to zero — past
+ *  SWEEP_STOP_MS it stops arming the alarm entirely. The trade-off: a
+ *  hard-killed peer can then linger until the edge notices the dead socket or
+ *  someone new joins the room (cosmetic — a graceful close still evicts
+ *  immediately via webSocketClose). The interval is persisted (DO storage) so it
+ *  survives hibernation between alarms. */
+const SWEEP_MIN_MS = 20_000;
+const SWEEP_MAX_MS = Infinity;
+/** Overflow/sanity guard for the unbounded backoff: once the doubled interval
+ *  passes a day, stop arming the sweep rather than hand setAlarm an ever-growing
+ *  (eventually non-finite) timestamp. A peer join revives sweeping at the floor
+ *  via ensureSweep, so phantom cleanup resumes whenever the room is used again. */
+const SWEEP_STOP_MS = 24 * 60 * 60 * 1000;
+const SWEEP_KEY = "sweepMs";
+
 /**
  * One Durable Object instance per token-room. Holds the live WebSocket
  * connections, keeps a registry of who is present, and relays WebRTC signals
@@ -117,9 +134,17 @@ export class Room implements DurableObject {
       }
     }
     if (evicted) this.broadcastPeers();
-    // Keep sweeping while anyone is connected; let idle rooms go quiet.
-    if (this.state.getWebSockets().length > 0) {
-      await this.state.storage.setAlarm(now + SWEEP_MS);
+    // Idle room: stop sweeping and let the DO hibernate.
+    if (this.state.getWebSockets().length === 0) return;
+    // Stable sweep -> double the interval (capped); an eviction means the room is
+    // changing, so reset to the floor and stay vigilant.
+    const prev = (await this.state.storage.get<number>(SWEEP_KEY)) ?? SWEEP_MIN_MS;
+    const next = evicted ? SWEEP_MIN_MS : Math.min(prev * 2, SWEEP_MAX_MS);
+    await this.state.storage.put(SWEEP_KEY, next);
+    // Unbounded backoff: past the stop horizon, leave the alarm unset — a long
+    // stable room sweeps no more. A join (ensureSweep) or eviction revives it.
+    if (next <= SWEEP_STOP_MS) {
+      await this.state.storage.setAlarm(now + next);
     }
   }
 
@@ -151,11 +176,12 @@ export class Room implements DurableObject {
     return att;
   }
 
-  /** Arm the sweep alarm if one isn't already pending. */
+  /** (Re)arm the sweep at the floor cadence. Called when a peer joins: a roster
+   *  change should be re-checked promptly, so reset the backoff and pull the
+   *  alarm in even if a (backed-off) one is already pending. */
   private async ensureSweep(): Promise<void> {
-    if ((await this.state.storage.getAlarm()) == null) {
-      await this.state.storage.setAlarm(Date.now() + SWEEP_MS);
-    }
+    await this.state.storage.put(SWEEP_KEY, SWEEP_MIN_MS);
+    await this.state.storage.setAlarm(Date.now() + SWEEP_MIN_MS);
   }
 
   private findByPeerId(peerId: string): WebSocket | null {