Claude Code Sources: CLI Architecture

Anatomy of Claude Code: What the Leaked Source Code Reveals

On March 31, 2026, the source code for Claude Code leaked via a sourcemap in an npm package. This isn't a clean git checkout, but a recovered snapshot of client-side code with transformations and missing files like assistant/index.ts or daemon/main.js. screens/REPL.tsx is already compiled with React Compiler, and main.tsx retains traces of launch optimizations: profileCheckpoint, keychain prefetching, parallel MDM-read.

The code reflects an evolution from a simple CLI to a terminal operating system. Imports are dynamic for lazy loading; --version runs without dependencies. But complexity is growing: daemon, remote-control, tmux, MCP servers.

CLI as the Facade of a Multi-Mode Runtime

entrypoints/cli.tsx is the routing hub: --version, system prompt, daemon, environment-runner, self-hosted-runner, ps/logs/attach/kill. Dynamic imports minimize evaluation: workers are lean. Fast paths don't pull heavy modules, reducing memory and crash risks.

Plus: startup optimization. Minus: knowing all modes makes the CLI feel like an airport. Lazy loading saves the day, but the structure is intimidating.

// Example from cli.tsx
if (fastPath) {
  // zero imports beyond this file
  console.log(version);
  process.exit(0);
}

main.tsx: The System's Center of Gravity

main.tsx is the convergence point: initialization, mode selection, tool pool, feature flags, KAIROS/Proactive, structured output, session recovery. Plus: all branching logic in one place. Minus: compromises like proactive mode before getTools() for SleepTool.isEnabled().

Evolution is visible: from CLI to a system with flags and checks. Scale breeds such constructs.

• Initialization and mode selection
• System prompt and tool pool
• Feature flags and remote sessions
• UI launch and sessions

React in the Terminal: Ink and the Frontend Combine

Claude Code is a React application on Ink. screens/REPL.tsx manages notifications, modals, IDE integration, MCP, plugins, teammate mode, floating UI, Buddy.

Synchronizes state, filters tools, mixes in plugins. Not a chat, but a frontend in the terminal with browser-like habits.

Orchestrating Agents as Infrastructure

Not a single agent, but a control center. AgentTool supports:

• Synchronous/asynchronous launch
• Background and worktree isolation
• Remote and teammate modes
• Its own tool pool and permission mode
• Cache identity for prompt/tools

Async agents with progress, notifications. Worktree as part of the route. Mature agent capabilities beyond Promise.all.

Explore agent is limited: read-only, no write/delete/redirect/heredoc, focused on parallel grep/read. A balance of autonomy and restraint.

Tool Execution: Concurrency and Fault Tolerance

Tools are grouped: read-only in parallel, risky ones—serially. A streaming executor with:

• Cancellation of siblings on error
• user_interrupted vs sibling_error vs streaming_fallback
• Buffering for order
• Interrupt handling

The product survives hangs and conflicts.

Bash Without Self-Destruction: Security Paranoia

bashPermissions and bashSecurity block:

• Command/process substitution
• Heredoc/zsh equals
• zmodload/ztcp/zpty
• Obfuscated flags
• env/sudo/nice/timeout
• Whitespace/escaping

A mature layer against real shell bites from LLMs.

The Human Touch: Buddy and Animations

buddy/ — ASCII sprites, speech bubbles, animations. A terminal companion adds life to the CLI.

Key Takeaways:

• Dynamic imports for fast mode startup
• main.tsx as the orchestration hub with scale compromises
• Agent infrastructure with isolation and lifecycle
• Parallel/serial tool calls with error-handling
• Bash-security against shell attacks
• React/Ink for terminal UI with Buddy

— Editorial Team