tokburn 0.1.0

package/proxy.js

@@ -0,0 +1,304 @@
+const http = require('http');
+const https = require('https');
+const { URL } = require('url');
+const { logUsage } = require('./tracker');
+const { getConfig } = require('./config');
+const path = require('path');
+const fs = require('fs');
+const { spawn } = require('child_process');
+
+function extractUsageFromSSE(buffer) {
+  // Parse buffered SSE data to extract usage information
+  const text = buffer.toString('utf8');
+  const lines = text.split('\n');
+  let model = null;
+  let inputTokens = 0;
+  let outputTokens = 0;
+
+  for (const line of lines) {
+    if (!line.startsWith('data: ')) continue;
+    const jsonStr = line.slice(6).trim();
+    if (jsonStr === '[DONE]') continue;
+
+    try {
+      const data = JSON.parse(jsonStr);
+
+      // message_start contains model and initial usage
+      if (data.type === 'message_start' && data.message) {
+        model = data.message.model || model;
+        if (data.message.usage) {
+          inputTokens = data.message.usage.input_tokens || 0;
+        }
+      }
+
+      // message_delta contains final usage
+      if (data.type === 'message_delta' && data.usage) {
+        outputTokens = data.usage.output_tokens || 0;
+      }
+
+      // Also check for content_block_delta model info
+      if (data.model) {
+        model = data.model;
+      }
+    } catch {
+      // Skip unparseable lines
+    }
+  }
+
+  return { model, input_tokens: inputTokens, output_tokens: outputTokens };
+}
+
+function extractUsageFromJSON(buffer) {
+  try {
+    const data = JSON.parse(buffer.toString('utf8'));
+    const model = data.model || null;
+    let inputTokens = 0;
+    let outputTokens = 0;
+
+    if (data.usage) {
+      inputTokens = data.usage.input_tokens || 0;
+      outputTokens = data.usage.output_tokens || 0;
+    }
+
+    return { model, input_tokens: inputTokens, output_tokens: outputTokens };
+  } catch {
+    return null;
+  }
+}
+
+function extractConversationId(reqHeaders, reqBody) {
+  // Try to extract conversation/session ID from request metadata
+  try {
+    if (reqHeaders['x-conversation-id']) return reqHeaders['x-conversation-id'];
+    if (reqHeaders['x-session-id']) return reqHeaders['x-session-id'];
+    if (reqBody) {
+      const body = JSON.parse(reqBody.toString('utf8'));
+      if (body.metadata && body.metadata.conversation_id) return body.metadata.conversation_id;
+      if (body.metadata && body.metadata.session_id) return body.metadata.session_id;
+    }
+  } catch {
+    // Ignore
+  }
+  return null;
+}
+
+function createProxy(config) {
+  const targetUrl = new URL(config.target || 'https://api.anthropic.com');
+  const port = config.port || 4088;
+
+  const server = http.createServer((clientReq, clientRes) => {
+    const startTime = Date.now();
+
+    // Collect request body
+    const reqChunks = [];
+    clientReq.on('data', (chunk) => reqChunks.push(chunk));
+    clientReq.on('end', () => {
+      const reqBody = Buffer.concat(reqChunks);
+      const conversationId = extractConversationId(clientReq.headers, reqBody);
+
+      // Build upstream request options
+      const isHTTPS = targetUrl.protocol === 'https:';
+      const mod = isHTTPS ? https : http;
+
+      const upstreamHeaders = { ...clientReq.headers };
+      // Update host header for upstream
+      upstreamHeaders.host = targetUrl.host;
+      // Remove hop-by-hop headers that shouldn't be forwarded
+      delete upstreamHeaders['connection'];
+      delete upstreamHeaders['keep-alive'];
+      delete upstreamHeaders['transfer-encoding'];
+
+      const options = {
+        hostname: targetUrl.hostname,
+        port: targetUrl.port || (isHTTPS ? 443 : 80),
+        path: clientReq.url,
+        method: clientReq.method,
+        headers: upstreamHeaders,
+      };
+
+      const upstreamReq = mod.request(options, (upstreamRes) => {
+        const contentType = upstreamRes.headers['content-type'] || '';
+        const isStreaming = contentType.includes('text/event-stream');
+
+        // Forward status and headers to client immediately
+        const responseHeaders = { ...upstreamRes.headers };
+        // Remove transfer-encoding to avoid conflicts
+        delete responseHeaders['transfer-encoding'];
+        clientRes.writeHead(upstreamRes.statusCode, responseHeaders);
+
+        // Buffer for async usage extraction
+        const resChunks = [];
+
+        upstreamRes.on('data', (chunk) => {
+          // Forward to client immediately
+          clientRes.write(chunk);
+          // Buffer copy for usage extraction
+          resChunks.push(Buffer.from(chunk));
+        });
+
+        upstreamRes.on('end', () => {
+          clientRes.end();
+          const latency = Date.now() - startTime;
+
+          // Async: extract usage and log (never block the response)
+          setImmediate(() => {
+            try {
+              const fullBuffer = Buffer.concat(resChunks);
+              let usage = null;
+
+              if (isStreaming) {
+                usage = extractUsageFromSSE(fullBuffer);
+              } else if (contentType.includes('application/json')) {
+                usage = extractUsageFromJSON(fullBuffer);
+              }
+
+              if (usage && (usage.input_tokens > 0 || usage.output_tokens > 0)) {
+                logUsage({
+                  model: usage.model,
+                  input_tokens: usage.input_tokens,
+                  output_tokens: usage.output_tokens,
+                  conversation_id: conversationId,
+                  latency_ms: latency,
+                });
+              }
+            } catch {
+              // Swallow all errors - never break the proxy
+            }
+          });
+        });
+
+        upstreamRes.on('error', () => {
+          try { clientRes.end(); } catch {}
+        });
+      });
+
+      upstreamReq.on('error', (err) => {
+        try {
+          clientRes.writeHead(502, { 'Content-Type': 'application/json' });
+          clientRes.end(JSON.stringify({ error: 'Proxy upstream error', message: err.message }));
+        } catch {
+          // Swallow
+        }
+      });
+
+      // Send request body to upstream
+      if (reqBody.length > 0) {
+        upstreamReq.write(reqBody);
+      }
+      upstreamReq.end();
+    });
+
+    clientReq.on('error', () => {
+      try { clientRes.end(); } catch {}
+    });
+  });
+
+  return { server, port };
+}
+
+function startServer() {
+  const config = getConfig();
+  const { server, port } = createProxy(config);
+
+  server.listen(port, '127.0.0.1', () => {
+    console.log(`tokburn proxy listening on http://127.0.0.1:${port}`);
+    console.log(`Forwarding to ${config.target || 'https://api.anthropic.com'}`);
+    console.log('Set ANTHROPIC_BASE_URL=http://127.0.0.1:' + port);
+  });
+
+  server.on('error', (err) => {
+    if (err.code === 'EADDRINUSE') {
+      console.error(`Error: Port ${port} is already in use. Is tokburn already running?`);
+      process.exit(1);
+    }
+    console.error('Proxy server error:', err.message);
+    process.exit(1);
+  });
+
+  return server;
+}
+
+// Daemon management
+const TOKBURN_DIR = path.join(process.env.HOME || process.env.USERPROFILE, '.tokburn');
+const PID_FILE = path.join(TOKBURN_DIR, 'tokburn.pid');
+
+function startDaemon() {
+  if (!fs.existsSync(TOKBURN_DIR)) {
+    fs.mkdirSync(TOKBURN_DIR, { recursive: true });
+  }
+
+  // Check if already running
+  if (isRunning()) {
+    const pid = fs.readFileSync(PID_FILE, 'utf8').trim();
+    return { success: false, message: `tokburn is already running (PID ${pid})` };
+  }
+
+  const logFile = path.join(TOKBURN_DIR, 'proxy.log');
+  const out = fs.openSync(logFile, 'a');
+  const err = fs.openSync(logFile, 'a');
+
+  const child = spawn(process.execPath, [__filename, '--serve'], {
+    detached: true,
+    stdio: ['ignore', out, err],
+    env: { ...process.env },
+  });
+
+  child.unref();
+
+  fs.writeFileSync(PID_FILE, String(child.pid) + '\n', 'utf8');
+
+  return { success: true, pid: child.pid, message: `tokburn proxy started (PID ${child.pid})` };
+}
+
+function stopDaemon() {
+  if (!fs.existsSync(PID_FILE)) {
+    return { success: false, message: 'tokburn is not running (no PID file)' };
+  }
+
+  const pid = parseInt(fs.readFileSync(PID_FILE, 'utf8').trim(), 10);
+  if (isNaN(pid)) {
+    fs.unlinkSync(PID_FILE);
+    return { success: false, message: 'Invalid PID file, cleaned up' };
+  }
+
+  try {
+    process.kill(pid, 'SIGTERM');
+    // Give it a moment, then clean up PID file
+    try { fs.unlinkSync(PID_FILE); } catch {}
+    return { success: true, message: `tokburn proxy stopped (PID ${pid})` };
+  } catch (e) {
+    if (e.code === 'ESRCH') {
+      try { fs.unlinkSync(PID_FILE); } catch {}
+      return { success: false, message: 'Process was not running, cleaned up stale PID file' };
+    }
+    return { success: false, message: `Failed to stop process: ${e.message}` };
+  }
+}
+
+function isRunning() {
+  if (!fs.existsSync(PID_FILE)) return false;
+
+  const pid = parseInt(fs.readFileSync(PID_FILE, 'utf8').trim(), 10);
+  if (isNaN(pid)) return false;
+
+  try {
+    process.kill(pid, 0); // Signal 0 = check if process exists
+    return true;
+  } catch {
+    // Process doesn't exist, clean up stale PID file
+    try { fs.unlinkSync(PID_FILE); } catch {}
+    return false;
+  }
+}
+
+// When run directly, start the server
+if (require.main === module) {
+  if (process.argv.includes('--serve')) {
+    startServer();
+  } else {
+    // If run directly without --serve, also start
+    startServer();
+  }
+}
+
+module.exports = { createProxy, startServer, startDaemon, stopDaemon, isRunning };

package/statusline.js

@@ -0,0 +1,205 @@
+#!/usr/bin/env node
+/**
+ * tokburn — Status line renderer for Claude Code
+ * Reads session JSON from stdin, renders configured modules.
+ * Configured via ~/.tokburn/config.json → statusline_modules
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+// Read stdin synchronously
+let input = '';
+try {
+  input = fs.readFileSync('/dev/stdin', 'utf8');
+} catch (_) {}
+
+let data = {};
+try {
+  data = JSON.parse(input);
+} catch (_) {}
+
+// Load config
+const configPath = path.join(process.env.HOME || process.env.USERPROFILE, '.tokburn', 'config.json');
+let config = {};
+try {
+  if (fs.existsSync(configPath)) {
+    config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  }
+} catch (_) {}
+
+const enabledModules = config.statusline_modules || [
+  'model_context', 'repo_branch', 'current_limit', 'weekly_limit', 'cost'
+];
+
+// ── Module renderers ────────────────────────────────────────────────────────────
+
+function dotBar(pct, count) {
+  count = count || 10;
+  const p = Math.max(0, Math.min(100, pct || 0));
+  const filled = Math.round((p / 100) * count);
+  return '\u25CF'.repeat(filled) + '\u25CB'.repeat(count - filled);
+}
+
+function abbreviate(n) {
+  n = n || 0;
+  if (n >= 1000000) return (n / 1000000).toFixed(1) + 'M';
+  if (n >= 1000) return (n / 1000).toFixed(1) + 'K';
+  return String(n);
+}
+
+function formatResetTime(resetTimestamp) {
+  if (!resetTimestamp) return '';
+  const reset = new Date(resetTimestamp * 1000);
+  const now = new Date();
+  const diff = reset - now;
+
+  if (diff <= 0) return 'now';
+
+  const mins = Math.floor(diff / 60000);
+  if (mins < 60) return mins + 'min';
+
+  const hrs = Math.floor(mins / 60);
+  const remainMins = mins % 60;
+  if (hrs < 24) return hrs + 'hr ' + (remainMins > 0 ? remainMins + 'min' : '');
+
+  // Show day + time for >24hr
+  const days = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+  const day = days[reset.getDay()];
+  const h = reset.getHours();
+  const m = reset.getMinutes();
+  const ampm = h >= 12 ? 'PM' : 'AM';
+  const h12 = h % 12 || 12;
+  return day + ' ' + h12 + ':' + String(m).padStart(2, '0') + ampm;
+}
+
+const MODULES = {
+  model_context: function () {
+    const model = (data.model && data.model.display_name) || '?';
+    const ctxPct = Math.round((data.context_window && data.context_window.used_percentage) || 0);
+    return model + ' | ctx ' + ctxPct + '%';
+  },
+
+  repo_branch: function () {
+    const cwd = (data.workspace && data.workspace.current_dir) || data.cwd || '';
+    const repoName = path.basename(cwd);
+    let branch = '';
+    try {
+      branch = execFileSync('git', ['-C', cwd, 'branch', '--show-current'], {
+        encoding: 'utf8', timeout: 500, stdio: ['pipe', 'pipe', 'pipe'],
+      }).trim();
+      const status = execFileSync('git', ['-C', cwd, 'status', '--porcelain'], {
+        encoding: 'utf8', timeout: 500, stdio: ['pipe', 'pipe', 'pipe'],
+      }).trim();
+      if (status) branch += '*';
+    } catch (_) {}
+
+    if (branch) return repoName + ' (' + branch + ')';
+    return repoName;
+  },
+
+  current_limit: function () {
+    const rl = data.rate_limits && data.rate_limits.five_hour;
+    if (!rl) return 'current  ' + dotBar(0) + '  0%';
+
+    const pct = Math.round(rl.used_percentage || 0);
+    const reset = formatResetTime(rl.resets_at);
+    return 'current  ' + dotBar(pct) + '  ' + pct + '%' + (reset ? ' \u21BB ' + reset : '');
+  },
+
+  weekly_limit: function () {
+    const rl = data.rate_limits && data.rate_limits.seven_day;
+    if (!rl) return 'weekly   ' + dotBar(0) + '  0%';
+
+    const pct = Math.round(rl.used_percentage || 0);
+    const reset = formatResetTime(rl.resets_at);
+    return 'weekly   ' + dotBar(pct) + '  ' + pct + '%' + (reset ? ' \u21BB ' + reset : '');
+  },
+
+  token_count: function () {
+    const input = (data.context_window && data.context_window.total_input_tokens) || 0;
+    const output = (data.context_window && data.context_window.total_output_tokens) || 0;
+    return abbreviate(input + output) + ' tok';
+  },
+
+  cost: function () {
+    const cost = (data.cost && data.cost.total_cost_usd) || 0;
+    return '$' + cost.toFixed(2);
+  },
+
+  burn_rate: function () {
+    try {
+      const usagePath = path.join(process.env.HOME || '', '.tokburn', 'usage.jsonl');
+      if (!fs.existsSync(usagePath)) return '';
+      const raw = fs.readFileSync(usagePath, 'utf8').trim();
+      if (!raw) return '';
+      const lines = raw.split('\n');
+      const today = new Date().toISOString().split('T')[0];
+      const todayEntries = [];
+      for (const l of lines) {
+        if (!l.startsWith('{"timestamp":"' + today)) continue;
+        try { todayEntries.push(JSON.parse(l)); } catch (_) {}
+      }
+      if (todayEntries.length < 2) return '';
+      const first = new Date(todayEntries[0].timestamp);
+      const last = new Date(todayEntries[todayEntries.length - 1].timestamp);
+      const elapsed = (last - first) / 60000;
+      if (elapsed <= 0) return '';
+      let total = 0;
+      for (const e of todayEntries) total += (e.input_tokens || 0) + (e.output_tokens || 0);
+      return '~' + abbreviate(Math.round(total / elapsed)) + '/min';
+    } catch (_) {
+      return '';
+    }
+  },
+};
+
+// ── Available modules metadata (used by init wizard) ────────────────────────────
+
+const MODULE_LIST = [
+  { key: 'model_context',  label: 'Model + context',    example: 'Opus 4.6 | ctx 13%' },
+  { key: 'repo_branch',    label: 'Repo + branch',      example: 'tokburn (master*)' },
+  { key: 'current_limit',  label: 'Current rate limit',  example: '\u25CB\u25CB\u25CB\u25CB\u25CB\u25CB\u25CB\u25CB\u25CB\u25CB 9% 3hr 32min' },
+  { key: 'weekly_limit',   label: 'Weekly rate limit',   example: '\u25CF\u25CF\u25CF\u25CF\u25CB\u25CB\u25CB\u25CB\u25CB\u25CB 45% Fri 12:30PM' },
+  { key: 'token_count',    label: 'Token count',         example: '142.8K tok' },
+  { key: 'cost',           label: 'Cost estimate',       example: '$1.95' },
+  { key: 'burn_rate',      label: 'Burn rate (proxy)',   example: '~2.1K/min' },
+];
+
+// ── Presets ──────────────────────────────────────────────────────────────────────
+
+const PRESETS = {
+  recommended: ['model_context', 'repo_branch', 'current_limit', 'weekly_limit', 'cost'],
+  minimal:     ['model_context', 'current_limit'],
+  full:        ['model_context', 'repo_branch', 'current_limit', 'weekly_limit', 'token_count', 'cost', 'burn_rate'],
+};
+
+// ── Render ───────────────────────────────────────────────────────────────────────
+
+if (require.main === module) {
+  const outputLines = [];
+  const lineOneModules = [];
+  const extraLines = [];
+
+  for (const mod of enabledModules) {
+    if (!MODULES[mod]) continue;
+    const val = MODULES[mod]();
+    if (!val) continue;
+
+    if (mod === 'current_limit' || mod === 'weekly_limit') {
+      extraLines.push(val);
+    } else {
+      lineOneModules.push(val);
+    }
+  }
+
+  if (lineOneModules.length > 0) {
+    outputLines.push(lineOneModules.join(' \u2502 '));
+  }
+  outputLines.push(...extraLines);
+
+  process.stdout.write(outputLines.join('\n'));
+}
+
+module.exports = { MODULE_LIST, PRESETS, MODULES };

package/statusline.sh

@@ -0,0 +1,48 @@
+#!/bin/bash
+# tokburn — Claude Code status line script
+# Receives session JSON on stdin, outputs a compact usage summary.
+# Install: tokburn init (or manually set statusLine in ~/.claude/settings.json)
+
+input=$(cat)
+
+model=$(echo "$input" | jq -r '.model.display_name // "?"')
+five_hr_pct=$(echo "$input" | jq -r '.rate_limits.five_hour.used_percentage // 0' | cut -d. -f1)
+cost=$(echo "$input" | jq -r '.cost.total_cost_usd // 0')
+input_tok=$(echo "$input" | jq -r '.context_window.total_input_tokens // 0')
+output_tok=$(echo "$input" | jq -r '.context_window.total_output_tokens // 0')
+
+total_tok=$((input_tok + output_tok))
+
+# Abbreviate token count
+if [ "$total_tok" -ge 1000000 ]; then
+  tok_fmt="$(echo "scale=1; $total_tok / 1000000" | bc)M"
+elif [ "$total_tok" -ge 1000 ]; then
+  tok_fmt="$(echo "scale=1; $total_tok / 1000" | bc)K"
+else
+  tok_fmt="$total_tok"
+fi
+
+cost_fmt=$(printf '$%.2f' "$cost")
+
+# State indicator
+if [ "$five_hr_pct" -ge 90 ]; then
+  state="!! ${tok_fmt} tok  ${five_hr_pct}% of 5hr  ${cost_fmt}"
+elif [ "$five_hr_pct" -ge 50 ]; then
+  state=">> ${tok_fmt} tok  ${five_hr_pct}% of 5hr  ${cost_fmt}"
+else
+  state=":: ${tok_fmt} tok  ${five_hr_pct}% of 5hr  ${cost_fmt}"
+fi
+
+# Append burn rate from proxy if running
+pid_file="$HOME/.tokburn/tokburn.pid"
+if [ -f "$pid_file" ]; then
+  pid=$(cat "$pid_file" 2>/dev/null)
+  if kill -0 "$pid" 2>/dev/null; then
+    rate=$(tokburn _burn-rate 2>/dev/null)
+    if [ -n "$rate" ] && [ "$rate" != "0" ]; then
+      state="${state}  ~${rate}/min"
+    fi
+  fi
+fi
+
+echo "$state"

package/store.js

@@ -0,0 +1,121 @@
+const fs = require('fs');
+const path = require('path');
+const { getTokburnDir } = require('./config');
+
+const USAGE_FILE = path.join(getTokburnDir(), 'usage.jsonl');
+
+function getAllEntries() {
+  try {
+    if (!fs.existsSync(USAGE_FILE)) return [];
+    const raw = fs.readFileSync(USAGE_FILE, 'utf8').trim();
+    if (!raw) return [];
+    return raw.split('\n').map(line => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    }).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+function dateStr(d) {
+  return d.toISOString().split('T')[0];
+}
+
+function todayStr() {
+  return dateStr(new Date());
+}
+
+function getToday() {
+  const today = todayStr();
+  return getAllEntries().filter(e => {
+    try {
+      return e.timestamp && e.timestamp.startsWith(today);
+    } catch {
+      return false;
+    }
+  });
+}
+
+function getRange(startDate, endDate) {
+  const start = typeof startDate === 'string' ? startDate : dateStr(startDate);
+  const end = typeof endDate === 'string' ? endDate : dateStr(endDate);
+  return getAllEntries().filter(e => {
+    try {
+      const d = e.timestamp.split('T')[0];
+      return d >= start && d <= end;
+    } catch {
+      return false;
+    }
+  });
+}
+
+function getWeek() {
+  const now = new Date();
+  const sevenDaysAgo = new Date(now);
+  sevenDaysAgo.setDate(sevenDaysAgo.getDate() - 6);
+  return getRange(sevenDaysAgo, now);
+}
+
+function clearToday() {
+  try {
+    const today = todayStr();
+    const entries = getAllEntries().filter(e => {
+      try {
+        return !e.timestamp.startsWith(today);
+      } catch {
+        return true;
+      }
+    });
+    const dir = getTokburnDir();
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    if (entries.length === 0) {
+      fs.writeFileSync(USAGE_FILE, '', 'utf8');
+    } else {
+      fs.writeFileSync(USAGE_FILE, entries.map(e => JSON.stringify(e)).join('\n') + '\n', 'utf8');
+    }
+  } catch {
+    // Fail silently
+  }
+}
+
+function exportCSV() {
+  const entries = getAllEntries();
+  const header = 'timestamp,model,input_tokens,output_tokens,conversation_id,latency_ms';
+  const rows = entries.map(e => {
+    return [
+      e.timestamp || '',
+      e.model || '',
+      e.input_tokens || 0,
+      e.output_tokens || 0,
+      e.conversation_id || '',
+      e.latency_ms || '',
+    ].join(',');
+  });
+  return [header, ...rows].join('\n') + '\n';
+}
+
+function getWeekByDay() {
+  const entries = getWeek();
+  const byDay = {};
+  // Initialize all 7 days
+  for (let i = 6; i >= 0; i--) {
+    const d = new Date();
+    d.setDate(d.getDate() - i);
+    byDay[dateStr(d)] = [];
+  }
+  for (const e of entries) {
+    const d = e.timestamp.split('T')[0];
+    if (byDay[d]) {
+      byDay[d].push(e);
+    }
+  }
+  return byDay;
+}
+
+module.exports = { getAllEntries, getToday, getRange, getWeek, clearToday, exportCSV, getWeekByDay };