tokentracker-cli 0.2.27 → 0.3.3

package/src/lib/cursor-config.js

@@ -0,0 +1,328 @@
+const os = require("node:os");
+const path = require("node:path");
+const fs = require("node:fs");
+const cp = require("node:child_process");
+const https = require("node:https");
+
+const { readJson } = require("./fs");
+
+// ── Path resolution ──
+
+function resolveCursorPaths({ home } = {}) {
+  const h = home || os.homedir();
+  const appSupport = path.join(h, "Library", "Application Support", "Cursor");
+  return {
+    appDir: appSupport,
+    stateDbPath: path.join(appSupport, "User", "globalStorage", "state.vscdb"),
+    cliConfigPath: path.join(h, ".cursor", "cli-config.json"),
+  };
+}
+
+function isCursorInstalled({ home } = {}) {
+  const { appDir } = resolveCursorPaths({ home });
+  try {
+    return fs.statSync(appDir).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+// ── Auth token extraction ──
+
+/**
+ * Extract Cursor session cookie from local SQLite + cli-config.json.
+ * Returns { cookie, userId } or null on failure.
+ *
+ * Cookie format: WorkosCursorSessionToken=user_XXXXX%3A%3A<jwt>
+ * - JWT from state.vscdb → ItemTable → cursorAuth/accessToken
+ * - userId from cli-config.json → authInfo.authId → "auth0|user_XXXXX"
+ */
+function extractCursorSessionToken({ home } = {}) {
+  const { stateDbPath, cliConfigPath } = resolveCursorPaths({ home });
+
+  // 1. Extract JWT from SQLite
+  let jwt;
+  try {
+    jwt = cp
+      .execSync(
+        `sqlite3 -readonly "${stateDbPath}" "SELECT value FROM ItemTable WHERE key = 'cursorAuth/accessToken';"`,
+        { encoding: "utf8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"] },
+      )
+      .trim();
+  } catch {
+    return null;
+  }
+  if (!jwt || jwt.length < 10) return null;
+
+  // 2. Extract userId — try cli-config.json first, fall back to JWT decode
+  let userId = extractUserIdFromCliConfig(cliConfigPath);
+  if (!userId) {
+    userId = extractUserIdFromJwt(jwt);
+  }
+  if (!userId) return null;
+
+  // 3. Build cookie
+  const cookie = `WorkosCursorSessionToken=${userId}%3A%3A${jwt}`;
+  return { cookie, userId };
+}
+
+function extractUserIdFromCliConfig(configPath) {
+  try {
+    const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+    const authId = config?.authInfo?.authId || "";
+    const match = authId.match(/\|(user_[A-Za-z0-9_]+)/);
+    return match ? match[1] : null;
+  } catch {
+    return null;
+  }
+}
+
+function extractUserIdFromJwt(jwt) {
+  try {
+    const parts = jwt.split(".");
+    if (parts.length !== 3) return null;
+    const payload = JSON.parse(Buffer.from(parts[1], "base64url").toString());
+    const sub = payload.sub || "";
+    const match = sub.match(/(user_[A-Za-z0-9_]+)/);
+    return match ? match[1] : null;
+  } catch {
+    return null;
+  }
+}
+
+// ── API client ──
+
+const CURSOR_CSV_URL = "https://cursor.com/api/dashboard/export-usage-events-csv?strategy=tokens";
+const CURSOR_SUMMARY_URL = "https://cursor.com/api/usage-summary";
+
+/**
+ * Fetch full usage CSV from Cursor API.
+ * Returns raw CSV string or throws on error.
+ */
+function fetchCursorUsageCsv({ cookie, timeoutMs = 30000 }) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(CURSOR_CSV_URL);
+    const req = https.request(
+      {
+        hostname: url.hostname,
+        path: url.pathname + url.search,
+        method: "GET",
+        headers: {
+          Accept: "*/*",
+          Cookie: cookie,
+          Referer: "https://www.cursor.com/settings",
+          "User-Agent":
+            "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+        },
+        timeout: timeoutMs,
+      },
+      (res) => {
+        if (res.statusCode === 401 || res.statusCode === 403) {
+          res.resume();
+          return reject(new Error("Cursor session expired — re-login in Cursor to refresh"));
+        }
+        if (res.statusCode === 308 || res.statusCode === 301 || res.statusCode === 302) {
+          // Follow redirect once
+          const location = res.headers.location;
+          res.resume();
+          if (!location) return reject(new Error(`Cursor API redirect without Location header`));
+          return fetchUrlRaw({ urlStr: location, cookie, timeoutMs }).then(resolve, reject);
+        }
+        if (res.statusCode !== 200) {
+          res.resume();
+          return reject(new Error(`Cursor API returned ${res.statusCode}`));
+        }
+        let data = "";
+        res.on("data", (chunk) => {
+          data += chunk;
+        });
+        res.on("end", () => resolve(data));
+        res.on("error", reject);
+      },
+    );
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("Cursor API request timed out"));
+    });
+    req.end();
+  });
+}
+
+function fetchUrlRaw({ urlStr, cookie, timeoutMs }) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(urlStr);
+    const req = https.request(
+      {
+        hostname: url.hostname,
+        path: url.pathname + url.search,
+        method: "GET",
+        headers: {
+          Accept: "*/*",
+          Cookie: cookie,
+          Referer: "https://www.cursor.com/settings",
+          "User-Agent":
+            "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+        },
+        timeout: timeoutMs,
+      },
+      (res) => {
+        if (res.statusCode !== 200) {
+          res.resume();
+          return reject(new Error(`Cursor API returned ${res.statusCode} from ${urlStr}`));
+        }
+        let data = "";
+        res.on("data", (chunk) => {
+          data += chunk;
+        });
+        res.on("end", () => resolve(data));
+        res.on("error", reject);
+      },
+    );
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("Cursor API request timed out"));
+    });
+    req.end();
+  });
+}
+
+// ── CSV parsing ──
+
+/**
+ * Parse Cursor usage CSV into structured records.
+ *
+ * New format columns:
+ *   Date, Kind, Model, Max Mode, Input (w/ Cache Write), Input (w/o Cache Write),
+ *   Cache Read, Output Tokens, Total Tokens, Cost
+ *
+ * Old format columns:
+ *   Date, Model, Input (w/ Cache Write), Input (w/o Cache Write),
+ *   Cache Read, Output Tokens, Total Tokens, Cost, Cost to you
+ */
+function parseCursorCsv(csvText) {
+  const lines = csvText.split("\n").filter((l) => l.trim().length > 0);
+  if (lines.length < 2) return [];
+
+  const header = lines[0];
+  const isNewFormat = header.includes("Kind");
+
+  const records = [];
+  for (let i = 1; i < lines.length; i++) {
+    const fields = parseCsvLine(lines[i]);
+    if (!fields || fields.length < 8) continue;
+
+    let record;
+    if (isNewFormat) {
+      // Date,Kind,Model,Max Mode,Input (w/ Cache Write),Input (w/o Cache Write),Cache Read,Output Tokens,Total Tokens,Cost
+      const inputWithCache = toNum(fields[4]);
+      const inputWithoutCache = toNum(fields[5]);
+      record = {
+        date: stripQuotes(fields[0]),
+        kind: stripQuotes(fields[1]),
+        model: stripQuotes(fields[2]),
+        maxMode: stripQuotes(fields[3]),
+        inputTokens: inputWithoutCache,
+        cacheWriteTokens: Math.max(0, inputWithCache - inputWithoutCache),
+        cacheReadTokens: toNum(fields[6]),
+        outputTokens: toNum(fields[7]),
+        totalTokens: toNum(fields[8]),
+        cost: toFloat(fields[9]),
+      };
+    } else {
+      // Date,Model,Input (w/ Cache Write),Input (w/o Cache Write),Cache Read,Output Tokens,Total Tokens,Cost,Cost to you
+      const inputWithCache = toNum(fields[2]);
+      const inputWithoutCache = toNum(fields[3]);
+      record = {
+        date: stripQuotes(fields[0]),
+        kind: "unknown",
+        model: stripQuotes(fields[1]),
+        maxMode: "No",
+        inputTokens: inputWithoutCache,
+        cacheWriteTokens: Math.max(0, inputWithCache - inputWithoutCache),
+        cacheReadTokens: toNum(fields[4]),
+        outputTokens: toNum(fields[5]),
+        totalTokens: toNum(fields[6]),
+        cost: toFloat(fields[7]),
+      };
+    }
+
+    // Skip records with no tokens
+    if (record.totalTokens <= 0 && record.inputTokens <= 0 && record.outputTokens <= 0) continue;
+
+    records.push(record);
+  }
+
+  return records;
+}
+
+/**
+ * Normalize a Cursor CSV record to TokenTracker's standard token format.
+ */
+function normalizeCursorUsage(record) {
+  const inputTokens = Math.max(0, Math.floor(record.inputTokens || 0));
+  const cacheWrite = Math.max(0, Math.floor(record.cacheWriteTokens || 0));
+  const cacheRead = Math.max(0, Math.floor(record.cacheReadTokens || 0));
+  const outputTokens = Math.max(0, Math.floor(record.outputTokens || 0));
+  const totalTokens = inputTokens + outputTokens + cacheWrite + cacheRead;
+  return {
+    input_tokens: inputTokens,
+    cached_input_tokens: cacheRead,
+    cache_creation_input_tokens: cacheWrite,
+    output_tokens: outputTokens,
+    reasoning_output_tokens: 0,
+    total_tokens: totalTokens,
+  };
+}
+
+// ── CSV helpers ──
+
+function parseCsvLine(line) {
+  const fields = [];
+  let current = "";
+  let inQuotes = false;
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (ch === '"') {
+      inQuotes = !inQuotes;
+      current += ch;
+    } else if (ch === "," && !inQuotes) {
+      fields.push(current.trim());
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  fields.push(current.trim());
+  return fields;
+}
+
+function stripQuotes(s) {
+  if (!s) return "";
+  const trimmed = s.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+
+function toNum(s) {
+  const n = Number(stripQuotes(s));
+  return Number.isFinite(n) && n >= 0 ? Math.floor(n) : 0;
+}
+
+function toFloat(s) {
+  const cleaned = stripQuotes(s).replace(/[$,]/g, "");
+  const n = Number(cleaned);
+  return Number.isFinite(n) ? n : 0;
+}
+
+module.exports = {
+  resolveCursorPaths,
+  isCursorInstalled,
+  extractCursorSessionToken,
+  fetchCursorUsageCsv,
+  parseCursorCsv,
+  normalizeCursorUsage,
+};

package/src/lib/local-api.js

@@ -57,6 +57,111 @@ function aggregateByDay(rows) {
   return Array.from(byDay.values()).sort((a, b) => a.day.localeCompare(b.day));
 }
 
+function getTimeZoneContext(url) {
+  const tz = String(url.searchParams.get("tz") || "").trim();
+  const rawOffset = Number(url.searchParams.get("tz_offset_minutes"));
+  return {
+    timeZone: tz || null,
+    offsetMinutes: Number.isFinite(rawOffset) ? Math.trunc(rawOffset) : null,
+  };
+}
+
+function getZonedParts(date, { timeZone, offsetMinutes } = {}) {
+  const dt = date instanceof Date ? date : new Date(date);
+  if (!Number.isFinite(dt.getTime())) return null;
+
+  if (timeZone && typeof Intl !== "undefined" && Intl.DateTimeFormat) {
+    try {
+      const formatter = new Intl.DateTimeFormat("en-CA", {
+        timeZone,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+        hourCycle: "h23",
+      });
+      const parts = formatter.formatToParts(dt);
+      const values = parts.reduce((acc, part) => {
+        if (part.type && part.value) acc[part.type] = part.value;
+        return acc;
+      }, {});
+      const year = Number(values.year);
+      const month = Number(values.month);
+      const day = Number(values.day);
+      const hour = Number(values.hour);
+      const minute = Number(values.minute);
+      const second = Number(values.second);
+      if ([year, month, day, hour, minute, second].every(Number.isFinite)) {
+        return { year, month, day, hour, minute, second };
+      }
+    } catch (_e) {
+      // fall through
+    }
+  }
+
+  if (Number.isFinite(offsetMinutes)) {
+    const shifted = new Date(dt.getTime() + offsetMinutes * 60 * 1000);
+    return {
+      year: shifted.getUTCFullYear(),
+      month: shifted.getUTCMonth() + 1,
+      day: shifted.getUTCDate(),
+      hour: shifted.getUTCHours(),
+      minute: shifted.getUTCMinutes(),
+      second: shifted.getUTCSeconds(),
+    };
+  }
+
+  return {
+    year: dt.getFullYear(),
+    month: dt.getMonth() + 1,
+    day: dt.getDate(),
+    hour: dt.getHours(),
+    minute: dt.getMinutes(),
+    second: dt.getSeconds(),
+  };
+}
+
+function formatPartsDayKey(parts) {
+  if (!parts) return "";
+  return `${parts.year}-${String(parts.month).padStart(2, "0")}-${String(parts.day).padStart(2, "0")}`;
+}
+
+function aggregateHourlyByDay(rows, dayKey, timeZoneContext) {
+  const byHour = new Map();
+  for (const row of rows) {
+    if (!row.hour_start) continue;
+    const parts = getZonedParts(new Date(row.hour_start), timeZoneContext);
+    if (!parts) continue;
+    if (formatPartsDayKey(parts) !== dayKey) continue;
+    const hourKey = `${dayKey}T${String(parts.hour).padStart(2, "0")}:00:00`;
+    if (!byHour.has(hourKey)) {
+      byHour.set(hourKey, {
+        hour: hourKey,
+        total_tokens: 0,
+        billable_total_tokens: 0,
+        input_tokens: 0,
+        output_tokens: 0,
+        cached_input_tokens: 0,
+        cache_creation_input_tokens: 0,
+        reasoning_output_tokens: 0,
+        conversation_count: 0,
+      });
+    }
+    const bucket = byHour.get(hourKey);
+    bucket.total_tokens += row.total_tokens || 0;
+    bucket.billable_total_tokens += row.total_tokens || 0;
+    bucket.input_tokens += row.input_tokens || 0;
+    bucket.output_tokens += row.output_tokens || 0;
+    bucket.cached_input_tokens += row.cached_input_tokens || 0;
+    bucket.cache_creation_input_tokens += row.cache_creation_input_tokens || 0;
+    bucket.reasoning_output_tokens += row.reasoning_output_tokens || 0;
+    bucket.conversation_count += row.conversation_count || 0;
+  }
+  return Array.from(byHour.values()).sort((a, b) => a.hour.localeCompare(b.hour));
+}
+
 // ---------------------------------------------------------------------------
 // Sync helper
 // ---------------------------------------------------------------------------
@@ -461,18 +566,9 @@ function createLocalApiHandler({ queuePath }) {
     // --- usage-hourly (stub for day-view) ---
     if (p === "/functions/vibeusage-usage-hourly") {
       const day = url.searchParams.get("day") || new Date().toISOString().slice(0, 10);
-      const rows = readQueueData(qp).filter((r) => r.hour_start && r.hour_start.startsWith(day));
-      const data = rows.map((r) => ({
-        hour: r.hour_start,
-        total_tokens: r.total_tokens || 0,
-        billable_total_tokens: r.total_tokens || 0,
-        input_tokens: r.input_tokens || 0,
-        output_tokens: r.output_tokens || 0,
-        cached_input_tokens: r.cached_input_tokens || 0,
-        cache_creation_input_tokens: r.cache_creation_input_tokens || 0,
-        reasoning_output_tokens: r.reasoning_output_tokens || 0,
-        conversation_count: r.conversation_count || 0,
-      }));
+      const timeZoneContext = getTimeZoneContext(url);
+      const rows = readQueueData(qp);
+      const data = aggregateHourlyByDay(rows, day, timeZoneContext);
       json(res, { day, data });
       return true;
     }