codeam-cli 2.76.37 → 2.76.38

package/CHANGELOG.md

@@ -4,6 +4,12 @@ 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.76.37] — 2026-10-26
+
+### Fixed
+
+- **cli:** Require cloudflared >= 2026.10.2 for previews (#994)
+
 ## [2.76.36] — 2026-10-25
 
 ### Added

package/dist/index.js

@@ -11354,7 +11354,7 @@ function readAnonId() {
 }
 function superProperties() {
   return {
-    cliVersion: true ? "2.76.37" : "0.0.0-dev",
+    cliVersion: true ? "2.76.38" : "0.0.0-dev",
     nodeVersion: process.version,
     platform: process.platform,
     arch: process.arch,
@@ -11603,7 +11603,7 @@ var http = __toESM(require("http"));
 // package.json
 var package_default = {
   name: "codeam-cli",
-  version: "2.76.37",
+  version: "2.76.38",
   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",
@@ -12979,7 +12979,7 @@ var CommandRelayService = class _CommandRelayService {
       // fresh + clear the "CLI update available" banner after a self-update
       // (a codespace that reinstalls @latest reconnects via heartbeat, not
       // pair/reconnect). Older backends ignore the extra field.
-      ..."2.76.37" ? { ideVersion: "2.76.37" } : {}
+      ..."2.76.38" ? { ideVersion: "2.76.38" } : {}
     };
     try {
       const res = await _postJson(`${API_BASE2}/api/plugin/heartbeat`, body, this.pollSecretHeader());
@@ -39471,6 +39471,95 @@ function _get(url2, headers) {
   });
 }
 
+// src/services/streaming/chunk-coalescer.ts
+var STREAMING_CHUNK_MIN_INTERVAL_MS = 100;
+var FINALIZED_MEMORY = 512;
+var StreamingChunkCoalescer = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  opts;
+  chunks = /* @__PURE__ */ new Map();
+  finalized = /* @__PURE__ */ new Set();
+  submit(event) {
+    const { chunkId } = event;
+    if (this.finalized.has(chunkId)) return Promise.resolve();
+    const state = this.chunks.get(chunkId) ?? this.open(chunkId);
+    const settled = new Promise((resolve13) => {
+      const waiters = state.pending ? state.pending.waiters : [];
+      waiters.push(resolve13);
+      state.pending = { event, waiters };
+    });
+    if (event.isFinal) {
+      this.markFinalized(chunkId);
+      this.drain(chunkId, state);
+    } else {
+      this.schedule(chunkId, state);
+    }
+    return settled;
+  }
+  /** Send every pending snapshot now (ignoring the spacing) and wait for all
+   *  requests to settle. Used on shutdown so the latest content is not lost. */
+  async flush() {
+    const work = Array.from(this.chunks.entries()).map(async ([chunkId, state]) => {
+      while (state.inFlight || state.pending) {
+        if (!state.inFlight) this.drain(chunkId, state);
+        await state.inFlight;
+      }
+    });
+    await Promise.all(work);
+  }
+  open(chunkId) {
+    const state = { pending: null, inFlight: null, timer: null, lastSentAt: 0 };
+    this.chunks.set(chunkId, state);
+    return state;
+  }
+  schedule(chunkId, state) {
+    if (state.inFlight || state.timer || !state.pending) return;
+    const wait = this.intervalFor(state.pending.event) - (Date.now() - state.lastSentAt);
+    if (wait <= 0) {
+      this.drain(chunkId, state);
+      return;
+    }
+    state.timer = setTimeout(() => {
+      state.timer = null;
+      this.drain(chunkId, state);
+    }, wait);
+  }
+  /** Send the pending snapshot now, unless a request is still in flight
+   *  (its completion re-enters here or {@link schedule}). */
+  drain(chunkId, state) {
+    if (state.inFlight || !state.pending) return;
+    if (state.timer) {
+      clearTimeout(state.timer);
+      state.timer = null;
+    }
+    const { event, waiters } = state.pending;
+    state.pending = null;
+    state.lastSentAt = Date.now();
+    state.inFlight = this.opts.send(event).catch(() => void 0).then(() => {
+      state.inFlight = null;
+      for (const resolve13 of waiters) resolve13();
+      if (!state.pending) {
+        if (event.isFinal) this.chunks.delete(chunkId);
+        return;
+      }
+      if (state.pending.event.isFinal) this.drain(chunkId, state);
+      else this.schedule(chunkId, state);
+    });
+  }
+  intervalFor(event) {
+    return this.opts.intervalFor?.(event) ?? STREAMING_CHUNK_MIN_INTERVAL_MS;
+  }
+  markFinalized(chunkId) {
+    this.finalized.add(chunkId);
+    if (this.finalized.size > FINALIZED_MEMORY) {
+      const oldest = this.finalized.values().next().value;
+      if (oldest !== void 0) this.finalized.delete(oldest);
+    }
+  }
+};
+
 // src/agents/acp/publisher.ts
 var STREAMING_CHUNK_SNAPSHOT_MAX_CHARS = 56 * 1024;
 var STREAMING_CHUNK_COALESCE_MIN_CHARS = 8 * 1024;
@@ -39516,8 +39605,12 @@ var AcpPublisher = class {
   /** chunkIds whose truncated snapshot already went out — nothing new to show
    *  until the terminal frame. */
   truncatedChunks = /* @__PURE__ */ new Set();
-  lastChunkPostAt = /* @__PURE__ */ new Map();
-  pendingChunkPosts = /* @__PURE__ */ new Map();
+  /** Latest-wins, one-in-flight-per-chunkId pacing of the streaming-chunk
+   *  feed (2026-10-29: one CLI posted 10–30 cumulative snapshots/s). */
+  chunkCoalescer = new StreamingChunkCoalescer({
+    send: (event) => this.postStreamingChunk(event),
+    intervalFor: (event) => event.content.length >= STREAMING_CHUNK_COALESCE_MIN_CHARS ? STREAMING_CHUNK_COALESCE_WINDOW_MS : STREAMING_CHUNK_MIN_INTERVAL_MS
+  });
   /** Latched on an unrecoverable 401/403 — every surface stops posting
    *  (2026-06-28 incident: a dead-token publisher spammed 401 ×34 while
    *  the agent's replies silently never reached the phone). */
@@ -39681,14 +39774,13 @@ var AcpPublisher = class {
    * ({@link publishOutput}) is independent and carries `type:'text'`
    * for the main chat bubble; this feed is purely additive for the
    * richer SessionDetail surface.
+   *
+   * POSTs are paced per chunkId by {@link StreamingChunkCoalescer}: latest
+   * snapshot wins, one request in flight, and the `isFinal` frame always goes
+   * last. The promise settles once this content (or a newer one) is sent.
    */
   async publishStreamingChunk(event) {
     const { chunkId, isFinal } = event;
-    const pending2 = this.pendingChunkPosts.get(chunkId);
-    if (pending2) {
-      clearTimeout(pending2.timer);
-      this.pendingChunkPosts.delete(chunkId);
-    }
     const bounded = boundStreamingChunkContent(event.content);
     if (bounded.truncated) {
       if (!isFinal && this.truncatedChunks.has(chunkId)) return;
@@ -39700,27 +39792,16 @@ var AcpPublisher = class {
       }
       this.truncatedChunks.add(chunkId);
     }
-    if (isFinal) {
-      this.truncatedChunks.delete(chunkId);
-      this.lastChunkPostAt.delete(chunkId);
-    } else if (!bounded.truncated && bounded.content.length >= STREAMING_CHUNK_COALESCE_MIN_CHARS) {
-      const last = this.lastChunkPostAt.get(chunkId) ?? 0;
-      const wait = STREAMING_CHUNK_COALESCE_WINDOW_MS - (Date.now() - last);
-      if (wait > 0) {
-        const timer = setTimeout(() => {
-          const latest = this.pendingChunkPosts.get(chunkId);
-          this.pendingChunkPosts.delete(chunkId);
-          if (latest) void this.postStreamingChunk(latest.event);
-        }, wait);
-        this.pendingChunkPosts.set(chunkId, { timer, event });
-        return;
-      }
-    }
-    await this.postStreamingChunk({ ...event, content: bounded.content });
+    if (isFinal) this.truncatedChunks.delete(chunkId);
+    await this.chunkCoalescer.submit({ ...event, content: bounded.content });
+  }
+  /** Send any coalesced streaming-chunk snapshot still waiting, and wait for
+   *  the in-flight ones — so shutdown never loses the latest content. */
+  flushStreamingChunks() {
+    return this.chunkCoalescer.flush();
   }
   async postStreamingChunk(event) {
     const url2 = `${this.apiBase}/api/sessions/${encodeURIComponent(this.opts.sessionId)}/streaming-chunk`;
-    if (!event.isFinal) this.lastChunkPostAt.set(event.chunkId, Date.now());
     try {
       const { statusCode, body } = await this.postWithReauth(
         url2,
@@ -45987,6 +46068,10 @@ async function runAcpSession(opts) {
   const shutdown = async (signal) => {
     showInfo(`Shutting down ACP session (${signal})\u2026`);
     clearTimeout(prewarmTimer);
+    await Promise.race([
+      publisher.flushStreamingChunks(),
+      new Promise((resolve13) => setTimeout(resolve13, 2e3).unref())
+    ]);
     await stopRelayWithGoodbye(relay);
     void fileWatcher.stop();
     turnFiles.stop();
@@ -46736,6 +46821,10 @@ var StreamingEmitterService = class {
    */
   lastSelectorSignature = null;
   selectorFirstSeenAt = 0;
+  /** Latest-wins, one-in-flight-per-chunkId pacing of the chunk POSTs. */
+  chunkCoalescer = new StreamingChunkCoalescer({
+    send: (event) => this.postChunk(event)
+  });
   // ─── Lifecycle ─────────────────────────────────────────────────────
   start() {
     if (this.active) return;
@@ -46766,13 +46855,14 @@ var StreamingEmitterService = class {
       const finalContent = this.activeChunk.currentContent;
       const chunk = this.activeChunk;
       this.activeChunk = null;
-      await this.postChunk({
+      await this.chunkCoalescer.submit({
         chunkId: chunk.chunkId,
         kind: chunk.kind,
         content: finalContent,
         isFinal: true
       });
     }
+    await this.chunkCoalescer.flush();
     log.trace("streamingEmitter", `stopped session=${this.opts.sessionId.slice(0, 8)}`);
   }
   // ─── Input pump ────────────────────────────────────────────────────
@@ -46823,7 +46913,7 @@ var StreamingEmitterService = class {
     if (this.activeChunk) {
       const closing = this.activeChunk;
       this.activeChunk = null;
-      void this.postChunk({
+      void this.chunkCoalescer.submit({
         chunkId: closing.chunkId,
         kind: closing.kind,
         content: closing.currentContent,
@@ -46847,7 +46937,7 @@ var StreamingEmitterService = class {
     if (chunk.currentContent === chunk.emittedContent) return;
     chunk.emittedContent = chunk.currentContent;
     chunk.lastEmitAt = now;
-    void this.postChunk({
+    void this.chunkCoalescer.submit({
       chunkId: chunk.chunkId,
       kind: chunk.kind,
       content: chunk.currentContent,
@@ -52063,7 +52153,7 @@ async function autoUpgradeBeforeCriticalCommand() {
   if (process.env.NODE_ENV === "test") return;
   if (process.env.CODEAM_DISABLE_UPDATE_CHECK === "1") return;
   if (process.env.CI) return;
-  const current2 = true ? "2.76.37" : null;
+  const current2 = true ? "2.76.38" : null;
   if (!current2) return;
   const cache = readCache();
   const fresh = cache && Date.now() - cache.fetchedAt < TTL_MS;
@@ -52080,7 +52170,7 @@ function checkForUpdates() {
   if (process.env.CODEAM_DISABLE_UPDATE_CHECK === "1") return;
   if (process.env.CI) return;
   if (!process.stdout.isTTY) return;
-  const current2 = true ? "2.76.37" : null;
+  const current2 = true ? "2.76.38" : null;
   if (!current2) return;
   const cache = readCache();
   const fresh = cache && Date.now() - cache.fetchedAt < TTL_MS;
@@ -52386,7 +52476,7 @@ var SELF_UPDATE_VIEW_TIMEOUT_MS = 3e4;
 var SELF_UPDATE_INSTALL_TIMEOUT_MS = 18e4;
 var SELF_UPDATE_LS_TIMEOUT_MS = 15e3;
 function currentCliVersion() {
-  return true ? "2.76.37" : null;
+  return true ? "2.76.38" : null;
 }
 async function installedVersion(deps) {
   const ls = await deps.run(
@@ -52609,7 +52699,7 @@ function signalHostReady(send = process.send?.bind(process)) {
 }
 function defaultDeps() {
   return {
-    ownVersion: true ? "2.76.37" : null,
+    ownVersion: true ? "2.76.38" : null,
     root: cliVersionsRoot(),
     args: process.argv.slice(3),
     execPath: process.execPath,
@@ -55147,7 +55237,7 @@ function checkChokidar() {
 }
 async function doctor(args2 = []) {
   const json = args2.includes("--json");
-  const cliVersion = true ? "2.76.37" : "0.0.0-dev";
+  const cliVersion = true ? "2.76.38" : "0.0.0-dev";
   const apiBase2 = resolveApiBaseUrl();
   const diagnosticId = (0, import_node_crypto17.randomUUID)();
   log.info("doctor", `run id=${diagnosticId} cli=${cliVersion}`);
@@ -55683,7 +55773,7 @@ async function mcpWarm(argv = [], opts = {}) {
 // src/commands/version.ts
 var import_picocolors15 = __toESM(require("picocolors"));
 function version2() {
-  const v = true ? "2.76.37" : "unknown";
+  const v = true ? "2.76.38" : "unknown";
   console.log(`${import_picocolors15.default.bold("codeam-cli")} ${import_picocolors15.default.cyan(v)}`);
 }
 

package/dist/postinstall.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+"use strict";
+
+// src/postinstall.ts
+var c = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  green: "\x1B[32m",
+  cyan: "\x1B[36m",
+  violet: "\x1B[35m",
+  white: "\x1B[97m"
+};
+var lines = [
+  "",
+  `  ${c.violet}${c.bold}codeam-cli${c.reset}  ${c.dim}\u2014 Claude Code remote control${c.reset}`,
+  "",
+  `  ${c.dim}1.${c.reset} Pair your phone:`,
+  `     ${c.cyan}codeam pair${c.reset}`,
+  "",
+  `  ${c.dim}2.${c.reset} Launch Claude Code with mobile control:`,
+  `     ${c.cyan}codeam${c.reset}`,
+  "",
+  `  ${c.dim}Other commands:${c.reset}`,
+  `     ${c.white}codeam sessions${c.reset}   ${c.dim}list paired devices${c.reset}`,
+  `     ${c.white}codeam status${c.reset}     ${c.dim}show connection info${c.reset}`,
+  `     ${c.white}codeam logout${c.reset}     ${c.dim}remove all sessions${c.reset}`,
+  "",
+  `  ${c.dim}Requires Claude Code:${c.reset} ${c.green}npm install -g @anthropic-ai/claude-code${c.reset}`,
+  `  ${c.dim}Mobile app:${c.reset}           ${c.green}https://www.codeagent-mobile.com${c.reset}`,
+  ""
+];
+process.stdout.write(lines.join("\n") + "\n");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeam-cli",
-  "version": "2.76.37",
+  "version": "2.76.38",
   "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",