@anibx/token-tracker 1.0.2

package/README.md

@@ -0,0 +1,137 @@
+# Token Tracker
+
+A cross-platform desktop app that shows real-time and historical token usage + costs for **Anthropic (Claude)** and **OpenAI (GPT)** APIs.
+
+Built with **Tauri v2** (Rust backend) + **React 19 + TypeScript** (frontend).
+
+---
+
+## Install
+
+```sh
+npm install -g @anibx/token-tracker
+token-tracker
+```
+
+Or download a binary directly from the [latest release](https://github.com/ani0x53/token-tracker/releases/latest).
+
+---
+
+## Features
+
+- **Real-time polling** — fetches usage from Anthropic and OpenAI APIs on a configurable interval (default 5 min)
+- **30-day history** — stored locally in SQLite, persists across restarts
+- **Daily line chart** — cost over time per provider
+- **Model breakdown bar chart** — cost per model (Claude Sonnet, Opus, GPT-4o, etc.)
+- **Spending alerts** — OS-level notifications when daily/monthly thresholds are exceeded
+- **System tray** — shows today's total cost, click to open window
+- **Dark UI** — Tailwind CSS dark theme
+
+---
+
+## Prerequisites
+
+### macOS / Windows
+Tauri's prerequisites are automatically handled by the platform toolchain.
+
+### Linux (Ubuntu/Debian)
+```bash
+sudo apt-get install -y \
+  libwebkit2gtk-4.1-dev \
+  libgtk-3-dev \
+  libayatana-appindicator3-dev \
+  librsvg2-dev \
+  pkg-config
+```
+
+### Rust
+```bash
+curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+source "$HOME/.cargo/env"
+```
+
+---
+
+## Setup
+
+```bash
+# 1. Install JS dependencies
+npm install
+
+# 2. Run in development mode
+npm run tauri dev
+
+# 3. Build a release binary
+npm run tauri build
+```
+
+---
+
+## Configuration
+
+On first launch the Settings panel opens automatically. Enter your API keys there.
+
+**Keys are stored only on your machine** — in your OS app data directory. They are never sent anywhere except the respective API provider.
+
+| Setting | Where to get it |
+|---------|----------------|
+| **Anthropic Admin Key** | [console.anthropic.com/settings/admin-keys](https://console.anthropic.com/settings/admin-keys) — must be an **Admin** key, not a regular API key |
+| **OpenAI API Key** | [platform.openai.com/api-keys](https://platform.openai.com/api-keys) |
+| **Poll Interval** | Seconds between data fetches (default 300) |
+| **Daily Alert ($)** | OS notification when daily spend exceeds this amount |
+| **Monthly Alert ($)** | OS notification when monthly spend exceeds this amount |
+
+You can leave out either key if you only use one provider.
+
+---
+
+## Architecture
+
+```
+token-tracker/
+├── src/                          # React frontend
+│   ├── App.tsx
+│   ├── components/
+│   │   ├── Dashboard.tsx         # Main layout
+│   │   ├── ProviderCard.tsx      # Per-provider summary card
+│   │   ├── UsageChart.tsx        # Line chart — daily usage
+│   │   ├── ModelBreakdown.tsx    # Bar chart — cost per model
+│   │   └── AlertSettings.tsx    # Settings modal
+│   ├── hooks/
+│   │   ├── useUsageData.ts       # SQLite query + event listeners
+│   │   └── useAlerts.ts          # Spending alert logic
+│   └── store/
+│       └── settingsStore.ts      # Zustand store for settings
+├── src-tauri/
+│   └── src/
+│       ├── lib.rs                # Tauri commands + app setup
+│       ├── api/
+│       │   ├── anthropic.rs      # Anthropic usage API client
+│       │   └── openai.rs         # OpenAI usage API client
+│       ├── poller.rs             # Background polling loop
+│       ├── storage.rs            # SQLite schema constants
+│       └── tray.rs               # System tray setup
+```
+
+### Data flow
+
+1. Rust `poller` fetches both APIs every N seconds
+2. New snapshots are emitted as `new-snapshots` Tauri events
+3. Frontend `useUsageData` hook receives events and upserts into local SQLite
+4. React Query re-fetches from DB and re-renders charts
+5. Tray tooltip is updated with today's total cost
+
+---
+
+## Tech Stack
+
+| Layer | Choice |
+|-------|--------|
+| Desktop shell | Tauri v2 |
+| Frontend | React 19 + TypeScript |
+| Styling | Tailwind CSS v4 |
+| Charts | Recharts |
+| State | Zustand |
+| DB | SQLite (tauri-plugin-sql) |
+| HTTP | reqwest (Rust) |
+| Notifications | tauri-plugin-notification |

package/bin/launch.cjs

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+'use strict';
+
+const { spawn, execFileSync } = require('child_process');
+const path = require('path');
+const os = require('os');
+const fs = require('fs');
+
+function launch() {
+  const p = process.platform;
+
+  if (p === 'linux') {
+    const bin = path.join(os.homedir(), '.local', 'share', 'token-tracker', 'token-tracker.AppImage');
+    if (!fs.existsSync(bin)) {
+      console.error(`Binary not found at ${bin}`);
+      console.error('Try reinstalling: npm install -g @anibx/token-tracker');
+      process.exit(1);
+    }
+    spawn(bin, [], { detached: true, stdio: 'ignore' }).unref();
+
+  } else if (p === 'darwin') {
+    const local = path.join(os.homedir(), 'Applications', 'Token Tracker.app');
+    const system = '/Applications/Token Tracker.app';
+    if (!fs.existsSync(local) && !fs.existsSync(system)) {
+      console.error('Token Tracker.app not found in ~/Applications or /Applications.');
+      console.error('Try reinstalling: npm install -g @anibx/token-tracker');
+      process.exit(1);
+    }
+    const appPath = fs.existsSync(local) ? local : system;
+    execFileSync('open', [appPath]);
+
+  } else if (p === 'win32') {
+    const exe = path.join(
+      process.env['ProgramFiles'] || 'C:\\Program Files',
+      'Token Tracker',
+      'Token Tracker.exe'
+    );
+    if (!fs.existsSync(exe)) {
+      console.error(`Executable not found at ${exe}`);
+      console.error('Try reinstalling: npm install -g @anibx/token-tracker');
+      process.exit(1);
+    }
+    spawn(exe, [], { detached: true, stdio: 'ignore' }).unref();
+
+  } else {
+    console.error(`Unsupported platform: ${p}`);
+    process.exit(1);
+  }
+}
+
+launch();

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@anibx/token-tracker",
+  "version": "1.0.2",
+  "description": "Real-time token usage and cost tracker for Anthropic and OpenAI APIs",
+  "type": "module",
+  "bin": {
+    "token-tracker": "./bin/launch.cjs"
+  },
+  "files": [
+    "bin/",
+    "scripts/"
+  ],
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc && vite build",
+    "preview": "vite preview",
+    "tauri": "tauri",
+    "postinstall": "node scripts/postinstall.cjs"
+  },
+  "dependencies": {
+    "@tanstack/react-query": "^5.90.21",
+    "@tauri-apps/api": "^2",
+    "@tauri-apps/plugin-notification": "^2.3.3",
+    "@tauri-apps/plugin-opener": "^2",
+    "@tauri-apps/plugin-sql": "^2.3.2",
+    "lucide-react": "^0.575.0",
+    "react": "^19.1.0",
+    "react-dom": "^19.1.0",
+    "recharts": "^3.7.0",
+    "zustand": "^5.0.11"
+  },
+  "devDependencies": {
+    "@tailwindcss/vite": "^4.2.1",
+    "@tauri-apps/cli": "^2",
+    "@types/react": "^19.1.8",
+    "@types/react-dom": "^19.1.6",
+    "@vitejs/plugin-react": "^4.6.0",
+    "tailwindcss": "^4.2.1",
+    "typescript": "~5.8.3",
+    "vite": "^7.0.4"
+  }
+}

package/scripts/postinstall.cjs

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+'use strict';
+
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execFileSync } = require('child_process');
+
+// Skip when running inside the source repository
+if (fs.existsSync(path.join(__dirname, '..', 'src', 'App.tsx'))) {
+  process.exit(0);
+}
+
+// Skip if explicitly disabled (e.g. in CI during npm publish)
+if (process.env.SKIP_POSTINSTALL) {
+  process.exit(0);
+}
+
+const REPO = 'ani0x53/token-tracker';
+const { version } = require('../package.json');
+
+function getInstallDir() {
+  if (process.platform === 'win32') {
+    return path.join(process.env.APPDATA || os.homedir(), 'token-tracker');
+  }
+  return path.join(os.homedir(), '.local', 'share', 'token-tracker');
+}
+
+function findAsset(assets) {
+  const p = process.platform;
+  const a = process.arch;
+
+  return assets.find(({ name }) => {
+    if (p === 'linux') {
+      if (!name.endsWith('.AppImage')) return false;
+      return a === 'arm64' ? name.includes('aarch64') : name.includes('amd64');
+    }
+    if (p === 'darwin') {
+      if (!name.endsWith('.dmg')) return false;
+      // universal dmg works for both arches; also match arch-specific ones
+      if (name.includes('universal')) return true;
+      return a === 'arm64' ? name.includes('aarch64') : name.includes('x64') && !name.includes('aarch64');
+    }
+    if (p === 'win32') {
+      return name.endsWith('-setup.exe') && name.includes('x64');
+    }
+    return false;
+  });
+}
+
+function get(url) {
+  return new Promise((resolve, reject) => {
+    https.get(url, { headers: { 'User-Agent': 'token-tracker-installer' } }, (res) => {
+      if (res.statusCode === 301 || res.statusCode === 302) {
+        resolve(get(res.headers.location));
+        return;
+      }
+      let body = '';
+      res.on('data', (chunk) => (body += chunk));
+      res.on('end', () => resolve(body));
+      res.on('error', reject);
+    }).on('error', reject);
+  });
+}
+
+function download(url, dest) {
+  return new Promise((resolve, reject) => {
+    function fetch(url) {
+      https.get(url, { headers: { 'User-Agent': 'token-tracker-installer' } }, (res) => {
+        if (res.statusCode === 301 || res.statusCode === 302) {
+          fetch(res.headers.location);
+          return;
+        }
+        if (res.statusCode !== 200) {
+          reject(new Error(`HTTP ${res.statusCode} from ${url}`));
+          return;
+        }
+        const total = parseInt(res.headers['content-length'] || '0', 10);
+        let received = 0;
+        const file = fs.createWriteStream(dest);
+
+        res.on('data', (chunk) => {
+          received += chunk.length;
+          if (total) {
+            const pct = Math.round((received / total) * 100);
+            process.stdout.write(`\r  Downloading... ${pct}%`);
+          }
+        });
+        res.pipe(file);
+        file.on('finish', () => {
+          process.stdout.write('\n');
+          resolve();
+        });
+        file.on('error', reject);
+      }).on('error', reject);
+    }
+    fetch(url);
+  });
+}
+
+async function main() {
+  console.log(`\nToken Tracker v${version} — fetching release info...`);
+
+  let release;
+  try {
+    const body = await get(`https://api.github.com/repos/${REPO}/releases/latest`);
+    release = JSON.parse(body);
+  } catch (e) {
+    console.error('Could not fetch release info:', e.message);
+    console.error(`Download manually: https://github.com/${REPO}/releases`);
+    process.exit(1);
+  }
+
+  const asset = findAsset(release.assets || []);
+  if (!asset) {
+    const names = (release.assets || []).map((a) => a.name).join(', ') || 'none';
+    console.error(`No binary found for ${process.platform}/${process.arch}.`);
+    console.error(`Available: ${names}`);
+    process.exit(1);
+  }
+
+  const installDir = getInstallDir();
+  fs.mkdirSync(installDir, { recursive: true });
+
+  const ext = path.extname(asset.name);
+  const tmp = path.join(installDir, `download${ext}`);
+
+  console.log(`Downloading ${asset.name}...`);
+  await download(asset.browser_download_url, tmp);
+
+  if (process.platform === 'linux') {
+    const dest = path.join(installDir, 'token-tracker.AppImage');
+    fs.renameSync(tmp, dest);
+    fs.chmodSync(dest, 0o755);
+    console.log(`Installed to ${dest}`);
+  } else if (process.platform === 'darwin') {
+    console.log('Mounting disk image...');
+    execFileSync('hdiutil', ['attach', tmp, '-quiet', '-nobrowse']);
+    const appsDir = path.join(os.homedir(), 'Applications');
+    fs.mkdirSync(appsDir, { recursive: true });
+    execFileSync('cp', ['-r', '/Volumes/Token Tracker/Token Tracker.app', appsDir]);
+    execFileSync('hdiutil', ['detach', '/Volumes/Token Tracker', '-quiet']);
+    fs.unlinkSync(tmp);
+    console.log(`Installed to ~/Applications/Token Tracker.app`);
+  } else if (process.platform === 'win32') {
+    console.log('Running installer (silent)...');
+    execFileSync(tmp, ['/S'], { windowsHide: true });
+    fs.unlinkSync(tmp);
+    console.log('Token Tracker installed.');
+  }
+
+  console.log('Done! Run: token-tracker\n');
+}
+
+main().catch((e) => {
+  console.error('\nInstallation failed:', e.message);
+  process.exit(1);
+});