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.

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.

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 LTS + Yarn, and Rust stable with the Tauri prerequisites for your OS.

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