@juliantanx/aiusage 1.3.0 → 1.3.1

package/dist/index.js

@@ -2,18 +2,17 @@
 
 // src/cli.ts
 import { Command } from "commander";
-import { writeFileSync as writeFileSync4 } from "fs";
+import { writeFileSync as writeFileSync5 } from "fs";
 
 // src/commands/serve.ts
 import http2 from "http";
-import { readFileSync as readFileSync5, existsSync as existsSync5, statSync as statSync2 } from "fs";
-import { join as join6, extname as extname2, dirname } from "path";
+import { readFileSync as readFileSync6, existsSync as existsSync6, statSync as statSync2, writeFileSync as writeFileSync4, unlinkSync } from "fs";
+import { join as join7, extname as extname2, dirname } from "path";
 import { fileURLToPath } from "url";
 
 // src/api/server.ts
 import http from "http";
-import path2 from "path";
-import { hostname as hostname2, platform as platform2 } from "os";
+import { hostname as hostname2, platform as platform3 } from "os";
 
 // ../core/dist/index.js
 import { createHash } from "crypto";
@@ -339,16 +338,24 @@ var ClaudeCodeParser = class {
       let callIndex = 0;
       for (const block of parsed.message.content) {
         if (block.type === "tool_use") {
-          const rawName = block.name ?? "";
-          const cleanName = rawName.replace(/[=:"'{\[\s].*$/s, "").replace(/[^a-zA-Z0-9_-]/g, "");
-          if (!cleanName) {
-            callIndex++;
-            continue;
+          let storedName;
+          if (block.name === "Skill") {
+            const raw = block.input?.skill ?? block.input?.skillName ?? block.input?.name ?? "";
+            const skillArg = typeof raw === "string" ? raw.trim() : "";
+            storedName = skillArg ? `skill__${skillArg}` : "skill__unknown";
+          } else {
+            const rawName = block.name ?? "";
+            const cleanName = rawName.replace(/[=:"'{\[\s].*$/s, "").replace(/[^a-zA-Z0-9_-]/g, "");
+            if (!cleanName) {
+              callIndex++;
+              continue;
+            }
+            storedName = cleanName;
           }
           toolCalls.push({
-            id: generateToolCallId(record.id, cleanName, ts, callIndex),
+            id: generateToolCallId(record.id, storedName, ts, callIndex),
             recordId: record.id,
-            name: cleanName,
+            name: storedName,
             ts,
             callIndex
           });
@@ -370,7 +377,7 @@ var CodexParser = class {
     } catch {
       return null;
     }
-    const payload = parsed.event_msg?.payload ?? (parsed.type === "event_msg" ? parsed.payload : void 0);
+    const payload = parsed.event_msg?.payload ?? (parsed.type === "event_msg" || parsed.type === "response_item" ? parsed.payload : void 0);
     const turnCtx = parsed.type === "turn_context" ? parsed.payload : void 0;
     if (turnCtx?.model) {
       this.currentModel = turnCtx.model;
@@ -383,7 +390,8 @@ var CodexParser = class {
     if (payload.type === "function_call") {
       const rawFcTs = parsed.event_msg?.timestamp ?? parsed.timestamp ?? context.now;
       this.pendingToolCalls.push({
-        name: payload.function?.name ?? "unknown",
+        // newer format: payload.name; older format: payload.function.name
+        name: payload.name ?? payload.function?.name ?? "unknown",
         ts: typeof rawFcTs === "number" ? rawFcTs : new Date(rawFcTs).getTime()
       });
       return null;
@@ -464,6 +472,27 @@ var OpenClawParser = class {
     } catch {
       return null;
     }
+    if (parsed.message?.role === "assistant" && Array.isArray(parsed.message.content) && !parsed.message?.usage) {
+      const rawTs2 = parsed.message.timestamp ?? parsed.timestamp ?? context.now;
+      const ts2 = typeof rawTs2 === "number" ? rawTs2 : new Date(rawTs2).getTime();
+      const toolCalls2 = [];
+      let callIndex = 0;
+      for (const block of parsed.message.content) {
+        if (block.type === "tool_use" || block.type === "toolCall") {
+          toolCalls2.push({
+            id: generateOrphanToolCallId(this.tool, block.name, ts2, callIndex),
+            recordId: null,
+            name: block.name,
+            ts: ts2,
+            callIndex
+          });
+          callIndex++;
+        }
+      }
+      if (toolCalls2.length > 0) {
+        return { record: null, toolCalls: toolCalls2 };
+      }
+    }
     if (!parsed.message?.usage) return null;
     const usage = parsed.message.usage;
     const model = parsed.message.model ?? "unknown";
@@ -522,7 +551,7 @@ var OpenClawParser = class {
     if (Array.isArray(parsed.message.content)) {
       let callIndex = 0;
       for (const block of parsed.message.content) {
-        if (block.type === "tool_use") {
+        if (block.type === "tool_use" || block.type === "toolCall") {
           toolCalls.push({
             id: generateToolCallId(record.id, block.name, ts, callIndex),
             recordId: record.id,
@@ -633,8 +662,20 @@ var QoderParser = class {
     return { record, toolCalls };
   }
   finalize() {
+    const toolCalls = [];
+    for (const pending of this.pendingToolCallsByLoopId.values()) {
+      for (const [callIndex, tc] of pending.entries()) {
+        toolCalls.push({
+          id: generateOrphanToolCallId(this.tool, tc.name, tc.ts, callIndex),
+          recordId: null,
+          name: tc.name,
+          ts: tc.ts,
+          callIndex
+        });
+      }
+    }
     this.pendingToolCallsByLoopId.clear();
-    return [];
+    return toolCalls.length > 0 ? [{ record: null, toolCalls }] : [];
   }
 };
 var Aggregator = class {
@@ -733,6 +774,28 @@ function loadCredential(key) {
 
 // src/api/project-extraction.ts
 import path from "path";
+var CWD_WORKSPACE_ROOTS = /* @__PURE__ */ new Set([
+  "WebstormProjects",
+  "Documents",
+  "Projects",
+  "workspace",
+  "Workspace",
+  "dev",
+  "code",
+  "repos",
+  "Developer",
+  "src"
+]);
+function extractProjectFromCwd(cwd) {
+  if (!cwd) return "unknown";
+  const normalized = cwd.replace(/\\/g, "/");
+  const withoutHome = normalized.replace(/^[A-Za-z]:\/(?:Users|home)\/[^/]+\//, "").replace(/^\/(Users|home)\/[^/]+\//, "").replace(/^\/root\//, "");
+  const parts = withoutHome.split("/").filter(Boolean);
+  for (const part of parts) {
+    if (!CWD_WORKSPACE_ROOTS.has(part)) return part;
+  }
+  return parts[parts.length - 1] ?? "unknown";
+}
 var GENERIC_DIRECTORY_NAMES = /* @__PURE__ */ new Set([
   "sessions",
   "session",
@@ -960,14 +1023,15 @@ function defaultFileData() {
     "openclaw": {},
     "opencode": {},
     "hermes": {},
-    "qoder": {}
+    "qoder": {},
+    "cursor": {}
   };
 }
 var WatermarkManager = class {
   data;
   path;
-  constructor(path3) {
-    this.path = path3;
+  constructor(path2) {
+    this.path = path2;
     this.data = this.load();
   }
   load() {
@@ -980,7 +1044,7 @@ var WatermarkManager = class {
       if (parsed && typeof parsed === "object" && !("files" in parsed)) {
         return { files: { ...defaultFileData(), ...parsed } };
       }
-      return { files: { ...defaultFileData(), ...parsed.files ?? {} }, opencode: parsed.opencode ?? null, hermes: parsed.hermes ?? null, qoder: parsed.qoder ?? null };
+      return { files: { ...defaultFileData(), ...parsed.files ?? {} }, opencode: parsed.opencode ?? null, hermes: parsed.hermes ?? null, qoder: parsed.qoder ?? null, cursor: parsed.cursor ?? null };
     } catch {
       return { files: defaultFileData() };
     }
@@ -1025,11 +1089,17 @@ var WatermarkManager = class {
   setQoderCursor(cursor) {
     this.data.qoder = cursor;
   }
+  getCursorCursor() {
+    return this.data.cursor ?? null;
+  }
+  setCursorCursor(cursor) {
+    this.data.cursor = cursor;
+  }
 };
 
 // src/commands/parse-opencode.ts
 function runParseOpenCode(db, options) {
-  const { dbPath, device, deviceInstanceId, platform: platform4, now, cursor, exchangeRate } = options;
+  const { dbPath, device, deviceInstanceId, platform: platform5, now, cursor, exchangeRate } = options;
   const records = [];
   const toolCalls = [];
   const errors = [];
@@ -1099,7 +1169,7 @@ function runParseOpenCode(db, options) {
       sourceFile: dbPath,
       device,
       deviceInstanceId,
-      platform: platform4
+      platform: platform5
     };
     records.push(record);
     const parts = partsStmt.all(message.id);
@@ -1129,7 +1199,7 @@ function runParseOpenCode(db, options) {
 
 // src/commands/parse-hermes.ts
 function runParseHermes(db, options) {
-  const { dbPath, device, deviceInstanceId, platform: platform4, now, cursor, exchangeRate } = options;
+  const { dbPath, device, deviceInstanceId, platform: platform5, now, cursor, exchangeRate } = options;
   const records = [];
   const toolCalls = [];
   const errors = [];
@@ -1202,7 +1272,7 @@ function runParseHermes(db, options) {
       sourceFile: dbPath,
       device,
       deviceInstanceId,
-      platform: platform4
+      platform: platform5
     };
     records.push(record);
     const messages = toolCallsStmt.all(session.id);
@@ -1250,7 +1320,7 @@ function parseModelKey(recordExtra) {
   }
 }
 function runParseQoder(db, options) {
-  const { dbPath, device, deviceInstanceId, platform: platform4, now, cursor, exchangeRate } = options;
+  const { dbPath, device, deviceInstanceId, platform: platform5, now, cursor, exchangeRate } = options;
   const records = [];
   const toolCalls = [];
   const errors = [];
@@ -1310,12 +1380,104 @@ function runParseQoder(db, options) {
       sourceFile: dbPath,
       device,
       deviceInstanceId,
-      platform: platform4
+      platform: platform5
     });
   }
   return { records, toolCalls, nextCursor: lastCursor, errors };
 }
 
+// src/commands/parse-cursor.ts
+function runParseCursor(db, options) {
+  const { dbPath, device, deviceInstanceId, platform: platform5, now, cursor } = options;
+  const records = [];
+  const toolCalls = [];
+  const errors = [];
+  let lastCursor = null;
+  const composerRows = db.prepare(`SELECT key, CAST(value AS TEXT) as value FROM cursorDiskKV WHERE key LIKE 'composerData:%' AND length(value) > 100`).all();
+  const composers = [];
+  for (const row of composerRows) {
+    try {
+      const j = JSON.parse(row.value);
+      const composerId = row.key.slice("composerData:".length);
+      const createdAt = j.createdAt ?? 0;
+      if (!createdAt) continue;
+      composers.push({
+        composerId,
+        createdAt,
+        usageData: j.usageData
+      });
+    } catch {
+    }
+  }
+  composers.sort(
+    (a, b) => a.createdAt !== b.createdAt ? a.createdAt - b.createdAt : a.composerId.localeCompare(b.composerId)
+  );
+  const filtered = cursor ? composers.filter(
+    (c) => c.createdAt > cursor.lastCreatedAt || c.createdAt === cursor.lastCreatedAt && c.composerId > cursor.lastId
+  ) : composers;
+  if (filtered.length === 0) {
+    return { records, toolCalls, nextCursor: lastCursor, errors };
+  }
+  const bubbleStmt = db.prepare(
+    `SELECT CAST(value AS TEXT) as value FROM cursorDiskKV WHERE key LIKE ?`
+  );
+  for (const composer of filtered) {
+    lastCursor = { lastCreatedAt: composer.createdAt, lastId: composer.composerId };
+    try {
+      const bubbleRows = bubbleStmt.all(`bubbleId:${composer.composerId}:%`);
+      let totalInputTokens = 0;
+      let totalOutputTokens = 0;
+      for (const row of bubbleRows) {
+        try {
+          const bubble = JSON.parse(row.value);
+          if (bubble.type !== 2) continue;
+          const tc = bubble.tokenCount;
+          if (!tc) continue;
+          totalInputTokens += tc.inputTokens ?? 0;
+          totalOutputTokens += tc.outputTokens ?? 0;
+        } catch {
+        }
+      }
+      if (totalInputTokens === 0 && totalOutputTokens === 0) continue;
+      const ts = composer.createdAt;
+      let cost = 0;
+      let costSource = "unknown";
+      const defaultUsage = composer.usageData?.default;
+      if (defaultUsage?.costInCents != null && defaultUsage.costInCents > 0) {
+        cost = defaultUsage.costInCents / 100;
+        costSource = "log";
+      }
+      const recordId = generateRecordId(deviceInstanceId, `${dbPath}:${composer.composerId}`, ts);
+      const record = {
+        id: recordId,
+        ts,
+        ingestedAt: now,
+        updatedAt: now,
+        lineOffset: 0,
+        tool: "cursor",
+        model: "cursor-composer",
+        provider: "cursor",
+        inputTokens: totalInputTokens,
+        outputTokens: totalOutputTokens,
+        cacheReadTokens: 0,
+        cacheWriteTokens: 0,
+        thinkingTokens: 0,
+        cost,
+        costSource,
+        sessionId: composer.composerId,
+        sourceFile: dbPath,
+        device,
+        deviceInstanceId,
+        platform: platform5
+      };
+      records.push(record);
+    } catch (e) {
+      errors.push(`composerId ${composer.composerId}: ${e instanceof Error ? e.message : e}`);
+    }
+  }
+  return { records, toolCalls, nextCursor: lastCursor, errors };
+}
+
 // src/commands/parse.ts
 function unique(paths) {
   return [...new Set(paths)];
@@ -1426,6 +1588,19 @@ function defaultQoderDbPath() {
   const xdgDataHome = process.env.XDG_DATA_HOME ?? join3(home, ".local", "share");
   return join3(xdgDataHome, "Qoder", "SharedClientCache", "cache", "db", "local.db");
 }
+function defaultCursorDbPath() {
+  const home = homedir2();
+  const plat = platform();
+  if (plat === "win32") {
+    const appData = process.env.APPDATA ?? join3(home, "AppData", "Roaming");
+    return join3(appData, "Cursor", "User", "globalStorage", "state.vscdb");
+  }
+  if (plat === "darwin") {
+    return join3(home, "Library", "Application Support", "Cursor", "User", "globalStorage", "state.vscdb");
+  }
+  const xdgConfigHome = process.env.XDG_CONFIG_HOME ?? join3(home, ".config");
+  return join3(xdgConfigHome, "Cursor", "User", "globalStorage", "state.vscdb");
+}
 function discoverLogFiles(sources) {
   const home = homedir2();
   const results = [];
@@ -1546,6 +1721,16 @@ async function runParse(db, filterTool, options) {
             continue;
           }
           if (byteOffset < offset) {
+            aggregator.parseLine(line, aggregator.createContext({
+              tool,
+              sourceFile: filePath,
+              lineOffset: byteOffset,
+              sessionId,
+              device,
+              deviceInstanceId,
+              platform: devicePlatform,
+              exchangeRate
+            }));
             byteOffset += Buffer.byteLength(line, "utf-8") + 1;
             continue;
           }
@@ -1687,6 +1872,36 @@ async function runParse(db, filterTool, options) {
       errors.push(`${qoderDbPath}: ${e instanceof Error ? e.message : e}`);
     }
   }
+  const cursorDbPath = options?.cursorDbPath ?? config?.sources?.["cursor"] ?? defaultCursorDbPath();
+  if ((!filterTool || filterTool === "cursor") && existsSync4(cursorDbPath)) {
+    try {
+      const cursorDb = new Database(cursorDbPath, { readonly: true });
+      try {
+        const result = runParseCursor(cursorDb, {
+          dbPath: cursorDbPath,
+          device,
+          deviceInstanceId,
+          platform: devicePlatform,
+          now: Date.now(),
+          cursor: wm.getCursorCursor()
+        });
+        for (const record of result.records) insertRecord(db, record);
+        for (const tc of result.toolCalls) insertToolCall(db, tc);
+        if (result.nextCursor) {
+          wm.setCursorCursor(result.nextCursor);
+          wm.save();
+        }
+        parsedCount += result.records.length;
+        toolCallCount += result.toolCalls.length;
+        errors.push(...result.errors);
+        onProgress({ phase: "Parsing SQLite", tool: "cursor", current: 1, total: 1, records: parsedCount, toolCalls: toolCallCount });
+      } finally {
+        cursorDb.close();
+      }
+    } catch (e) {
+      errors.push(`${cursorDbPath}: ${e instanceof Error ? e.message : e}`);
+    }
+  }
   if (deviceInstanceId !== "unknown") {
     db.prepare(
       `UPDATE records SET device_instance_id = ?, device = ? WHERE device_instance_id = 'unknown'`
@@ -1714,8 +1929,180 @@ async function runParse(db, filterTool, options) {
     } catch {
     }
   }
+  backfillSkillNames(db);
+  backfillCodexModels(db);
+  backfillMissingToolCalls(db, exchangeRate);
   return { parsedCount, toolCallCount, errors };
 }
+function backfillSkillNames(db) {
+  const rows = db.prepare(`
+    SELECT tc.id, tc.record_id, tc.ts, tc.call_index,
+           r.source_file, r.line_offset
+    FROM tool_calls tc
+    JOIN records r ON r.id = tc.record_id
+    WHERE (tc.name = 'Skill' OR tc.name = 'skill__unknown')
+      AND r.source_file NOT LIKE 'synced/%'
+  `).all();
+  if (rows.length === 0) return;
+  const updateStmt = db.prepare("UPDATE tool_calls SET id = ?, name = ? WHERE id = ?");
+  for (const row of rows) {
+    try {
+      const fd = openSync(row.source_file, "r");
+      const buf = Buffer.alloc(65536);
+      const n = readSync(fd, buf, 0, buf.length, row.line_offset);
+      closeSync(fd);
+      let lineEnd = 0;
+      while (lineEnd < n && buf[lineEnd] !== 10) lineEnd++;
+      const line = buf.subarray(0, lineEnd).toString("utf8");
+      const parsed = JSON.parse(line);
+      if (!Array.isArray(parsed.message?.content)) continue;
+      let callIndex = 0;
+      let skillArg = "";
+      for (const block of parsed.message.content) {
+        if (block.type !== "tool_use") continue;
+        if (callIndex === row.call_index) {
+          if (block.name === "Skill") {
+            const raw = block.input?.skill ?? block.input?.skillName ?? block.input?.name ?? "";
+            skillArg = typeof raw === "string" ? raw.trim() : "";
+          }
+          break;
+        }
+        callIndex++;
+      }
+      const storedName = skillArg ? `skill__${skillArg}` : "skill__unknown";
+      const newId = generateToolCallId(row.record_id, storedName, row.ts, row.call_index);
+      updateStmt.run(newId, storedName, row.id);
+    } catch {
+    }
+  }
+}
+function backfillCodexModels(db) {
+  const rows = db.prepare(`
+    SELECT id, source_file, line_offset
+    FROM records
+    WHERE tool = 'codex' AND model = 'unknown'
+      AND source_file NOT LIKE 'synced/%'
+  `).all();
+  if (rows.length === 0) return;
+  const byFile = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const list = byFile.get(row.source_file) ?? [];
+    list.push(row);
+    byFile.set(row.source_file, list);
+  }
+  const updateStmt = db.prepare(
+    `UPDATE records SET model = ?, provider = ?, cost = ?, cost_source = ?, updated_at = ? WHERE id = ?`
+  );
+  for (const [sourceFile, fileRows] of byFile) {
+    try {
+      const content = readFileSync4(sourceFile, "utf-8");
+      const lines = content.split("\n");
+      const offsetToModel = /* @__PURE__ */ new Map();
+      let currentModel = "";
+      let byteOffset = 0;
+      for (const line of lines) {
+        if (line.trim()) {
+          try {
+            const parsed = JSON.parse(line);
+            const turnModel = parsed.type === "turn_context" ? parsed.payload?.model : void 0;
+            if (turnModel) currentModel = turnModel;
+            const payload = parsed.event_msg?.payload ?? (parsed.type === "event_msg" ? parsed.payload : void 0);
+            if (payload?.type === "token_count" && currentModel) {
+              offsetToModel.set(byteOffset, currentModel);
+            }
+          } catch {
+          }
+        }
+        byteOffset += Buffer.byteLength(line, "utf-8") + 1;
+      }
+      for (const row of fileRows) {
+        const model = offsetToModel.get(row.line_offset);
+        if (!model) continue;
+        const provider = inferProvider(model);
+        updateStmt.run(model, provider, 0, "unknown", Date.now(), row.id);
+      }
+    } catch {
+    }
+  }
+}
+function backfillMissingToolCalls(db, exchangeRate) {
+  const rows = db.prepare(`
+    SELECT r.id, r.source_file, r.tool, r.line_offset, r.session_id
+    FROM records r
+    LEFT JOIN tool_calls tc ON tc.record_id = r.id
+    WHERE r.tool IN ('codex', 'openclaw', 'qoder')
+      AND r.source_file NOT LIKE 'synced/%'
+      AND tc.id IS NULL
+  `).all();
+  if (rows.length === 0) return;
+  const rowsByFile = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const list = rowsByFile.get(row.source_file) ?? [];
+    list.push(row);
+    rowsByFile.set(row.source_file, list);
+  }
+  for (const [sourceFile, fileRows] of rowsByFile) {
+    try {
+      const content = readFileSync4(sourceFile, "utf-8");
+      const lines = content.split("\n");
+      const aggregator = new Aggregator();
+      const recordIdByOffset = /* @__PURE__ */ new Map();
+      const sessionIdByOffset = /* @__PURE__ */ new Map();
+      const tool = fileRows[0]?.tool;
+      if (!tool) continue;
+      for (const row of fileRows) {
+        recordIdByOffset.set(row.line_offset, row.id);
+        sessionIdByOffset.set(row.line_offset, row.session_id);
+      }
+      let byteOffset = 0;
+      for (const line of lines) {
+        if (!line.trim()) {
+          byteOffset += Buffer.byteLength(line, "utf-8") + 1;
+          continue;
+        }
+        const context = aggregator.createContext({
+          tool,
+          sourceFile,
+          lineOffset: byteOffset,
+          sessionId: sessionIdByOffset.get(byteOffset) ?? deriveSessionId(tool, sourceFile),
+          device: "",
+          deviceInstanceId: "",
+          exchangeRate
+        });
+        const result = aggregator.parseLine(line, context);
+        if (result?.toolCalls?.length) {
+          insertBackfilledToolCalls(db, result.toolCalls, tool, recordIdByOffset.get(byteOffset) ?? null);
+        }
+        byteOffset += Buffer.byteLength(line, "utf-8") + 1;
+      }
+      const orphanResults = aggregator.finalize();
+      for (const result of orphanResults) {
+        if (result.toolCalls.length) insertBackfilledToolCalls(db, result.toolCalls, tool, null);
+      }
+    } catch {
+    }
+  }
+}
+function insertBackfilledToolCalls(db, toolCalls, tool, actualRecordId) {
+  for (const tc of toolCalls) {
+    if (actualRecordId) {
+      const name = tc.name;
+      const id = generateToolCallId(actualRecordId, name, tc.ts, tc.callIndex);
+      const dup2 = db.prepare("SELECT 1 FROM tool_calls WHERE id = ?").get(id);
+      if (!dup2) insertToolCall(db, { ...tc, id, recordId: actualRecordId });
+      continue;
+    }
+    const dup = db.prepare("SELECT 1 FROM tool_calls WHERE id = ?").get(tc.id);
+    if (!dup) insertToolCall(db, { ...tc, tool });
+  }
+}
+function deriveSessionId(tool, sourceFile) {
+  const normalized = sourceFile.replace(/\\/g, "/");
+  const fileName = normalized.split("/").pop() ?? sourceFile;
+  if (tool === "openclaw") return fileName.replace(/\.(trajectory\.)?jsonl$/, "");
+  if (tool === "qoder") return normalized.split("/").slice(-2, -1)[0] ?? fileName.replace(/\.jsonl$/, "");
+  return fileName.replace(/\.jsonl$/, "");
+}
 function getDefaultSourcePaths() {
   const home = homedir2();
   return {
@@ -1725,10 +2112,293 @@ function getDefaultSourcePaths() {
     "opencode": defaultOpenCodeDbPath(),
     "hermes": defaultHermesDbPath(),
     "qoder": join3(home, ".qoder", "logs", "sessions"),
-    "qoder-db": defaultQoderDbPath()
+    "qoder-db": defaultQoderDbPath(),
+    "cursor": defaultCursorDbPath()
   };
 }
 
+// src/quota.ts
+import { readFileSync as readFileSync5, existsSync as existsSync5 } from "fs";
+import { join as join4 } from "path";
+import { homedir as homedir3, platform as platform2 } from "os";
+import { execSync } from "child_process";
+function nowMs() {
+  return Date.now();
+}
+function notFound(tool) {
+  return { tool, credentialStatus: "not_found", credentialMessage: null, success: false, tiers: [], error: null, queriedAt: null };
+}
+function parseError(tool, message) {
+  return { tool, credentialStatus: "parse_error", credentialMessage: message, success: false, tiers: [], error: message, queriedAt: nowMs() };
+}
+function expiredError(tool, message) {
+  return { tool, credentialStatus: "expired", credentialMessage: message, success: false, tiers: [], error: message, queriedAt: nowMs() };
+}
+function apiError(tool, message) {
+  return { tool, credentialStatus: "valid", credentialMessage: null, success: false, tiers: [], error: message, queriedAt: nowMs() };
+}
+function isExpired(expiresAt) {
+  if (expiresAt == null) return false;
+  const nowSecs = Date.now() / 1e3;
+  if (typeof expiresAt === "number") {
+    const secs = expiresAt > 1e12 ? expiresAt / 1e3 : expiresAt;
+    return secs < nowSecs;
+  }
+  if (typeof expiresAt === "string") {
+    const ts = Date.parse(expiresAt);
+    if (!isNaN(ts)) return ts / 1e3 < nowSecs;
+  }
+  return false;
+}
+function readFromKeychain(service) {
+  if (platform2() !== "darwin") return null;
+  try {
+    const result = execSync(`security find-generic-password -s "${service}" -w 2>/dev/null`, {
+      timeout: 3e3,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    return result || null;
+  } catch {
+    return null;
+  }
+}
+function parseClaudeCredJson(content) {
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch (e) {
+    return { token: null, status: "parse_error", message: `Failed to parse credentials JSON: ${e}` };
+  }
+  const entry = parsed["claudeAiOauth"] ?? parsed["claude.ai_oauth"];
+  if (!entry) {
+    return { token: null, status: "parse_error", message: "No OAuth entry found in credentials" };
+  }
+  const accessToken = entry["accessToken"];
+  if (!accessToken) {
+    return { token: null, status: "parse_error", message: "accessToken is empty or missing" };
+  }
+  if (isExpired(entry["expiresAt"])) {
+    return { token: accessToken, status: "expired", message: "OAuth token has expired" };
+  }
+  return { token: accessToken, status: "valid", message: null };
+}
+function readClaudeCredentials() {
+  const keychainJson = readFromKeychain("Claude Code-credentials");
+  if (keychainJson) {
+    return parseClaudeCredJson(keychainJson);
+  }
+  const credPath = join4(homedir3(), ".claude", ".credentials.json");
+  if (!existsSync5(credPath)) {
+    return { token: null, status: "not_found", message: null };
+  }
+  let content;
+  try {
+    content = readFileSync5(credPath, "utf-8");
+  } catch (e) {
+    return { token: null, status: "parse_error", message: `Failed to read credentials file: ${e}` };
+  }
+  return parseClaudeCredJson(content);
+}
+function parseCodexCredJson(content) {
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch (e) {
+    return { token: null, accountId: null, status: "parse_error", message: `Failed to parse Codex auth JSON: ${e}` };
+  }
+  if (parsed["auth_mode"] !== "chatgpt") {
+    return { token: null, accountId: null, status: "not_found", message: "Codex not using OAuth mode" };
+  }
+  const tokens = parsed["tokens"];
+  if (!tokens) {
+    return { token: null, accountId: null, status: "parse_error", message: "No tokens in Codex auth" };
+  }
+  const accessToken = tokens["access_token"];
+  if (!accessToken) {
+    return { token: null, accountId: null, status: "parse_error", message: "access_token is empty or missing" };
+  }
+  const accountId = tokens["account_id"] ?? parsed["account_id"] ?? null;
+  const expiresAt = tokens["expires_at"] ?? tokens["expiresAt"];
+  if (isExpired(expiresAt)) {
+    return { token: accessToken, accountId, status: "expired", message: "Codex OAuth token may be stale" };
+  }
+  return { token: accessToken, accountId, status: "valid", message: null };
+}
+function readCodexCredentials() {
+  const keychainJson = readFromKeychain("Codex Auth");
+  if (keychainJson) {
+    return parseCodexCredJson(keychainJson);
+  }
+  const authPath = join4(homedir3(), ".codex", "auth.json");
+  if (!existsSync5(authPath)) {
+    return { token: null, accountId: null, status: "not_found", message: null };
+  }
+  let content;
+  try {
+    content = readFileSync5(authPath, "utf-8");
+  } catch (e) {
+    return { token: null, accountId: null, status: "parse_error", message: `Failed to read Codex auth file: ${e}` };
+  }
+  return parseCodexCredJson(content);
+}
+var CLAUDE_KNOWN_TIERS = ["five_hour", "seven_day", "seven_day_opus", "seven_day_sonnet"];
+var CLAUDE_QUOTA_URL = "https://api.anthropic.com/api/oauth/usage";
+async function queryClaudeQuota(accessToken) {
+  let resp;
+  try {
+    resp = await fetch(CLAUDE_QUOTA_URL, {
+      headers: {
+        "Authorization": `Bearer ${accessToken}`,
+        "anthropic-beta": "oauth-2025-04-20",
+        "Accept": "application/json"
+      },
+      signal: AbortSignal.timeout(1e4)
+    });
+  } catch (e) {
+    return apiError("claude-code", `Network error: ${e}`);
+  }
+  if (resp.status === 401 || resp.status === 403) {
+    return expiredError("claude-code", `Authentication failed (HTTP ${resp.status}). Please re-login with Claude CLI.`);
+  }
+  if (!resp.ok) {
+    const body2 = await resp.text().catch(() => "");
+    return apiError("claude-code", `API error (HTTP ${resp.status}): ${body2}`);
+  }
+  let body;
+  try {
+    body = await resp.json();
+  } catch (e) {
+    return apiError("claude-code", `Failed to parse API response: ${e}`);
+  }
+  const tiers = [];
+  for (const name of CLAUDE_KNOWN_TIERS) {
+    const window = body[name];
+    if (!window) continue;
+    const utilization = window["utilization"];
+    if (utilization == null) continue;
+    tiers.push({
+      name,
+      utilization,
+      resetsAt: window["resets_at"] ?? null
+    });
+  }
+  for (const [key, value] of Object.entries(body)) {
+    if (key === "extra_usage" || CLAUDE_KNOWN_TIERS.includes(key)) continue;
+    const window = value;
+    if (!window || typeof window !== "object") continue;
+    const utilization = window["utilization"];
+    if (utilization == null) continue;
+    tiers.push({
+      name: key,
+      utilization,
+      resetsAt: window["resets_at"] ?? null
+    });
+  }
+  return {
+    tool: "claude-code",
+    credentialStatus: "valid",
+    credentialMessage: null,
+    success: true,
+    tiers,
+    error: null,
+    queriedAt: nowMs()
+  };
+}
+var CODEX_QUOTA_URL = "https://chatgpt.com/backend-api/wham/usage";
+function windowSecondsToTierName(seconds) {
+  if (seconds <= 3600 * 6) return "five_hour";
+  if (seconds <= 86400 * 7) return "weekly_limit";
+  return `${seconds}s`;
+}
+async function callCodexQuotaApi(accessToken, accountId) {
+  const headers = {
+    "Authorization": `Bearer ${accessToken}`,
+    "User-Agent": "codex-cli",
+    "Accept": "application/json"
+  };
+  if (accountId) headers["ChatGPT-Account-Id"] = accountId;
+  let resp;
+  try {
+    resp = await fetch(CODEX_QUOTA_URL, {
+      headers,
+      signal: AbortSignal.timeout(1e4)
+    });
+  } catch (e) {
+    return apiError("codex", `Network error: ${e}`);
+  }
+  if (resp.status === 401 || resp.status === 403) {
+    return expiredError("codex", `Authentication failed (HTTP ${resp.status}). Please re-login with Codex CLI.`);
+  }
+  if (!resp.ok) {
+    const body2 = await resp.text().catch(() => "");
+    return apiError("codex", `API error (HTTP ${resp.status}): ${body2}`);
+  }
+  let body;
+  try {
+    body = await resp.json();
+  } catch (e) {
+    return apiError("codex", `Failed to parse API response: ${e}`);
+  }
+  const tiers = [];
+  const rateLimit = body["rate_limit"];
+  if (rateLimit) {
+    for (const windowKey of ["primary_window", "secondary_window"]) {
+      const window = rateLimit[windowKey];
+      if (!window) continue;
+      const usedPercent = window["used_percent"];
+      if (usedPercent == null) continue;
+      const windowSecs = window["limit_window_seconds"];
+      const name = windowSecs != null ? windowSecondsToTierName(windowSecs) : "unknown";
+      const resetAt = window["reset_at"];
+      const resetsAt = resetAt ? new Date(resetAt * 1e3).toISOString() : null;
+      tiers.push({ name, utilization: usedPercent, resetsAt });
+    }
+  }
+  return {
+    tool: "codex",
+    credentialStatus: "valid",
+    credentialMessage: null,
+    success: true,
+    tiers,
+    error: null,
+    queriedAt: nowMs()
+  };
+}
+async function queryClaudeCodeQuota() {
+  const cred = readClaudeCredentials();
+  if (cred.status === "not_found") return notFound("claude-code");
+  if (cred.status === "parse_error") return parseError("claude-code", cred.message ?? "Failed to parse credentials");
+  if (cred.status === "expired") {
+    if (cred.token) {
+      const result = await queryClaudeQuota(cred.token);
+      if (result.success) return result;
+    }
+    return expiredError("claude-code", cred.message ?? "OAuth token has expired");
+  }
+  return queryClaudeQuota(cred.token);
+}
+async function queryCodexQuota() {
+  const cred = readCodexCredentials();
+  if (cred.status === "not_found") return notFound("codex");
+  if (cred.status === "parse_error") return parseError("codex", cred.message ?? "Failed to parse credentials");
+  if (cred.status === "expired") {
+    if (cred.token) {
+      const result = await callCodexQuotaApi(cred.token, cred.accountId);
+      if (result.success) return result;
+    }
+    return expiredError("codex", cred.message ?? "Codex OAuth token may be stale");
+  }
+  return callCodexQuotaApi(cred.token, cred.accountId);
+}
+async function queryAllQuotas() {
+  const [claude, codex] = await Promise.all([
+    queryClaudeCodeQuota(),
+    queryCodexQuota()
+  ]);
+  return [claude, codex];
+}
+
 // src/api/server.ts
 function getDateRangeFilter(range, from, to, prefix = "", weekStart = 1) {
   const ts = prefix ? `${prefix}.ts` : "ts";
@@ -1769,6 +2439,27 @@ function getToolFilter(tool, prefix = "") {
   const col = prefix ? `${prefix}.tool` : "tool";
   return { where: `AND ${col} = @tool`, params: { tool } };
 }
+function classifyToolCall(name) {
+  if (name.startsWith("mcp__")) return "mcp";
+  if (name.startsWith("skill__") || name === "Skill") return "skill";
+  return "builtin";
+}
+function parseMcpName(name) {
+  const withoutPrefix = name.slice(5);
+  const idx = withoutPrefix.indexOf("__");
+  if (idx === -1) return { server: withoutPrefix, action: "", display: withoutPrefix };
+  return {
+    server: withoutPrefix.slice(0, idx),
+    action: withoutPrefix.slice(idx + 2),
+    display: `${withoutPrefix.slice(0, idx)} / ${withoutPrefix.slice(idx + 2)}`
+  };
+}
+function getToolTypeFilter(toolType) {
+  if (toolType === "mcp") return "AND tc.name LIKE 'mcp\\_\\_%' ESCAPE '\\'";
+  if (toolType === "skill") return "AND (tc.name LIKE 'skill\\_\\_%' ESCAPE '\\' OR tc.name = 'Skill')";
+  if (toolType === "builtin") return "AND tc.name NOT LIKE 'mcp\\_\\_%' ESCAPE '\\' AND tc.name NOT LIKE 'skill\\_\\_%' ESCAPE '\\' AND tc.name != 'Skill'";
+  return "";
+}
 var LOCAL_ONLY_FILTER = "AND source_file NOT LIKE 'synced/%'";
 function getDeviceFilter(device, currentDeviceInstanceId) {
   if (!currentDeviceInstanceId) {
@@ -1809,7 +2500,7 @@ function createApiServer(db, options) {
     const from = url.searchParams.get("from");
     const to = url.searchParams.get("to");
     const toolParam = url.searchParams.get("tool");
-    const VALID_TOOLS = ["claude-code", "codex", "openclaw", "opencode", "hermes", "qoder"];
+    const VALID_TOOLS = ["claude-code", "codex", "openclaw", "opencode", "hermes", "qoder", "cursor"];
     if (toolParam && !VALID_TOOLS.includes(toolParam)) {
       json(res, { error: { code: "INVALID_PARAM", message: "Invalid tool" } }, 400);
       return;
@@ -1920,6 +2611,21 @@ function createApiServer(db, options) {
           WHERE 1=1 ${dfJoin} ${drJoin.where} ${tfJoin.where}
           GROUP BY tc.name ORDER BY count DESC LIMIT 10
         `).all({ ...drJoin.params, ...df.params, ...tfJoin.params });
+        const topMcpServersRaw = db.prepare(`
+          SELECT tc.name, COUNT(*) AS count
+          FROM tool_calls tc
+          JOIN records r ON r.id = tc.record_id
+          WHERE tc.name LIKE 'mcp\\_\\_%' ESCAPE '\\'
+            AND INSTR(SUBSTR(tc.name, 6), '__') > 0
+            ${dfJoin} ${drJoin.where} ${tfJoin.where}
+          GROUP BY tc.name ORDER BY count DESC
+        `).all({ ...drJoin.params, ...df.params, ...tfJoin.params });
+        const mcpServerMap = /* @__PURE__ */ new Map();
+        for (const row of topMcpServersRaw) {
+          const server2 = parseMcpName(row.name).server;
+          mcpServerMap.set(server2, (mcpServerMap.get(server2) ?? 0) + row.count);
+        }
+        const topMcpServers = Array.from(mcpServerMap.entries()).sort((a, b) => b[1] - a[1]).slice(0, 10).map(([server2, count]) => ({ server: server2, count }));
         json(res, {
           inputTokens: totals.inputTokens,
           outputTokens: totals.outputTokens,
@@ -1931,7 +2637,8 @@ function createApiServer(db, options) {
           activeDays: totals.activeDays,
           totalSessions: totals.totalSessions,
           byTool,
-          topToolCalls
+          topToolCalls,
+          topMcpServers
         });
         return;
       }
@@ -2127,31 +2834,126 @@ function createApiServer(db, options) {
         const dr = getDateRangeFilter(range, from, to, "r", weekStart);
         const tool = url.searchParams.get("tool");
         const tf = getToolFilter(tool, "r");
+        const toolType = url.searchParams.get("toolType");
+        if (toolType && !["mcp", "skill", "builtin"].includes(toolType)) {
+          json(res, { error: { code: "INVALID_PARAM", message: "Invalid toolType" } }, 400);
+          return;
+        }
+        const ttf = getToolTypeFilter(toolType);
         const totalRow = db.prepare(`
           SELECT COUNT(*) AS total FROM tool_calls tc
           JOIN records r ON r.id = tc.record_id
-          WHERE 1=1 ${dr.where} ${tf.where}
+          WHERE 1=1 ${dr.where} ${tf.where} ${ttf}
         `).get({ ...dr.params, ...tf.params });
         const total = totalRow.total || 1;
         const rows = db.prepare(`
           SELECT tc.name, COUNT(*) AS count
           FROM tool_calls tc
           JOIN records r ON r.id = tc.record_id
-          WHERE 1=1 ${dr.where} ${tf.where}
+          WHERE 1=1 ${dr.where} ${tf.where} ${ttf}
           GROUP BY tc.name ORDER BY count DESC
         `).all({ ...dr.params, ...tf.params });
-        const toolCalls = rows.map((r) => ({
-          name: r.name,
-          count: r.count,
-          percentage: Math.round(r.count / total * 1e3) / 10
-        }));
+        const toolCalls = rows.map((r) => {
+          const type = classifyToolCall(r.name);
+          const mcpParsed = type === "mcp" ? parseMcpName(r.name) : null;
+          const displayName = mcpParsed ? mcpParsed.display : type === "skill" && r.name.startsWith("skill__") ? r.name.slice("skill__".length) : r.name;
+          return {
+            name: r.name,
+            displayName,
+            mcpServer: mcpParsed ? mcpParsed.server : null,
+            type,
+            count: r.count,
+            percentage: Math.round(r.count / total * 1e3) / 10
+          };
+        });
         json(res, { toolCalls });
         return;
       }
+      if (url.pathname.startsWith("/api/sessions/") && req.method === "GET") {
+        const sessionId = decodeURIComponent(url.pathname.slice("/api/sessions/".length));
+        if (!sessionId) {
+          json(res, { error: { code: "INVALID_PARAM", message: "Missing sessionId" } }, 400);
+          return;
+        }
+        const toolParam2 = url.searchParams.get("tool");
+        const deviceParam = url.searchParams.get("device");
+        const toolClause = toolParam2 ? "AND tool = @tool" : "";
+        const deviceClause = deviceParam ? "AND device_instance_id = @device" : "";
+        const filterParams = { sessionId };
+        if (toolParam2) filterParams.tool = toolParam2;
+        if (deviceParam) filterParams.device = deviceParam;
+        const meta = db.prepare(`
+          SELECT session_id AS sessionId,
+                 tool, model,
+                 MIN(ts) AS firstTs,
+                 MAX(ts) AS lastTs,
+                 MAX(ts) - MIN(ts) AS duration,
+                 SUM(input_tokens) AS inputTokens,
+                 SUM(output_tokens) AS outputTokens,
+                 SUM(cache_read_tokens) AS cacheReadTokens,
+                 SUM(cache_write_tokens) AS cacheWriteTokens,
+                 SUM(thinking_tokens) AS thinkingTokens,
+                 SUM(cost) AS cost,
+                 COUNT(*) AS recordCount
+          FROM records
+          WHERE session_id = @sessionId ${toolClause} ${deviceClause}
+          GROUP BY session_id, tool, model
+          ORDER BY MIN(ts) ASC
+          LIMIT 1
+        `).get(filterParams);
+        if (!meta) {
+          json(res, { error: { code: "NOT_FOUND", message: "Session not found" } }, 404);
+          return;
+        }
+        const records = db.prepare(`
+          SELECT id, ts, model,
+                 input_tokens AS inputTokens,
+                 output_tokens AS outputTokens,
+                 cache_read_tokens AS cacheReadTokens,
+                 cache_write_tokens AS cacheWriteTokens,
+                 thinking_tokens AS thinkingTokens,
+                 cost
+          FROM records
+          WHERE session_id = @sessionId ${toolClause} ${deviceClause}
+          ORDER BY ts ASC
+        `).all(filterParams);
+        const rToolClause = toolParam2 ? "AND r.tool = @tool" : "";
+        const rDeviceClause = deviceParam ? "AND r.device_instance_id = @device" : "";
+        const toolCallRows = db.prepare(`
+          SELECT tc.record_id AS recordId, tc.name, tc.ts, tc.call_index AS callIndex
+          FROM tool_calls tc
+          JOIN records r ON r.id = tc.record_id
+          WHERE r.session_id = @sessionId ${rToolClause} ${rDeviceClause}
+          ORDER BY tc.record_id, tc.call_index ASC
+        `).all(filterParams);
+        const toolCallsByRecord = {};
+        for (const tc of toolCallRows) {
+          if (!toolCallsByRecord[tc.recordId]) toolCallsByRecord[tc.recordId] = [];
+          const type = classifyToolCall(tc.name);
+          const mcpParsed = type === "mcp" ? parseMcpName(tc.name) : null;
+          const displayName = mcpParsed ? mcpParsed.display : type === "skill" && tc.name.startsWith("skill__") ? tc.name.slice("skill__".length) : tc.name;
+          toolCallsByRecord[tc.recordId].push({
+            name: tc.name,
+            displayName,
+            type,
+            ts: tc.ts,
+            callIndex: tc.callIndex
+          });
+        }
+        const toolCallCount = toolCallRows.length;
+        json(res, {
+          session: { ...meta, toolCallCount },
+          records: records.map((r) => ({
+            ...r,
+            toolCalls: toolCallsByRecord[r.id] ?? []
+          }))
+        });
+        return;
+      }
       if (url.pathname === "/api/sessions") {
         const page = Math.max(1, parseInt(url.searchParams.get("page") || "1", 10));
         const pageSize = Math.min(100, Math.max(1, parseInt(url.searchParams.get("pageSize") || "50", 10)));
-        const dr = getDateRangeFilter(range, from, to, "", weekStart);
+        const dr = getDateRangeFilter(range, from, to, "r", weekStart);
         const device = url.searchParams.get("device");
         const df = getDeviceFilter(device, options?.currentDeviceInstanceId);
         const tool = url.searchParams.get("tool");
@@ -2164,26 +2966,30 @@ function createApiServer(db, options) {
           });
           return;
         }
-        const tf = getToolFilter(tool);
+        const tf = getToolFilter(tool, "r");
         const params = { ...dr.params, ...tf.params };
         const totalRow = db.prepare(`
-          SELECT COUNT(DISTINCT session_id) AS total
-          FROM records WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where}
+          SELECT COUNT(DISTINCT r.session_id) AS total
+          FROM records r
+          WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where}
         `).get(params);
         const sessions = db.prepare(`
-          SELECT session_id AS sessionId,
-                 tool,
-                 model,
-                 MIN(ts) AS ts,
-                 SUM(input_tokens) AS inputTokens,
-                 SUM(output_tokens) AS outputTokens,
-                 SUM(cache_read_tokens) AS cacheReadTokens,
-                 SUM(cache_write_tokens) AS cacheWriteTokens,
-                 SUM(cost) AS cost
-          FROM records
+          SELECT r.session_id AS sessionId,
+                 r.tool,
+                 r.model,
+                 MIN(r.ts) AS ts,
+                 MAX(r.ts) - MIN(r.ts) AS duration,
+                 SUM(r.input_tokens) AS inputTokens,
+                 SUM(r.output_tokens) AS outputTokens,
+                 SUM(r.cache_read_tokens) AS cacheReadTokens,
+                 SUM(r.cache_write_tokens) AS cacheWriteTokens,
+                 SUM(r.cost) AS cost,
+                 COUNT(DISTINCT tc.id) AS toolCallCount
+          FROM records r
+          LEFT JOIN tool_calls tc ON tc.record_id = r.id
           WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where}
-          GROUP BY session_id
-          ORDER BY ts DESC
+          GROUP BY r.session_id
+          ORDER BY MIN(r.ts) DESC
           LIMIT @limit OFFSET @offset
         `).all({ ...params, limit: pageSize, offset: (page - 1) * pageSize });
         json(res, {
@@ -2212,10 +3018,23 @@ function createApiServer(db, options) {
           FROM records WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where}
           GROUP BY source_file ORDER BY totalTokens DESC
         `).all({ ...dr.params, ...tf.params });
+        const cwdByEncodedDir = {};
+        for (const row of rows) {
+          if (row.cwd) {
+            const m = row.source_file.replace(/\\/g, "/").match(/\.claude\/projects\/([^/]+)/);
+            if (m && !cwdByEncodedDir[m[1]]) cwdByEncodedDir[m[1]] = row.cwd;
+          }
+        }
         const projectMap = {};
         for (const row of rows) {
-          const project = row.cwd ? path2.basename(row.cwd) : extractProject(row.source_file);
-          if (!projectMap[project]) projectMap[project] = { sessions: 0, tokens: 0, cost: 0 };
+          let effectiveCwd = row.cwd || "";
+          if (!effectiveCwd) {
+            const m = row.source_file.replace(/\\/g, "/").match(/\.claude\/projects\/([^/]+)/);
+            if (m) effectiveCwd = cwdByEncodedDir[m[1]] || "";
+          }
+          const fromCwd = effectiveCwd ? extractProjectFromCwd(effectiveCwd) : null;
+          const project = fromCwd && fromCwd !== "unknown" ? fromCwd : extractProject(row.source_file);
+          if (!projectMap[project]) projectMap[project] = { sessions: 0, tokens: 0, cost: 0, fullPath: effectiveCwd || row.source_file };
           projectMap[project].sessions += row.sessionCount;
           projectMap[project].tokens += row.totalTokens;
           projectMap[project].cost += row.cost;
@@ -2226,7 +3045,8 @@ function createApiServer(db, options) {
           sessions: data.sessions,
           tokens: data.tokens,
           cost: data.cost,
-          percentage: Math.round(data.tokens / totalTokens * 1e3) / 10
+          percentage: Math.round(data.tokens / totalTokens * 1e3) / 10,
+          fullPath: data.fullPath
         })).sort((a, b) => b.tokens - a.tokens);
         json(res, { projects });
         return;
@@ -2376,6 +3196,11 @@ function createApiServer(db, options) {
         json(res, result);
         return;
       }
+      if (url.pathname === "/api/quotas" && req.method === "GET") {
+        const results = await queryAllQuotas();
+        json(res, { quotas: results });
+        return;
+      }
       if (url.pathname === "/api/devices") {
         let getDisplayName2 = function(device, deviceInstanceId) {
           if (deviceInstanceId === currentId) return currentDeviceAlias;
@@ -2416,7 +3241,7 @@ function createApiServer(db, options) {
           WHERE device_instance_id != @currentId
           GROUP BY device_instance_id
         `).all({ currentId });
-        const currentPlatform = config?.platform || platform2();
+        const currentPlatform = config?.platform || platform3();
         const deviceMap = /* @__PURE__ */ new Map();
         for (const row of localRows) {
           const displayName = getDisplayName2(row.device, row.deviceInstanceId);
@@ -2453,7 +3278,7 @@ function createApiServer(db, options) {
       if (url.pathname === "/api/config") {
         if (req.method === "GET") {
           const currentCfg = loadConfig() ?? {};
-          const osPlatform = platform2();
+          const osPlatform = platform3();
           const { credentials, priceOverrides, platform: _cfgPlatform, ...rest } = currentCfg;
           json(res, {
             device: rest.device ?? null,
@@ -2468,7 +3293,8 @@ function createApiServer(db, options) {
               opencode: rest.sources?.opencode ?? null,
               hermes: rest.sources?.hermes ?? null,
               qoder: rest.sources?.qoder ?? null,
-              "qoder-db": rest.sources?.["qoder-db"] ?? null
+              "qoder-db": rest.sources?.["qoder-db"] ?? null,
+              cursor: rest.sources?.cursor ?? null
             },
             sync: rest.sync ?? null,
             displayCurrency: rest.displayCurrency ?? "USD",
@@ -2531,7 +3357,7 @@ function createApiServer(db, options) {
             if (update.sources && typeof update.sources === "object") {
               const src = update.sources;
               const s = existing.sources ?? {};
-              for (const key of ["claude-code", "codex", "openclaw", "opencode", "hermes", "qoder", "qoder-db"]) {
+              for (const key of ["claude-code", "codex", "openclaw", "opencode", "hermes", "qoder", "qoder-db", "cursor"]) {
                 if (key in src) {
                   if (!src[key]) delete s[key];
                   else s[key] = String(src[key]);
@@ -2599,7 +3425,7 @@ function createApiServer(db, options) {
 }
 
 // src/commands/sync.ts
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 
 // src/db/synced-records.ts
 function insertSyncedRecord(db, record) {
@@ -2803,15 +3629,15 @@ var SyncOrchestrator = class {
     });
     if (paths.length === 0) return 0;
     let totalPulled = 0;
-    for (const [index, path3] of paths.entries()) {
+    for (const [index, path2] of paths.entries()) {
       this.options.onProgress?.({
         phase: "pulling",
-        currentPath: path3,
+        currentPath: path2,
         completedFiles: index,
         totalFiles: paths.length,
         pulledCount: totalPulled
       });
-      const content = await this.backend.readFile(path3);
+      const content = await this.backend.readFile(path2);
       if (!content) continue;
       for (const line of content.split("\n").filter(Boolean)) {
         try {
@@ -2829,7 +3655,7 @@ var SyncOrchestrator = class {
       }
       this.options.onProgress?.({
         phase: "pulling",
-        currentPath: path3,
+        currentPath: path2,
         completedFiles: index + 1,
         totalFiles: paths.length,
         pulledCount: totalPulled
@@ -2837,13 +3663,13 @@ var SyncOrchestrator = class {
     }
     return totalPulled;
   }
-  async uploadFile(path3, localSyncRecords) {
-    const existingContent = await this.backend.readFile(path3);
+  async uploadFile(path2, localSyncRecords) {
+    const existingContent = await this.backend.readFile(path2);
     const existing = existingContent ? parseNdjson(existingContent) : /* @__PURE__ */ new Map();
     const changedCount = mergeRecords(existing, localSyncRecords);
     if (changedCount === 0) return 0;
     const content = Array.from(existing.values()).map((r) => JSON.stringify(r)).join("\n") + "\n";
-    await this.backend.writeFile(path3, content);
+    await this.backend.writeFile(path2, content);
     return changedCount;
   }
   async upload() {
@@ -2851,9 +3677,9 @@ var SyncOrchestrator = class {
     if (unsynced.length === 0) return 0;
     const byPath = /* @__PURE__ */ new Map();
     for (const record of unsynced) {
-      const path3 = getSyncPath(record.ts, this.options.deviceInstanceId);
-      if (!byPath.has(path3)) byPath.set(path3, []);
-      byPath.get(path3).push(record);
+      const path2 = getSyncPath(record.ts, this.options.deviceInstanceId);
+      if (!byPath.has(path2)) byPath.set(path2, []);
+      byPath.get(path2).push(record);
     }
     let totalUploaded = 0;
     const uploads = Array.from(byPath.entries());
@@ -2863,20 +3689,20 @@ var SyncOrchestrator = class {
       totalFiles: uploads.length,
       uploadedCount: 0
     });
-    for (const [index, [path3, localRecords]] of uploads.entries()) {
+    for (const [index, [path2, localRecords]] of uploads.entries()) {
       this.options.onProgress?.({
         phase: "uploading",
-        currentPath: path3,
+        currentPath: path2,
         completedFiles: index,
         totalFiles: uploads.length,
         uploadedCount: totalUploaded
       });
       const localSyncRecords = localRecords.map(mapStatsRecordToSyncRecord);
-      const changedCount = await this.uploadFile(path3, localSyncRecords);
+      const changedCount = await this.uploadFile(path2, localSyncRecords);
       totalUploaded += changedCount;
       this.options.onProgress?.({
         phase: "uploading",
-        currentPath: path3,
+        currentPath: path2,
         completedFiles: index + 1,
         totalFiles: uploads.length,
         uploadedCount: totalUploaded
@@ -2915,7 +3741,7 @@ function verifyConsent(storedFingerprint, currentConfig) {
 import { execFile } from "child_process";
 import { promisify } from "util";
 import { readFile, writeFile, mkdir, readdir, stat } from "fs/promises";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 var exec = promisify(execFile);
 var GitSyncBackend = class _GitSyncBackend {
   repo;
@@ -2927,7 +3753,7 @@ var GitSyncBackend = class _GitSyncBackend {
     this.repo = config.repo;
     this.token = config.token;
     this.cacheDir = config.cacheDir;
-    this.dataDir = join4(config.cacheDir, "data");
+    this.dataDir = join5(config.cacheDir, "data");
     this.branch = config.branch ?? "main";
   }
   get remoteUrl() {
@@ -2959,7 +3785,7 @@ var GitSyncBackend = class _GitSyncBackend {
   /** Clone or pull the repo to get latest remote state */
   async prepare() {
     try {
-      await stat(join4(this.cacheDir, ".git"));
+      await stat(join5(this.cacheDir, ".git"));
       await this.git(["fetch", "origin", this.branch, "--depth=1"]);
       await this.git(["reset", "--hard", `origin/${this.branch}`]);
     } catch {
@@ -2974,17 +3800,17 @@ var GitSyncBackend = class _GitSyncBackend {
       }
     }
   }
-  async readFile(path3) {
+  async readFile(path2) {
     try {
-      const fullPath = join4(this.dataDir, path3);
+      const fullPath = join5(this.dataDir, path2);
       return await readFile(fullPath, "utf-8");
     } catch {
       return null;
     }
   }
-  async writeFile(path3, content) {
-    const fullPath = join4(this.dataDir, path3);
-    await mkdir(join4(fullPath, ".."), { recursive: true });
+  async writeFile(path2, content) {
+    const fullPath = join5(this.dataDir, path2);
+    await mkdir(join5(fullPath, ".."), { recursive: true });
     await writeFile(fullPath, content, "utf-8");
   }
   async listFiles() {
@@ -3018,7 +3844,7 @@ var GitSyncBackend = class _GitSyncBackend {
     for (const entry of entries) {
       const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
       if (entry.isDirectory()) {
-        files.push(...await this.walkDir(join4(dir, entry.name), relPath));
+        files.push(...await this.walkDir(join5(dir, entry.name), relPath));
       } else if (entry.name.endsWith(".ndjson")) {
         files.push(relPath);
       }
@@ -3045,11 +3871,11 @@ var S3SyncBackend = class {
       }
     });
   }
-  getObjectKey(path3) {
-    return `${this.prefix}${path3}`;
+  getObjectKey(path2) {
+    return `${this.prefix}${path2}`;
   }
-  async readFile(path3) {
-    const key = this.getObjectKey(path3);
+  async readFile(path2) {
+    const key = this.getObjectKey(path2);
     try {
       const command = new GetObjectCommand({
         Bucket: this.bucket,
@@ -3065,8 +3891,8 @@ var S3SyncBackend = class {
       throw error;
     }
   }
-  async writeFile(path3, content) {
-    const key = this.getObjectKey(path3);
+  async writeFile(path2, content) {
+    const key = this.getObjectKey(path2);
     const command = new PutObjectCommand({
       Bucket: this.bucket,
       Key: key,
@@ -3098,8 +3924,8 @@ var S3SyncBackend = class {
     } while (continuationToken);
     return files.sort();
   }
-  async fileExists(path3) {
-    const key = this.getObjectKey(path3);
+  async fileExists(path2) {
+    const key = this.getObjectKey(path2);
     try {
       const command = new HeadObjectCommand({
         Bucket: this.bucket,
@@ -3127,7 +3953,7 @@ function createBackend(config) {
     return new GitSyncBackend({
       repo: sync.repo,
       token,
-      cacheDir: join5(AIUSAGE_DIR, "sync-repo")
+      cacheDir: join6(AIUSAGE_DIR, "sync-repo")
     });
   }
   if (sync.backend === "s3") {
@@ -3348,6 +4174,7 @@ var RuntimeSettingsController = class {
 
 // src/commands/serve.ts
 var MAX_PORT_ATTEMPTS = 10;
+var PORT_FILE = join7(AIUSAGE_DIR, ".serve-port");
 var MIME_TYPES = {
   ".html": "text/html",
   ".js": "application/javascript",
@@ -3399,9 +4226,9 @@ function serve(options) {
     onConfigUpdated: () => runtimeSettings.reload()
   });
   const webBuildDir = (() => {
-    const prodDir = join6(dirname(fileURLToPath(import.meta.url)), "web");
-    if (existsSync5(prodDir)) return prodDir;
-    return join6(dirname(fileURLToPath(import.meta.url)), "..", "..", "..", "web", "build");
+    const prodDir = join7(dirname(fileURLToPath(import.meta.url)), "web");
+    if (existsSync6(prodDir)) return prodDir;
+    return join7(dirname(fileURLToPath(import.meta.url)), "..", "..", "..", "web", "build");
   })();
   const server = http2.createServer(async (req, res) => {
     const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
@@ -3409,19 +4236,19 @@ function serve(options) {
       apiServer.emit("request", req, res);
       return;
     }
-    if (existsSync5(webBuildDir)) {
-      let filePath = join6(webBuildDir, url.pathname);
+    if (existsSync6(webBuildDir)) {
+      let filePath = join7(webBuildDir, url.pathname);
       try {
         if (statSync2(filePath).isDirectory()) {
-          filePath = join6(filePath, "index.html");
+          filePath = join7(filePath, "index.html");
         }
       } catch {
       }
-      if (!existsSync5(filePath)) {
-        filePath = join6(webBuildDir, "index.html");
+      if (!existsSync6(filePath)) {
+        filePath = join7(webBuildDir, "index.html");
       }
       try {
-        const content = readFileSync5(filePath);
+        const content = readFileSync6(filePath);
         const ext = extname2(filePath);
         const contentType = MIME_TYPES[ext] ?? "application/octet-stream";
         res.writeHead(200, { "Content-Type": contentType });
@@ -3441,6 +4268,7 @@ function serve(options) {
   };
   server.on("listening", () => {
     started = true;
+    writeFileSync4(PORT_FILE, String(currentPort), "utf-8");
     console.log(`aiusage serve listening on http://localhost:${currentPort}`);
   });
   server.on("error", (error) => {
@@ -3456,14 +4284,22 @@ function serve(options) {
     throw error;
   });
   listenOnPort(options.port);
+  const cleanup = () => {
+    try {
+      unlinkSync(PORT_FILE);
+    } catch {
+    }
+  };
   process.on("SIGINT", () => {
     console.log("\nShutting down...");
+    cleanup();
     runtimeSettings.stop();
     server.close(() => {
       process.exit(0);
     });
   });
   process.on("SIGTERM", () => {
+    cleanup();
     runtimeSettings.stop();
     server.close(() => {
       process.exit(0);
@@ -3472,13 +4308,13 @@ function serve(options) {
 }
 
 // src/commands/init.ts
-import { platform as platform3 } from "os";
+import { platform as platform4 } from "os";
 function runInit(options) {
   const existingConfig = loadConfig();
   if (options.backend === "skip" || !options.backend) {
     const config = {
       device: options.device ?? existingConfig?.device,
-      platform: existingConfig?.platform ?? platform3(),
+      platform: existingConfig?.platform ?? platform4(),
       retentionDays: existingConfig?.retentionDays,
       parseInterval: existingConfig?.parseInterval,
       dashboardPollInterval: existingConfig?.dashboardPollInterval,
@@ -3501,7 +4337,7 @@ function runInit(options) {
         credentialRef: `github/${options.repo}/token`
       },
       device: options.device ?? existingConfig?.device,
-      platform: existingConfig?.platform ?? platform3(),
+      platform: existingConfig?.platform ?? platform4(),
       retentionDays: existingConfig?.retentionDays,
       parseInterval: existingConfig?.parseInterval,
       dashboardPollInterval: existingConfig?.dashboardPollInterval,
@@ -3547,7 +4383,7 @@ Consent recorded for schema v1.`
         credentialRef: `s3/${options.bucket}/accessKeyId`
       },
       device: options.device ?? existingConfig?.device,
-      platform: existingConfig?.platform ?? platform3(),
+      platform: existingConfig?.platform ?? platform4(),
       retentionDays: existingConfig?.retentionDays,
       parseInterval: existingConfig?.parseInterval,
       dashboardPollInterval: existingConfig?.dashboardPollInterval,
@@ -3672,9 +4508,9 @@ function generateSummary(db, options) {
 }
 
 // src/commands/status.ts
-import { statSync as statSync3, existsSync as existsSync6 } from "fs";
+import { statSync as statSync3, existsSync as existsSync7 } from "fs";
 import { hostname as hostname3 } from "os";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 function formatFileSize(bytes) {
   if (bytes < 1024) return `${bytes} B`;
   if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
@@ -3692,9 +4528,9 @@ function generateStatus(db) {
   const schemaVersion = db.prepare("SELECT version FROM schema_version ORDER BY version DESC LIMIT 1").get()?.version ?? 0;
   const tableCount = db.prepare("SELECT COUNT(*) as count FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%'").get()?.count ?? 0;
   const viewCount = db.prepare("SELECT COUNT(*) as count FROM sqlite_master WHERE type = 'view'").get()?.count ?? 0;
-  const sizePath = join7(AIUSAGE_DIR, "cache.db");
+  const sizePath = join8(AIUSAGE_DIR, "cache.db");
   let databaseSize = "0 B";
-  if (existsSync6(sizePath)) {
+  if (existsSync7(sizePath)) {
     try {
       const stat2 = statSync3(sizePath);
       databaseSize = formatFileSize(stat2.size);
@@ -3769,16 +4605,16 @@ function exportData(db, format) {
 }
 
 // src/commands/reset.ts
-import { unlinkSync, existsSync as existsSync7 } from "fs";
-import { join as join8 } from "path";
+import { unlinkSync as unlinkSync2, existsSync as existsSync8 } from "fs";
+import { join as join9 } from "path";
 function runReset(db) {
   const recordsResult = db.prepare("DELETE FROM records").run();
   const toolCallsResult = db.prepare("DELETE FROM tool_calls").run();
   const syncedResult = db.prepare("DELETE FROM synced_records").run();
-  const watermarkPath = join8(AIUSAGE_DIR, "watermark.json");
+  const watermarkPath = join9(AIUSAGE_DIR, "watermark.json");
   let watermarkRemoved = false;
-  if (existsSync7(watermarkPath)) {
-    unlinkSync(watermarkPath);
+  if (existsSync8(watermarkPath)) {
+    unlinkSync2(watermarkPath);
     watermarkRemoved = true;
   }
   return {
@@ -3858,6 +4694,59 @@ var ProgressReporter = class {
   }
 };
 
+// src/commands/widget.ts
+import { existsSync as existsSync9, readFileSync as readFileSync7 } from "fs";
+import { spawn, execSync as execSync2 } from "child_process";
+import { join as join10 } from "path";
+var WIDGET_PID_PATH = join10(AIUSAGE_DIR, "widget.pid");
+async function launchWidget() {
+  if (isWidgetRunning()) {
+    console.log("aiusage widget is already running in the system tray.");
+    return;
+  }
+  const electronBin = resolveElectronBin();
+  if (!electronBin) {
+    console.error(
+      "Widget not installed. Run: npm install -g @juliantanx/aiusage-widget"
+    );
+    process.exit(1);
+  }
+  const child = spawn(electronBin, [], {
+    detached: true,
+    stdio: "ignore",
+    shell: false
+  });
+  child.unref();
+  console.log("aiusage widget started.");
+}
+function isWidgetRunning() {
+  if (!existsSync9(WIDGET_PID_PATH)) return false;
+  let pid;
+  try {
+    pid = parseInt(readFileSync7(WIDGET_PID_PATH, "utf-8").trim(), 10);
+  } catch {
+    return false;
+  }
+  if (isNaN(pid)) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code !== "ESRCH";
+  }
+}
+function resolveElectronBin() {
+  try {
+    const result = execSync2(
+      process.platform === "win32" ? "where aiusage-widget" : "which aiusage-widget",
+      { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+    ).trim();
+    return result || null;
+  } catch {
+    return null;
+  }
+}
+
 // src/db/index.ts
 import Database2 from "better-sqlite3";
 import { mkdirSync as mkdirSync2 } from "fs";
@@ -4098,18 +4987,18 @@ function initializeDatabase(db) {
   applyPragmas(db);
   runMigrations(db);
 }
-function createDatabase(path3) {
-  mkdirSync2(dirname2(path3), { recursive: true, mode: 448 });
-  const db = new Database2(path3);
+function createDatabase(path2) {
+  mkdirSync2(dirname2(path2), { recursive: true, mode: 448 });
+  const db = new Database2(path2);
   initializeDatabase(db);
   return db;
 }
 
 // src/cli.ts
-import { join as join9 } from "path";
-var DB_PATH = join9(AIUSAGE_DIR, "cache.db");
+import { join as join11 } from "path";
+var DB_PATH = join11(AIUSAGE_DIR, "cache.db");
 var program = new Command();
-program.name("aiusage").version(true ? "1.3.0" : "dev").description("CLI tool for AI usage statistics");
+program.name("aiusage").version(true ? "1.3.1" : "dev").description("CLI tool for AI usage statistics");
 program.action(() => {
   const db = createDatabase(DB_PATH);
   const state = getState(AIUSAGE_DIR);
@@ -4136,7 +5025,7 @@ program.action(() => {
   }
   db.close();
 });
-program.command("summary").description("Show usage summary").option("--week", "Show this week").option("--month", "Show this month").option("--from <date>", "Start date (YYYY-MM-DD)").option("--to <date>", "End date (YYYY-MM-DD)").option("--device <id>", "Filter by device instance ID").option("--tool <tool>", "Filter by tool type (claude-code|codex|openclaw|opencode|hermes|qoder)").action((options) => {
+program.command("summary").description("Show usage summary").option("--week", "Show this week").option("--month", "Show this month").option("--from <date>", "Start date (YYYY-MM-DD)").option("--to <date>", "End date (YYYY-MM-DD)").option("--device <id>", "Filter by device instance ID").option("--tool <tool>", "Filter by tool type (claude-code|codex|openclaw|opencode|hermes|qoder|cursor)").action((options) => {
   const db = createDatabase(DB_PATH);
   const state = getState(AIUSAGE_DIR);
   const summary = generateSummary(db, {
@@ -4185,14 +5074,14 @@ program.command("export").description("Export data").requiredOption("--format <f
   const db = createDatabase(DB_PATH);
   const data = exportData(db, format);
   if (options.output) {
-    writeFileSync4(options.output, data, "utf-8");
+    writeFileSync5(options.output, data, "utf-8");
     console.log(`Exported to ${options.output}`);
   } else {
     console.log(data);
   }
   db.close();
 });
-program.command("parse").description("Parse AI tool session logs").option("--tool <tool>", "Specific tool to parse (claude-code|codex|openclaw|opencode|hermes|qoder)").option("--progress", "Show real-time progress").action(async (options) => {
+program.command("parse").description("Parse AI tool session logs").option("--tool <tool>", "Specific tool to parse (claude-code|codex|openclaw|opencode|hermes|qoder|cursor)").option("--progress", "Show real-time progress").action(async (options) => {
   const db = createDatabase(DB_PATH);
   const reporter = options.progress ? new ProgressReporter() : void 0;
   try {
@@ -4272,6 +5161,9 @@ program.command("sync").description("Sync data with cloud storage").action(async
   }
   db.close();
 });
+program.command("widget").description("Start the system tray widget").action(async () => {
+  await launchWidget();
+});
 
 // src/index.ts
 program.parse(process.argv);