codeam-cli 2.23.3 → 2.23.5

package/CHANGELOG.md

@@ -4,6 +4,18 @@ All notable changes to `codeam-cli` are documented here.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.23.4] — 2026-05-25
+
+### Fixed
+
+- **cli+workflow:** Unblock prompt flow + restore PostHog telemetry (#192)
+
+## [2.23.3] — 2026-05-25
+
+### Fixed
+
+- **cli:** Reap in-flight spawnAndCapture children on sigint/exit (#191)
+
 ## [2.23.2] — 2026-05-25
 
 ### Fixed

package/dist/index.js

@@ -441,7 +441,7 @@ var import_qrcode_terminal = __toESM(require("qrcode-terminal"));
 // package.json
 var package_default = {
   name: "codeam-cli",
-  version: "2.23.3",
+  version: "2.23.5",
   description: "Workflow-continuity bridge for AI coding agents. Wrap Claude Code or Codex in a PTY and supervise, approve, and redirect the session from any device \u2014 async. The terminal companion for CodeAgent Mobile.",
   type: "commonjs",
   main: "dist/index.js",
@@ -5768,7 +5768,7 @@ function readAnonId() {
 }
 function superProperties() {
   return {
-    cliVersion: true ? "2.23.3" : "0.0.0-dev",
+    cliVersion: true ? "2.23.5" : "0.0.0-dev",
     nodeVersion: process.version,
     platform: process.platform,
     arch: process.arch,
@@ -5781,7 +5781,7 @@ function initTelemetry() {
     log.trace("telemetry", "opted out (CODEAM_TELEMETRY / CI / NODE_ENV=test)");
     return false;
   }
-  const apiKey = true ? "" : "";
+  const apiKey = true ? "phc_Otx6LUf0KeabkbTnPuLPLg6d6r8319k8bKDYqoXyeb4" : "";
   if (!apiKey) {
     log.trace("telemetry", "no PostHog API key baked into build \u2014 disabled");
     return false;
@@ -5860,6 +5860,8 @@ function maybePrintFirstRunBanner() {
 
 // src/services/command-relay.service.ts
 var API_BASE2 = resolveApiBaseUrl();
+var SSE_LIVENESS_TIMEOUT_MS = 45e3;
+var SSE_WATCHDOG_INTERVAL_MS = 1e4;
 var CommandRelayService = class {
   constructor(pluginId, onCommand, agentMeta) {
     this.pluginId = pluginId;
@@ -5889,10 +5891,25 @@ var CommandRelayService = class {
   /** Reconnect backoff state for the SSE stream. */
   sseFailures = 0;
   sseReconnectTimer = null;
+  /**
+   * Liveness watchdog for the SSE socket. The server pings every 30 s
+   * (`pending-stream.controller.ts` interval(30_000)). If we go more
+   * than `SSE_LIVENESS_TIMEOUT_MS` without ANY bytes, we assume the
+   * TCP peer died half-open (Cloud Run scaled / redeployed mid-stream,
+   * NAT dropped the conntrack entry, laptop slept) and force a
+   * reconnect. Without this the kernel can keep the socket in a
+   * zombie ESTABLISHED state for HOURS before the default TCP
+   * keepalive triggers — observed live in #190 where a 17:18 redeploy
+   * left CLIs subscribed for >30 minutes without ever receiving a
+   * pushed command.
+   */
+  sseWatchdog = null;
+  sseLastByteAt = 0;
   start() {
     this.cleanup();
     this._running = true;
     this.agentsRegistered = false;
+    log.info("relay", `start pluginId=${this.pluginId.slice(0, 8)} agent=${this.agentMeta.id}`);
     this.sendHeartbeat(true);
     this.heartbeatTimer = setInterval(() => this.sendHeartbeat(true), 2e4);
     this.agentsTimer = setInterval(() => {
@@ -5900,6 +5917,7 @@ var CommandRelayService = class {
     }, 5e3);
     this.reportAgents();
     if (process.env.NODE_ENV === "test" || process.env.CODEAM_DISABLE_SSE_PULL === "1") {
+      log.info("relay", "SSE disabled \u2014 using polling fallback");
       this.startPollingFallback();
     } else {
       this.connectSSE();
@@ -5921,7 +5939,7 @@ var CommandRelayService = class {
     const url = new URL(`${API_BASE2}/api/commands/pending/stream`);
     url.searchParams.set("pluginId", this.pluginId);
     const transport = url.protocol === "https:" ? https2 : http2;
-    log.trace("relay", `sse connect ${url.pathname}`);
+    log.info("relay", `sse connect pluginId=${this.pluginId.slice(0, 8)}`);
     const req = transport.request(
       {
         hostname: url.hostname,
@@ -5933,11 +5951,11 @@ var CommandRelayService = class {
       },
       (res) => {
         if (res.statusCode !== 200) {
-          log.trace("relay", `sse status=${res.statusCode}`);
+          log.info("relay", `sse status=${res.statusCode} \u2014 backing off`);
           res.resume();
           this.sseFailures += 1;
           if (this.sseFailures >= 2) {
-            log.trace("relay", "sse unavailable, falling back to polling");
+            log.info("relay", "sse unavailable \u2014 falling back to polling");
             capture("sse_fallback_to_poll", {
               pluginId: this.pluginId,
               agentId: this.agentMeta.id,
@@ -5950,10 +5968,13 @@ var CommandRelayService = class {
           this.scheduleSseReconnect();
           return;
         }
+        log.info("relay", "sse connected");
         this.sseFailures = 0;
+        this.armSseWatchdog();
         let buffer = "";
         res.setEncoding("utf8");
         res.on("data", (chunk) => {
+          this.sseLastByteAt = Date.now();
           buffer += chunk;
           let frameEnd;
           while ((frameEnd = buffer.indexOf("\n\n")) !== -1) {
@@ -5963,15 +5984,26 @@ var CommandRelayService = class {
           }
         });
         res.on("end", () => {
+          log.info("relay", "sse end \u2014 reconnecting");
+          this.disarmSseWatchdog();
           if (this._running) this.scheduleSseReconnect();
         });
-        res.on("error", () => {
+        res.on("error", (err) => {
+          log.info("relay", `sse res error \u2014 reconnecting (${err.message})`);
+          this.disarmSseWatchdog();
           if (this._running) this.scheduleSseReconnect();
         });
       }
     );
+    req.on("socket", (socket) => {
+      try {
+        socket.setKeepAlive(true, 3e4);
+      } catch {
+      }
+    });
     req.on("error", (err) => {
-      log.trace("relay", "sse req error", err);
+      log.info("relay", `sse req error \u2014 ${err.message}`);
+      this.disarmSseWatchdog();
       this.sseFailures += 1;
       if (this.sseFailures >= 2) {
         capture("sse_fallback_to_poll", {
@@ -5986,11 +6018,43 @@ var CommandRelayService = class {
       this.scheduleSseReconnect();
     });
     req.on("timeout", () => {
+      log.info("relay", "sse req timeout \u2014 destroying + reconnecting");
       req.destroy();
     });
     req.end();
     this.sseRequest = req;
   }
+  // ─── SSE liveness watchdog ───────────────────────────────────────
+  //
+  // The server pings every 30 s; if more than SSE_LIVENESS_TIMEOUT_MS
+  // pass without a byte, we assume the TCP peer is dead-zombie and
+  // force the request to destroy → triggers `error`/`end` → standard
+  // reconnect path. Without this, observed in the field: half-open
+  // socket sits ESTABLISHED for 30 + minutes (until macOS default
+  // 2 h TCP keepalive kicks in) and the CLI silently misses every
+  // pushed command.
+  armSseWatchdog() {
+    this.disarmSseWatchdog();
+    this.sseLastByteAt = Date.now();
+    this.sseWatchdog = setInterval(() => {
+      const idle = Date.now() - this.sseLastByteAt;
+      if (idle > SSE_LIVENESS_TIMEOUT_MS) {
+        log.info("relay", `sse watchdog \u2014 ${idle}ms since last byte, forcing reconnect`);
+        try {
+          this.sseRequest?.destroy();
+        } catch {
+        }
+        this.disarmSseWatchdog();
+      }
+    }, SSE_WATCHDOG_INTERVAL_MS);
+    this.sseWatchdog.unref?.();
+  }
+  disarmSseWatchdog() {
+    if (this.sseWatchdog) {
+      clearInterval(this.sseWatchdog);
+      this.sseWatchdog = null;
+    }
+  }
   handleSseFrame(frame) {
     let event = "message";
     let data = "";
@@ -6003,10 +6067,13 @@ var CommandRelayService = class {
       const parsed = JSON.parse(data);
       const commands = parsed.commands ?? [];
       if (commands.length === 0) return;
-      log.trace("relay", `sse received ${commands.length} command(s)`);
+      log.info(
+        "relay",
+        `sse received ${commands.length} command(s) types=[${commands.map((c2) => c2.type).join(",")}]`
+      );
       void this.dispatchCommands(commands);
     } catch (err) {
-      log.trace("relay", "sse parse error", err);
+      log.info("relay", "sse parse error", err);
     }
   }
   scheduleSseReconnect() {
@@ -6064,7 +6131,8 @@ var CommandRelayService = class {
     await _postJson(`${API_BASE2}/api/plugin/heartbeat`, {
       pluginId: this.pluginId,
       online,
-      agentId: this.agentMeta.id
+      agentId: this.agentMeta.id,
+      branch: detectCurrentBranch()
     }).then(() => log.trace("relay", `heartbeat ok online=${online}`)).catch((err) => log.trace("relay", `heartbeat failed online=${online}`, err));
   }
   reportAgents() {
@@ -6101,6 +6169,7 @@ var CommandRelayService = class {
       clearTimeout(this.sseReconnectTimer);
       this.sseReconnectTimer = null;
     }
+    this.disarmSseWatchdog();
     if (this.sseRequest) {
       try {
         this.sseRequest.destroy();
@@ -12601,11 +12670,17 @@ var FileWatcherService = class {
       } : {},
       awaitWriteFinish: {
         // Coalesces rapid sequential writes (npm install spam, build
-        // tools emitting bursts). Lower than chokidar's default so
-        // the user sees their Files screen update within 0.5 s of
-        // saving.
-        stabilityThreshold: 150,
-        pollInterval: 50
+        // tools emitting bursts). Tuned for monorepo workloads after
+        // observing a CLI process spike to 126% CPU on the codeagent
+        // monorepo: pollInterval=50ms caused thousands of fs.stat
+        // calls per second when many files were being edited
+        // concurrently (agent edits + AI summary subprocess writes +
+        // git status outputs all touching files in the watched tree).
+        // 200ms is still well below the typical user perception
+        // threshold for "the file appeared in the Files screen" while
+        // keeping the polling cost bounded.
+        stabilityThreshold: 300,
+        pollInterval: 200
       }
     });
     watcher.on("add", (filePath) => this.schedule(filePath, "add"));
@@ -18326,7 +18401,7 @@ function checkChokidar() {
 }
 async function doctor(args2 = []) {
   const json = args2.includes("--json");
-  const cliVersion = true ? "2.23.3" : "0.0.0-dev";
+  const cliVersion = true ? "2.23.5" : "0.0.0-dev";
   const apiBase = resolveApiBaseUrl();
   const diagnosticId = (0, import_node_crypto5.randomUUID)();
   log.info("doctor", `run id=${diagnosticId} cli=${cliVersion}`);
@@ -18525,7 +18600,7 @@ async function completion(args2) {
 // src/commands/version.ts
 var import_picocolors13 = __toESM(require("picocolors"));
 function version2() {
-  const v = true ? "2.23.3" : "unknown";
+  const v = true ? "2.23.5" : "unknown";
   console.log(`${import_picocolors13.default.bold("codeam-cli")} ${import_picocolors13.default.cyan(v)}`);
 }
 
@@ -18753,7 +18828,7 @@ function checkForUpdates() {
   if (process.env.CODEAM_DISABLE_UPDATE_CHECK === "1") return;
   if (process.env.CI) return;
   if (!process.stdout.isTTY) return;
-  const current = true ? "2.23.3" : null;
+  const current = true ? "2.23.5" : null;
   if (!current) return;
   const cache = readCache();
   const fresh = cache && Date.now() - cache.fetchedAt < TTL_MS;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeam-cli",
-  "version": "2.23.3",
+  "version": "2.23.5",
   "description": "Workflow-continuity bridge for AI coding agents. Wrap Claude Code or Codex in a PTY and supervise, approve, and redirect the session from any device — async. The terminal companion for CodeAgent Mobile.",
   "type": "commonjs",
   "main": "dist/index.js",