Claude Code History Viewer: one desktop app for 29 AI coding assistants' logs

The gap CCHV fills: your agents write history, none of them let you read it back

Every AI coding assistant keeps a local record of what you asked and what it changed. Claude Code writes under ~/.claude/projects/, Codex CLI under ~/.codex/sessions/, Gemini CLI under ~/.gemini/history/. None of those tools ship a general-purpose browser for that data. The README's framing is blunt: assistants "generate thousands of conversation messages, but none of them provide a way to look back at your history across tools."

That second word matters more than the first. Reading one provider's logs is a solved problem if you are willing to open JSONL in an editor. Reading Claude Code and Codex CLI side by side, comparing token spend, and searching for the one session where you fixed a migration is not. CCHV targets developers who run several agents on the same machine and want a single index over all of them, offline. The audience is individual engineers and small teams, not platform teams building a company-wide audit system; there is no multi-user account model in the README.

How CCHV reads 29 providers without a database of its own

The architecture is a Tauri app: a React and TypeScript frontend in src/ against a Rust backend in src-tauri/. The Rust side owns filesystem access and parsing; the frontend owns rendering, with @tanstack/react-virtual for long transcripts and flexsearch for in-memory search. Nothing is copied into a central store. The app opens the provider's own files where they already sit.

That design explains the provider table in the README. Each row is a data location plus a parser: Claude Code at ~/.claude/projects/, Cursor at ~/.cursor/, Aider in project directories, ForgeCode in ~/.forge/.forge.db, Kiro and Amazon Q CLI in SQLite files, Continue.dev in ~/.continue/sessions/*.json. Some parsers are shared rather than duplicated: Open Interpreter reuses the Codex rollout parser, oh-my-pi reuses the Pi parser, and PearAI is a Continue fork with the same session format. Amazon Q CLI and Kiro CLI are noted as sharing a format too.

The consequence is that CCHV's coverage is only as current as its parsers. When a provider changes its on-disk schema, the viewer breaks until the parser is updated. That is a real maintenance surface for a project tracking 29 tools, and the release cadence (v1.26.2 and v1.26.3 on 2026-08-29, v1.27.0 on 2026-09-01) suggests the author is chasing those changes rather than sitting still. The last push to main was on 2026-09-04.

Installing Claude Code History Viewer and opening your first session

The README gives two paths. The desktop app is a download: a universal .dmg for macOS, an .exe or portable .zip for Windows x64, and an .AppImage for Linux x64, all from the releases page. macOS users can take the Homebrew cask instead.

brew install --cask jhlee0409/tap/claude-code-history-viewer

After that, launch the app. It reads local conversation files directly, so there is no import step and no account. If your Claude Code sessions exist, they should appear in the conversation list without further configuration.

The second path is the headless server, which serves the same interface to a browser. Install it with Homebrew or the install script, then start it:

brew install jhlee0409/tap/cchv-server
cchv-server --serve

The README states this listens on http://localhost:3727. The install script alternative is curl -fsSL https://raw.githubusercontent.com/jhlee0409/claude-code-history-viewer/main/install-server.sh | sh.

For a container, the repository ships a docker-compose.yml that mounts three host directories read-only and publishes the port on loopback:

services:
  webui:
    build: .
    ports:
      - "127.0.0.1:3727:3727"
    volumes:
      - ${HOME}/.claude:/home/cchv/.claude:ro
      - ${HOME}/.codex:/home/cchv/.codex:ro
      - ${HOME}/.local/share/opencode:/home/cchv/.local/share/opencode:ro

Note the :ro suffixes and the 127.0.0.1 binding. The compose file also sets no-new-privileges, a 512M memory limit and a healthcheck against /health. The README's guidance for server mode is to keep authentication enabled, which is the right default given that the server exposes your prompt history.

Where CCHV stops: read-only providers, remote machines, and schema drift

The README labels the GitHub Copilot source "read-only, WSL-aware". That is a deliberate boundary, not an oversight, and it tells you what kind of tool this is. CCHV displays history; it does not resume, edit, delete or replay sessions. If you want to continue a Claude Code conversation, you use Claude Code.

A second limit is locality. Both modes read files on the machine where the binary runs. The compose file shows how to mount a few directories into a container, but that only works for paths you can mount. If your sessions live on a remote dev server, the desktop app will not see them; you would run cchv-server there and reach it over the network, which trades a local-only tool for a network-exposed one holding your prompts. The README's advice to keep authentication enabled is doing real work in that scenario.

Third, the parser-per-provider model means a provider update can silently produce empty or partial sessions. The README does not document a fallback or a schema-version check, so the practical symptom is a provider that used to list conversations and now lists none. Treat a new provider release as a reason to re-check the viewer.

Finally, the repository's own package.json still reads version 1.26.3 while the latest release is v1.27.0. The justfile has a sync-version target that copies the version from package.json into Cargo.toml, so this is a known step in the release process rather than a mystery. It is worth knowing before you file a bug about a version mismatch.

CCHV versus just grepping ~/.claude/projects

The obvious alternative is the filesystem itself. Claude Code stores sessions as files under ~/.claude/projects/, and jq or ripgrep will find a string across them in seconds. That approach has no install, no dependency on a third-party parser, and no risk that a schema change breaks it, because you are reading the raw format.

What it does not give you is a cross-provider view. Searching Claude Code and Codex CLI at once means writing two queries against two formats, one of them SQLite. It also gives you no token accounting, no rendered diffs, and no virtualized transcript view for sessions with thousands of messages. CCHV bundles those into one binary and one UI. The trade is that you inherit its parser coverage: the moment CCHV does not understand a format, you are back to reading raw files anyway. For a single provider and occasional lookups, grep is the better tool. For someone running five agents and wanting a monthly token picture, the app earns its install.

Maintenance, licensing, and what an MIT-licensed Tauri app costs you

The licence is MIT, which permits commercial use, modification and redistribution with the copyright notice retained. That is the permissive end of the spectrum, and it matters here because the app reads your entire prompt history; you can read the source and, if you want, build it yourself. The Dockerfile is a three-stage build that compiles the frontend with pnpm, builds the Rust binary with the webui-server feature, and copies the result into a debian:bookworm-slim runtime. The Dockerfile comments note that the binary links against webkit2gtk and gtk3 even in --serve mode because of Tauri's compile-time dependencies, which is why the runtime image is not a scratch image.

Upgrade cost depends on how you installed it. Homebrew casks and the cchv-server formula move with brew upgrade. The AppImage and .zip are manual replacements. The desktop app includes @tauri-apps/plugin-updater, so in-app updates exist as a mechanism, though the README does not spell out the update channel. For the server, you are responsible for restarting the process and for deciding whether the container image is rebuilt from source or pulled.

None of this is legal advice, but the practical licence question for a team is not the MIT terms; it is whether pointing a tool at ~/.claude and ~/.codex is acceptable under your employer's policy on local tooling that reads source-adjacent data. CCHV stays offline, which removes the exfiltration concern, but the files it reads contain your prompts and diffs.

Editorial conclusion

Adopt it if you already have months of Claude Code, Codex CLI or Gemini CLI sessions on one machine and want to search and compare them without uploading anything. Skip it if you need to write back to sessions, if your history lives only on a remote dev box, or if you expect it to index a provider whose format the README lists as read-only and you need edits. Verify first that your provider's data directory matches the table in the README, then run the server mode with authentication left on before exposing port 3727 beyond localhost.

Frequently asked questions

Official sources

1. jhlee0409/claude-code-history-viewer on GitHub
2. License: MIT
3. Project website
4. README
5. Releases