codeam-cli 2.12.11 → 2.12.13

package/CHANGELOG.md

@@ -4,6 +4,21 @@ 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.12.12] — 2026-05-14
+
+### Fixed
+
+- **cli:** Codex-specific renderer with DECSTBM scroll-region support — captures full multi-paragraph replies
+- **cli:** Inject Markdown ``` fences for Codex-emitted code blocks
+
+## [2.12.11] — 2026-05-14
+
+### Fixed
+
+- **cli:** Codex-specific renderer with DECSTBM scroll-region support — captures full multi-paragraph replies
+
+## [2.12.10] — 2026-05-14
+
 ## [2.12.9] — 2026-05-14
 
 ### Fixed

package/dist/index.js

@@ -1682,7 +1682,7 @@ var import_qrcode_terminal = __toESM(require("qrcode-terminal"));
 // package.json
 var package_default = {
   name: "codeam-cli",
-  version: "2.12.11",
+  version: "2.12.13",
   description: "Remote control Claude Code (and other AI coding agents) from your mobile phone. Pair your device, send prompts, stream responses in real-time, and approve commands \u2014 from anywhere.",
   type: "commonjs",
   main: "dist/index.js",
@@ -5834,6 +5834,7 @@ function filterCodexChrome(lines) {
     }
     out.push(t2);
   }
+  const wrapped = wrapCodexCodeBlocks(out);
   const hasRealInput = lines.some((l) => /\w/.test(l));
   if (out.length > 0 || hasRealInput) {
     const sampleIn = lines.slice(-50).map((l, i) => `  in[${i}] ${JSON.stringify(l)}`).join("\n");
@@ -5845,7 +5846,116 @@ ${sampleOut}`);
   } else {
     log.trace("codex-parse", `filterCodexChrome in=${lines.length} out=${out.length}`);
   }
-  return out;
+  return wrapped;
+}
+var CODE_CHAR_RE = /[;{}]|=>|^\s*(?:import|public|private|static|class|function|interface|type|const|let|var|def|return|if|else|for|while)\b/;
+var DIFF_HUNK_RE = /^@@\s+-\d+(?:,\d+)?\s+\+\d+(?:,\d+)?\s+@@/;
+var DIFF_GIT_RE = /^diff\s+--git\s+/;
+var DIFF_OLD_RE = /^---\s+(?:a\/)?\S/;
+var DIFF_NEW_RE = /^\+\+\+\s+(?:b\/)?\S/;
+var COMMIT_HEAD_RE = /^\[[\w./@-]+\s+[0-9a-f]{7,40}\]\s+/;
+var COMMIT_STATS_RE = /\d+\s+files?\s+changed/;
+var PUSH_TO_RE = /^To\s+(?:https?:\/\/|git@)/;
+var PUSH_NEW_RE = /\[new branch\]\s+\S+\s*->\s*\S+/;
+var PUSH_UPDATE_RE = /^\s*[0-9a-f]{7,40}\.\.[0-9a-f]{7,40}\s+\S+\s*->\s*\S+/;
+var MERGE_UPD_RE = /^Updating\s+[0-9a-f]{7,40}\.\.[0-9a-f]{7,40}/;
+var MERGE_FF_RE = /^Fast-forward\s*$/;
+var PR_TITLE_RE = /^title:\s+\S/;
+var PR_STATE_RE = /^state:\s+(?:OPEN|CLOSED|MERGED|DRAFT)/i;
+var PR_URL_RE = /https?:\/\/github\.com\/[\w.-]+\/[\w.-]+\/pull\/\d+/;
+var PR_BANNER_RE = /^\s*[✓✔]?\s*Pull request created\s*$/i;
+function isStructuredBlock(block) {
+  if (block.some((l) => DIFF_HUNK_RE.test(l))) return true;
+  if (block.some((l) => DIFF_GIT_RE.test(l))) return true;
+  if (block.some((l) => DIFF_OLD_RE.test(l)) && block.some((l) => DIFF_NEW_RE.test(l))) return true;
+  if (block.some((l) => COMMIT_HEAD_RE.test(l))) return true;
+  if (block.some((l) => COMMIT_STATS_RE.test(l))) return true;
+  if (block.some((l) => PUSH_TO_RE.test(l))) return true;
+  if (block.some((l) => PUSH_NEW_RE.test(l))) return true;
+  if (block.some((l) => PUSH_UPDATE_RE.test(l))) return true;
+  if (block.some((l) => MERGE_UPD_RE.test(l))) return true;
+  if (block.some((l) => MERGE_FF_RE.test(l))) return true;
+  if (block.some((l) => PR_TITLE_RE.test(l)) && block.some((l) => PR_STATE_RE.test(l))) return true;
+  if (block.some((l) => PR_URL_RE.test(l))) return true;
+  if (block.some((l) => PR_BANNER_RE.test(l))) return true;
+  return false;
+}
+function inferLanguage(block) {
+  const head = block.slice(0, 10).join("\n");
+  if (/\bpublic\s+(?:static\s+)?(?:class|void|int|String)\b|System\.out\.println|\bjava\.util/.test(head)) return "java";
+  if (/\b(?:interface|type)\s+\w+\s*=?\s*[{<]|\bas\s+(?:string|number|boolean)\b|\b(?:string|number|boolean)\s*[;,)\]]/.test(head)) return "typescript";
+  if (/\bimport\s+\w+\s+from\s+['"]|=>\s*[{(]|\bconst\s+\w+\s*=\s*(?:async\s+)?\(/.test(head)) return "javascript";
+  if (/^\s*def\s+\w+\(|^\s*from\s+\w+\s+import|print\(/m.test(head)) return "python";
+  if (/^\s*package\s+\w+|^\s*func\s+\w+\(|\binterface\s*{/m.test(head)) return "go";
+  if (/^\s*fn\s+\w+\(|^\s*use\s+\w+::|^\s*impl\s+/m.test(head)) return "rust";
+  if (/#include\s*<|int\s+main\s*\(/.test(head)) return "cpp";
+  return "";
+}
+function wrapCodexCodeBlocks(lines) {
+  if (isStructuredBlock(lines)) {
+    return lines;
+  }
+  const result = [];
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (!CODE_CHAR_RE.test(line)) {
+      result.push(line);
+      i++;
+      continue;
+    }
+    const start2 = i;
+    let end = i;
+    let j2 = i + 1;
+    while (j2 < lines.length) {
+      const l = lines[j2];
+      if (CODE_CHAR_RE.test(l)) {
+        end = j2;
+        j2++;
+        continue;
+      }
+      if (l.trim() === "") {
+        let k2 = j2 + 1;
+        while (k2 < lines.length && lines[k2].trim() === "") k2++;
+        if (k2 < lines.length && CODE_CHAR_RE.test(lines[k2])) {
+          end = k2;
+          j2 = k2 + 1;
+          continue;
+        }
+        break;
+      }
+      if (/^\s{2,}\S/.test(l)) {
+        end = j2;
+        j2++;
+        continue;
+      }
+      break;
+    }
+    const runLen = end - start2 + 1;
+    const body = lines.slice(start2, end + 1);
+    if (isStructuredBlock(body)) {
+      for (const l of body) result.push(l);
+      i = end + 1;
+      continue;
+    }
+    const codeShapedCount = body.filter((l) => CODE_CHAR_RE.test(l)).length;
+    if (codeShapedCount >= 3) {
+      const lang = inferLanguage(body);
+      result.push("```" + lang);
+      for (const l of body) result.push(l);
+      while (result.length > 0 && result[result.length - 1].trim() === "") {
+        result.pop();
+      }
+      result.push("```");
+      i = end + 1;
+    } else {
+      for (let k2 = start2; k2 <= end && k2 < lines.length; k2++) result.push(lines[k2]);
+      i = end + 1;
+      if (i === start2) i++;
+    }
+    void runLen;
+  }
+  return result;
 }
 function parseCodexChrome(_line) {
   return null;
@@ -10314,7 +10424,7 @@ async function stopWorkspaceFromLocal(target) {
 // src/commands/version.ts
 var import_picocolors11 = __toESM(require("picocolors"));
 function version() {
-  const v = true ? "2.12.11" : "unknown";
+  const v = true ? "2.12.13" : "unknown";
   console.log(`${import_picocolors11.default.bold("codeam-cli")} ${import_picocolors11.default.cyan(v)}`);
 }
 
@@ -10449,7 +10559,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.12.11" : null;
+  const current = true ? "2.12.13" : 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.12.11",
+  "version": "2.12.13",
   "description": "Remote control Claude Code (and other AI coding agents) from your mobile phone. Pair your device, send prompts, stream responses in real-time, and approve commands — from anywhere.",
   "type": "commonjs",
   "main": "dist/index.js",