open-claude-p 1.2.1 → 1.2.2

package/CHANGELOG.md

@@ -7,6 +7,75 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## [1.2.2] — 2026-09-13
+
+Fixes the two defects listed as known issues in 1.2.1. Both were
+pre-existing — they predate the 1.2.x work — and both were tracked to
+root cause before anything was changed.
+
+### Fixed
+
+- **Replies lost every space between words.** The upstream TUI does not
+  emit literal spaces between words on a redraw; it positions each word
+  with an absolute column move and lets the terminal leave the gap blank:
+
+  ```
+  A\x1b[5Gpseudoterminal\x1b[20Gis\x1b[23Ga\x1b[25Gsoftware
+  ```
+
+  `ansi-strip` translated only CUF (`ESC [ Pn C`) into spaces. CHA
+  (`ESC [ Pn G`) — which the current CLI uses for nearly every word — was
+  deleted by the general CSI strip, so the reply came back as
+  `Apseudoterminalisasoftware…`. The parser now tracks the cursor column
+  and expands any forward horizontal move, CUF and CHA alike, into the
+  run of spaces it would have left on screen. CUP (`H`/`f`) adopts the
+  column without padding, since it is a jump to another region rather
+  than a gap.
+
+- **The CLI printed the TUI's spinner cell and usage meters around the
+  answer.** `cleanResponse` exists as the last line of defence for
+  PTY-extracted text — its own docstring says so — but only the chat
+  client ever called it. The CLI printed raw PTY text whenever the
+  upstream session file was unavailable, which is exactly when the scrub
+  is needed. Both CLI paths now scrub, and the pattern set gained the
+  rate-limit meters (`Usage ██░░ 16% (resets in 3h)`), the bare context
+  meter, and the spinner status cell with its token counters (`63✢  88`).
+  Guards keep real prose intact: meters must carry bar glyphs, counter
+  cells must carry a digit beside the glyph and the multi-space padding
+  the TUI uses, and a reply that is legitimately just a number ("what is
+  6*7" → "42") is never swallowed.
+
+- **Sessions started from inside a Claude Code session were never
+  persisted.** When `ocp` itself runs under Claude Code — an agent
+  driving it, or a developer testing from one — the spawned `claude`
+  inherited the caller's session identity, most decisively
+  `CLAUDE_CODE_CHILD_SESSION`, and concluded it was a continuation of the
+  parent rather than a new session. It then wrote no session JSONL at
+  all: `sessionId` came back `null`, the clean transcript ocp prefers was
+  unavailable so every answer fell back to PTY-scraped text, and
+  `--continue` / `--resume` had nothing to resume. The driver now removes
+  the caller's session-identity variables when spawning. User-facing
+  configuration (`CLAUDE_CODE_SIMPLE`, `CLAUDE_CODE_SAFE_MODE`, provider
+  toggles, …) is untouched, an explicit value in `opts.env` still wins,
+  and `OCP_KEEP_PARENT_SESSION_ENV=1` restores the old behaviour.
+
+### Tests
+
+- 237 → 243. New coverage: `test/ansi-cha.test.js` (absolute column moves,
+  including the verbatim byte sequence captured off the wire) and
+  `test/parent-session-env.test.js`. `test/clean-response.test.js` gains
+  the meter, spinner-cell and numeric-answer cases.
+
+### Verification
+
+Each fix was reproduced first, then confirmed against the real CLI:
+replaying the captured session through the parser now yields the sentence
+with its spacing intact; a warm-daemon second turn prints the answer with
+no chrome; and `--continue` recalls a word from the previous turn, which
+it could not do before.
+
+---
+
 ## [1.2.1] — 2026-09-13
 
 Re-sync with Claude Code 2.1.270 and the current model lineup, and fix a

package/bin/cli.js

@@ -65,6 +65,27 @@ const EXIT = {
   NOT_IMPLEMENTED: 8,
 };
 
+/**
+ * Scrub TUI chrome out of PTY-extracted text.
+ *
+ * Only for text reconstructed from terminal frames. Text read from the
+ * upstream session JSONL is already clean and must be passed through
+ * untouched. Failures are swallowed: a scrub that throws must never cost
+ * the caller their answer.
+ *
+ * @param {string} text
+ * @returns {Promise<string>}
+ */
+async function scrubPtyText(text) {
+  if (typeof text !== 'string' || text === '') return text;
+  try {
+    const { cleanResponse } = await import('../src/chat/index.js');
+    return cleanResponse(text);
+  } catch {
+    return text;
+  }
+}
+
 async function main() {
   const { options, positional, unknown, errors, supplied } = parseArgv(process.argv.slice(2));
 
@@ -309,8 +330,10 @@ async function main() {
         process.stdout,
       );
       for (const ev of (result.events ?? [])) adapter.onEvent(ev);
+      // Daemon results are always PTY-extracted — the daemon does not read
+      // the upstream session file — so they need the same scrub.
       adapter.end({
-        text: result.text,
+        text: await scrubPtyText(result.text),
         isError: result.isError,
         sessionId: result.sessionId,
         cost: result.cost,
@@ -466,17 +489,24 @@ async function runOneTurn({ driver, adapter, options, unknown, ac, prompt, resum
   let finalText = result.text;
   let usage = null;
   let toolsFromSession = [];
+  let fromSessionFile = false;
   if (!result.isError) {
     try {
       const { readSessionText } = await import('../src/chat/index.js');
       const sessionRead = await readSessionText(
         result.sessionId, startTime, options.cwd, { expectPrompt: prompt },
       );
-      if (sessionRead?.text) finalText = sessionRead.text;
+      if (sessionRead?.text) { finalText = sessionRead.text; fromSessionFile = true; }
       if (sessionRead?.usage) usage = sessionRead.usage;
       if (sessionRead?.tools) toolsFromSession = sessionRead.tools;
     } catch { /* keep PTY-extracted fallback */ }
   }
+  // The JSONL is always clean; PTY-extracted text is not. `cleanResponse`
+  // exists as the last line of defence for exactly this fallback, but the
+  // CLI never called it — only the chat client did — so a run that could
+  // not read the session file printed the TUI's spinner cell and usage
+  // meters around the answer.
+  if (!fromSessionFile) finalText = await scrubPtyText(finalText);
 
   adapter.end({
     text: finalText,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-claude-p",
-  "version": "1.2.1",
+  "version": "1.2.2",
   "description": "A PTY-backed compatibility shim for `claude -p` (Claude Code headless/print mode). Drives the interactive `claude` CLI via node-pty and exposes the same option surface and stream-json contract. Ships as both a library and an `ocp` CLI binary.",
   "type": "module",
   "main": "./src/index.js",

package/src/chat/index.js

@@ -1328,7 +1328,28 @@ export const TUI_CHROME_PATTERNS = [
 // 2 MCPs | 4 hooks - Zero-config…"). These must NOT drop the whole
 // line — only the matched fragment. Order matters: longer / more
 // specific variants first so the shorter ones don't partial-match.
+// Spinner glyphs the TUI cycles through. Kept in sync with
+// `PATTERNS.spinnerLeading` in `src/parsers/tui-frame.js`.
+const SPINNER_GLYPHS = '✻✶✺✹✸✷✵●✢✳✽·✾✿❀❁❂❃❄❅❆❇❈❉❊❋';
+
 export const TUI_CHROME_INLINE_PATTERNS = [
+  // Rate-limit meters painted to the right of a streamed reply:
+  // `Usage ██░░░░░░░░ 16% (resets in 3h 18m)`, `| Weekly ░░░ 3% (resets in 6d 1h)`.
+  // Anchored on the bar glyphs so ordinary prose with a percentage is safe.
+  new RegExp(
+    String.raw`\s*\|?\s*(?:Usage|Weekly)\s*[█░▒▓]+\s*\d+%\s*\(resets in [^)]*\)`,
+    'gi',
+  ),
+  // Bare context meter: `██████░░░░ 22% │`.
+  /\s*[█░▒▓]{2,}\s*\d+%\s*│?/g,
+  // The animated status cell the TUI paints to the LEFT of a reply,
+  // carrying token counters: `63✢      88  `. Two guards keep real prose
+  // safe: a digit must sit beside the glyph, and the cell must be
+  // separated from the content by the multi-space padding the TUI uses.
+  // That padding is what distinguishes the chrome `✳ 128  Here is …`
+  // from an ordinary bullet like `· 5 minutes later`.
+  new RegExp(String.raw`^\s*\d+\s*[${SPINNER_GLYPHS}]\s*\d*\s{2,}`, 'g'),
+  new RegExp(String.raw`^\s*[${SPINNER_GLYPHS}]\s*\d+\s{2,}`, 'g'),
   /\s*\d+\s+CLAUDE\.md\s*\|\s*\d+\s+rules?\s*\|\s*\d+\s+MCPs?\s*\|\s*\d+\s+hooks?/gi,
   /\s*\d+\s+rules?\s*\|\s*\d+\s+MCPs?\s*\|\s*\d+\s+hooks?/gi,
   /\s*\d+\s+MCP servers?\s+need(?:s)?\s+auth\s*·\s*\/mcp/gi,
@@ -1344,7 +1365,7 @@ export const TUI_CHROME_INLINE_PATTERNS = [
  * @param {string} text
  */
 export function cleanResponse(text) {
-  return String(text ?? '')
+  const cleaned = String(text ?? '')
     .replace(/\r/g, '\n')
     .split('\n')
     .map((l) => l.trimEnd())
@@ -1368,4 +1389,19 @@ export function cleanResponse(text) {
     .replace(/\n{3,}/g, '\n\n')
     .replace(SENTINEL_REGEX, '')
     .trim();
+
+  // The TUI paints bare token counters (`63`, `128`) around a streamed
+  // reply, and once the surrounding chrome is gone they are left stranded
+  // on their own lines. Drop them — but ONLY when other content survives,
+  // so a reply that is legitimately just a number ("what is 6*7" -> "42")
+  // is never swallowed.
+  const lines = cleaned.split('\n');
+  // A counter cell is a bare integer, optionally still carrying the
+  // spinner glyph it was painted next to.
+  const isBareCounter = (l) =>
+    new RegExp(String.raw`^\s*[${SPINNER_GLYPHS}]?\s*\d{1,6}\s*$`).test(l);
+  if (lines.some((l) => l.trim() !== '' && !isBareCounter(l))) {
+    return lines.filter((l) => !isBareCounter(l)).join('\n').trim();
+  }
+  return cleaned;
 }

package/src/index.js

@@ -143,6 +143,51 @@ export function sanitizePassThroughArgv(argv) {
  * `runOneShot()` spawns a fresh PTY session; pass `poolSize: N` to opt
  * into warm-session reuse.
  */
+// Environment variables that identify the *calling* Claude Code session —
+// its id, its IPC bridge, its resolved binary — rather than configuring
+// Claude generally. When `ocp` itself runs inside a Claude Code session
+// (an agent driving it, or a developer testing from one) the child
+// `claude` inherits all of them and concludes it is a continuation of the
+// parent rather than a new session. The visible consequence is that it
+// writes no session JSONL at all: `sessionId` comes back null, the clean
+// transcript ocp prefers is unavailable so answers fall back to
+// PTY-scraped text, and `--continue` / `--resume` have nothing to resume.
+//
+// The child is a new, independent session, so these must not carry over.
+// User-facing configuration (`CLAUDE_CODE_SIMPLE`, `CLAUDE_CODE_SAFE_MODE`,
+// provider toggles, …) is deliberately NOT in this list and passes through
+// untouched. Set OCP_KEEP_PARENT_SESSION_ENV=1 to disable the scrub.
+const PARENT_SESSION_ENV = [
+  'CLAUDE_CODE_SESSION_ID',
+  'CLAUDE_CODE_BRIDGE_SESSION_ID',
+  'CLAUDE_CODE_CHILD_SESSION',
+  'CLAUDE_CODE_ENTRYPOINT',
+  'CLAUDE_CODE_MESSAGING_SOCKET',
+  'CLAUDE_CODE_MESSAGING_TOKEN',
+  'CLAUDE_CODE_EXECPATH',
+];
+
+/**
+ * Remove the calling Claude Code session's identity from a spawn env.
+ *
+ * Returns a new object; the input is not mutated. An explicit value in
+ * `opts.env` wins — if a caller deliberately sets one of these, we honour
+ * it rather than second-guessing them.
+ *
+ * @param {Record<string, string|undefined>} env
+ * @param {Record<string, string|undefined>} [explicit]  caller-supplied overrides
+ * @returns {Record<string, string|undefined>}
+ */
+export function scrubParentSessionEnv(env, explicit = {}) {
+  if (process.env.OCP_KEEP_PARENT_SESSION_ENV === '1') return { ...env };
+  const out = { ...env };
+  for (const key of PARENT_SESSION_ENV) {
+    if (Object.prototype.hasOwnProperty.call(explicit, key)) continue;
+    delete out[key];
+  }
+  return out;
+}
+
 export function createDriver(driverOpts = {}) {
   return new Driver(driverOpts);
 }
@@ -252,7 +297,7 @@ class Driver {
       process.env.OCP_PRINT_MODE === 'true';
     if (printMode) {
       const cwd = req.cwd ?? this.opts.cwd;
-      const env = { ...process.env, ...this.opts.env };
+      const env = scrubParentSessionEnv({ ...process.env, ...this.opts.env }, this.opts.env);
       const r = await runPrintMode({
         bin: this.opts.claudeBin,
         req,
@@ -331,7 +376,7 @@ class Driver {
     // Pool eligibility: explicit resume/continue bind to a specific past
     // session and are not poolable (they bypass the pool entirely).
     const cwd = req.cwd ?? this.opts.cwd;
-    const env = { ...process.env, ...this.opts.env };
+    const env = scrubParentSessionEnv({ ...process.env, ...this.opts.env }, this.opts.env);
     const pool = this._getPool();
     const isResumeLike =
       (typeof req.resume === 'string' && req.resume !== '') ||

package/src/parsers/ansi-strip.js

@@ -1,8 +1,24 @@
 // Baseline parser: strip ANSI escape sequences.
 //
-// We do not attempt to reconstruct a terminal screen here. Cursor moves,
-// clears, and color codes are simply removed. The remaining text is what
-// downstream parsers consume.
+// We do not attempt to reconstruct a terminal screen here. Colors, clears
+// and vertical moves are simply removed. The one thing we DO model is the
+// cursor's horizontal position, because the upstream TUI uses horizontal
+// moves in place of literal spaces:
+//
+//   A\x1b[5Gpseudoterminal\x1b[20Gis\x1b[23Ga\x1b[25Gsoftware
+//
+// Every inter-word gap there is an absolute column move, not a space. Strip
+// the sequences blindly and the words run together — "Apseudoterminalisa…".
+// So we track the column and translate a forward move into the run of
+// spaces it would have left blank on screen.
+//
+// Two sequences produce those gaps:
+//   CUF — `ESC [ Pn C`  move right Pn columns (relative, default 1)
+//   CHA — `ESC [ Pn G`  move to column Pn    (absolute, 1-based, default 1)
+//
+// CUF alone used to be enough; the current CLI emits CHA for nearly every
+// word, which is what made this worth modelling properly rather than
+// special-casing one sequence.
 //
 // Buffering rule for partial chunks: if the chunk ends with an ESC that has
 // not yet been terminated (e.g. mid-CSI), hold it until the next chunk.
@@ -10,37 +26,9 @@
 const ESC = '\x1b';
 const BEL = '\x07';
 
-// Cursor Forward (CUF): `ESC [ Pn C` advances the cursor `Pn` columns
-// (default 1). In headless captures the upstream `claude` CLI uses this
-// in place of literal space characters for inter-word gaps (a TUI
-// rendering optimization). Stripping the sequence collapses words
-// together — `each<CUF1>other` becomes `eachother`. We translate CUF
-// into the equivalent run of spaces BEFORE the general CSI strip so the
-// visible text is preserved.
-const RE_CSI_CURSOR_FORWARD = /\x1b\[(\d*)C/g;
-function expandCursorForward(text) {
-  return text.replace(RE_CSI_CURSOR_FORWARD, (_match, n) => {
-    const count = parseInt(n || '1', 10);
-    return ' '.repeat(Math.min(count, 200)); // cap defensively
-  });
-}
-
-// Complete-sequence regexes — used only on input slices we have proven to be
-// complete (i.e. without a dangling partial at the end).
-const RE_CSI = /\x1b\[[0-?]*[ -/]*[@-~]/g;       // ESC [ params intermediates final
-// OSC-style sequences: ESC introducer then arbitrary content then BEL or ST.
-// Covers OSC (`]`), DCS (`P`), SOS (`X`), PM (`^`), APC (`_`).
-const RE_STRING_TERMINATED =
-  /\x1b[\]PX^_][^\x07\x1b]*(?:\x07|\x1b\\)/g;
-// Two-byte ESC forms — covers C1 7-bit aliases (`ESC @`..`ESC _` except the
-// CSI/OSC/etc. introducers, which are handled above) AND the DEC private
-// single-letter sequences in the 0x30..0x3F range (`ESC 7` = DECSC save
-// cursor, `ESC 8` = DECRC restore, `ESC =` / `ESC >` keypad modes, etc.).
-// Order is: CSI -> string-terminated -> this, so by the time we reach
-// RE_C1 the only `\x1b[`/`\x1b]`/`\x1b_`/... left in the input is either
-// complete-and-already-stripped or partial-and-held-back by the pending
-// buffer.
-const RE_C1  = /\x1b[0-?@-_]/g;
+// Defensive ceiling on generated padding. A corrupt or hostile column
+// target must not let one escape sequence expand into megabytes.
+const MAX_PAD = 200;
 
 /** Introducer characters for OSC-style sequences (BEL/ST terminated). */
 const STRING_INTRODUCERS = new Set([']', 'P', 'X', '^', '_']);
@@ -56,11 +44,136 @@ function isCompleteEscapeTail(tail) {
   return tail.length >= 2;
 }
 
+/** First numeric parameter of a CSI parameter string, or `fallback`. */
+function firstParam(params, fallback) {
+  const n = parseInt(params, 10);
+  return Number.isNaN(n) ? fallback : n;
+}
+
+/** Nth (0-based) numeric parameter of a CSI parameter string. */
+function nthParam(params, index, fallback) {
+  const raw = params.split(';')[index];
+  if (raw === undefined || raw === '') return fallback;
+  const n = parseInt(raw, 10);
+  return Number.isNaN(n) ? fallback : n;
+}
+
+/**
+ * Strip escapes from `input` while tracking the cursor column, expanding
+ * forward horizontal moves into spaces.
+ *
+ * `state.col` is the 0-based column and persists across chunks, since a
+ * rendered line routinely spans several PTY reads.
+ *
+ * @param {string} input
+ * @param {{col: number}} state
+ * @returns {string}
+ */
+function stripTrackingColumn(input, state) {
+  let out = '';
+  let i = 0;
+  const len = input.length;
+
+  while (i < len) {
+    const ch = input[i];
+
+    if (ch === '\r' || ch === '\n') {
+      out += ch;
+      state.col = 0;
+      i += 1;
+      continue;
+    }
+
+    if (ch !== ESC) {
+      out += ch;
+      state.col += 1;
+      i += 1;
+      continue;
+    }
+
+    const c1 = input[i + 1];
+
+    // ── CSI: ESC [ params intermediates final ────────────────────────────
+    if (c1 === '[') {
+      let j = i + 2;
+      while (j < len) {
+        const c = input.charCodeAt(j);
+        if (c >= 0x30 && c <= 0x3f) j += 1; // parameter bytes
+        else break;
+      }
+      const paramsEnd = j;
+      while (j < len) {
+        const c = input.charCodeAt(j);
+        if (c >= 0x20 && c <= 0x2f) j += 1; // intermediate bytes
+        else break;
+      }
+      if (j >= len) {
+        // Incomplete despite the pending-buffer guard; drop the remainder.
+        break;
+      }
+      const final = input[j];
+      const params = input.slice(i + 2, paramsEnd);
+      i = j + 1;
+
+      // Private-parameter sequences (`ESC [ ? 25 h`) never move the cursor
+      // horizontally in a way we can model; strip them.
+      if (params.charCodeAt(0) >= 0x3c && params.charCodeAt(0) <= 0x3f) continue;
+
+      if (final === 'C') {
+        // CUF — relative forward move.
+        const n = Math.max(0, firstParam(params, 1));
+        const pad = Math.min(n, MAX_PAD);
+        out += ' '.repeat(pad);
+        state.col += pad;
+      } else if (final === 'G' || final === '`') {
+        // CHA / HPA — absolute column, 1-based.
+        const target = Math.max(1, firstParam(params, 1)) - 1;
+        if (target > state.col) {
+          const pad = Math.min(target - state.col, MAX_PAD);
+          out += ' '.repeat(pad);
+          state.col += pad;
+        }
+        // A backwards move would overwrite already-emitted text. We cannot
+        // represent that without a screen model, so we neither pad nor
+        // rewind — the text simply continues.
+      } else if (final === 'H' || final === 'f') {
+        // CUP — absolute row;col. This is a jump to another part of the
+        // screen (status line, input box), so it never means "gap here";
+        // adopt the column but emit no padding.
+        state.col = Math.max(1, nthParam(params, 1, 1)) - 1;
+      }
+      // Everything else (SGR, erase, vertical moves, scroll regions) is
+      // zero-width for our purposes: stripped, column untouched.
+      continue;
+    }
+
+    // ── OSC and friends: ESC ] … BEL | ST ────────────────────────────────
+    if (STRING_INTRODUCERS.has(c1)) {
+      let j = i + 2;
+      while (j < len) {
+        if (input[j] === BEL) { j += 1; break; }
+        if (input[j] === ESC && input[j + 1] === '\\') { j += 2; break; }
+        j += 1;
+      }
+      i = j;
+      continue;
+    }
+
+    // ── Two-byte ESC forms (ESC 7, ESC 8, ESC =, C1 aliases) ─────────────
+    if (c1 === undefined) break; // dangling ESC; pending guard should catch it
+    i += 2;
+  }
+
+  return out;
+}
+
 export const ansiStripParser = {
   name: 'ansi-strip',
   priority: 10,
   create() {
     let pending = '';
+    // Cursor column persists across feeds — a line spans many PTY reads.
+    const state = { col: 0 };
     return {
       feed(chunk) {
         let input = pending + chunk;
@@ -77,17 +190,11 @@ export const ansiStripParser = {
           }
         }
 
-        // Translate visible-gap CSI sequences (cursor forward) into
-        // literal spaces BEFORE the general CSI strip eats them.
-        const expanded = expandCursorForward(input);
-        const out = expanded
-          .replace(RE_CSI, '')
-          .replace(RE_STRING_TERMINATED, '')
-          .replace(RE_C1, '');
-        return { text: out, events: [] };
+        return { text: stripTrackingColumn(input, state), events: [] };
       },
       reset() {
         pending = '';
+        state.col = 0;
       },
     };
   },