getaimeter 0.1.0

package/README.md

@@ -0,0 +1,81 @@
+# AIMeter
+
+Track your Claude AI token usage across every surface — CLI, VS Code, Desktop App — in one dashboard.
+
+![Dashboard](https://getaimeter.com/og-image.png)
+
+## Why
+
+Anthropic doesn't show per-session or per-project token usage. If you use Claude Code across multiple tools, you have no idea where your tokens are going.
+
+AIMeter watches Claude's transcript files locally, extracts token counts, and sends them to your dashboard at [getaimeter.com](https://getaimeter.com). No proxy, no code changes, no config files.
+
+## Quick Start
+
+```bash
+npx aimeter setup
+```
+
+The wizard will:
+1. Ask for your API key (get one free at [getaimeter.com](https://getaimeter.com))
+2. Detect your Claude installations
+3. Install a background service that auto-starts on login
+
+That's it. Use Claude normally — your dashboard updates in real time.
+
+## What Gets Tracked
+
+| Source | How |
+|--------|-----|
+| **Claude Code CLI** | File watcher on `~/.claude/projects/` |
+| **VS Code Extension** | File watcher on `~/.claude/projects/` |
+| **Desktop App (Agent Mode)** | File watcher on local-agent-mode sessions |
+| **claude.ai (Web/Desktop Chat)** | Browser extension (optional) |
+
+**Only token counts are sent** — no prompts, no responses, no code. Your conversations stay on your machine.
+
+## Commands
+
+```
+aimeter setup       Full onboarding wizard (recommended)
+aimeter status      Check configuration and service status
+aimeter watch       Run watcher in foreground (for testing)
+aimeter install     Install as background service
+aimeter uninstall   Remove background service
+aimeter start       Start the background service
+aimeter stop        Stop the background service
+aimeter logs        Tail the watcher log
+aimeter key         Print your API key
+```
+
+## How It Works
+
+Claude Code (CLI, VS Code, Desktop Agent Mode) writes JSONL transcript files with full token usage data. AIMeter watches these files using `fs.watch`, reads only new bytes via offset tracking, and POSTs token counts to your dashboard.
+
+- **Zero dependencies** — pure Node.js, no native modules
+- **Minimal overhead** — file watcher + byte offset reads, ~5MB memory
+- **Deduplication** — MD5 hashing prevents double-counting
+- **Crash-safe** — state persisted to disk every 30 seconds
+
+## Privacy
+
+AIMeter sends **only**:
+- Token counts (input, output, thinking, cache)
+- Model name (e.g., `claude-sonnet-4-20250514`)
+- Source type (CLI, VS Code, Desktop)
+
+It **never** sends your prompts, responses, code, or file contents.
+
+## Requirements
+
+- Node.js 18+
+- Claude Code (CLI, VS Code extension, or Desktop App)
+
+## Links
+
+- **Dashboard**: [getaimeter.com](https://getaimeter.com)
+- **Issues**: [github.com/AlejoCJaworworski/aimeter](https://github.com/AlejoCJaworworski/aimeter)
+
+## License
+
+MIT

package/cli.js

@@ -0,0 +1,356 @@
+#!/usr/bin/env node
+'use strict';
+
+const { getApiKey, saveApiKey, getWatchPaths, AIMETER_DIR } = require('./config');
+const { startWatching }   = require('./watcher');
+const { install, uninstall, isInstalled, startNow, stopNow } = require('./service');
+const { checkForUpdate, getCurrentVersion } = require('./update-check');
+
+const command = process.argv[2] || 'help';
+
+// Version check on interactive commands (non-blocking)
+if (['setup', 'status', 'help', '--help', '-h'].includes(command)) {
+  checkForUpdate();
+}
+
+switch (command) {
+  case 'setup':   runSetup();     break;
+  case 'watch':   runWatch();     break;
+  case 'install': runInstall();   break;
+  case 'uninstall': runUninstall(); break;
+  case 'start':   runStart();     break;
+  case 'stop':    runStop();      break;
+  case 'status':  runStatus();    break;
+  case 'logs':    runLogs();      break;
+  case 'key':     runKey();       break;
+  case 'version': case '--version': case '-v':
+    console.log(getCurrentVersion());
+    break;
+  case 'help': case '--help': case '-h':
+    printHelp();
+    break;
+  default:
+    console.log(`Unknown command: ${command}\n`);
+    printHelp();
+    process.exitCode = 1;
+    break;
+}
+
+// ---------------------------------------------------------------------------
+// setup — full onboarding wizard
+// ---------------------------------------------------------------------------
+
+async function runSetup() {
+  const readline = require('readline');
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const ask = (q) => new Promise((resolve) => rl.question(q, (a) => resolve(a.trim())));
+
+  console.log('');
+  console.log('  ╔══════════════════════════════════╗');
+  console.log('  ║       AIMeter Setup Wizard       ║');
+  console.log('  ╚══════════════════════════════════╝');
+  console.log('');
+
+  // Step 1: API Key
+  console.log('  Step 1: API Key');
+  console.log('  ───────────────');
+  const existing = getApiKey();
+  let key = existing;
+
+  if (existing) {
+    console.log(`  Current key: ${existing.slice(0, 8)}...${existing.slice(-4)}`);
+    const answer = await ask('  Press Enter to keep, or paste a new key: ');
+    if (answer.length > 0) {
+      if (!answer.startsWith('aim_')) {
+        console.log('  ✗ Invalid key (must start with aim_)');
+        rl.close();
+        return;
+      }
+      saveApiKey(answer);
+      key = answer;
+      console.log('  ✓ Key updated.');
+    } else {
+      console.log('  ✓ Key unchanged.');
+    }
+  } else {
+    console.log('  Sign up at: https://getaimeter.com');
+    console.log('  Then copy your API key from the dashboard.\n');
+    while (!key || !key.startsWith('aim_')) {
+      key = await ask('  Paste your API key: ');
+      if (!key.startsWith('aim_')) {
+        console.log('  ✗ Invalid — keys start with aim_');
+      }
+    }
+    saveApiKey(key);
+    console.log('  ✓ Key saved.');
+  }
+
+  // Step 2: Check watch paths
+  console.log('');
+  console.log('  Step 2: Detect Claude installations');
+  console.log('  ────────────────────────────────────');
+  const paths = getWatchPaths();
+  if (paths.length === 0) {
+    console.log('  ⚠ No Claude transcript directories found.');
+    console.log('  Install Claude Code (CLI, VS Code, or Desktop App) first.');
+    console.log('  Paths checked:');
+    console.log('    ~/.claude/projects/');
+    const platform = process.platform;
+    if (platform === 'win32') {
+      console.log('    %APPDATA%/Claude/local-agent-mode-sessions/');
+    } else if (platform === 'darwin') {
+      console.log('    ~/Library/Application Support/Claude/local-agent-mode-sessions/');
+    }
+  } else {
+    for (const p of paths) {
+      console.log(`  ✓ ${p}`);
+    }
+  }
+
+  // Step 3: Install background service
+  console.log('');
+  console.log('  Step 3: Background service');
+  console.log('  ──────────────────────────');
+
+  if (isInstalled()) {
+    console.log('  ✓ Already installed as a background service.');
+    const reinstall = await ask('  Reinstall? (y/N): ');
+    if (reinstall.toLowerCase() === 'y') {
+      const result = install();
+      startNow();
+      console.log(`  ✓ Reinstalled at: ${result.path}`);
+    }
+  } else {
+    const doInstall = await ask('  Install as background service? (Y/n): ');
+    if (doInstall.toLowerCase() !== 'n') {
+      const result = install();
+      startNow();
+      console.log(`  ✓ Installed at: ${result.path}`);
+      if (result.platform === 'windows') {
+        console.log('  ✓ Will auto-start on login (Windows Startup folder)');
+      } else if (result.platform === 'macos') {
+        console.log('  ✓ Will auto-start on login (launchd)');
+      } else {
+        console.log('  ✓ Will auto-start on login (systemd user service)');
+      }
+    } else {
+      console.log('  Skipped. You can run manually with: aimeter watch');
+    }
+  }
+
+  // Done!
+  console.log('');
+  console.log('  ╔══════════════════════════════════╗');
+  console.log('  ║          Setup complete!          ║');
+  console.log('  ╚══════════════════════════════════╝');
+  console.log('');
+  console.log('  Your Claude usage is now being tracked.');
+  console.log('  View your dashboard at: https://getaimeter.com/dashboard');
+  console.log('');
+  console.log('  Commands:');
+  console.log('    aimeter status    — check what\'s running');
+  console.log('    aimeter logs      — view watcher logs');
+  console.log('    aimeter stop      — stop the watcher');
+  console.log('');
+
+  rl.close();
+}
+
+// ---------------------------------------------------------------------------
+// watch — foreground mode
+// ---------------------------------------------------------------------------
+
+function runWatch() {
+  const cleanup = startWatching();
+
+  process.on('SIGINT',  () => { cleanup(); process.exit(0); });
+  process.on('SIGTERM', () => { cleanup(); process.exit(0); });
+
+  process.on('uncaughtException', (err) => {
+    console.error('[aimeter] Uncaught:', err.message);
+  });
+
+  process.on('unhandledRejection', (reason) => {
+    console.error('[aimeter] Unhandled rejection:', reason);
+  });
+}
+
+// ---------------------------------------------------------------------------
+// install / uninstall / start / stop
+// ---------------------------------------------------------------------------
+
+function runInstall() {
+  if (!getApiKey()) {
+    console.log('No API key configured. Run: aimeter setup');
+    process.exitCode = 1;
+    return;
+  }
+
+  const result = install();
+  console.log(`Installed background service (${result.platform})`);
+  console.log(`  File: ${result.path}`);
+  console.log('Starting...');
+  startNow();
+  console.log('Done. AIMeter is now tracking your Claude usage.');
+}
+
+function runUninstall() {
+  stopNow();
+  const removed = uninstall();
+  if (removed) {
+    console.log('Background service removed.');
+  } else {
+    console.log('No background service found to remove.');
+  }
+}
+
+function runStart() {
+  if (!isInstalled()) {
+    console.log('Service not installed. Run: aimeter install');
+    process.exitCode = 1;
+    return;
+  }
+  startNow();
+  console.log('AIMeter watcher started.');
+}
+
+function runStop() {
+  stopNow();
+  console.log('AIMeter watcher stopped.');
+}
+
+// ---------------------------------------------------------------------------
+// status
+// ---------------------------------------------------------------------------
+
+function runStatus() {
+  const fs   = require('fs');
+  const path = require('path');
+
+  console.log('');
+  console.log('  AIMeter Status');
+  console.log('  ══════════════');
+  console.log('');
+
+  // API key
+  const key = getApiKey();
+  console.log(`  API key:     ${key ? key.slice(0, 8) + '...' + key.slice(-4) : '✗ NOT SET (run: aimeter setup)'}`);
+
+  // Service
+  const installed = isInstalled();
+  console.log(`  Service:     ${installed ? '✓ installed' : '✗ not installed'}`);
+
+  // Watch paths
+  const paths = getWatchPaths();
+  console.log(`  Watch paths: ${paths.length > 0 ? '' : '(none found)'}`);
+  for (const p of paths) console.log(`    → ${p}`);
+
+  // State
+  const stateFile = path.join(AIMETER_DIR, 'state.json');
+  try {
+    const state = JSON.parse(fs.readFileSync(stateFile, 'utf8'));
+    const fileCount = Object.keys(state.fileOffsets || {}).length;
+    console.log(`  Files:       ${fileCount} tracked`);
+    console.log(`  Last active: ${state.lastSaved || 'never'}`);
+  } catch {
+    console.log('  State:       no data yet (first run?)');
+  }
+
+  // Log file
+  const logFile = path.join(AIMETER_DIR, 'watcher.log');
+  try {
+    const stat = fs.statSync(logFile);
+    const sizeMB = (stat.size / 1024 / 1024).toFixed(1);
+    console.log(`  Log file:    ${logFile} (${sizeMB} MB)`);
+  } catch {
+    console.log('  Log file:    (none)');
+  }
+
+  console.log('');
+}
+
+// ---------------------------------------------------------------------------
+// logs — tail the watcher log
+// ---------------------------------------------------------------------------
+
+function runLogs() {
+  const fs   = require('fs');
+  const path = require('path');
+  const logFile = path.join(AIMETER_DIR, 'watcher.log');
+
+  if (!fs.existsSync(logFile)) {
+    console.log('No log file yet. Start the watcher first.');
+    return;
+  }
+
+  // Show last 50 lines, then follow
+  const lines = process.argv[3] ? parseInt(process.argv[3], 10) : 50;
+  const content = fs.readFileSync(logFile, 'utf8');
+  const allLines = content.split('\n');
+  const tail = allLines.slice(-lines).join('\n');
+  console.log(tail);
+
+  // Follow mode
+  console.log('\n--- Watching for new entries (Ctrl+C to stop) ---\n');
+
+  let fileSize = fs.statSync(logFile).size;
+  fs.watch(logFile, () => {
+    try {
+      const newSize = fs.statSync(logFile).size;
+      if (newSize > fileSize) {
+        const fd  = fs.openSync(logFile, 'r');
+        const buf = Buffer.alloc(newSize - fileSize);
+        fs.readSync(fd, buf, 0, buf.length, fileSize);
+        fs.closeSync(fd);
+        process.stdout.write(buf.toString('utf8'));
+        fileSize = newSize;
+      }
+    } catch {}
+  });
+}
+
+// ---------------------------------------------------------------------------
+// key — quick key management
+// ---------------------------------------------------------------------------
+
+function runKey() {
+  const key = getApiKey();
+  if (key) {
+    console.log(key);
+  } else {
+    console.log('No API key configured. Run: aimeter setup');
+    process.exitCode = 1;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// help
+// ---------------------------------------------------------------------------
+
+function printHelp() {
+  console.log(`
+  AIMeter — Track your Claude AI usage
+  ═════════════════════════════════════
+
+  Usage: aimeter <command>
+
+  Getting started:
+    setup        Full onboarding wizard (recommended)
+
+  Service management:
+    install      Install background service
+    uninstall    Remove background service
+    start        Start the background service
+    stop         Stop the background service
+
+  Manual mode:
+    watch        Run watcher in foreground
+
+  Info:
+    status       Show current configuration
+    logs [N]     Tail watcher log (last N lines, default 50)
+    key          Print current API key
+
+  https://getaimeter.com
+`);
+}

package/config.js

@@ -0,0 +1,74 @@
+'use strict';
+
+const fs   = require('fs');
+const os   = require('os');
+const path = require('path');
+
+const AIMETER_DIR  = path.join(os.homedir(), '.aimeter');
+const CONFIG_FILE  = path.join(AIMETER_DIR, 'config.json');
+const LEGACY_KEY   = path.join(os.homedir(), '.claude', 'aimeter-key');
+
+function ensureDir() {
+  fs.mkdirSync(AIMETER_DIR, { recursive: true });
+}
+
+function loadConfig() {
+  try {
+    return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+function saveConfig(cfg) {
+  ensureDir();
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(cfg, null, 2) + '\n', { mode: 0o600 });
+}
+
+function getApiKey() {
+  if (process.env.AIMETER_KEY) return process.env.AIMETER_KEY.trim();
+
+  const cfg = loadConfig();
+  if (cfg.apiKey) return cfg.apiKey;
+
+  // Legacy: ~/.claude/aimeter-key
+  try {
+    const key = fs.readFileSync(LEGACY_KEY, 'utf8').trim();
+    if (key) return key;
+  } catch {}
+
+  return null;
+}
+
+function saveApiKey(key) {
+  const cfg = loadConfig();
+  cfg.apiKey = key.trim();
+  saveConfig(cfg);
+}
+
+/**
+ * Return all directories to watch for JSONL transcripts.
+ */
+function getWatchPaths() {
+  const paths = [];
+
+  // 1. ~/.claude/projects/ — CLI + VS Code transcripts
+  const claudeProjects = path.join(os.homedir(), '.claude', 'projects');
+  if (fs.existsSync(claudeProjects)) paths.push(claudeProjects);
+
+  // 2. Desktop app agent mode sessions
+  const platform = process.platform;
+  let desktopSessions;
+  if (platform === 'win32') {
+    desktopSessions = path.join(process.env.APPDATA || '', 'Claude', 'local-agent-mode-sessions');
+  } else if (platform === 'darwin') {
+    desktopSessions = path.join(os.homedir(), 'Library', 'Application Support', 'Claude', 'local-agent-mode-sessions');
+  } else {
+    desktopSessions = path.join(os.homedir(), '.config', 'Claude', 'local-agent-mode-sessions');
+  }
+  if (fs.existsSync(desktopSessions)) paths.push(desktopSessions);
+
+  return paths;
+}
+
+module.exports = { loadConfig, saveConfig, getApiKey, saveApiKey, getWatchPaths, AIMETER_DIR };

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "getaimeter",
+  "version": "0.1.0",
+  "description": "Track your Claude AI usage across CLI, VS Code, and Desktop App. One command to start.",
+  "bin": {
+    "aimeter": "cli.js"
+  },
+  "main": "watcher.js",
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "MIT",
+  "keywords": [
+    "claude",
+    "anthropic",
+    "usage",
+    "tracking",
+    "ai",
+    "tokens",
+    "cost",
+    "monitor",
+    "claude-code",
+    "vscode"
+  ],
+  "files": [
+    "cli.js",
+    "watcher.js",
+    "reporter.js",
+    "config.js",
+    "state.js",
+    "service.js",
+    "update-check.js",
+    "README.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AlejoCJaworworski/aimeter.git"
+  },
+  "homepage": "https://getaimeter.com",
+  "author": "Alejandro Ceja",
+  "preferGlobal": true
+}

package/reporter.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const https = require('https');
+
+const INGEST_HOST = 'aimeter-api.fly.dev';
+const INGEST_PATH = '/ingest/events';
+
+/**
+ * POST a usage event to the AIMeter backend.
+ * Returns { ok, status, error }.
+ */
+function postUsage(apiKey, payload) {
+  return new Promise((resolve) => {
+    const body = JSON.stringify(payload);
+    const options = {
+      hostname: INGEST_HOST,
+      port:     443,
+      path:     INGEST_PATH,
+      method:   'POST',
+      headers: {
+        'Content-Type':   'application/json',
+        'Content-Length':  Buffer.byteLength(body),
+        'X-AIMeter-Key':  apiKey,
+      },
+    };
+
+    const req = https.request(options, (res) => {
+      res.resume(); // drain
+      resolve({ ok: res.statusCode >= 200 && res.statusCode < 300, status: res.statusCode });
+    });
+
+    req.on('error', (err) => resolve({ ok: false, status: 0, error: err.message }));
+    req.setTimeout(8000, () => { req.destroy(); resolve({ ok: false, status: 0, error: 'timeout' }); });
+    req.write(body);
+    req.end();
+  });
+}
+
+module.exports = { postUsage };

package/service.js

@@ -0,0 +1,294 @@
+'use strict';
+
+const fs   = require('fs');
+const os   = require('os');
+const path = require('path');
+
+// ---------------------------------------------------------------------------
+// Cross-platform background service installer
+// ---------------------------------------------------------------------------
+
+const SERVICE_NAME = 'aimeter';
+
+function getNodePath() {
+  return process.execPath;
+}
+
+/**
+ * Resolve the best way to launch the watcher.
+ * If installed globally (npm i -g), use the global bin path.
+ * If running via npx or dev, use __dirname but warn if it looks temporary.
+ */
+function getWatcherScript() {
+  const cliPath = path.join(__dirname, 'cli.js');
+
+  // Check if we're in a temp/npx cache directory
+  const normalized = __dirname.replace(/\\/g, '/').toLowerCase();
+  const isTempDir = normalized.includes('/_npx/') ||
+                    normalized.includes('\\_npx\\') ||
+                    normalized.includes('/temp/') ||
+                    normalized.includes('\\temp\\') ||
+                    normalized.includes('/tmp/');
+
+  if (isTempDir) {
+    // Try to find the globally installed aimeter
+    const { execSync } = require('child_process');
+    try {
+      const globalBin = execSync('npm root -g', { encoding: 'utf8' }).trim();
+      const globalCli = path.join(globalBin, 'aimeter', 'cli.js');
+      if (fs.existsSync(globalCli)) return globalCli;
+    } catch {}
+
+    console.log('');
+    console.log('  WARNING: You ran this via npx. The background service needs a');
+    console.log('  permanent install. Installing globally first...');
+    console.log('');
+    try {
+      const { execSync: ex } = require('child_process');
+      ex('npm install -g aimeter', { stdio: 'inherit' });
+      const globalBin = ex('npm root -g', { encoding: 'utf8' }).trim();
+      const globalCli = path.join(globalBin, 'aimeter', 'cli.js');
+      if (fs.existsSync(globalCli)) return globalCli;
+    } catch {
+      console.log('  Could not install globally. Install manually:');
+      console.log('    npm install -g aimeter');
+      console.log('  Then run: aimeter install');
+    }
+  }
+
+  return cliPath;
+}
+
+// ---------------------------------------------------------------------------
+// Windows — VBS script in Startup folder (runs hidden, no console window)
+// ---------------------------------------------------------------------------
+
+function getWindowsStartupDir() {
+  return path.join(os.homedir(), 'AppData', 'Roaming', 'Microsoft', 'Windows', 'Start Menu', 'Programs', 'Startup');
+}
+
+function getWindowsVbsPath() {
+  return path.join(getWindowsStartupDir(), 'aimeter.vbs');
+}
+
+function installWindows() {
+  const vbsPath = getWindowsVbsPath();
+  const nodePath = getNodePath().replace(/\\/g, '\\\\');
+  const script   = getWatcherScript().replace(/\\/g, '\\\\');
+  const logFile  = path.join(os.homedir(), '.aimeter', 'watcher.log').replace(/\\/g, '\\\\');
+
+  // VBS script that runs node hidden (no console window)
+  const vbs = `' AIMeter Watcher — auto-start script
+' Created by: npx aimeter install
+Set WshShell = CreateObject("WScript.Shell")
+WshShell.Run """${nodePath}"" ""${script}"" watch", 0, False
+`;
+
+  fs.mkdirSync(path.dirname(vbsPath), { recursive: true });
+  fs.writeFileSync(vbsPath, vbs, 'utf8');
+  return vbsPath;
+}
+
+function uninstallWindows() {
+  const vbsPath = getWindowsVbsPath();
+  try { fs.unlinkSync(vbsPath); return true; } catch { return false; }
+}
+
+function isInstalledWindows() {
+  return fs.existsSync(getWindowsVbsPath());
+}
+
+// ---------------------------------------------------------------------------
+// macOS — LaunchAgent plist
+// ---------------------------------------------------------------------------
+
+function getMacPlistPath() {
+  return path.join(os.homedir(), 'Library', 'LaunchAgents', 'com.aimeter.watcher.plist');
+}
+
+function installMac() {
+  const plistPath = getMacPlistPath();
+  const logFile   = path.join(os.homedir(), '.aimeter', 'watcher.log');
+
+  const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>com.aimeter.watcher</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>${getNodePath()}</string>
+        <string>${getWatcherScript()}</string>
+        <string>watch</string>
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <true/>
+    <key>StandardOutPath</key>
+    <string>${logFile}</string>
+    <key>StandardErrorPath</key>
+    <string>${logFile}</string>
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>PATH</key>
+        <string>/usr/local/bin:/usr/bin:/bin</string>
+    </dict>
+</dict>
+</plist>
+`;
+
+  fs.mkdirSync(path.dirname(plistPath), { recursive: true });
+  fs.writeFileSync(plistPath, plist, 'utf8');
+  return plistPath;
+}
+
+function uninstallMac() {
+  const plistPath = getMacPlistPath();
+  try {
+    // Try to unload first
+    require('child_process').execSync(`launchctl unload "${plistPath}" 2>/dev/null`, { stdio: 'ignore' });
+  } catch {}
+  try { fs.unlinkSync(plistPath); return true; } catch { return false; }
+}
+
+function isInstalledMac() {
+  return fs.existsSync(getMacPlistPath());
+}
+
+// ---------------------------------------------------------------------------
+// Linux — systemd user service
+// ---------------------------------------------------------------------------
+
+function getLinuxServicePath() {
+  return path.join(os.homedir(), '.config', 'systemd', 'user', 'aimeter.service');
+}
+
+function installLinux() {
+  const servicePath = getLinuxServicePath();
+
+  const unit = `[Unit]
+Description=AIMeter Watcher — Claude AI usage tracker
+After=default.target
+
+[Service]
+Type=simple
+ExecStart=${getNodePath()} ${getWatcherScript()} watch
+Restart=on-failure
+RestartSec=10
+
+[Install]
+WantedBy=default.target
+`;
+
+  fs.mkdirSync(path.dirname(servicePath), { recursive: true });
+  fs.writeFileSync(servicePath, unit, 'utf8');
+
+  // Enable and start
+  const { execSync } = require('child_process');
+  try {
+    execSync('systemctl --user daemon-reload', { stdio: 'ignore' });
+    execSync('systemctl --user enable aimeter.service', { stdio: 'ignore' });
+    execSync('systemctl --user start aimeter.service', { stdio: 'ignore' });
+  } catch {}
+
+  return servicePath;
+}
+
+function uninstallLinux() {
+  const servicePath = getLinuxServicePath();
+  const { execSync } = require('child_process');
+  try {
+    execSync('systemctl --user stop aimeter.service', { stdio: 'ignore' });
+    execSync('systemctl --user disable aimeter.service', { stdio: 'ignore' });
+  } catch {}
+  try { fs.unlinkSync(servicePath); return true; } catch { return false; }
+  try { execSync('systemctl --user daemon-reload', { stdio: 'ignore' }); } catch {}
+}
+
+function isInstalledLinux() {
+  return fs.existsSync(getLinuxServicePath());
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+function install() {
+  const platform = process.platform;
+  if (platform === 'win32')  return { path: installWindows(),  platform: 'windows' };
+  if (platform === 'darwin') return { path: installMac(),      platform: 'macos' };
+  return { path: installLinux(), platform: 'linux' };
+}
+
+function uninstall() {
+  const platform = process.platform;
+  if (platform === 'win32')  return uninstallWindows();
+  if (platform === 'darwin') return uninstallMac();
+  return uninstallLinux();
+}
+
+function isInstalled() {
+  const platform = process.platform;
+  if (platform === 'win32')  return isInstalledWindows();
+  if (platform === 'darwin') return isInstalledMac();
+  return isInstalledLinux();
+}
+
+function startNow() {
+  const platform = process.platform;
+  const { execSync, exec } = require('child_process');
+
+  if (platform === 'win32') {
+    // Launch via wscript (hidden, non-blocking)
+    const vbsPath = getWindowsVbsPath();
+    if (fs.existsSync(vbsPath)) {
+      exec(`wscript "${vbsPath}"`, { stdio: 'ignore' });
+      return true;
+    }
+    return false;
+  }
+
+  if (platform === 'darwin') {
+    try {
+      execSync(`launchctl load "${getMacPlistPath()}"`, { stdio: 'ignore' });
+      return true;
+    } catch { return false; }
+  }
+
+  // Linux
+  try {
+    execSync('systemctl --user start aimeter.service', { stdio: 'ignore' });
+    return true;
+  } catch { return false; }
+}
+
+function stopNow() {
+  const platform = process.platform;
+  const { execSync } = require('child_process');
+
+  if (platform === 'win32') {
+    // Kill any running node process with our watcher
+    try {
+      execSync('taskkill /F /FI "WINDOWTITLE eq aimeter*" 2>nul', { stdio: 'ignore' });
+      // Also kill by script name
+      execSync(`wmic process where "commandline like '%aimeter-watcher%cli.js%watch%'" call terminate 2>nul`, { stdio: 'ignore' });
+      return true;
+    } catch { return false; }
+  }
+
+  if (platform === 'darwin') {
+    try {
+      execSync(`launchctl unload "${getMacPlistPath()}"`, { stdio: 'ignore' });
+      return true;
+    } catch { return false; }
+  }
+
+  try {
+    execSync('systemctl --user stop aimeter.service', { stdio: 'ignore' });
+    return true;
+  } catch { return false; }
+}
+
+module.exports = { install, uninstall, isInstalled, startNow, stopNow };

package/state.js

@@ -0,0 +1,50 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+const { AIMETER_DIR } = require('./config');
+
+const STATE_FILE = path.join(AIMETER_DIR, 'state.json');
+
+let _state = null;
+
+function load() {
+  if (_state) return _state;
+  try {
+    _state = JSON.parse(fs.readFileSync(STATE_FILE, 'utf8'));
+  } catch {
+    _state = { fileOffsets: {}, recentHashes: [] };
+  }
+  return _state;
+}
+
+function save() {
+  if (!_state) return;
+  fs.mkdirSync(AIMETER_DIR, { recursive: true });
+  // Keep recentHashes bounded
+  if (_state.recentHashes && _state.recentHashes.length > 200) {
+    _state.recentHashes = _state.recentHashes.slice(-100);
+  }
+  _state.lastSaved = new Date().toISOString();
+  fs.writeFileSync(STATE_FILE, JSON.stringify(_state, null, 2) + '\n');
+}
+
+function getOffset(filePath) {
+  const s = load();
+  return s.fileOffsets[filePath] || 0;
+}
+
+function setOffset(filePath, offset) {
+  const s = load();
+  s.fileOffsets[filePath] = offset;
+}
+
+function isDuplicate(hash) {
+  const s = load();
+  if (!s.recentHashes) s.recentHashes = [];
+  if (s.recentHashes.includes(hash)) return true;
+  s.recentHashes.push(hash);
+  return false;
+}
+
+module.exports = { load, save, getOffset, setOffset, isDuplicate };

package/update-check.js

@@ -0,0 +1,75 @@
+'use strict';
+
+const https = require('https');
+const fs    = require('fs');
+const path  = require('path');
+const { AIMETER_DIR } = require('./config');
+
+const PACKAGE_NAME   = 'getaimeter';
+const CHECK_FILE     = path.join(AIMETER_DIR, 'last-update-check.json');
+const CHECK_INTERVAL = 24 * 60 * 60 * 1000; // 24 hours
+
+function getCurrentVersion() {
+  const pkg = require('./package.json');
+  return pkg.version;
+}
+
+/**
+ * Non-blocking check for newer version on npm.
+ * Shows a message if a newer version exists.
+ * Only checks once every 24 hours.
+ */
+function checkForUpdate() {
+  try {
+    // Skip if checked recently
+    try {
+      const data = JSON.parse(fs.readFileSync(CHECK_FILE, 'utf8'));
+      if (Date.now() - data.lastCheck < CHECK_INTERVAL) {
+        // Still show cached message if there was an update
+        if (data.latestVersion && data.latestVersion !== getCurrentVersion()) {
+          showUpdateMessage(data.latestVersion);
+        }
+        return;
+      }
+    } catch {}
+
+    // Fetch latest version from npm registry
+    const req = https.get(`https://registry.npmjs.org/${PACKAGE_NAME}/latest`, {
+      headers: { 'Accept': 'application/json' },
+      timeout: 3000,
+    }, (res) => {
+      let body = '';
+      res.on('data', (chunk) => body += chunk);
+      res.on('end', () => {
+        try {
+          const data = JSON.parse(body);
+          const latest = data.version;
+
+          // Save check result
+          fs.mkdirSync(AIMETER_DIR, { recursive: true });
+          fs.writeFileSync(CHECK_FILE, JSON.stringify({
+            lastCheck: Date.now(),
+            latestVersion: latest,
+          }) + '\n');
+
+          if (latest && latest !== getCurrentVersion()) {
+            showUpdateMessage(latest);
+          }
+        } catch {}
+      });
+    });
+
+    req.on('error', () => {}); // Silently fail — not critical
+    req.setTimeout(3000, () => req.destroy());
+  } catch {}
+}
+
+function showUpdateMessage(latest) {
+  const current = getCurrentVersion();
+  console.log('');
+  console.log(`  Update available: ${current} → ${latest}`);
+  console.log(`  Run: npm update -g aimeter`);
+  console.log('');
+}
+
+module.exports = { checkForUpdate, getCurrentVersion };

package/watcher.js

@@ -0,0 +1,272 @@
+'use strict';
+
+const fs     = require('fs');
+const path   = require('path');
+const crypto = require('crypto');
+const { getApiKey, getWatchPaths } = require('./config');
+const { getOffset, setOffset, isDuplicate, save: saveState } = require('./state');
+const { postUsage } = require('./reporter');
+
+// ---------------------------------------------------------------------------
+// Logging
+// ---------------------------------------------------------------------------
+
+const LOG_FILE = path.join(require('./config').AIMETER_DIR, 'watcher.log');
+
+function log(...args) {
+  const ts  = new Date().toISOString();
+  const msg = `[${ts}] ${args.join(' ')}`;
+  console.log(msg);
+  try {
+    fs.mkdirSync(path.dirname(LOG_FILE), { recursive: true });
+    fs.appendFileSync(LOG_FILE, msg + '\n');
+  } catch {}
+}
+
+function logError(...args) {
+  log('ERROR:', ...args);
+}
+
+// ---------------------------------------------------------------------------
+// Source detection from file path
+// ---------------------------------------------------------------------------
+
+function detectSource(filePath) {
+  const normalized = filePath.replace(/\\/g, '/');
+  if (normalized.includes('local-agent-mode-sessions')) return 'desktop_agent_mode';
+  // VS Code uses lowercase 'c' in the sanitized project dir name on Windows
+  const projectsMatch = normalized.match(/\.claude\/projects\/([^/])/);
+  if (projectsMatch) {
+    const firstChar = projectsMatch[1];
+    // On Windows: CLI produces uppercase (C--Users), VS Code produces lowercase (c--Users)
+    if (firstChar === firstChar.toLowerCase() && firstChar !== firstChar.toUpperCase()) {
+      return 'claude_code_vscode';
+    }
+  }
+  return 'claude_code_cli';
+}
+
+// ---------------------------------------------------------------------------
+// JSONL parsing — extract usage from new bytes in a transcript file
+// ---------------------------------------------------------------------------
+
+function extractNewUsage(filePath) {
+  let stat;
+  try { stat = fs.statSync(filePath); } catch { return []; }
+
+  const currentSize = stat.size;
+  const lastOffset  = getOffset(filePath);
+
+  if (currentSize <= lastOffset) return [];
+
+  // Read only the new bytes
+  const fd  = fs.openSync(filePath, 'r');
+  const buf = Buffer.alloc(currentSize - lastOffset);
+  fs.readSync(fd, buf, 0, buf.length, lastOffset);
+  fs.closeSync(fd);
+
+  const text  = buf.toString('utf8');
+  const lines = text.split('\n');
+
+  // If we're reading from mid-file (offset > 0), the first line may be partial
+  if (lastOffset > 0 && lines.length > 0) lines.shift();
+
+  const usageEvents = [];
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+
+    let obj;
+    try { obj = JSON.parse(trimmed); } catch { continue; }
+
+    if (obj.type !== 'assistant' || !obj.message || !obj.message.usage) continue;
+
+    const u = obj.message.usage;
+    const model = obj.message.model || 'unknown';
+
+    // Build dedup hash
+    const hash = crypto.createHash('md5')
+      .update(`${filePath}:${model}:${u.input_tokens || 0}:${u.output_tokens || 0}:${currentSize}`)
+      .digest('hex');
+
+    if (isDuplicate(hash)) continue;
+
+    usageEvents.push({
+      provider:         'anthropic',
+      model,
+      source:           detectSource(filePath),
+      inputTokens:      u.input_tokens               || 0,
+      outputTokens:     u.output_tokens              || 0,
+      thinkingTokens:   u.thinking_tokens            || 0,
+      cacheReadTokens:  u.cache_read_input_tokens    || 0,
+      cacheWriteTokens: u.cache_creation_input_tokens || 0,
+    });
+  }
+
+  // Update offset to current file size
+  setOffset(filePath, currentSize);
+
+  return usageEvents;
+}
+
+// ---------------------------------------------------------------------------
+// Report usage events to backend
+// ---------------------------------------------------------------------------
+
+async function reportEvents(events) {
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    logError('No API key configured. Run: aimeter setup');
+    return;
+  }
+
+  for (const evt of events) {
+    const result = await postUsage(apiKey, evt);
+    if (result.ok) {
+      log(`Reported: ${evt.source} ${evt.model} in=${evt.inputTokens} out=${evt.outputTokens} cache_r=${evt.cacheReadTokens}`);
+    } else {
+      logError(`Failed to report: HTTP ${result.status} ${result.error || ''}`);
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// File watcher
+// ---------------------------------------------------------------------------
+
+const _debounceTimers = new Map();
+
+function handleFileChange(filePath) {
+  // Only care about .jsonl files
+  if (!filePath.endsWith('.jsonl')) return;
+
+  // Debounce: wait 500ms after last change before processing
+  const existing = _debounceTimers.get(filePath);
+  if (existing) clearTimeout(existing);
+
+  _debounceTimers.set(filePath, setTimeout(async () => {
+    _debounceTimers.delete(filePath);
+    try {
+      const events = extractNewUsage(filePath);
+      if (events.length > 0) {
+        await reportEvents(events);
+        saveState();
+      }
+    } catch (err) {
+      logError(`Processing ${filePath}:`, err.message);
+    }
+  }, 500));
+}
+
+/**
+ * Recursively find all .jsonl files under a directory.
+ */
+function findJsonlFiles(dir) {
+  const results = [];
+  let entries;
+  try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return results; }
+
+  for (const entry of entries) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...findJsonlFiles(full));
+    } else if (entry.name.endsWith('.jsonl')) {
+      results.push(full);
+    }
+  }
+  return results;
+}
+
+/**
+ * Start watching all configured paths.
+ * Returns a cleanup function.
+ */
+function startWatching() {
+  const watchPaths = getWatchPaths();
+
+  if (watchPaths.length === 0) {
+    logError('No Claude transcript directories found. Is Claude Code installed?');
+    process.exit(1);
+  }
+
+  log('AIMeter Watcher starting...');
+  log('Watching:', watchPaths.join(', '));
+
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    log('WARNING: No API key found. Usage will not be reported.');
+    log('Run: aimeter setup');
+  } else {
+    log('API key:', apiKey.slice(0, 8) + '...' + apiKey.slice(-4));
+  }
+
+  // Initial scan: mark existing files as "already read" so we only report
+  // NEW usage going forward. Without this, first run floods the backend.
+  const { load: loadState } = require('./state');
+  const state = loadState();
+  const isFirstRun = Object.keys(state.fileOffsets || {}).length === 0;
+
+  let filesMarked = 0;
+  for (const watchPath of watchPaths) {
+    const files = findJsonlFiles(watchPath);
+    for (const file of files) {
+      if (isFirstRun) {
+        // First run: skip to end of all files
+        try {
+          const size = fs.statSync(file).size;
+          setOffset(file, size);
+          filesMarked++;
+        } catch {}
+      } else {
+        // Subsequent runs: process new data since last offset
+        const events = extractNewUsage(file);
+        if (events.length > 0) {
+          reportEvents(events);
+          filesMarked += events.length;
+        }
+      }
+    }
+  }
+  if (isFirstRun) {
+    log(`First run: marked ${filesMarked} existing files as read. Only new usage will be reported.`);
+  } else if (filesMarked > 0) {
+    log(`Catch-up: processed ${filesMarked} new events since last run`);
+  }
+  saveState();
+
+  // Set up fs.watch on each path
+  const watchers = [];
+  for (const watchPath of watchPaths) {
+    try {
+      const w = fs.watch(watchPath, { recursive: true }, (eventType, filename) => {
+        if (!filename) return;
+        const fullPath = path.join(watchPath, filename);
+        handleFileChange(fullPath);
+      });
+
+      w.on('error', (err) => {
+        logError(`Watcher error on ${watchPath}:`, err.message);
+      });
+
+      watchers.push(w);
+      log('Watching:', watchPath);
+    } catch (err) {
+      logError(`Could not watch ${watchPath}:`, err.message);
+    }
+  }
+
+  // Periodic state save
+  const saveInterval = setInterval(() => saveState(), 30_000);
+
+  // Return cleanup
+  return () => {
+    clearInterval(saveInterval);
+    for (const w of watchers) w.close();
+    for (const t of _debounceTimers.values()) clearTimeout(t);
+    saveState();
+    log('Watcher stopped.');
+  };
+}
+
+module.exports = { startWatching };