[>_] OpenBoardCLI

CLI · TUI · Apache-2.0 licensed

Ship analytics dashboards
without leaving the terminal.

OpenBoardCLI turns a single CSV, Excel, or JSON file into one authenticated React analytics app — then builds it, pushes it to GitHub, and deploys it to Vercel. Every new dataset becomes another tab in the same app, and a master Overview tab tracks spend and insights across all of them. Privacy-first: pick Local only (Ollama / LM Studio, nothing leaves your machine), Hybrid, or All remote before anything else.

$ npm install -g openboard-cli
Read the quickstart
The OpenBoardCLI terminal UI: a boxed banner reading '[>_] OpenBoardCLI — Analytics Dashboard Generator — v2.3.0', above a menu with Onboarding — start here, Integrations, Dashboards, Settings, and Exit, a one-line description of the highlighted option, and the key hints 'arrows move, enter selects'.
The welcome screen — openboard

# the loop

  1. 01onboard

    Pick your privacy mode first — Local only, Hybrid, or All remote — then an LLM provider, and (All remote only) GitHub + Vercel tokens. A first run opens onboarding automatically; everything is stored encrypted in ~/.openboard.

  2. 02point at data

    Hand it a CSV, Excel (.xlsx), or JSON path. OpenBoardCLI parses it, infers types, and summarizes the columns — with 10 category presets (travel, food, subscriptions, invoices, …) that tune the first generation.

  3. 03describe the board

    An internal chat drives the model. Ask for the metrics, charts, and tables you actually want.

  4. 04deploy

    Build, commit, push, and ship to Vercel — one step, with a live progress bar. Each deploy is tagged for rollback and health-checked before OpenBoardCLI calls it done.

# what's in the box

Three privacy modes

Local only — local LLM (Ollama / LM Studio) + local preview, nothing leaves your machine. Hybrid — cloud LLM, local preview. All remote — cloud LLM + GitHub + live Vercel app. The mode is chosen first and shapes everything: wizard steps, chat commands, and the agent pipeline.

Bring your own model

OpenAI, Anthropic, OpenAI Codex, Google Gemini, Moonshot, xAI, Mistral, OpenRouter — or a local Ollama / LM Studio server — with a pick-a-model list and an execution-effort dial (low → max) that maps to each provider's reasoning knob. Switch any time with /model. Keys are encrypted with AES-256-GCM.

One app, many tabs

The first dataset scaffolds a shared authenticated React app. Each later dataset is added as a tab — same shell, same login, same deploy target. Tab composition is deterministic and product-owned: the model writes dashboard components, never your app shell, so one generation can't break another dashboard's tab.

Master Overview tab

A landing tab generated across all your dashboards: total spend, past 7 days, cross-app trend, per-app breakdown, and top spending + saving insights. Refreshed automatically as dashboards come and go.

10 category presets

Health, finance, grocery, travel & rides, food delivery, shopping, subscriptions, utilities & bills, invoice ledgers, or custom — each ships a tuned prompt so the first generation already knows your columns.

Invoice inbox → dashboards

Point OpenBoardCLI at Gmail — under the top-level Integrations menu — and it turns receipts into per-biller spending dashboards on a schedule. Ready-made fetchers ship for Amazon, Amazon Pay, Rapido, Swiggy Food & Instamart, Uber, Urban Company and Zomato. Bring an existing CSV and its dashboard is built from the data already on disk — no waiting for new mail. Your App Password is encrypted and handed to each fetcher through its environment at run time — never written to disk.

Biller Studio — it writes the fetcher

No shipped list covers your billers, so OpenBoardCLI builds one. Give it a sender address and a subject fragment; it samples one real email — forwarded receipts count too — shows you the exact text before anything reaches your model, proposes the fields it can extract, then writes, compiles and dry-runs a fetcher against your mailbox before saving. PDF receipts included. The model writes only the biller-specific regions and OpenBoardCLI splices them into its own skeleton — ~5× less output, so even a slow local model finishes without truncating. Generated code is scanned first — a fetcher reads mail and writes a CSV, nothing else.

Fetches you can watch — and stop

Scheduled runs write to a persistent fetch log you can scroll through later, and the screen says fetching now while one is in flight. Stop fetch aborts a run mid-way — even one the scheduler started — and the schedule anchors when a run starts, so quitting part-way never triggers a full re-fetch on the next launch.

Server-side auth by default

Login runs through a real /api/auth endpoint backed by an httpOnly cookie. No credentials and no auth decisions are shipped to the client.

One shell, every screen

The main menu reads Onboarding · Integrations · Dashboards · Settings, and every screen shares the same frame: a breadcrumb title, one line of facts, the options, a one-line description of whatever is highlighted, and key hints worded identically everywhere. Data sources live under Integrations; deploy targets stay in Settings.

Headless & scriptable

The same pipeline runs non-interactively from an agent — step-labelled progress ([3/8] + generation heartbeats), NDJSON events, stable error codes, dry runs, idempotency keys. Flip to the view for the command contract.

Prompt history

Every change is recorded per dashboard, so openboard update can regenerate from fresh data without you re-describing intent.

Deploys itself

Build → GitHub push → Vercel deploy is part of the flow. If CLI auth is missing, it falls back to Vercel's Git integration on the pushed commit.

Self-healing builds

When generated code fails to build, the error is fed back to the model for an automatic repair pass — most broken generations fix themselves before you ever see them.

Verified, reversible deploys

After every deploy the live URL is health-checked (app shell + auth API), and each deploy is git-tagged — openboard rollback restores the previous one in a single command.

Resumable runs

Every run persists its state under ~/.openboard/runs. If a deploy dies after generation, agent resume picks up at the build step — no second LLM bill.

# quickstart

Node 18+.

# install from npm
npm install -g openboard-cli

# launch the interactive TUI
openboard

# …or run it headless (csv, xlsx, or json)
openboard agent create --data ./rides.csv --name "Rides" --type travel
openboard agent create --data ./invoices.xlsx --name "Invoices" --type invoices
openboard agent update --dashboard rides --prompt "add a weekday vs weekend chart"

# from source instead
git clone https://github.com/syedateebulislam/openboard
cd openboard && npm install && npm run build

Built with TypeScript, Ink, and a pluggable LLM layer. Generated apps use React, Vite, Recharts, and Tailwind.