/tree crashes with RangeError: Maximum call stack size exceeded on sessions deeper than ~2k entries

[chwzw]

Summary

Running /tree on a session with a long history crashes the CLI. The tree never opens: the TUI prints an unhandled promise rejection (RangeError: Maximum call stack size exceeded) and the process exits back to the shell. Long-running sessions therefore cannot use /tree at all — the longer the session, the more certain the crash.

Expected Behavior

/tree opens the session-tree navigator for any session, regardless of how many entries it has.

Actual Behavior

The navigator never renders; the CLI prints the standard crash block and exits:

✖ CRITICAL: Unhandled Promise Rejection!
This is an unexpected error. Please file a bug report at https://github.com/CommandCodeAI/command-code/issues/new
✖ ERROR → RangeError
ℹ REASON → Maximum call stack size exceeded
ℹ ERROR STACK ↓
 RangeError: Maximum call stack size exceeded
    at buildNode (file:///…/command-code/dist/cli.mjs:2:537086)
    at Array.map (<anonymous>)
    at buildNode (file:///…/command-code/dist/cli.mjs:2:537120)
    at Array.map (<anonymous>)
    at buildNode (file:///…/command-code/dist/cli.mjs:2:537120)
    ...

Steps to reproduce the issue

1. Use a session whose tree is deeper than roughly 2–3k entries — a long linear conversation (depth == number of entries) is enough; heavy rewinding/forking also builds depth.
2. Run /tree.
3. The CLI crashes instead of opening the navigator.

Observed with a 12 MB transcript: 4,275 entries, tree depth 4,266, 3 roots, no cycles and nothing corrupt. For contrast, an empty session correctly shows "No session entries yet." without crashing, and a 700-entry session (depth 687) opens fine.

Isolated measurements of the shipped buildNode on synthetic linear chains: depth 2,000 → OK, depth 3,000 → RangeError.

Command Code Version

1.54.1 (latest on npm at the time of writing, so there is no newer release to upgrade to)

Operating System

Linux

Terminal/IDE

tmux 3.x

Shell

fish

Session file (optional)

Not attached — the repro transcript is 12 MB. Happy to share it privately, or run anything you'd like against it.

Fix prompt (optional)

The session-tree walkers recurse once per tree level, so stack depth is proportional to session depth. Convert them to explicit-stack iteration:

• SessionStoreV3.getTree() → buildNode (cli.mjs ≈ 2:537086): const r=(e.get(n.id)??[]).slice().sort(t).map(buildNode)
• the tree navigator's entryById visitor and buildToolCallMap's inner visit
• buildVisibleNodes, containsId, reorderActiveFirst, flattenVisibleTree's inner visit

These are all pure traversals with no depth-dependent behavior, so the output should be identical.

Additional context

I patched all seven walkers locally to explicit-stack iteration and verified:

• the walkers return byte-identical output (JSON, key order included) versus the recursive originals across linear / branchy / wide (13.5k nodes) / deep trees;
• rendering a 700-entry and a 338-entry session via cmd --session <copy>, captured with tmux, is pixel-identical before and after the change;
• /tree now opens and navigates the 4,266-deep session (filters, fold/unfold, Esc all work), plus a synthetic 30k-deep one, with no crash.

That patch is a local edit to the minified dist/cli.mjs (it is overwritten on upgrade), so it is not a fix to ship — but the approach may save someone time. I can send the patch script if useful.

Note: the investigation, reproduction and patch above were produced by an AI coding agent (Command Code itself) working against the shipped bundle.

[chwzw]

Fixing this locally turned out to be straightforward, so here is the patch script in case it saves whoever picks this up some time. It rewrites all seven walkers as explicit-stack iteration and leaves the traversal semantics untouched.

tree-recursion-patch.js — node tree-recursion-patch.js [/path/to/dist/cli.mjs], backs up cli.mjs first

#!/usr/bin/env node
/*
 * Fix: "/tree crashes with RangeError: Maximum call stack size exceeded"
 *      (Command Code CLI 1.54.1, upstream issue #865)
 *
 * The session-tree walkers recurse once per tree level, so stack depth grows with
 * session depth (a linear conversation's depth == its number of entries). Past
 * roughly 2-3k entries /tree dies with an unhandled promise rejection and the CLI
 * exits. This script rewrites the seven walkers on the /tree path as explicit-stack
 * iteration. Traversal semantics are unchanged.
 *
 * Usage:
 *   node tree-recursion-patch.js                 # auto-locate the installed bundle
 *   node tree-recursion-patch.js /path/to/cli.mjs
 *
 * Notes:
 *   - Idempotent: safe to re-run; it detects an already-patched build.
 *   - Writes a backup next to the file: cli.mjs.orig-<version>
 *   - A package upgrade replaces dist/cli.mjs, so re-run this after upgrading.
 */

const fs = require('fs');
const path = require('path');
const { execSync } = require('child_process');

// ---------------------------------------------------------------- locate ---
function resolveTarget() {
  if (process.argv[2]) return process.argv[2];
  const candidates = [];
  try {
    candidates.push(path.join(execSync('npm root -g', { encoding: 'utf8' }).trim(), 'command-code', 'dist', 'cli.mjs'));
  } catch {}
  candidates.push(
    '/usr/local/lib/node_modules/command-code/dist/cli.mjs',
    '/usr/lib/node_modules/command-code/dist/cli.mjs',
    path.join(process.env.HOME || '', '.local/share/node24/lib/node_modules/command-code/dist/cli.mjs')
  );
  for (const c of candidates) if (fs.existsSync(c)) return c;
  throw new Error('could not locate command-code/dist/cli.mjs — pass the path as an argument');
}

const FILE = resolveTarget();
let out = fs.readFileSync(FILE, 'utf8');
const src = out;

if (out.includes('__bnStack')) {
  console.log(`${FILE}\n  already patched — nothing to do.`);
  process.exit(0);
}
if (!out.includes('function buildNode(n){')) {
  console.log(`${FILE}\n  this build does not match the anchors this patch knows (upstream may have fixed or refactored it) — aborting.`);
  process.exit(1);
}

// --------------------------------------------------------------- helpers ---
function scanBlock(text, open) {
  let depth = 0, i = open, str = null;
  while (i < text.length) {
    const c = text[i];
    if (str) {
      if (c === '\\') { i += 2; continue; }
      if (c === str) str = null;
      i++; continue;
    }
    if (c === '"' || c === "'" || c === '`') { str = c; i++; continue; }
    if (c === '/' && text[i + 1] === '/') { while (i < text.length && text[i] !== '\n') i++; continue; }
    if (c === '/' && text[i + 1] === '*') { i = text.indexOf('*/', i) + 2; continue; }
    if (c === '{') depth++;
    else if (c === '}') { depth--; if (depth === 0) return i + 1; }
    i++;
  }
  throw new Error('unbalanced braces');
}
function replaceFunction(anchor, replacement) {
  const first = out.indexOf(anchor);
  if (first < 0) throw new Error('anchor not found: ' + anchor);
  if (out.indexOf(anchor, first + 1) >= 0) throw new Error('anchor not unique: ' + anchor);
  const end = scanBlock(out, out.indexOf('{', first));
  out = out.slice(0, first) + replacement + out.slice(end);
}
function replaceExact(original, replacement) {
  const first = out.indexOf(original);
  if (first < 0) throw new Error('snippet not found: ' + original.slice(0, 60));
  if (out.indexOf(original, first + 1) >= 0) throw new Error('snippet not unique: ' + original.slice(0, 60));
  out = out.slice(0, first) + replacement + out.slice(first + original.length);
}

// 1. SessionStoreV3.getTree -> buildNode -----------------------------------
replaceFunction(
  'function buildNode(n){',
  'function buildNode(n){' +
  'const __bnRoot={entry:n,children:[]},__bnStack=[[n,__bnRoot]];' +
  'while(__bnStack.length){' +
    'const __bnPair=__bnStack.pop(),__bnEntry=__bnPair[0],__bnNode=__bnPair[1],' +
    '__bnKids=(e.get(__bnEntry.id)??[]).slice().sort(t);' +
    'for(const __bnChild of __bnKids){' +
      'const __bnLabel=u.get(__bnChild.id),__bnTs=m.get(__bnChild.id),' +
      '__bnObj={entry:__bnChild,children:[],' +
      '...void 0!==__bnLabel?{label:__bnLabel}:{},' +
      '...void 0!==__bnTs?{labelTimestamp:__bnTs}:{}};' +
      '__bnNode.children.push(__bnObj),__bnStack.push([__bnChild,__bnObj])' +
    '}' +
  '}' +
  'const __bnL=u.get(n.id),__bnT=m.get(n.id);' +
  'return{...__bnRoot,...void 0!==__bnL?{label:__bnL}:{},...void 0!==__bnT?{labelTimestamp:__bnT}:{}}}'
);

// 2. buildToolCallMap -------------------------------------------------------
replaceFunction(
  'function buildToolCallMap(e){',
  'function buildToolCallMap(e){' +
  'const t=new Map,n=__name(e=>{' +
    'const __btStack=[e];' +
    'while(__btStack.length){' +
      'const __btList=__btStack.pop();' +
      'for(const __btRow of __btList){' +
        'const{entry:__btEntry}=__btRow;' +
        'if("message"===__btEntry.type&&"assistant"===__btEntry.message.role)' +
        'for(const __btPart of __btEntry.message.content)' +
        '"tool_use"===__btPart.type&&t.set(__btPart.id,{name:__btPart.name,input:__btPart.input});' +
        '__btStack.push(__btRow.children)' +
      '}' +
    '}' +
  '},"visit");return n(e),t}'
);

// 3. buildVisibleNodes ------------------------------------------------------
replaceFunction(
  'function buildVisibleNodes(e){',
  'function buildVisibleNodes(e){' +
  'const{nodes:t,mode:n,currentLeafId:r}=e,o=[],__bvStack=[{list:t,i:0,target:o}];' +
  'while(__bvStack.length){' +
    'const __bvFrame=__bvStack[__bvStack.length-1];' +
    'if(__bvFrame.i>=__bvFrame.list.length){__bvStack.pop();continue}' +
    'const __bvNode=__bvFrame.list[__bvFrame.i++],__bvKids=[];' +
    'passesFilter({entry:__bvNode.entry,mode:n,isCurrentLeaf:__bvNode.entry.id===r,hasLabel:void 0!==__bvNode.label})' +
    '?(__bvFrame.target.push({entry:__bvNode.entry,children:__bvKids,' +
      '...void 0!==__bvNode.label?{label:__bvNode.label}:{},' +
      '...void 0!==__bvNode.labelTimestamp?{labelTimestamp:__bvNode.labelTimestamp}:{}}),' +
      '__bvStack.push({list:__bvNode.children,i:0,target:__bvKids}))' +
    ':__bvStack.push({list:__bvNode.children,i:0,target:__bvFrame.target})' +
  '}' +
  'return o}'
);

// 4. containsId -------------------------------------------------------------
replaceFunction(
  'function containsId(e,t){',
  'function containsId(e,t){' +
  'const __ciStack=[e];' +
  'while(__ciStack.length){' +
    'const __ciNode=__ciStack.pop();' +
    'if(__ciNode.entry.id===t)return!0;' +
    'for(const __ciChild of __ciNode.children)__ciStack.push(__ciChild)' +
  '}' +
  'return!1}'
);

// 5. reorderActiveFirst -----------------------------------------------------
replaceFunction(
  'function reorderActiveFirst(e,t){',
  'function reorderActiveFirst(e,t){' +
  'const __roStack=[e];' +
  'while(__roStack.length){' +
    'const __roArr=__roStack.pop();' +
    'for(const __roNode of __roArr)__roStack.push(__roNode.children);' +
    'if(null!==t){' +
      'const __roIdx=__roArr.findIndex(e=>containsId(e,t));' +
      'if(__roIdx>0){' +
        'const __roKeep=__roArr[__roIdx],__roRest=[];' +
        'for(let __roI=0;__roI<__roArr.length;__roI++)__roI!==__roIdx&&__roRest.push(__roArr[__roI]);' +
        '__roArr.length=0,__roArr.push(__roKeep);' +
        'for(const __roX of __roRest)__roArr.push(__roX)' +
      '}' +
    '}' +
  '}' +
  'return e}'
);

// 6. flattenVisibleTree (inner visit) --------------------------------------
replaceFunction(
  'function flattenVisibleTree(e){',
  'function flattenVisibleTree(e){' +
  'const{roots:t,activePathIds:n,foldedNodes:r}=e,o=[],s=new Map,i=t.length>1,__fvStack=[];' +
  'for(let __fvI=t.length-1;__fvI>=0;__fvI--)' +
    '__fvStack.push({node:t[__fvI],parentId:null,indent:i?1:0,justBranched:i,showConnector:i,isLast:__fvI===t.length-1,gutters:[],isVirtualRootChild:i});' +
  'while(__fvStack.length){' +
    'const __fvFrame=__fvStack.pop(),__fvNode=__fvFrame.node,__fvParent=__fvFrame.parentId,' +
    '__fvIndent=__fvFrame.indent,__fvJustBranched=__fvFrame.justBranched,__fvIsLast=__fvFrame.isLast,' +
    '__fvGutters=__fvFrame.gutters,__fvChildIds=__fvNode.children.map(e=>e.entry.id);' +
    's.set(__fvNode.entry.id,__fvChildIds);' +
    'const __fvFolded=r.has(__fvNode.entry.id),__fvFoldable=__fvNode.children.length>0,' +
    '__fvConnector=__fvFrame.showConnector&&!__fvFrame.isVirtualRootChild,' +
    '__fvDisplayIndent=i?Math.max(0,__fvIndent-1):__fvIndent;' +
    'if(o.push({id:__fvNode.entry.id,entry:__fvNode.entry,parentId:__fvParent,' +
      'prefix:buildRowPrefix({displayIndent:__fvDisplayIndent,gutters:__fvGutters,connectorVisible:__fvConnector,isLast:__fvIsLast,folded:__fvFolded,foldable:__fvFoldable}),' +
      'isActivePath:n.has(__fvNode.entry.id),isBranchChild:__fvFrame.showConnector,hasVisibleChildren:__fvFoldable,' +
      '...void 0!==__fvNode.label?{label:__fvNode.label}:{},' +
      '...void 0!==__fvNode.labelTimestamp?{labelTimestamp:__fvNode.labelTimestamp}:{}}),__fvFolded)continue;' +
    'const __fvBranch=__fvNode.children.length>1,' +
    '__fvChildIndent=__fvBranch||__fvJustBranched&&__fvIndent>0?__fvIndent+1:__fvIndent,' +
    '__fvChildGutters=__fvConnector?[...__fvGutters,{position:Math.max(0,__fvDisplayIndent-1),show:!__fvIsLast}]:__fvGutters;' +
    'for(let __fvJ=__fvNode.children.length-1;__fvJ>=0;__fvJ--)' +
      '__fvStack.push({node:__fvNode.children[__fvJ],parentId:__fvNode.entry.id,indent:__fvChildIndent,justBranched:__fvBranch,showConnector:__fvBranch,isLast:__fvJ===__fvNode.children.length-1,gutters:__fvChildGutters,isVirtualRootChild:!1})' +
  '}' +
  'return{rows:o,visibleChildrenIds:s}}'
);

// 7. tree component entryById map ------------------------------------------
replaceExact(
  'const t=new Map,n=__name(e=>{for(const r of e)t.set(r.entry.id,r.entry),n(r.children)},"visit");return n(e),t',
  'const t=new Map,n=__name(e=>{const __ebStack=[e];while(__ebStack.length){const __ebList=__ebStack.pop();for(const __ebNode of __ebList)t.set(__ebNode.entry.id,__ebNode.entry),__ebStack.push(__ebNode.children)}},"visit");return n(e),t'
);

// ----------------------------------------------------------------- write ---
let version = 'unknown';
try {
  version = JSON.parse(fs.readFileSync(path.join(path.dirname(FILE), '..', 'package.json'), 'utf8')).version;
} catch {}
const backup = `${FILE}.orig-${version}`;
if (!fs.existsSync(backup)) fs.copyFileSync(FILE, backup);
fs.writeFileSync(FILE, out);
console.log(`patched ${FILE}`);
console.log(`  backup: ${backup}`);
console.log('  restart the CLI for the fix to take effect.');

How I verified the rewrite, since "identical output" is the whole point:

• all seven walkers produce byte-identical results (JSON, key order included) versus the recursive originals on linear / branchy / wide (13.5k nodes) / deep trees;
• rendering a 700-entry and a 338-entry session with cmd --session <copy> is pixel-identical before and after, captured with tmux and diffed;
• /tree opens and navigates the 4,266-deep session (filters, fold/unfold, Esc all work) and a synthetic 30k-deep one.

The bundle keeps function names, so the anchors the script matches on are stable for 1.54.1; it refuses to run rather than guess if a future build no longer matches.