codehost 0.20.0 → 0.20.1

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [0.20.1](https://github.com/snomiao/codehost/compare/v0.20.0...v0.20.1) (2026-06-11)
+
+
+### Bug Fixes
+
+* **signaling:** tame the room-DO request storm; live agent titles on the sidepanel ([d39dceb](https://github.com/snomiao/codehost/commit/d39dceb2c7e3cd47dcb17f099aa8e0d37d3a7e13))
+
 # [0.20.0](https://github.com/snomiao/codehost/compare/v0.19.0...v0.20.0) (2026-06-11)
 
 

package/package.json

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

package/src/cli/commands/serve.ts

@@ -146,16 +146,26 @@ export const serveCommand: CommandModule<{}, ServeArgs> = {
     // so the advertised list and the provisioned paths agree.
     const layout = readCodehostConfig(dir).workspace || DEFAULT_LAYOUT;
     const plugins = [agentYesPlugin()].filter((p) => p != null);
+    // buildMeta runs every AGENTS_META_POLL_MS so live agent titles propagate
+    // (the room only sees a push when something changed). The filesystem walk
+    // for checkouts is the expensive part — memoize it; registered workspaces
+    // and agents are cheap reads and stay fresh on every call.
+    const WORKSPACE_WALK_TTL_MS = 30_000;
+    let wsWalk: { at: number; list: ReturnType<typeof enumerateWorkspaces> } | null = null;
     const buildMeta = (): PeerMeta => {
       // Layout-enumerated checkouts plus directories other `codehost dev` runs
       // registered with this host daemon (git-identified best-effort).
-      const workspaces = enumerateWorkspaces(dir, layout);
-      // The config dir itself is editable from the site (rendered as ⚙, opens
-      // in the editor) — advertised so its /host/<host>/<path> link resolves.
-      const configDir = join(dir, ".codehost");
-      if (existsSync(configDir)) {
-        workspaces.push({ path: toPosixPath(configDir), config: true });
+      if (!wsWalk || Date.now() - wsWalk.at > WORKSPACE_WALK_TTL_MS) {
+        const list = enumerateWorkspaces(dir, layout);
+        // The config dir itself is editable from the site (rendered as ⚙, opens
+        // in the editor) — advertised so its /host/<host>/<path> link resolves.
+        const configDir = join(dir, ".codehost");
+        if (existsSync(configDir)) {
+          list.push({ path: toPosixPath(configDir), config: true });
+        }
+        wsWalk = { at: Date.now(), list };
       }
+      const workspaces = [...wsWalk.list];
       for (const w of readRegisteredWorkspaces()) {
         const path = toPosixPath(w.path);
         if (workspaces.some((x) => x.path === path)) continue;
@@ -193,6 +203,9 @@ export const serveCommand: CommandModule<{}, ServeArgs> = {
       signal: argv.signal,
       meta: buildMeta(),
       refreshMeta: buildMeta,
+      // Fast poll so agents' self-set titles go live on the site sidepanel;
+      // per tick it's pid-liveness checks + log-tail stat()s (see liveTitle).
+      metaRefreshMs: 3_000,
       watchFiles: [workspacesFile()],
       plugins,
       label: `serving workspace root ${dir}`,

package/src/cli/plugins/agent-yes.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, test } from "bun:test";
 import { mkdtempSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { agentYesPlugin, readAgents } from "./agent-yes";
+import { agentYesPlugin, liveTitle, readAgents } from "./agent-yes";
 import { routePlugins, withPluginMeta } from "./types";
 
 function makeAyDir(lines: object[]): string {
@@ -34,6 +34,42 @@ describe("readAgents", () => {
   test("missing registry -> empty", () => {
     expect(readAgents(mkdtempSync(join(tmpdir(), "codehost-ay-empty-")))).toEqual([]);
   });
+
+  test("live OSC title from the log tail beats the launch prompt", () => {
+    const dir = mkdtempSync(join(tmpdir(), "codehost-ay-title-"));
+    const log = join(dir, "agent.raw.log");
+    writeFileSync(log, "boot\x1b]2;first title\x07work work\x1b]0;renamed by agent\x07tail");
+    writeFileSync(
+      join(dir, "pids.jsonl"),
+      JSON.stringify({
+        pid: process.pid,
+        cli: "claude",
+        prompt: "the launch prompt",
+        cwd: "/tmp/x",
+        log_file: log,
+        status: "active",
+      }) + "\n",
+    );
+    expect(readAgents(dir)[0].title).toBe("renamed by agent");
+  });
+});
+
+describe("liveTitle", () => {
+  test("returns the LAST OSC 0/2 title, cached by (size, mtime)", () => {
+    const dir = mkdtempSync(join(tmpdir(), "codehost-ay-osc-"));
+    const log = join(dir, "x.log");
+    writeFileSync(log, "\x1b]0;one\x07...\x1b]2;two\x1b\\rest");
+    expect(liveTitle(log)).toBe("two");
+    expect(liveTitle(log)).toBe("two"); // cache hit path
+  });
+
+  test("missing file / no title -> null", () => {
+    expect(liveTitle("/nonexistent/x.log")).toBeNull();
+    const dir = mkdtempSync(join(tmpdir(), "codehost-ay-osc2-"));
+    const log = join(dir, "plain.log");
+    writeFileSync(log, "no escapes here");
+    expect(liveTitle(log)).toBeNull();
+  });
 });
 
 describe("plugin routing + meta", () => {

package/src/cli/plugins/agent-yes.ts

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync } from "node:fs";
+import { closeSync, existsSync, fstatSync, openSync, readFileSync, readSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { toPosixPath } from "../../shared/repo";
@@ -22,10 +22,47 @@ interface AyRecord {
   cli?: string;
   prompt?: string | null;
   cwd?: string;
+  log_file?: string | null;
   status?: "active" | "idle" | "exited";
   started_at?: number;
 }
 
+// Agents retitle their terminal by writing OSC 0/2 (\x1b]2;name\x07) into the
+// PTY stream agent-yes logs; the most recent one is the live title (same trick
+// `ay serve` uses for /api/ls). Read straight from the log tail so it works
+// even when ay serve is down. Cached per (size, mtime): only logs that grew
+// since the last refresh are re-read, so a frequent meta poll stays cheap.
+const TITLE_TAIL_BYTES = 65536;
+const titleCache = new Map<string, { size: number; mtimeMs: number; title: string | null }>();
+
+export function liveTitle(logFile: string | null | undefined): string | null {
+  if (!logFile) return null;
+  try {
+    const fd = openSync(logFile, "r");
+    try {
+      const { size, mtimeMs } = fstatSync(fd);
+      const hit = titleCache.get(logFile);
+      if (hit && hit.size === size && hit.mtimeMs === mtimeMs) return hit.title;
+      const len = Math.min(size, TITLE_TAIL_BYTES);
+      const buf = Buffer.allocUnsafe(len);
+      const bytesRead = readSync(fd, buf, 0, len, size - len);
+      const text = buf.toString("utf-8", 0, bytesRead);
+      // eslint-disable-next-line no-control-regex
+      const oscTitleRe = /\x1b\][02];([^\x07\x1b]*)(?:\x07|\x1b\\)/g;
+      let title: string | null = null;
+      for (let m: RegExpExecArray | null; (m = oscTitleRe.exec(text)); ) {
+        if (m[1].trim()) title = m[1].trim();
+      }
+      titleCache.set(logFile, { size, mtimeMs, title });
+      return title;
+    } finally {
+      closeSync(fd);
+    }
+  } catch {
+    return null;
+  }
+}
+
 /** agent-yes's global registry: JSONL, last line per pid wins. */
 export function readAgents(dir: string = AY_DIR): AgentInfo[] {
   let raw: string;
@@ -48,10 +85,12 @@ export function readAgents(dir: string = AY_DIR): AgentInfo[] {
   for (const rec of [...byPid.values()].sort((a, b) => (b.started_at ?? 0) - (a.started_at ?? 0))) {
     if (out.length >= MAX_AGENTS) break;
     if (rec.status === "exited" || !alive(rec.pid)) continue;
+    // Live self-set title from the PTY log beats the static launch prompt.
+    const title = liveTitle(rec.log_file) ?? rec.prompt ?? null;
     out.push({
       pid: rec.pid,
       tool: rec.cli || "agent",
-      ...(rec.prompt ? { title: rec.prompt.slice(0, 120) } : {}),
+      ...(title ? { title: title.slice(0, 120) } : {}),
       cwd: toPosixPath(rec.cwd ?? ""),
       state: rec.status === "active" ? "active" : "idle",
       ...(rec.started_at ? { startedAt: rec.started_at } : {}),

package/src/cli/run-server.ts

@@ -31,10 +31,14 @@ export interface RunServerOptions {
   /** Enables `/__codehost/provision` on the tunnel (serve only — runs the home's
    *  setup.sh). Omitted by `expose`, which has no home/workspace. */
   provision?: ProvisionDeps;
-  /** Recompute the advertised meta (e.g. re-enumerate workspaces). Polled on a
-   *  slow interval and right after each provision; pushed to the room only when
+  /** Recompute the advertised meta (e.g. re-enumerate workspaces). Polled on
+   *  an interval and right after each provision; pushed to the room only when
    *  it actually changed. */
   refreshMeta?: () => PeerMeta;
+  /** Meta poll cadence (default META_REFRESH_MS). `serve` polls fast so live
+   *  agent titles propagate — refreshMeta must then be cheap per call. The
+   *  room only sees a message when the meta actually changed. */
+  metaRefreshMs?: number;
   /** Daemon plugins: tunneled routes under /__codehost/<name>/ (their meta
    *  contributions are the caller's job, inside `meta`/`refreshMeta`). */
   plugins?: DaemonPlugin[];
@@ -113,16 +117,24 @@ export async function runServer(opts: RunServerOptions): Promise<never> {
 
   client.connect();
   if (opts.refreshMeta) {
-    setInterval(refreshMeta, META_REFRESH_MS);
-    // Instant re-advertise when a watched file changes (debounced — editors
-    // and fs.watch both fire in bursts).
+    setInterval(refreshMeta, opts.metaRefreshMs ?? META_REFRESH_MS);
+    // Near-instant re-advertise when a watched file changes. Throttled, not
+    // debounced: fs.watch fires in bursts, but a file that changes CONSTANTLY
+    // (a busy registry) would keep resetting a debounce forever — a trailing
+    // throttle guarantees a refresh at most/at least every 300ms.
     let pending: ReturnType<typeof setTimeout> | null = null;
+    const requestRefresh = () => {
+      if (pending) return;
+      pending = setTimeout(() => {
+        pending = null;
+        refreshMeta();
+      }, 300);
+    };
     for (const file of opts.watchFiles ?? []) {
       try {
         watch(dirname(file), (_event, filename) => {
           if (filename && filename !== basename(file)) return;
-          if (pending) clearTimeout(pending);
-          pending = setTimeout(refreshMeta, 300);
+          requestRefresh();
         });
       } catch {
         // missing dir / unsupported platform — the interval still covers it

package/src/shared/signaling-client.ts

@@ -34,8 +34,10 @@ export interface CloseInfo {
  *  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;
+ *  open/close cycle becomes a sub-second reconnect storm. A server that drops
+ *  sockets every few tens of seconds (room DO redeploys, sweep evictions) must
+ *  also keep backing off, so this sits above any such churn period. */
+const STABLE_MS = 60_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
@@ -43,6 +45,20 @@ const STABLE_MS = 10_000;
  *  freshly-created socket to the same room opens instantly. */
 const CONNECT_TIMEOUT_MS = 10_000;
 
+/** Reconnect backoff bounds. Every signaling round-trip (WS upgrade, hello,
+ *  ping) is a billable request on the room Durable Object, so idle/broken
+ *  clients must converge to a slow cadence: cap at 2 min, with ±25% jitter so
+ *  a fleet of daemons dropped by one server restart doesn't thundering-herd. */
+const RECONNECT_MIN_MS = 1_000;
+const RECONNECT_MAX_MS = 120_000;
+
+/** Heartbeat cadence. Paired with the room's STALE_MS (65s): the sweep
+ *  tolerates ~2 missed beats. Each ping is a billable DO request — at 25s a
+ *  day-long connection costs ~3.5k requests, vs ~8.6k at the old 10s. Hidden
+ *  tabs survive too: Chrome's intensive throttling clamps timers to 1/min,
+ *  still inside the 65s window. */
+const HEARTBEAT_MS = 25_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
@@ -52,8 +68,10 @@ export class SignalingClient {
   readonly peerId: string;
   private ws: WebSocket | null = null;
   private closed = false;
-  private reconnectDelay = 1000;
+  private reconnectDelay = RECONNECT_MIN_MS;
   private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+  /** True while a hidden tab sits out reconnection; onWake resumes it. */
+  private dormant = false;
   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;
@@ -90,13 +108,24 @@ export class SignalingClient {
       }
       return;
     }
-    // Closed and waiting out the (throttled) backoff: skip the wait.
-    if (this.reconnectTimer != null) {
+    // Dormant (hidden tab sat out reconnection) or waiting out a throttled
+    // backoff: reconnect now.
+    if (this.dormant || this.reconnectTimer != null) {
+      this.dormant = false;
       this.clearReconnectTimer();
       this.open();
     }
   };
 
+  /** A hidden tab doesn't reconnect at all — abandoned tabs used to churn
+   *  evict/reconnect cycles against the room DO all night. Existing WebRTC
+   *  tunnels keep working without signaling; on visibility/focus/online the
+   *  wake handler reconnects within milliseconds. */
+  private hidden(): boolean {
+    const doc = (globalThis as { document?: { visibilityState?: string } }).document;
+    return doc?.visibilityState === "hidden";
+  }
+
   private attachWakeListeners(): void {
     const doc = (globalThis as { document?: EventTarget }).document;
     doc?.addEventListener("visibilitychange", this.onWake);
@@ -143,7 +172,7 @@ export class SignalingClient {
       // its backoff keeps growing instead of hammering at 1s.
       this.clearStableTimer();
       this.stableTimer = setTimeout(() => {
-        this.reconnectDelay = 1000;
+        this.reconnectDelay = RECONNECT_MIN_MS;
       }, STABLE_MS);
       const hello: ClientMessage = {
         type: "hello",
@@ -186,9 +215,8 @@ export class SignalingClient {
     };
   }
 
-  // Heartbeat keeps the room's liveness sweep from evicting us. At 10s, the DO
-  // (STALE_MS 35s) tolerates ~3 missed beats before treating us as gone — fast
-  // enough that a crashed peer stops showing as a phantom server within ~1 sweep.
+  // Heartbeat keeps the room's liveness sweep from evicting us — see
+  // HEARTBEAT_MS for the cadence/cost trade-off.
   private startHeartbeat(): void {
     this.stopHeartbeat();
     this.heartbeat = setInterval(() => {
@@ -197,7 +225,7 @@ export class SignalingClient {
       } catch {
         // socket gone; onclose will reconnect
       }
-    }, 10000);
+    }, HEARTBEAT_MS);
   }
 
   private stopHeartbeat(): void {
@@ -215,12 +243,23 @@ export class SignalingClient {
   }
 
   private scheduleReconnect(): void {
-    const delay = this.reconnectDelay;
-    this.reconnectDelay = Math.min(delay * 2, 15000);
+    if (this.hidden()) {
+      this.dormant = true;
+      return;
+    }
+    // ±25% jitter so a fleet dropped together doesn't reconnect together.
+    const delay = Math.round(this.reconnectDelay * (0.75 + Math.random() * 0.5));
+    this.reconnectDelay = Math.min(this.reconnectDelay * 2, RECONNECT_MAX_MS);
     this.clearReconnectTimer();
     this.reconnectTimer = setTimeout(() => {
       this.reconnectTimer = null;
-      if (!this.closed) this.open();
+      if (this.closed) return;
+      if (this.hidden()) {
+        // Went hidden while waiting — sit out until the wake handler fires.
+        this.dormant = true;
+        return;
+      }
+      this.open();
     }, delay);
   }
 
@@ -248,6 +287,7 @@ export class SignalingClient {
 
   close(): void {
     this.closed = true;
+    this.dormant = false;
     this.detachWakeListeners();
     this.clearReconnectTimer();
     this.stopHeartbeat();

package/src/web/discovery.tsx

@@ -1000,6 +1000,7 @@ export function Discovery() {
                       >
                         <span style={{ color: a.state === "active" ? "#4ec9b0" : "#777" }}>●</span> {a.tool}{" "}
                         {a.pid}
+                        {a.title && <span style={styles.agentTitle}>{a.title}</span>}
                       </a>
                     ))}
                   </div>
@@ -1118,6 +1119,13 @@ const styles: Record<string, React.CSSProperties> = {
   agentChip: {
     fontFamily: "monospace", fontSize: 11.5, padding: "2px 8px", borderRadius: 999,
     border: "1px solid #3d3d3d", color: "#9aa4af", textDecoration: "none", cursor: "pointer",
+    display: "inline-flex", alignItems: "baseline", gap: 4, maxWidth: 360,
+  },
+  // Live self-set agent title (daemon re-reads it from the PTY log and pushes
+  // a meta update, so this re-renders as the agent renames itself).
+  agentTitle: {
+    color: "#6e7681", overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap",
+    minWidth: 0, flex: "0 1 auto",
   },
   card: { display: "flex", alignItems: "center", gap: 12, background: "#252525", border: "1px solid #3d3d3d", borderRadius: 8, padding: "12px 14px" },
   cardMain: { flex: 1, minWidth: 0 },

package/src/web/room-client.ts

@@ -25,12 +25,19 @@ export interface RoomOptions {
   onStatus?: (open: boolean) => void;
 }
 
+/** After a failed dial, refuse redials to that peer for this long. Pollers
+ *  (the agent-yes console asks every host for /api/ls every ~3s) would
+ *  otherwise spin up a fresh RTCPeerConnection per poll, and every ICE
+ *  candidate of every attempt is a billable signaling-DO request. */
+const DIAL_FAIL_COOLDOWN_MS = 10_000;
+
 export class CodehostRoom {
   /** Server peers currently in the room (viewers filtered out). */
   peers: PeerInfo[] = [];
   private signaling: SignalingClient;
   private rtcs = new Map<string, RtcClient>();
   private tunnels = new Map<string, Promise<TunnelClient>>();
+  private dialFailedAt = new Map<string, number>();
   private closed = false;
 
   constructor(opts: RoomOptions) {
@@ -65,6 +72,10 @@ export class CodehostRoom {
   private dial(peerId: string): Promise<TunnelClient> {
     const existing = this.tunnels.get(peerId);
     if (existing) return existing;
+    const failedAt = this.dialFailedAt.get(peerId);
+    if (failedAt != null && Date.now() - failedAt < DIAL_FAIL_COOLDOWN_MS) {
+      return Promise.reject(new Error("dial failed recently; cooling down"));
+    }
     const drop = () => {
       this.tunnels.delete(peerId);
       this.rtcs.get(peerId)?.close();
@@ -79,6 +90,7 @@ export class CodehostRoom {
         sendSignal: (data: RtcSignal) => this.signaling.sendSignal(peerId, data),
         onOpen: (channel) => {
           clearTimeout(timer);
+          this.dialFailedAt.delete(peerId);
           resolve(new TunnelClient(channel));
         },
         onClose: drop,
@@ -94,7 +106,10 @@ export class CodehostRoom {
       });
     });
     this.tunnels.set(peerId, dialing);
-    dialing.catch(() => this.tunnels.delete(peerId));
+    dialing.catch(() => {
+      this.dialFailedAt.set(peerId, Date.now());
+      this.tunnels.delete(peerId);
+    });
     return dialing;
   }
 

package/worker/room.ts

@@ -15,10 +15,14 @@ interface Attachment {
 }
 
 /** How often the room scans for dead sockets, and how long a socket may go
- *  silent before eviction. Clients heartbeat every ~10s; allow ~3 misses, so a
- *  crashed peer drops out within ~35-50s instead of lingering as a phantom. */
-const SWEEP_MS = 15_000;
-const STALE_MS = 35_000;
+ *  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;
+const STALE_MS = 65_000;
 
 /**
  * One Durable Object instance per token-room. Holds the live WebSocket