VaultOne

VaultOne doesn't store your AI data. It helps you understand and manage data you already own.

A local-first desktop dashboard for your AI CLI token usage and cost — read straight from the session logs your tools already write (Claude Code, Codex, Gemini CLI, OpenCode), with optional multi-device sync through a GitHub repo you control.

English | 简体中文 | 日本語 | Changelog

---

Why VaultOne?

Every time an AI CLI runs, it writes session logs to disk. VaultOne turns those logs into a clear usage picture — tokens, cost, cache efficiency, trends — without a proxy, an API key, or sending anything anywhere.

Two stances shape the whole product:

• Local-first. The dashboard works with zero network — reading your own logs is all it needs.
• Read-only. VaultOne only ever reads the session logs; it never modifies them and never touches the tools' behavior. They keep running exactly as before.

Multi-device sync is a purely opt-in layer on top — never a precondition.

Highlights

• Reads logs from four AI CLIs — Claude Code, Codex, Gemini CLI, and OpenCode, each parsed straight off disk in its native format. No proxy, no API key, no network.
• Token economics that match your bill — four-bucket consumption (input / output / cache creation / cache read), cache-hit rate, and cost frozen at collection time. Source quirks (e.g. Codex's cache-inclusive input) are normalized away into one consistent model.
• Multi-device sync through your own GitHub repo — plain-text artifacts partitioned by device and date, in a repo you own. No third party in the middle. Then scope any view to a single device.
• Per-device file relay (Library) — drag files or directories into the app to relay them through your sync repo (each device writes its own subtree, zero conflict); preview in-app and export to a path you choose. Upload is the only automatic direction — nothing ever writes into an AI tool's own config dir.
• Lightweight glance mode — tuck a mini-bar to the screen edge that always shows today's total, or expand into a floating card mirroring the dashboard. Switch full ⇄ expanded ⇄ tucked from any shape; each shape remembers its own placement.
• Multi-skin theming — five accent + chart palettes (Neutral, Sage, Azure, Crimson, Mauve); recolor the whole app without touching content.
• Tray-resident background collection — an incremental scanner keeps the dashboard fresh behind the scenes.
• Auto-update & three languages — install signed updates straight from GitHub Releases; UI in English, 简体中文, or 日本語.

Screenshots

	Light	Dark
Dashboard
Consumption
Glance mode

Download

Grab the installer for your OS from the Releases page.

OS	Installer
Windows	.msi or .exe (NSIS) setup
macOS	.dmg (Apple Silicon, arm64)
Linux	.deb, .AppImage (.rpm where available)

First run: launch VaultOne — it scans your local AI CLI session logs and the dashboard fills in. No account, no sign-in, no network. To see usage across machines, enable sync in Settings and point VaultOne at a GitHub repo you control.

macOS note: builds are currently unsigned. On first launch, right-click the app → Open, or strip the quarantine attribute:

xattr -dr com.apple.quarantine /Applications/VaultOne.app

Features

Dashboard

• Four-bucket token consumption — input, output, cache creation, cache read.
• Cache-hit rate — cache_read / (input + cache_creation + cache_read), aligned with how upstream usage is counted.
• Requests & cost — total request count and total cost (USD), frozen at collection time.
• Usage trends — multi-line token-vs-cost chart over time, one series per metric.
• Per-call request log — source, model, token breakdown, cost, turn duration, and stop_reason / service_tier chips.
• Per-turn view — whole-turn cost and wall-clock duration, separate from single-call timing.

Collection

• Read-only source — parses the session logs the CLIs already write; never modifies them.
• Incremental scan — a cursor-based scanner picks up only what changed.
• Tray-resident scheduler — collects on a timer without keeping a window open.
• Pluggable providers — Claude Code, Codex, Gemini CLI, and OpenCode today. Each is parsed from its native log format (JSONL, JSON, or SQLite) with token semantics normalized to one four-bucket model.

Sync (optional)

• Standalone mode — full dashboard, zero network.
• Synced mode — align usage across devices through a GitHub repo you own.
• Device-scoped — filter the dashboard, the glance card, and the tucked bar to a single device; forget a peer locally, and stale peers auto-clear.
• System-proxy aware — push/fetch follows the OS proxy (Clash/Mihomo, corporate gateways), so Synced mode just works behind one.
• Plain-text artifacts — partitioned by device and date (data/<device>/usage-YYYY-MM-DD.jsonl), so diffs stay readable and reviewable.
• Conflict-free auto-recovery — each device writes its own data/<device>/ subtree, so concurrent pushes never collide; if a device loses a push race, the next sync rebases its local commits on top and self-heals. Every collected row also reaches the sync artifact — a row that ever missed it is backfilled on the next collect — so the devices converge without manual git intervention or a stuck state.

Library

• Drag-to-relay upload — dropping a file or directory uploads (= pushes) it into the device's subtree of the sync repo; nested directories work at every depth.
• In-app preview — images fit-to-width with ctrl+wheel zoom; everything else renders in a sandboxed iframe.
• Manual export — save an entry to a path you choose via a file dialog; VaultOne never learns the target path and never writes into an AI tool's config dir.
• Safe overwrites — same-name same-kind overwrites (git history is the safety net); same-name different-kind is rejected.
• Per-device, zero conflict — each device holds its own subtree; forgetting a peer offers to migrate its files into yours (from-<peer>/) or delete them.

Cost & pricing

• Editable per-model pricing — override seed prices; VaultOne uses your numbers.
• Rebill — backfill records that had no price when collected, without re-costing existing history.

Experience

• Lightweight glance mode — edge-tucked mini-bar + expandable floating card, each shape remembering its own placement.
• Multi-skin theming — five palettes; Neutral (greyscale) by default.
• Auto-update — signed installers straight from GitHub Releases, with a manual check in Settings.
• Light / dark theme, three languages, private by default — usage data stays on your machines unless you opt into sync.

How it works

  AI CLI session logs
  (Claude Code · Codex · Gemini CLI · OpenCode)
          │  (read-only)
          ▼
       Collect ──────▶ Local store ──────▶ Dashboard
          │
          │  (optional · Synced mode)
          ▼
   Artifact (plain text, per device + date)
          │
    push / pull via your GitHub repo
          │
          ▼
     Other devices

A Tauri 2 app: a Rust backend handles collection, the local store, and optional Git-repo sync; a React frontend renders the dashboard through generated, type-safe IPC bindings. The collector is a pluggable provider model (Claude Code, Codex, Gemini CLI, OpenCode), the local store is the dashboard's single read source, and sync is an opt-in projection of that store into plain-text artifacts partitioned by device and date.

Build from source

Prerequisites: Node.js 20+ LTS + Yarn 4 (via Corepack), and Rust stable with the Tauri prerequisites for your OS.

corepack enable  # activate the Yarn version pinned in package.json
yarn install     # install dependencies
yarn dev         # run the desktop app in development
yarn dist        # build a release binary
yarn check       # static checks (Biome + tsc + Rust fmt/clippy) — same gates as CI
yarn test        # run the test suite

Tech stack: Tauri 2 (Rust) · React 19 · TypeScript · Vite · Tailwind CSS v4 · shadcn/ui · Redux Toolkit · Recharts

Contributing

Issues and suggestions are welcome. Before a PR, run yarn check and yarn test. For larger features, open an issue to discuss the approach first.

License

MIT © VaultOne Contributors