codeam-cli 2.76.36 → 2.76.38

package/CHANGELOG.md

@@ -4,6 +4,23 @@ 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
+
+- **shared:** One Point-at-it picker for Remix and the Preview
+- **cli:** The Preview picker is Remix's Point at it
+
+### Fixed
+
+- **shared:** Point picker swallows the post-pick click, valid selectors, reload-safe mark ids
+
 ## [2.76.35] — 2026-10-22
 
 ### Fixed

package/dist/index.js

@@ -11354,7 +11354,7 @@ function readAnonId() {
 }
 function superProperties() {
   return {
-    cliVersion: true ? "2.76.36" : "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.36",
+  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.36" ? { ideVersion: "2.76.36" } : {}
+      ..."2.76.38" ? { ideVersion: "2.76.38" } : {}
     };
     try {
       const res = await _postJson(`${API_BASE2}/api/plugin/heartbeat`, body, this.pollSecretHeader());
@@ -24113,27 +24113,153 @@ var import_os10 = __toESM(require("os"));
 var import_path5 = __toESM(require("path"));
 var import_promises3 = require("stream/promises");
 var import_which = __toESM(require("which"));
-var CACHED_BINARY = import_path5.default.join(import_os10.default.homedir(), ".codeam", "bin", "cloudflared");
+var CACHE_DIR = import_path5.default.join(import_os10.default.homedir(), ".codeam", "bin");
+var LEGACY_CACHED_BINARY = import_path5.default.join(CACHE_DIR, "cloudflared");
+function cachedCloudflaredPath(platform3 = process.platform) {
+  return platform3 === "win32" ? import_path5.default.join(CACHE_DIR, "cloudflared.exe") : LEGACY_CACHED_BINARY;
+}
+var MIN_CLOUDFLARED_VERSION = [2026, 10, 2];
+var MIN_CLOUDFLARED_VERSION_DARWIN_NON_BREW = [2026, 10, 3];
+var DEFAULT_HOMEBREW_PREFIXES = [
+  "/opt/homebrew/",
+  "/usr/local/Cellar/",
+  "/usr/local/Homebrew/",
+  "/home/linuxbrew/"
+];
+function homebrewPrefixes(env = process.env) {
+  const custom = env.HOMEBREW_PREFIX?.replace(/\/+$/, "");
+  return custom ? [...DEFAULT_HOMEBREW_PREFIXES, `${custom}/`, `${custom}/Cellar/`] : [...DEFAULT_HOMEBREW_PREFIXES];
+}
+function parseCloudflaredVersion(output) {
+  const m = /cloudflared version (\d+)\.(\d+)\.(\d+)/.exec(output);
+  return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : null;
+}
+function isHomebrewPath(bin, prefixes = homebrewPrefixes()) {
+  return prefixes.some((prefix) => bin.startsWith(prefix));
+}
+function formatCloudflaredVersion(v) {
+  return v.join(".");
+}
+function minimumCloudflaredVersion(bin, platform3 = process.platform, prefixes = homebrewPrefixes()) {
+  return platform3 === "darwin" && !isHomebrewPath(bin, prefixes) ? MIN_CLOUDFLARED_VERSION_DARWIN_NON_BREW : MIN_CLOUDFLARED_VERSION;
+}
+function compareVersions(a, b) {
+  for (let i = 0; i < 3; i++) {
+    if (a[i] !== b[i]) return a[i] - b[i];
+  }
+  return 0;
+}
+function meetsMinimumCloudflaredVersion(version3, bin, platform3 = process.platform, prefixes = homebrewPrefixes()) {
+  if (!version3) return false;
+  return compareVersions(version3, minimumCloudflaredVersion(bin, platform3, prefixes)) >= 0;
+}
+var versionCache = /* @__PURE__ */ new Map();
+var warnedOutdated = /* @__PURE__ */ new Set();
+function readCloudflaredVersion(bin) {
+  let cached2 = versionCache.get(bin);
+  if (!cached2) {
+    const pending2 = new Promise((resolve13) => {
+      (0, import_child_process14.execFile)(bin, ["--version"], { timeout: 1e4 }, (err, stdout, stderr) => {
+        resolve13(err ? null : parseCloudflaredVersion(`${stdout}
+${stderr}`));
+      });
+    }).then((version3) => {
+      if (!version3 && versionCache.get(bin) === pending2) versionCache.delete(bin);
+      return version3;
+    });
+    cached2 = pending2;
+    versionCache.set(bin, pending2);
+  }
+  return cached2;
+}
+async function realpathOrSelf(p2) {
+  try {
+    return await import_promises2.default.realpath(p2);
+  } catch {
+    return p2;
+  }
+}
+async function checkCloudflaredVersion(bin) {
+  const version3 = await readCloudflaredVersion(bin);
+  const real = await realpathOrSelf(bin);
+  const prefixes = homebrewPrefixes();
+  const customPrefix = process.env.HOMEBREW_PREFIX?.replace(/\/+$/, "");
+  if (customPrefix) {
+    const realPrefix = await realpathOrSelf(customPrefix);
+    if (realPrefix !== customPrefix) prefixes.push(`${realPrefix}/`, `${realPrefix}/Cellar/`);
+  }
+  const brewBin = isHomebrewPath(bin, prefixes) ? bin : real;
+  return {
+    ok: meetsMinimumCloudflaredVersion(version3, brewBin, process.platform, prefixes),
+    version: version3,
+    min: minimumCloudflaredVersion(brewBin, process.platform, prefixes)
+  };
+}
+async function migrateLegacyWindowsCache(target) {
+  if (target === LEGACY_CACHED_BINARY) return;
+  try {
+    await import_promises2.default.access(target);
+    return;
+  } catch {
+  }
+  try {
+    await import_promises2.default.access(LEGACY_CACHED_BINARY);
+    await import_promises2.default.rename(LEGACY_CACHED_BINARY, target);
+  } catch {
+  }
+}
+function describeVersion(v) {
+  return v ? formatCloudflaredVersion(v) : "an unknown version";
+}
 async function resolveCloudflared(opts = {}) {
+  let pathBin;
   try {
-    return await (0, import_which.default)("cloudflared");
+    pathBin = await (0, import_which.default)("cloudflared");
   } catch {
   }
+  if (pathBin) {
+    const check2 = await checkCloudflaredVersion(pathBin);
+    if (check2.ok) return pathBin;
+    if (!warnedOutdated.has(pathBin)) {
+      warnedOutdated.add(pathBin);
+      log.warn(
+        "preview",
+        `ignoring ${pathBin} (${describeVersion(check2.version)}): previews need cloudflared >= ${formatCloudflaredVersion(check2.min)}; upgrade cloudflared with your package manager (e.g. \`brew upgrade cloudflared\`). Using a CodeAgent-managed copy instead.`
+      );
+    }
+  }
+  const cached2 = cachedCloudflaredPath();
+  await migrateLegacyWindowsCache(cached2);
+  let staleCache = false;
   try {
-    await import_promises2.default.access(CACHED_BINARY);
-    if (await isExecutableBinary(CACHED_BINARY)) {
-      return CACHED_BINARY;
+    await import_promises2.default.access(cached2);
+    if (!await isExecutableBinary(cached2)) {
+      await import_promises2.default.rm(cached2, { force: true });
+    } else if ((await checkCloudflaredVersion(cached2)).ok) {
+      return cached2;
+    } else {
+      staleCache = true;
     }
-    await import_promises2.default.rm(CACHED_BINARY, { force: true });
   } catch {
   }
   if (opts.skipDownload) {
     throw new Error(
-      "cloudflared not installed. Install via `brew install cloudflared` (macOS) or download from https://github.com/cloudflare/cloudflared/releases."
+      `cloudflared not installed (or older than ${formatCloudflaredVersion(minimumCloudflaredVersion(cached2))}). Install or upgrade via \`brew install cloudflared\` (macOS) or download from https://github.com/cloudflare/cloudflared/releases.`
     );
   }
-  await downloadCloudflared(CACHED_BINARY);
-  return CACHED_BINARY;
+  if (staleCache) await import_promises2.default.rm(cached2, { force: true });
+  versionCache.delete(cached2);
+  await downloadCloudflared(cached2);
+  versionCache.delete(cached2);
+  const check = await checkCloudflaredVersion(cached2);
+  if (!check.ok) {
+    await import_promises2.default.rm(cached2, { force: true });
+    versionCache.delete(cached2);
+    throw new Error(
+      `Downloaded cloudflared reports ${describeVersion(check.version)}, but previews need cloudflared >= ${formatCloudflaredVersion(check.min)}. Install the latest version manually via \`brew install cloudflared\` (macOS) or from https://github.com/cloudflare/cloudflared/releases.`
+    );
+  }
+  return cached2;
 }
 async function downloadCloudflared(target) {
   const url2 = downloadUrlForPlatform();
@@ -39345,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;
@@ -39390,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). */
@@ -39555,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;
@@ -39574,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,
@@ -45861,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();
@@ -46610,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;
@@ -46640,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 ────────────────────────────────────────────────────
@@ -46697,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,
@@ -46721,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,
@@ -51037,9 +51253,9 @@ async function probeCodeamPair(provider, workspace) {
 }
 async function stopWorkspaceFromLocal(target) {
   if (target.provider.id === "github-codespaces") {
-    const { execFile: execFile21 } = await import("child_process");
+    const { execFile: execFile22 } = await import("child_process");
     const { promisify: promisify17 } = await import("util");
-    const execFileP10 = promisify17(execFile21);
+    const execFileP10 = promisify17(execFile22);
     await execFileP10("gh", ["codespace", "stop", "-c", target.id], { maxBuffer: 8 * 1024 * 1024 });
     return;
   }
@@ -51937,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.36" : null;
+  const current2 = true ? "2.76.38" : null;
   if (!current2) return;
   const cache = readCache();
   const fresh = cache && Date.now() - cache.fetchedAt < TTL_MS;
@@ -51954,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.36" : null;
+  const current2 = true ? "2.76.38" : null;
   if (!current2) return;
   const cache = readCache();
   const fresh = cache && Date.now() - cache.fetchedAt < TTL_MS;
@@ -52260,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.36" : null;
+  return true ? "2.76.38" : null;
 }
 async function installedVersion(deps) {
   const ls = await deps.run(
@@ -52483,7 +52699,7 @@ function signalHostReady(send = process.send?.bind(process)) {
 }
 function defaultDeps() {
   return {
-    ownVersion: true ? "2.76.36" : null,
+    ownVersion: true ? "2.76.38" : null,
     root: cliVersionsRoot(),
     args: process.argv.slice(3),
     execPath: process.execPath,
@@ -55021,7 +55237,7 @@ function checkChokidar() {
 }
 async function doctor(args2 = []) {
   const json = args2.includes("--json");
-  const cliVersion = true ? "2.76.36" : "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}`);
@@ -55557,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.36" : "unknown";
+  const v = true ? "2.76.38" : "unknown";
   console.log(`${import_picocolors15.default.bold("codeam-cli")} ${import_picocolors15.default.cyan(v)}`);
 }
 

package/package.json

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