@juliantanx/aiusage 1.0.1

package/dist/index.js

@@ -0,0 +1,2734 @@
+#!/usr/bin/env node
+import {
+  Aggregator,
+  DEFAULT_PRICE_TABLE,
+  calculateCost,
+  generateRecordId,
+  generateSessionKey,
+  generateSyncRecordId,
+  generateToolCallId,
+  getPriceTable,
+  getUserOverrides,
+  inferProvider,
+  removePriceOverride,
+  resolvePrice,
+  setPriceOverride
+} from "./chunk-C6IKRE2P.js";
+
+// src/cli.ts
+import { Command } from "commander";
+import { writeFileSync as writeFileSync4 } 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 { fileURLToPath } from "url";
+
+// src/api/server.ts
+import http from "http";
+import { hostname, platform } from "os";
+
+// src/config.ts
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var AIUSAGE_DIR = join(homedir(), ".aiusage");
+var CONFIG_PATH = join(AIUSAGE_DIR, "config.json");
+var SYNC_FIELDS = [
+  "ts",
+  "inputTokens",
+  "outputTokens",
+  "cacheReadTokens",
+  "cacheWriteTokens",
+  "thinkingTokens",
+  "cost",
+  "costSource",
+  "tool",
+  "model",
+  "provider",
+  "sessionKey",
+  "device",
+  "deviceInstanceId",
+  "updatedAt"
+];
+function loadConfig() {
+  if (!existsSync(CONFIG_PATH)) return null;
+  try {
+    return JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function saveConfig(config) {
+  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 384 });
+}
+function buildConsentConfig(config) {
+  const sync = config.sync;
+  if (!sync) return null;
+  const backend = sync.backend;
+  const target = backend === "github" ? sync.repo ?? "" : `${sync.bucket}/${sync.prefix ?? "aiusage/"}`;
+  const endpoint = backend === "github" ? "https://api.github.com" : sync.endpoint ?? "https://s3.amazonaws.com";
+  const region = sync.region ?? "global";
+  return {
+    backend,
+    target,
+    endpoint,
+    region,
+    fields: SYNC_FIELDS,
+    operations: ["read", "write"],
+    schemaVersion: "v1"
+  };
+}
+function loadCredential(key) {
+  const config = loadConfig();
+  if (!config?.credentials) return null;
+  return config.credentials[key] ?? null;
+}
+
+// src/api/server.ts
+function getDateRangeFilter(range, from, to, prefix = "") {
+  const ts = prefix ? `${prefix}.ts` : "ts";
+  if (from && to) {
+    const startMs = new Date(from).getTime();
+    const endMs = (/* @__PURE__ */ new Date(to + "T23:59:59.999Z")).getTime();
+    return { where: `AND ${ts} >= @start AND ${ts} < @end`, params: { start: startMs, end: endMs } };
+  }
+  const now = /* @__PURE__ */ new Date();
+  const today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+  if (range === "week") {
+    const dayOfWeek = today.getDay();
+    const startOfWeek = new Date(today);
+    startOfWeek.setDate(today.getDate() - dayOfWeek);
+    return { where: `AND ${ts} >= @start`, params: { start: startOfWeek.getTime() } };
+  }
+  if (range === "month") {
+    const startOfMonth = new Date(now.getFullYear(), now.getMonth(), 1);
+    return { where: `AND ${ts} >= @start`, params: { start: startOfMonth.getTime() } };
+  }
+  if (range === "last30") {
+    const start = new Date(today);
+    start.setDate(start.getDate() - 30);
+    return { where: `AND ${ts} >= @start`, params: { start: start.getTime() } };
+  }
+  if (range === "all") {
+    return { where: "", params: {} };
+  }
+  return { where: `AND ${ts} >= @start`, params: { start: today.getTime() } };
+}
+function json(res, data, status = 200) {
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(data));
+}
+function extractProject(sourceFile) {
+  const match = sourceFile.match(/\.claude\/projects\/([^/]+)/);
+  if (!match) return "unknown";
+  const raw = match[1];
+  const parts = raw.split("-").filter(Boolean);
+  const wpIdx = parts.indexOf("WebstormProjects");
+  if (wpIdx >= 0 && wpIdx < parts.length - 1) return parts.slice(wpIdx + 1).join("-");
+  const docIdx = parts.indexOf("Documents");
+  if (docIdx >= 0 && docIdx < parts.length - 1) return parts.slice(docIdx + 1).join("-");
+  if (parts.length <= 3) return "~";
+  return parts.slice(-2).join("-") || raw;
+}
+function getToolFilter(tool, prefix = "") {
+  if (!tool) return { where: "", params: {} };
+  const col = prefix ? `${prefix}.tool` : "tool";
+  return { where: `AND ${col} = @tool`, params: { tool } };
+}
+var LOCAL_ONLY_FILTER = "AND source_file NOT LIKE 'synced/%'";
+function getDeviceFilter(device, currentDeviceInstanceId) {
+  if (!currentDeviceInstanceId) {
+    return { where: "", params: {}, useUnion: false, localOnly: false };
+  }
+  if (!device) {
+    return {
+      where: "",
+      params: { currentDeviceId: currentDeviceInstanceId },
+      useUnion: true,
+      localOnly: true
+    };
+  }
+  if (device === currentDeviceInstanceId) {
+    return { where: "", params: {}, useUnion: false, localOnly: true };
+  }
+  return {
+    where: "AND device_instance_id = @deviceId",
+    params: { deviceId: device },
+    useUnion: false,
+    localOnly: false
+  };
+}
+function createApiServer(db, options) {
+  const server = http.createServer(async (req, res) => {
+    const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    const range = url.searchParams.get("range");
+    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"];
+    if (toolParam && !VALID_TOOLS.includes(toolParam)) {
+      json(res, { error: { code: "INVALID_PARAM", message: "Invalid tool" } }, 400);
+      return;
+    }
+    try {
+      if (url.pathname === "/api/summary") {
+        if (range && !["day", "week", "month", "last30", "all"].includes(range)) {
+          json(res, { error: { code: "INVALID_PARAM", message: "Invalid range" } }, 400);
+          return;
+        }
+        const device = url.searchParams.get("device");
+        const df = getDeviceFilter(device, options?.currentDeviceInstanceId);
+        const dr = getDateRangeFilter(range, from, to);
+        const tool = url.searchParams.get("tool");
+        const tf = getToolFilter(tool);
+        let totals;
+        let byToolRows;
+        if (df.useUnion) {
+          const unionSql = `
+            SELECT input_tokens, output_tokens, cache_read_tokens, cache_write_tokens, thinking_tokens, cost, ts, session_id
+            FROM records WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where}
+            UNION ALL
+            SELECT input_tokens, output_tokens, cache_read_tokens, cache_write_tokens, thinking_tokens, cost, ts, session_key AS session_id
+            FROM synced_records WHERE device_instance_id != @currentDeviceId ${dr.where} ${tf.where}
+          `;
+          totals = db.prepare(`
+            SELECT
+              COALESCE(SUM(input_tokens), 0) AS inputTokens,
+              COALESCE(SUM(output_tokens), 0) AS outputTokens,
+              COALESCE(SUM(cache_read_tokens), 0) AS cacheReadTokens,
+              COALESCE(SUM(cache_write_tokens), 0) AS cacheWriteTokens,
+              COALESCE(SUM(thinking_tokens), 0) AS thinkingTokens,
+              COALESCE(SUM(input_tokens + output_tokens + cache_read_tokens + cache_write_tokens + thinking_tokens), 0) AS totalTokens,
+              COALESCE(SUM(cost), 0) AS totalCost,
+              COUNT(DISTINCT strftime('%Y-%m-%d', ts/1000, 'unixepoch')) AS activeDays,
+              COUNT(DISTINCT session_id) AS totalSessions
+            FROM (${unionSql})
+          `).get({ ...dr.params, ...df.params, ...tf.params });
+          byToolRows = db.prepare(`
+            SELECT tool, SUM(tokens) AS tokens, SUM(cost) AS cost FROM (
+              SELECT tool,
+                     SUM(input_tokens + output_tokens + cache_read_tokens + cache_write_tokens + thinking_tokens) AS tokens,
+                     SUM(cost) AS cost
+              FROM records WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where}
+              GROUP BY tool
+              UNION ALL
+              SELECT tool,
+                     SUM(input_tokens + output_tokens + cache_read_tokens + cache_write_tokens + thinking_tokens) AS tokens,
+                     SUM(cost) AS cost
+              FROM synced_records WHERE device_instance_id != @currentDeviceId ${dr.where} ${tf.where}
+              GROUP BY tool
+            ) GROUP BY tool ORDER BY cost DESC
+          `).all({ ...dr.params, ...df.params, ...tf.params });
+        } else if (df.where) {
+          totals = db.prepare(`
+            SELECT
+              COALESCE(SUM(input_tokens), 0) AS inputTokens,
+              COALESCE(SUM(output_tokens), 0) AS outputTokens,
+              COALESCE(SUM(cache_read_tokens), 0) AS cacheReadTokens,
+              COALESCE(SUM(cache_write_tokens), 0) AS cacheWriteTokens,
+              COALESCE(SUM(thinking_tokens), 0) AS thinkingTokens,
+              COALESCE(SUM(input_tokens + output_tokens + cache_read_tokens + cache_write_tokens + thinking_tokens), 0) AS totalTokens,
+              COALESCE(SUM(cost), 0) AS totalCost,
+              COUNT(DISTINCT strftime('%Y-%m-%d', ts/1000, 'unixepoch')) AS activeDays,
+              COUNT(DISTINCT session_key) AS totalSessions
+            FROM synced_records WHERE 1=1 ${df.where} ${dr.where} ${tf.where}
+          `).get({ ...dr.params, ...df.params, ...tf.params });
+          byToolRows = db.prepare(`
+            SELECT tool,
+                   SUM(input_tokens + output_tokens + cache_read_tokens + cache_write_tokens + thinking_tokens) AS tokens,
+                   SUM(cost) AS cost
+            FROM synced_records WHERE 1=1 ${df.where} ${dr.where} ${tf.where}
+            GROUP BY tool ORDER BY cost DESC
+          `).all({ ...dr.params, ...df.params, ...tf.params });
+        } else {
+          totals = db.prepare(`
+            SELECT
+              COALESCE(SUM(input_tokens), 0) AS inputTokens,
+              COALESCE(SUM(output_tokens), 0) AS outputTokens,
+              COALESCE(SUM(cache_read_tokens), 0) AS cacheReadTokens,
+              COALESCE(SUM(cache_write_tokens), 0) AS cacheWriteTokens,
+              COALESCE(SUM(thinking_tokens), 0) AS thinkingTokens,
+              COALESCE(SUM(input_tokens + output_tokens + cache_read_tokens + cache_write_tokens + thinking_tokens), 0) AS totalTokens,
+              COALESCE(SUM(cost), 0) AS totalCost,
+              COUNT(DISTINCT strftime('%Y-%m-%d', ts/1000, 'unixepoch')) AS activeDays,
+              COUNT(DISTINCT session_id) AS totalSessions
+            FROM records WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where}
+          `).get({ ...dr.params, ...tf.params });
+          byToolRows = db.prepare(`
+            SELECT tool,
+                   SUM(input_tokens + output_tokens + cache_read_tokens + cache_write_tokens + thinking_tokens) AS tokens,
+                   SUM(cost) AS cost
+            FROM records WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where}
+            GROUP BY tool ORDER BY cost DESC
+          `).all({ ...dr.params, ...tf.params });
+        }
+        const byTool = {};
+        for (const row of byToolRows) {
+          byTool[row.tool] = { tokens: row.tokens, cost: row.cost };
+        }
+        const drJoin = getDateRangeFilter(range, from, to, "r");
+        const dfJoin = df.where ? df.where.replace(/device_instance_id/g, "r.device_instance_id") : "";
+        const tfJoin = getToolFilter(tool, "r");
+        const topToolCalls = db.prepare(`
+          SELECT tc.name, COUNT(*) AS count
+          FROM tool_calls tc
+          JOIN records r ON r.id = tc.record_id
+          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 });
+        json(res, {
+          inputTokens: totals.inputTokens,
+          outputTokens: totals.outputTokens,
+          cacheReadTokens: totals.cacheReadTokens,
+          cacheWriteTokens: totals.cacheWriteTokens,
+          thinkingTokens: totals.thinkingTokens,
+          totalTokens: totals.totalTokens,
+          totalCost: totals.totalCost,
+          activeDays: totals.activeDays,
+          totalSessions: totals.totalSessions,
+          byTool,
+          topToolCalls
+        });
+        return;
+      }
+      if (url.pathname === "/api/tokens") {
+        const dr = getDateRangeFilter(range, from, to);
+        const device = url.searchParams.get("device");
+        const df = getDeviceFilter(device, options?.currentDeviceInstanceId);
+        const tool = url.searchParams.get("tool");
+        const tf = getToolFilter(tool);
+        let sql;
+        let params;
+        if (df.useUnion) {
+          sql = `
+            SELECT strftime('%Y-%m-%d', ts/1000, 'unixepoch') AS date,
+                   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
+            FROM (
+              SELECT input_tokens, output_tokens, cache_read_tokens, cache_write_tokens, thinking_tokens, ts FROM records WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where}
+              UNION ALL
+              SELECT input_tokens, output_tokens, cache_read_tokens, cache_write_tokens, thinking_tokens, ts FROM synced_records WHERE device_instance_id != @currentDeviceId ${dr.where} ${tf.where}
+            )
+            GROUP BY date ORDER BY date`;
+          params = { ...dr.params, currentDeviceId: df.params.currentDeviceId, ...tf.params };
+        } else if (device && device !== options?.currentDeviceInstanceId) {
+          sql = `
+            SELECT strftime('%Y-%m-%d', ts/1000, 'unixepoch') AS date,
+                   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
+            FROM synced_records WHERE 1=1 ${df.where} ${dr.where} ${tf.where}
+            GROUP BY date ORDER BY date`;
+          params = { ...df.params, ...dr.params, ...tf.params };
+        } else {
+          sql = `
+            SELECT strftime('%Y-%m-%d', ts/1000, 'unixepoch') AS date,
+                   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
+            FROM records WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where}
+            GROUP BY date ORDER BY date`;
+          params = { ...dr.params, ...tf.params };
+        }
+        const rows = db.prepare(sql).all(params);
+        json(res, { data: rows });
+        return;
+      }
+      if (url.pathname === "/api/cost") {
+        const dr = getDateRangeFilter(range, from, to);
+        const device = url.searchParams.get("device");
+        const df = getDeviceFilter(device, options?.currentDeviceInstanceId);
+        const tool = url.searchParams.get("tool");
+        const tf = getToolFilter(tool);
+        let daily;
+        let byToolRows;
+        let byModelRows;
+        if (df.useUnion) {
+          daily = db.prepare(`
+            SELECT strftime('%Y-%m-%d', ts/1000, 'unixepoch') AS date,
+                   SUM(cost) AS cost
+            FROM (
+              SELECT cost, ts FROM records WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where}
+              UNION ALL
+              SELECT cost, ts FROM synced_records WHERE device_instance_id != @currentDeviceId ${dr.where} ${tf.where}
+            )
+            GROUP BY date ORDER BY date
+          `).all({ ...dr.params, currentDeviceId: df.params.currentDeviceId, ...tf.params });
+          byToolRows = db.prepare(`
+            SELECT tool, SUM(cost) AS cost FROM (
+              SELECT tool, SUM(cost) AS cost FROM records WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where} GROUP BY tool
+              UNION ALL
+              SELECT tool, SUM(cost) AS cost FROM synced_records WHERE device_instance_id != @currentDeviceId ${dr.where} ${tf.where} GROUP BY tool
+            ) GROUP BY tool ORDER BY cost DESC
+          `).all({ ...dr.params, currentDeviceId: df.params.currentDeviceId, ...tf.params });
+          byModelRows = db.prepare(`
+            SELECT model, SUM(cost) AS cost FROM (
+              SELECT model, SUM(cost) AS cost FROM records WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where} GROUP BY model
+              UNION ALL
+              SELECT model, SUM(cost) AS cost FROM synced_records WHERE device_instance_id != @currentDeviceId ${dr.where} ${tf.where} GROUP BY model
+            ) GROUP BY model ORDER BY cost DESC
+          `).all({ ...dr.params, currentDeviceId: df.params.currentDeviceId, ...tf.params });
+        } else if (device && device !== options?.currentDeviceInstanceId) {
+          daily = db.prepare(`
+            SELECT strftime('%Y-%m-%d', ts/1000, 'unixepoch') AS date,
+                   SUM(cost) AS cost
+            FROM synced_records WHERE 1=1 ${df.where} ${dr.where} ${tf.where}
+            GROUP BY date ORDER BY date
+          `).all({ ...df.params, ...dr.params, ...tf.params });
+          byToolRows = db.prepare(`
+            SELECT tool, SUM(cost) AS cost
+            FROM synced_records WHERE 1=1 ${df.where} ${dr.where} ${tf.where}
+            GROUP BY tool ORDER BY cost DESC
+          `).all({ ...df.params, ...dr.params, ...tf.params });
+          byModelRows = db.prepare(`
+            SELECT model, SUM(cost) AS cost
+            FROM synced_records WHERE 1=1 ${df.where} ${dr.where} ${tf.where}
+            GROUP BY model ORDER BY cost DESC
+          `).all({ ...df.params, ...dr.params, ...tf.params });
+        } else {
+          daily = db.prepare(`
+            SELECT strftime('%Y-%m-%d', ts/1000, 'unixepoch') AS date,
+                   SUM(cost) AS cost
+            FROM records WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where}
+            GROUP BY date ORDER BY date
+          `).all({ ...dr.params, ...tf.params });
+          byToolRows = db.prepare(`
+            SELECT tool, SUM(cost) AS cost
+            FROM records WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where}
+            GROUP BY tool ORDER BY cost DESC
+          `).all({ ...dr.params, ...tf.params });
+          byModelRows = db.prepare(`
+            SELECT model, SUM(cost) AS cost
+            FROM records WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where}
+            GROUP BY model ORDER BY cost DESC
+          `).all({ ...dr.params, ...tf.params });
+        }
+        const byTool = {};
+        for (const r of byToolRows) byTool[r.tool] = r.cost;
+        const byModel = {};
+        for (const r of byModelRows) byModel[r.model] = r.cost;
+        json(res, { data: daily, byTool, byModel });
+        return;
+      }
+      if (url.pathname === "/api/models") {
+        const dr = getDateRangeFilter(range, from, to);
+        const device = url.searchParams.get("device");
+        const df = getDeviceFilter(device, options?.currentDeviceInstanceId);
+        const tool = url.searchParams.get("tool");
+        const tf = getToolFilter(tool);
+        let total;
+        let rows;
+        if (df.useUnion) {
+          const unionSql = `
+            SELECT model, provider, COUNT(*) AS callCount,
+                   SUM(input_tokens + output_tokens + cache_read_tokens + cache_write_tokens + thinking_tokens) AS totalTokens
+            FROM records WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where}
+            GROUP BY model, provider
+            UNION ALL
+            SELECT model, provider, COUNT(*) AS callCount,
+                   SUM(input_tokens + output_tokens + cache_read_tokens + cache_write_tokens + thinking_tokens) AS totalTokens
+            FROM synced_records WHERE device_instance_id != @currentDeviceId ${dr.where} ${tf.where}
+            GROUP BY model, provider
+          `;
+          const mergedRows = db.prepare(`
+            SELECT model, provider, SUM(callCount) AS callCount, SUM(totalTokens) AS totalTokens
+            FROM (${unionSql})
+            GROUP BY model, provider ORDER BY callCount DESC
+          `).all({ ...dr.params, ...df.params, ...tf.params });
+          total = mergedRows.reduce((s, r) => s + r.callCount, 0) || 1;
+          rows = mergedRows;
+        } else if (device && device !== options?.currentDeviceInstanceId) {
+          rows = db.prepare(`
+            SELECT model, provider,
+                   COUNT(*) AS callCount,
+                   SUM(input_tokens + output_tokens + cache_read_tokens + cache_write_tokens + thinking_tokens) AS totalTokens
+            FROM synced_records WHERE 1=1 ${df.where} ${dr.where} ${tf.where}
+            GROUP BY model, provider ORDER BY callCount DESC
+          `).all({ ...df.params, ...dr.params, ...tf.params });
+          total = rows.reduce((s, r) => s + r.callCount, 0) || 1;
+        } else {
+          rows = db.prepare(`
+            SELECT model, provider,
+                   COUNT(*) AS callCount,
+                   SUM(input_tokens + output_tokens + cache_read_tokens + cache_write_tokens + thinking_tokens) AS totalTokens
+            FROM records WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where}
+            GROUP BY model, provider ORDER BY callCount DESC
+          `).all({ ...dr.params, ...tf.params });
+          total = rows.reduce((s, r) => s + r.callCount, 0) || 1;
+        }
+        const models = rows.map((r) => ({
+          model: r.model,
+          provider: r.provider,
+          callCount: r.callCount,
+          totalTokens: r.totalTokens,
+          percentage: Math.round(r.callCount / total * 1e3) / 10
+        }));
+        json(res, { models });
+        return;
+      }
+      if (url.pathname === "/api/tool-calls") {
+        const device = url.searchParams.get("device");
+        if (device && device !== options?.currentDeviceInstanceId) {
+          json(res, { toolCalls: [] });
+          return;
+        }
+        const dr = getDateRangeFilter(range, from, to, "r");
+        const tool = url.searchParams.get("tool");
+        const tf = getToolFilter(tool, "r");
+        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}
+        `).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}
+          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
+        }));
+        json(res, { toolCalls });
+        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);
+        const device = url.searchParams.get("device");
+        const df = getDeviceFilter(device, options?.currentDeviceInstanceId);
+        const tool = url.searchParams.get("tool");
+        if (device && !df.localOnly && !df.useUnion) {
+          json(res, {
+            sessions: [],
+            total: 0,
+            page,
+            pageSize
+          });
+          return;
+        }
+        const tf = getToolFilter(tool);
+        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}
+        `).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
+          WHERE 1=1 ${dr.where} ${df.localOnly ? LOCAL_ONLY_FILTER : ""} ${tf.where}
+          GROUP BY session_id
+          ORDER BY ts DESC
+          LIMIT @limit OFFSET @offset
+        `).all({ ...params, limit: pageSize, offset: (page - 1) * pageSize });
+        json(res, {
+          sessions,
+          total: totalRow.total,
+          page,
+          pageSize
+        });
+        return;
+      }
+      if (url.pathname === "/api/projects") {
+        const dr = getDateRangeFilter(range, from, to);
+        const device = url.searchParams.get("device");
+        const df = getDeviceFilter(device, options?.currentDeviceInstanceId);
+        const tool = url.searchParams.get("tool");
+        const tf = getToolFilter(tool);
+        if (df.where && !df.useUnion) {
+          json(res, { projects: [] });
+          return;
+        }
+        const rows = db.prepare(`
+          SELECT source_file,
+                 COUNT(*) AS sessionCount,
+                 SUM(input_tokens + output_tokens + cache_read_tokens + cache_write_tokens + thinking_tokens) AS totalTokens,
+                 SUM(cost) AS cost
+          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 projectMap = {};
+        for (const row of rows) {
+          const project = extractProject(row.source_file);
+          if (!projectMap[project]) projectMap[project] = { sessions: 0, tokens: 0, cost: 0 };
+          projectMap[project].sessions += row.sessionCount;
+          projectMap[project].tokens += row.totalTokens;
+          projectMap[project].cost += row.cost;
+        }
+        const totalTokens = Object.values(projectMap).reduce((s, p) => s + p.tokens, 0) || 1;
+        const projects = Object.entries(projectMap).map(([name, data]) => ({
+          name,
+          sessions: data.sessions,
+          tokens: data.tokens,
+          cost: data.cost,
+          percentage: Math.round(data.tokens / totalTokens * 1e3) / 10
+        })).sort((a, b) => b.tokens - a.tokens);
+        json(res, { projects });
+        return;
+      }
+      if (url.pathname === "/api/pricing") {
+        if (req.method === "GET") {
+          const table = getPriceTable();
+          const overrides = getUserOverrides();
+          const dbModels = db.prepare("SELECT DISTINCT model FROM records ORDER BY model").all();
+          const models = dbModels.map((r) => {
+            const model = r.model;
+            const exactPrice = table[model];
+            const resolvedPrice = resolvePrice(model);
+            const isOverride = model in overrides;
+            const isDefault = model in DEFAULT_PRICE_TABLE && !isOverride;
+            let matchedBy = null;
+            if (!exactPrice && resolvedPrice) {
+              for (const prefix of Object.keys(table)) {
+                if (model.startsWith(prefix) || model.toLowerCase().startsWith(prefix)) {
+                  matchedBy = prefix;
+                  break;
+                }
+              }
+              if (!matchedBy) {
+                const stripped = model.replace(/^[^/]+\//, "").toLowerCase();
+                for (const prefix of Object.keys(table)) {
+                  if (stripped.startsWith(prefix)) {
+                    matchedBy = prefix;
+                    break;
+                  }
+                }
+              }
+            }
+            return {
+              model,
+              price: resolvedPrice ?? null,
+              isDefault,
+              isOverride,
+              matchedBy
+            };
+          });
+          json(res, { models, overrides });
+          return;
+        }
+        if (req.method === "PUT") {
+          let body = "";
+          for await (const chunk of req) body += chunk;
+          try {
+            const data = JSON.parse(body);
+            if (!data.model || typeof data.input !== "number" || typeof data.output !== "number") {
+              json(res, { error: { code: "INVALID_PARAM", message: "model, input, output required" } }, 400);
+              return;
+            }
+            const entry = {
+              input: data.input,
+              output: data.output,
+              cacheRead: data.cacheRead,
+              cacheWrite: data.cacheWrite,
+              thinking: data.thinking
+            };
+            setPriceOverride(data.model, entry);
+            const cfg = loadConfig() ?? {};
+            cfg.priceOverrides = { ...cfg.priceOverrides, [data.model]: entry };
+            saveConfig(cfg);
+            json(res, { ok: true });
+          } catch {
+            json(res, { error: { code: "INVALID_JSON", message: "Invalid JSON body" } }, 400);
+          }
+          return;
+        }
+        if (req.method === "DELETE") {
+          const model = url.searchParams.get("model");
+          if (!model) {
+            json(res, { error: { code: "INVALID_PARAM", message: "model param required" } }, 400);
+            return;
+          }
+          removePriceOverride(model);
+          const cfg = loadConfig() ?? {};
+          if (cfg.priceOverrides) {
+            delete cfg.priceOverrides[model];
+            saveConfig(cfg);
+          }
+          json(res, { ok: true });
+          return;
+        }
+      }
+      if (url.pathname === "/api/pricing/recalc" && req.method === "POST") {
+        const { resolvePrice: resolvePrice2 } = await import("./dist-XHYTXDVT.js");
+        const BATCH_SIZE2 = 1e3;
+        let updated = 0;
+        let lastId = "";
+        while (true) {
+          const records = db.prepare(
+            "SELECT id, model, input_tokens, output_tokens, cache_read_tokens, cache_write_tokens, thinking_tokens FROM records WHERE id > ? ORDER BY id LIMIT ?"
+          ).all(lastId, BATCH_SIZE2);
+          if (records.length === 0) break;
+          const updateStmt = db.prepare("UPDATE records SET cost = ?, cost_source = ? WHERE id = ?");
+          const tx = db.transaction((batch) => {
+            for (const r of batch) {
+              const price = resolvePrice2(r.model);
+              if (!price) continue;
+              const cost = r.input_tokens / 1e6 * price.input + r.output_tokens / 1e6 * price.output + r.cache_read_tokens / 1e6 * (price.cacheRead ?? 0) + r.cache_write_tokens / 1e6 * (price.cacheWrite ?? 0) + r.thinking_tokens / 1e6 * (price.thinking ?? price.output);
+              updateStmt.run(cost, "pricing", r.id);
+              updated++;
+            }
+          });
+          tx(records);
+          lastId = records[records.length - 1].id;
+        }
+        json(res, { updated });
+        return;
+      }
+      if (url.pathname === "/api/sync") {
+        if (req.method === "POST") {
+          if (!options?.onSyncStart) {
+            json(res, { error: { code: "NOT_AVAILABLE", message: "Sync not configured" } }, 501);
+            return;
+          }
+          const result = options.onSyncStart();
+          json(res, result, result.accepted ? 202 : 200);
+          return;
+        }
+        const status = options?.getSyncStatus?.() ?? null;
+        json(res, { status });
+        return;
+      }
+      if (url.pathname === "/api/refresh") {
+        if (!options?.onRefresh) {
+          json(res, { error: { code: "NOT_AVAILABLE", message: "Refresh not available" } }, 501);
+          return;
+        }
+        const result = await options.onRefresh();
+        json(res, result);
+        return;
+      }
+      if (url.pathname === "/api/devices") {
+        let getDisplayName2 = function(device, deviceInstanceId) {
+          if (deviceInstanceId === currentId) return currentDeviceAlias;
+          if (device && device !== "unknown" && !/^[0-9a-f]{8}$/.test(device)) return device;
+          if (/^[0-9a-f]{8}-/.test(deviceInstanceId)) return deviceInstanceId.slice(0, 8);
+          if (device && device !== "unknown") return device;
+          return "Unknown Device";
+        }, getPlatformLabel2 = function(p) {
+          if (p === "win32") return "Windows";
+          if (p === "darwin") return "macOS";
+          if (p === "linux") return "Linux";
+          return "";
+        }, inferPlatform2 = function(device, deviceInstanceId) {
+          const name = (device || "").toLowerCase();
+          const id = (deviceInstanceId || "").toLowerCase();
+          if (/^(desktop|laptop)-/.test(name)) return "Windows";
+          if (name.endsWith(".local") || /macbook|imac|mac\s*mini|mac\s*pro|mac\s*studio/.test(name)) return "macOS";
+          if (/^(ubuntu|debian|centos|fedora|arch|linux|server|node|prod|dev|staging)/.test(name)) return "Linux";
+          return "";
+        };
+        var getDisplayName = getDisplayName2, getPlatformLabel = getPlatformLabel2, inferPlatform = inferPlatform2;
+        const currentId = options?.currentDeviceInstanceId;
+        if (!currentId) {
+          json(res, { currentDeviceInstanceId: null, devices: [] });
+          return;
+        }
+        const config = loadConfig();
+        const currentDeviceAlias = config?.device || hostname();
+        const localRows = db.prepare(`
+          SELECT device, device_instance_id AS deviceInstanceId, COUNT(*) AS recordCount
+          FROM records
+          WHERE device_instance_id = @currentId AND source_file NOT LIKE 'synced/%'
+          GROUP BY device_instance_id
+        `).all({ currentId });
+        const syncedRows = db.prepare(`
+          SELECT device, device_instance_id AS deviceInstanceId, platform, COUNT(*) AS recordCount
+          FROM synced_records
+          WHERE device_instance_id != @currentId
+          GROUP BY device_instance_id
+        `).all({ currentId });
+        const currentPlatform = config?.platform || platform();
+        const deviceMap = /* @__PURE__ */ new Map();
+        for (const row of localRows) {
+          const displayName = getDisplayName2(row.device, row.deviceInstanceId);
+          deviceMap.set(row.deviceInstanceId, { device: row.device, deviceInstanceId: row.deviceInstanceId, displayName, platform: getPlatformLabel2(currentPlatform), recordCount: row.recordCount });
+        }
+        for (const row of syncedRows) {
+          const displayName = getDisplayName2(row.device, row.deviceInstanceId);
+          const platformLabel = getPlatformLabel2(row.platform) || inferPlatform2(row.device, row.deviceInstanceId);
+          const existing = deviceMap.get(row.deviceInstanceId);
+          if (existing) {
+            existing.recordCount += row.recordCount;
+          } else {
+            deviceMap.set(row.deviceInstanceId, { device: row.device, deviceInstanceId: row.deviceInstanceId, displayName, platform: platformLabel, recordCount: row.recordCount });
+          }
+        }
+        const devices = [...deviceMap.values()].sort((a, b) => b.recordCount - a.recordCount);
+        json(res, { currentDeviceInstanceId: currentId, devices });
+        return;
+      }
+      json(res, { error: { code: "NOT_FOUND", message: "Endpoint not found" } }, 404);
+    } catch (error) {
+      console.error("API error:", error);
+      json(res, { error: { code: "INTERNAL", message: "Internal server error" } }, 500);
+    }
+  });
+  return server;
+}
+
+// src/commands/parse.ts
+import Database from "better-sqlite3";
+import { readFileSync as readFileSync4, readdirSync, statSync, existsSync as existsSync4 } from "fs";
+import { join as join3, extname } from "path";
+import { homedir as homedir2, hostname as hostname2, platform as platform2 } from "os";
+
+// src/db/records.ts
+function insertRecord(db, record) {
+  db.prepare(`
+    INSERT OR REPLACE INTO records (
+      id, ts, ingested_at, synced_at, updated_at, line_offset,
+      tool, model, provider, input_tokens, output_tokens,
+      cache_read_tokens, cache_write_tokens, thinking_tokens,
+      cost, cost_source, session_id, source_file, device, device_instance_id, platform
+    ) VALUES (
+      @id, @ts, @ingestedAt, @syncedAt, @updatedAt, @lineOffset,
+      @tool, @model, @provider, @inputTokens, @outputTokens,
+      @cacheReadTokens, @cacheWriteTokens, @thinkingTokens,
+      @cost, @costSource, @sessionId, @sourceFile, @device, @deviceInstanceId, @platform
+    )
+  `).run({
+    id: record.id,
+    ts: record.ts,
+    ingestedAt: record.ingestedAt,
+    syncedAt: record.syncedAt ?? null,
+    updatedAt: record.updatedAt,
+    lineOffset: record.lineOffset,
+    tool: record.tool,
+    model: record.model,
+    provider: record.provider,
+    inputTokens: record.inputTokens,
+    outputTokens: record.outputTokens,
+    cacheReadTokens: record.cacheReadTokens,
+    cacheWriteTokens: record.cacheWriteTokens,
+    thinkingTokens: record.thinkingTokens,
+    cost: record.cost,
+    costSource: record.costSource,
+    sessionId: record.sessionId,
+    sourceFile: record.sourceFile,
+    device: record.device,
+    deviceInstanceId: record.deviceInstanceId,
+    platform: record.platform ?? ""
+  });
+}
+function getUnsyncedRecords(db) {
+  const rows = db.prepare(
+    "SELECT * FROM records WHERE synced_at IS NULL OR updated_at > synced_at"
+  ).all();
+  return rows.map(mapRowToRecord);
+}
+function mapRowToRecord(row) {
+  return {
+    id: row.id,
+    ts: row.ts,
+    ingestedAt: row.ingested_at,
+    syncedAt: row.synced_at != null ? row.synced_at : void 0,
+    updatedAt: row.updated_at,
+    lineOffset: row.line_offset,
+    tool: row.tool,
+    model: row.model,
+    provider: row.provider,
+    inputTokens: row.input_tokens,
+    outputTokens: row.output_tokens,
+    cacheReadTokens: row.cache_read_tokens,
+    cacheWriteTokens: row.cache_write_tokens,
+    thinkingTokens: row.thinking_tokens,
+    cost: row.cost,
+    costSource: row.cost_source,
+    sessionId: row.session_id,
+    sourceFile: row.source_file,
+    device: row.device,
+    deviceInstanceId: row.device_instance_id,
+    platform: row.platform || void 0
+  };
+}
+
+// src/db/tool-calls.ts
+function insertToolCall(db, tc) {
+  db.prepare(`
+    INSERT OR REPLACE INTO tool_calls (id, record_id, tool, name, ts, call_index)
+    VALUES (@id, @recordId, @tool, @name, @ts, @callIndex)
+  `).run({
+    id: tc.id,
+    recordId: tc.recordId ?? null,
+    tool: tc.recordId ? null : tc.tool,
+    name: tc.name,
+    ts: tc.ts,
+    callIndex: tc.callIndex
+  });
+}
+function getToolCallStats(db) {
+  return db.prepare(`
+    SELECT name, COUNT(*) as count
+    FROM tool_calls
+    GROUP BY name
+    ORDER BY count DESC
+  `).all();
+}
+
+// src/init.ts
+import { mkdirSync, readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+import { randomUUID } from "crypto";
+function getState(aiusageDir) {
+  const statePath = join2(aiusageDir, "state.json");
+  if (!existsSync2(statePath)) return null;
+  try {
+    const content = readFileSync2(statePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function setState(aiusageDir, updates) {
+  const statePath = join2(aiusageDir, "state.json");
+  const current = getState(aiusageDir) ?? {
+    deviceInstanceId: randomUUID(),
+    lastSyncStatus: "ok"
+  };
+  const updated = { ...current, ...updates };
+  writeFileSync2(statePath, JSON.stringify(updated, null, 2), "utf-8");
+}
+
+// src/watermark.ts
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync as existsSync3 } from "fs";
+function defaultFileData() {
+  return {
+    "claude-code": {},
+    "codex": {},
+    "openclaw": {},
+    "opencode": {}
+  };
+}
+var WatermarkManager = class {
+  data;
+  path;
+  constructor(path) {
+    this.path = path;
+    this.data = this.load();
+  }
+  load() {
+    if (!existsSync3(this.path)) {
+      return { files: defaultFileData() };
+    }
+    try {
+      const content = readFileSync3(this.path, "utf-8");
+      const parsed = JSON.parse(content);
+      if (parsed && typeof parsed === "object" && !("files" in parsed)) {
+        return { files: { ...defaultFileData(), ...parsed } };
+      }
+      return { files: parsed.files ?? defaultFileData(), opencode: parsed.opencode ?? null };
+    } catch {
+      return { files: defaultFileData() };
+    }
+  }
+  save() {
+    writeFileSync3(this.path, JSON.stringify(this.data, null, 2), "utf-8");
+  }
+  getEntry(tool, filePath) {
+    return this.data.files[tool]?.[filePath] ?? null;
+  }
+  setEntry(tool, filePath, entry) {
+    if (!this.data.files[tool]) {
+      this.data.files[tool] = {};
+    }
+    this.data.files[tool][filePath] = entry;
+  }
+  cleanup(existingFiles) {
+    const existingSet = new Set(existingFiles);
+    for (const tool of Object.keys(this.data.files)) {
+      for (const filePath of Object.keys(this.data.files[tool])) {
+        if (!existingSet.has(filePath)) {
+          delete this.data.files[tool][filePath];
+        }
+      }
+    }
+  }
+  getOpenCodeCursor() {
+    return this.data.opencode ?? null;
+  }
+  setOpenCodeCursor(cursor) {
+    this.data.opencode = cursor;
+  }
+};
+
+// src/commands/parse-opencode.ts
+function runParseOpenCode(db, options) {
+  const { dbPath, device, deviceInstanceId, platform: platform4, now, cursor } = options;
+  const records = [];
+  const toolCalls = [];
+  const errors = [];
+  let lastCursor = null;
+  const messages = db.prepare(
+    `SELECT m.id, m.session_id, m.time_created, m.data
+       FROM message m
+       WHERE m.time_created > ? OR (m.time_created = ? AND m.id > ?)
+       ORDER BY m.time_created, m.id`
+  ).all(
+    cursor?.lastMessageCreatedAt ?? 0,
+    cursor?.lastMessageCreatedAt ?? 0,
+    cursor?.lastMessageId ?? ""
+  );
+  const partsStmt = db.prepare(
+    `SELECT id, message_id, session_id, time_created, data
+     FROM part
+     WHERE message_id = ?
+     ORDER BY time_created, id`
+  );
+  for (const message of messages) {
+    lastCursor = {
+      lastMessageCreatedAt: message.time_created,
+      lastMessageId: message.id
+    };
+    let parsed;
+    try {
+      parsed = JSON.parse(message.data);
+    } catch (e) {
+      errors.push(`message ${message.id}: invalid JSON: ${e instanceof Error ? e.message : e}`);
+      continue;
+    }
+    if (parsed.role !== "assistant" || !parsed.tokens) continue;
+    const inputTokens = parsed.tokens.input ?? 0;
+    const outputTokens = parsed.tokens.output ?? 0;
+    const reasoningTokens = parsed.tokens.reasoning ?? 0;
+    const cacheReadTokens = parsed.tokens.cache?.read ?? 0;
+    const cacheWriteTokens = parsed.tokens.cache?.write ?? 0;
+    if (inputTokens === 0 && outputTokens === 0 && reasoningTokens === 0 && cacheReadTokens === 0 && cacheWriteTokens === 0) continue;
+    const model = parsed.modelID ?? "unknown";
+    const provider = parsed.providerID ?? inferProvider(model);
+    const ts = parsed.time?.created ?? message.time_created;
+    const recordId = generateRecordId(deviceInstanceId, dbPath + ":" + message.id, message.time_created);
+    const tokenArgs = { inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens, thinkingTokens: reasoningTokens };
+    const calculatedCost = model !== "unknown" ? calculateCost(model, tokenArgs) : 0;
+    const logCostValid = parsed.cost != null && parsed.cost > 0;
+    const cost = logCostValid ? parsed.cost : calculatedCost;
+    const costSource = logCostValid ? "log" : calculatedCost > 0 ? "pricing" : "unknown";
+    const record = {
+      id: recordId,
+      ts,
+      ingestedAt: now,
+      updatedAt: now,
+      lineOffset: 0,
+      // DB-sourced records have no byte offset; use 0 as sentinel
+      tool: "opencode",
+      model,
+      provider,
+      inputTokens,
+      outputTokens,
+      cacheReadTokens,
+      cacheWriteTokens,
+      thinkingTokens: reasoningTokens,
+      cost,
+      costSource,
+      sessionId: message.session_id,
+      sourceFile: dbPath,
+      device,
+      deviceInstanceId,
+      platform: platform4
+    };
+    records.push(record);
+    const parts = partsStmt.all(message.id);
+    let callIndex = 0;
+    for (const part of parts) {
+      let partParsed;
+      try {
+        partParsed = JSON.parse(part.data);
+      } catch (e) {
+        errors.push(`message ${message.id} part ${part.id}: invalid JSON: ${e instanceof Error ? e.message : e}`);
+        continue;
+      }
+      if (partParsed.type === "tool" && partParsed.tool) {
+        toolCalls.push({
+          id: generateToolCallId(recordId, partParsed.tool, part.time_created, callIndex),
+          recordId,
+          name: partParsed.tool,
+          ts: part.time_created,
+          callIndex
+        });
+        callIndex++;
+      }
+    }
+  }
+  return { records, toolCalls, nextCursor: records.length > 0 ? lastCursor : null, errors };
+}
+
+// src/commands/parse.ts
+function findJsonlFiles(dir) {
+  const results = [];
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join3(dir, entry.name);
+      if (entry.isDirectory()) {
+        results.push(...findJsonlFiles(fullPath));
+      } else if (entry.isFile() && extname(entry.name) === ".jsonl") {
+        results.push(fullPath);
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+function defaultOpenCodeDbPath() {
+  const home = homedir2();
+  const plat = platform2();
+  if (plat === "win32") {
+    const appData = process.env.APPDATA ?? join3(home, "AppData", "Roaming");
+    return join3(appData, "opencode", "opencode.db");
+  }
+  if (plat === "darwin") {
+    return join3(home, "Library", "Application Support", "opencode", "opencode.db");
+  }
+  const xdgDataHome = process.env.XDG_DATA_HOME ?? join3(home, ".local", "share");
+  return join3(xdgDataHome, "opencode", "opencode.db");
+}
+function discoverLogFiles(sources) {
+  const home = homedir2();
+  const results = [];
+  const claudeDir = sources?.["claude-code"] ?? join3(home, ".claude", "projects");
+  if (existsSync4(claudeDir)) {
+    const claudePaths = findJsonlFiles(claudeDir);
+    if (claudePaths.length > 0) {
+      results.push({ tool: "claude-code", paths: claudePaths });
+    }
+  }
+  const codexDir = sources?.["codex"] ?? join3(home, ".codex", "sessions");
+  if (existsSync4(codexDir)) {
+    const codexPaths = findJsonlFiles(codexDir);
+    if (codexPaths.length > 0) {
+      results.push({ tool: "codex", paths: codexPaths });
+    }
+  }
+  const openclawBase = sources?.["openclaw"] ?? join3(home, ".openclaw", "agents");
+  if (existsSync4(openclawBase)) {
+    let openclawPaths;
+    if (sources?.["openclaw"]) {
+      openclawPaths = findJsonlFiles(openclawBase).filter((p) => !p.includes(".checkpoint."));
+    } else {
+      openclawPaths = [];
+      try {
+        const agentEntries = readdirSync(openclawBase, { withFileTypes: true });
+        for (const agentEntry of agentEntries) {
+          if (!agentEntry.isDirectory()) continue;
+          const sessionsDir = join3(openclawBase, agentEntry.name, "sessions");
+          if (existsSync4(sessionsDir)) {
+            openclawPaths.push(...findJsonlFiles(sessionsDir).filter((p) => !p.includes(".checkpoint.")));
+          }
+        }
+      } catch {
+      }
+    }
+    if (openclawPaths.length > 0) {
+      results.push({ tool: "openclaw", paths: openclawPaths });
+    }
+  }
+  return results;
+}
+function extractSessionId(filePath, tool) {
+  if (tool === "claude-code") {
+    const parts = filePath.split("/");
+    const filename = parts[parts.length - 1];
+    return filename.replace(".jsonl", "");
+  }
+  if (tool === "codex") {
+    const filename = filePath.split("/").pop() ?? "";
+    const match = filename.match(/rollout-(.+)\.jsonl$/);
+    return match ? match[1] : filename.replace(".jsonl", "");
+  }
+  if (tool === "openclaw") {
+    const filename = filePath.split("/").pop() ?? "";
+    return filename.replace(".jsonl", "");
+  }
+  return "unknown";
+}
+async function runParse(db, filterTool, options) {
+  const state = getState(AIUSAGE_DIR);
+  const config = loadConfig();
+  const device = config?.device || hostname2() || state?.deviceInstanceId?.slice(0, 8) || "unknown";
+  const deviceInstanceId = state?.deviceInstanceId ?? "unknown";
+  const devicePlatform = config?.platform;
+  const watermarkPath = join3(AIUSAGE_DIR, "watermark.json");
+  const wm = new WatermarkManager(watermarkPath);
+  const toolPaths = discoverLogFiles(config?.sources);
+  const aggregator = new Aggregator();
+  let parsedCount = 0;
+  let toolCallCount = 0;
+  const errors = [];
+  for (const { tool, paths } of toolPaths) {
+    if (filterTool && tool !== filterTool) continue;
+    for (const filePath of paths) {
+      try {
+        const stat2 = statSync(filePath);
+        const entry = wm.getEntry(tool, filePath);
+        const offset = entry?.offset ?? 0;
+        if (offset >= stat2.size) continue;
+        const content = readFileSync4(filePath, "utf-8");
+        const lines = content.split("\n");
+        let byteOffset = 0;
+        const sessionId = extractSessionId(filePath, tool);
+        for (const line of lines) {
+          if (!line.trim()) {
+            byteOffset += Buffer.byteLength(line, "utf-8") + 1;
+            continue;
+          }
+          if (byteOffset < offset) {
+            byteOffset += Buffer.byteLength(line, "utf-8") + 1;
+            continue;
+          }
+          const context = aggregator.createContext({
+            tool,
+            sourceFile: filePath,
+            lineOffset: byteOffset,
+            sessionId,
+            device,
+            deviceInstanceId,
+            platform: devicePlatform
+          });
+          const result = aggregator.parseLine(line, context);
+          if (result) {
+            insertRecord(db, result.record);
+            parsedCount++;
+            for (const tc of result.toolCalls) {
+              insertToolCall(db, tc);
+              toolCallCount++;
+            }
+          }
+          byteOffset += Buffer.byteLength(line, "utf-8") + 1;
+        }
+        const orphanResults = aggregator.finalize();
+        for (const result of orphanResults) {
+          for (const tc of result.toolCalls) {
+            insertToolCall(db, tc);
+            toolCallCount++;
+          }
+        }
+        wm.setEntry(tool, filePath, {
+          offset: stat2.size,
+          size: stat2.size,
+          mtime: stat2.mtimeMs
+        });
+        wm.save();
+      } catch (e) {
+        errors.push(`${filePath}: ${e instanceof Error ? e.message : e}`);
+      }
+    }
+  }
+  const openCodeDbPath = options?.openCodeDbPath ?? config?.sources?.["opencode"] ?? defaultOpenCodeDbPath();
+  if ((!filterTool || filterTool === "opencode") && existsSync4(openCodeDbPath)) {
+    try {
+      const openCodeDb = new Database(openCodeDbPath, { readonly: true });
+      try {
+        const result = runParseOpenCode(openCodeDb, {
+          dbPath: openCodeDbPath,
+          device,
+          deviceInstanceId,
+          platform: devicePlatform,
+          now: Date.now(),
+          cursor: wm.getOpenCodeCursor()
+        });
+        for (const record of result.records) insertRecord(db, record);
+        for (const tc of result.toolCalls) insertToolCall(db, tc);
+        if (result.nextCursor) {
+          wm.setOpenCodeCursor(result.nextCursor);
+          wm.save();
+        }
+        parsedCount += result.records.length;
+        toolCallCount += result.toolCalls.length;
+        errors.push(...result.errors);
+      } finally {
+        openCodeDb.close();
+      }
+    } catch (e) {
+      errors.push(`${openCodeDbPath}: ${e instanceof Error ? e.message : e}`);
+    }
+  }
+  if (deviceInstanceId !== "unknown") {
+    db.prepare(
+      `UPDATE records SET device_instance_id = ?, device = ? WHERE device_instance_id = 'unknown'`
+    ).run(deviceInstanceId, device);
+  }
+  if (devicePlatform) {
+    db.prepare(
+      `UPDATE records SET platform = ? WHERE platform = '' AND source_file NOT LIKE 'synced/%'`
+    ).run(devicePlatform);
+  }
+  return { parsedCount, toolCallCount, errors };
+}
+
+// src/commands/sync.ts
+import { join as join5 } from "path";
+
+// src/db/synced-records.ts
+function insertSyncedRecord(db, record) {
+  db.prepare(`
+    INSERT INTO synced_records (
+      id, ts, tool, model, provider, input_tokens, output_tokens,
+      cache_read_tokens, cache_write_tokens, thinking_tokens,
+      cost, cost_source, session_key, device, device_instance_id, platform, updated_at
+    ) VALUES (
+      @id, @ts, @tool, @model, @provider, @inputTokens, @outputTokens,
+      @cacheReadTokens, @cacheWriteTokens, @thinkingTokens,
+      @cost, @costSource, @sessionKey, @device, @deviceInstanceId, @platform, @updatedAt
+    )
+    ON CONFLICT(id) DO UPDATE SET
+      ts = excluded.ts,
+      tool = excluded.tool,
+      model = excluded.model,
+      provider = excluded.provider,
+      input_tokens = excluded.input_tokens,
+      output_tokens = excluded.output_tokens,
+      cache_read_tokens = excluded.cache_read_tokens,
+      cache_write_tokens = excluded.cache_write_tokens,
+      thinking_tokens = excluded.thinking_tokens,
+      cost = excluded.cost,
+      cost_source = excluded.cost_source,
+      session_key = excluded.session_key,
+      device = excluded.device,
+      device_instance_id = excluded.device_instance_id,
+      platform = excluded.platform,
+      updated_at = excluded.updated_at
+    WHERE excluded.updated_at > synced_records.updated_at
+  `).run({
+    id: record.id,
+    ts: record.ts,
+    tool: record.tool,
+    model: record.model,
+    provider: record.provider,
+    inputTokens: record.inputTokens,
+    outputTokens: record.outputTokens,
+    cacheReadTokens: record.cacheReadTokens,
+    cacheWriteTokens: record.cacheWriteTokens,
+    thinkingTokens: record.thinkingTokens,
+    cost: record.cost,
+    costSource: record.costSource,
+    sessionKey: record.sessionKey,
+    device: record.device,
+    deviceInstanceId: record.deviceInstanceId,
+    platform: record.platform ?? "",
+    updatedAt: record.updatedAt
+  });
+}
+function mergeSyncedRecordsIntoRecords(db) {
+  const now = Date.now();
+  const newRows = db.prepare(`
+    SELECT sr.* FROM synced_records sr
+    LEFT JOIN records r ON sr.id = r.id
+    WHERE r.id IS NULL
+  `).all();
+  if (newRows.length === 0) return 0;
+  const insertStmt = db.prepare(`
+    INSERT OR IGNORE INTO records (
+      id, ts, ingested_at, synced_at, updated_at, line_offset,
+      tool, model, provider, input_tokens, output_tokens,
+      cache_read_tokens, cache_write_tokens, thinking_tokens,
+      cost, cost_source, session_id, source_file, device, device_instance_id
+    ) VALUES (
+      @id, @ts, @ingestedAt, @syncedAt, @updatedAt, 0,
+      @tool, @model, @provider, @inputTokens, @outputTokens,
+      @cacheReadTokens, @cacheWriteTokens, @thinkingTokens,
+      @cost, @costSource, @sessionId, @sourceFile, @device, @deviceInstanceId
+    )
+  `);
+  const tx = db.transaction((rows) => {
+    for (const row of rows) {
+      insertStmt.run({
+        id: row.id,
+        ts: row.ts,
+        ingestedAt: now,
+        syncedAt: now,
+        updatedAt: row.updated_at,
+        tool: row.tool,
+        model: row.model,
+        provider: row.provider,
+        inputTokens: row.input_tokens,
+        outputTokens: row.output_tokens,
+        cacheReadTokens: row.cache_read_tokens,
+        cacheWriteTokens: row.cache_write_tokens,
+        thinkingTokens: row.thinking_tokens,
+        cost: row.cost,
+        costSource: row.cost_source,
+        sessionId: row.session_key,
+        sourceFile: `synced/${row.device_instance_id}`,
+        device: row.device,
+        deviceInstanceId: row.device_instance_id
+      });
+    }
+  });
+  tx(newRows);
+  return newRows.length;
+}
+
+// src/sync/mapper.ts
+function mapStatsRecordToSyncRecord(record) {
+  const id = record.sourceFile.startsWith("synced/") ? record.id : record.tool === "opencode" ? record.id : generateSyncRecordId(record.deviceInstanceId, record.sourceFile, record.lineOffset);
+  return {
+    id,
+    ts: record.ts,
+    tool: record.tool,
+    model: record.model,
+    provider: record.provider,
+    inputTokens: record.inputTokens,
+    outputTokens: record.outputTokens,
+    cacheReadTokens: record.cacheReadTokens,
+    cacheWriteTokens: record.cacheWriteTokens,
+    thinkingTokens: record.thinkingTokens,
+    cost: record.cost,
+    costSource: record.costSource,
+    sessionKey: generateSessionKey(record.device, record.sessionId),
+    device: record.device,
+    deviceInstanceId: record.deviceInstanceId,
+    platform: record.platform,
+    updatedAt: record.updatedAt
+  };
+}
+
+// src/sync/index.ts
+function getSyncPath(ts, deviceInstanceId) {
+  const d = new Date(ts);
+  const date = `${d.getUTCFullYear()}/${String(d.getUTCMonth() + 1).padStart(2, "0")}/${String(d.getUTCDate()).padStart(2, "0")}`;
+  return `${deviceInstanceId}/${date}.ndjson`;
+}
+function parseNdjson(content) {
+  const records = /* @__PURE__ */ new Map();
+  for (const line of content.split("\n").filter(Boolean)) {
+    try {
+      const record = JSON.parse(line);
+      if (typeof record.ts === "string") {
+        record.ts = new Date(record.ts).getTime();
+      }
+      if (typeof record.updatedAt === "string") {
+        record.updatedAt = new Date(record.updatedAt).getTime();
+      }
+      records.set(record.id, record);
+    } catch {
+    }
+  }
+  return records;
+}
+function mergeRecords(existing, newRecords) {
+  let changed = 0;
+  for (const record of newRecords) {
+    const prev = existing.get(record.id);
+    if (!prev || record.updatedAt > prev.updatedAt) {
+      existing.set(record.id, record);
+      changed++;
+    }
+  }
+  return changed;
+}
+var SyncOrchestrator = class {
+  db;
+  backend;
+  options;
+  constructor(db, backend, options) {
+    this.db = db;
+    this.backend = backend;
+    this.options = options;
+  }
+  async sync() {
+    if (!this.options.consentVerified) {
+      return { status: "blocked_pending_consent", pulledCount: 0, uploadedCount: 0, mergedCount: 0 };
+    }
+    try {
+      await this.backend.prepare?.();
+      const pulledCount = await this.pull();
+      this.options.onProgress?.({ phase: "merging", pulledCount });
+      const mergedCount = mergeSyncedRecordsIntoRecords(this.db);
+      const uploadedCount = await this.upload();
+      await this.backend.flush?.();
+      this.options.onProgress?.({ phase: "finalizing", pulledCount, uploadedCount });
+      return { status: "ok", pulledCount, uploadedCount, mergedCount };
+    } catch (error) {
+      return {
+        status: "failed",
+        pulledCount: 0,
+        uploadedCount: 0,
+        mergedCount: 0,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
+  async pull() {
+    const allPaths = await this.backend.listFiles();
+    const localDevicePrefix = `${this.options.deviceInstanceId}/`;
+    const paths = allPaths.filter((p) => !p.startsWith(localDevicePrefix));
+    this.options.onProgress?.({
+      phase: "pulling",
+      completedFiles: 0,
+      totalFiles: paths.length,
+      pulledCount: 0
+    });
+    if (paths.length === 0) return 0;
+    let totalPulled = 0;
+    for (const [index, path] of paths.entries()) {
+      this.options.onProgress?.({
+        phase: "pulling",
+        currentPath: path,
+        completedFiles: index,
+        totalFiles: paths.length,
+        pulledCount: totalPulled
+      });
+      const content = await this.backend.readFile(path);
+      if (!content) continue;
+      for (const line of content.split("\n").filter(Boolean)) {
+        try {
+          const record = JSON.parse(line);
+          if (typeof record.ts === "string") {
+            record.ts = new Date(record.ts).getTime();
+          }
+          if (typeof record.updatedAt === "string") {
+            record.updatedAt = new Date(record.updatedAt).getTime();
+          }
+          insertSyncedRecord(this.db, record);
+          totalPulled++;
+        } catch {
+        }
+      }
+      this.options.onProgress?.({
+        phase: "pulling",
+        currentPath: path,
+        completedFiles: index + 1,
+        totalFiles: paths.length,
+        pulledCount: totalPulled
+      });
+    }
+    return totalPulled;
+  }
+  async uploadFile(path, localSyncRecords) {
+    const existingContent = await this.backend.readFile(path);
+    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(path, content);
+    return changedCount;
+  }
+  async upload() {
+    const unsynced = getUnsyncedRecords(this.db);
+    if (unsynced.length === 0) return 0;
+    const byPath = /* @__PURE__ */ new Map();
+    for (const record of unsynced) {
+      const path = getSyncPath(record.ts, this.options.deviceInstanceId);
+      if (!byPath.has(path)) byPath.set(path, []);
+      byPath.get(path).push(record);
+    }
+    let totalUploaded = 0;
+    const uploads = Array.from(byPath.entries());
+    this.options.onProgress?.({
+      phase: "uploading",
+      completedFiles: 0,
+      totalFiles: uploads.length,
+      uploadedCount: 0
+    });
+    for (const [index, [path, localRecords]] of uploads.entries()) {
+      this.options.onProgress?.({
+        phase: "uploading",
+        currentPath: path,
+        completedFiles: index,
+        totalFiles: uploads.length,
+        uploadedCount: totalUploaded
+      });
+      const localSyncRecords = localRecords.map(mapStatsRecordToSyncRecord);
+      const changedCount = await this.uploadFile(path, localSyncRecords);
+      totalUploaded += changedCount;
+      this.options.onProgress?.({
+        phase: "uploading",
+        currentPath: path,
+        completedFiles: index + 1,
+        totalFiles: uploads.length,
+        uploadedCount: totalUploaded
+      });
+    }
+    const syncedAt = Date.now();
+    const updateStmt = this.db.prepare("UPDATE records SET synced_at = ? WHERE id = ?");
+    const tx = this.db.transaction((ids) => {
+      for (const id of ids) updateStmt.run(syncedAt, id);
+    });
+    tx(unsynced.map((r) => r.id));
+    return totalUploaded;
+  }
+};
+
+// src/sync/consent.ts
+import { createHash } from "crypto";
+function generateConsentFingerprint(config) {
+  const input = [
+    config.backend,
+    config.target,
+    config.endpoint,
+    config.region,
+    config.fields.join(","),
+    config.operations.join(","),
+    config.schemaVersion
+  ].join("|");
+  return createHash("sha256").update(input).digest("hex").slice(0, 16);
+}
+function verifyConsent(storedFingerprint, currentConfig) {
+  const currentFingerprint = generateConsentFingerprint(currentConfig);
+  return storedFingerprint === currentFingerprint;
+}
+
+// src/sync/git.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { readFile, writeFile, mkdir, readdir, stat } from "fs/promises";
+import { join as join4 } from "path";
+var exec = promisify(execFile);
+var GitSyncBackend = class _GitSyncBackend {
+  repo;
+  token;
+  cacheDir;
+  dataDir;
+  constructor(config) {
+    this.repo = config.repo;
+    this.token = config.token;
+    this.cacheDir = config.cacheDir;
+    this.dataDir = join4(config.cacheDir, "data");
+  }
+  get remoteUrl() {
+    return `https://x-access-token:${this.token}@github.com/${this.repo}.git`;
+  }
+  async git(args, cwd) {
+    const { stdout } = await exec("git", args, {
+      cwd: cwd ?? this.cacheDir,
+      timeout: 6e4,
+      env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
+    });
+    return stdout.trim();
+  }
+  /** Clone or pull the repo to get latest remote state */
+  async prepare() {
+    try {
+      await stat(join4(this.cacheDir, ".git"));
+      await this.git(["fetch", "origin", "main", "--depth=1"]);
+      await this.git(["reset", "--hard", "origin/main"]);
+    } catch {
+      await mkdir(this.cacheDir, { recursive: true });
+      await exec("git", ["clone", "--depth=1", this.remoteUrl, this.cacheDir], {
+        timeout: 12e4,
+        env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
+      });
+    }
+  }
+  async readFile(path) {
+    try {
+      const fullPath = join4(this.dataDir, path);
+      return await readFile(fullPath, "utf-8");
+    } catch {
+      return null;
+    }
+  }
+  async writeFile(path, content) {
+    const fullPath = join4(this.dataDir, path);
+    await mkdir(join4(fullPath, ".."), { recursive: true });
+    await writeFile(fullPath, content, "utf-8");
+  }
+  async listFiles() {
+    try {
+      return await this.walkDir(this.dataDir, "");
+    } catch {
+      return [];
+    }
+  }
+  static MAX_PUSH_RETRIES = 3;
+  /** Commit and push all changes. Returns true if anything was pushed. */
+  async flush() {
+    const status = await this.git(["status", "--porcelain"]);
+    if (!status) return false;
+    await this.git(["add", "data/"]);
+    await this.git(["commit", "-m", `sync ${(/* @__PURE__ */ new Date()).toISOString()}`]);
+    for (let attempt = 1; attempt <= _GitSyncBackend.MAX_PUSH_RETRIES; attempt++) {
+      try {
+        await this.git(["push", "origin", "main"]);
+        return true;
+      } catch (error) {
+        if (attempt >= _GitSyncBackend.MAX_PUSH_RETRIES) throw error;
+        await this.git(["pull", "--rebase", "origin", "main"]);
+      }
+    }
+    return false;
+  }
+  async walkDir(dir, prefix) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    const files = [];
+    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));
+      } else if (entry.name.endsWith(".ndjson")) {
+        files.push(relPath);
+      }
+    }
+    return files.sort();
+  }
+};
+
+// src/sync/s3.ts
+import { S3Client, GetObjectCommand, PutObjectCommand, HeadObjectCommand, ListObjectsV2Command } from "@aws-sdk/client-s3";
+var S3SyncBackend = class {
+  client;
+  bucket;
+  prefix;
+  constructor(config) {
+    this.bucket = config.bucket;
+    this.prefix = config.prefix.replace(/^\/+/, "").replace(/\/?$/, "/");
+    this.client = new S3Client({
+      region: config.region ?? "auto",
+      ...config.endpoint ? { endpoint: config.endpoint } : {},
+      credentials: {
+        accessKeyId: config.accessKeyId,
+        secretAccessKey: config.secretAccessKey
+      }
+    });
+  }
+  getObjectKey(path) {
+    return `${this.prefix}${path}`;
+  }
+  async readFile(path) {
+    const key = this.getObjectKey(path);
+    try {
+      const command = new GetObjectCommand({
+        Bucket: this.bucket,
+        Key: key
+      });
+      const response = await this.client.send(command);
+      if (!response.Body) return null;
+      return await response.Body.transformToString("utf-8");
+    } catch (error) {
+      if (error.name === "NoSuchKey" || error.$metadata?.httpStatusCode === 404) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  async writeFile(path, content) {
+    const key = this.getObjectKey(path);
+    const command = new PutObjectCommand({
+      Bucket: this.bucket,
+      Key: key,
+      Body: content,
+      ContentType: "application/x-ndjson"
+    });
+    await this.client.send(command);
+  }
+  async listFiles() {
+    const files = [];
+    let continuationToken;
+    do {
+      const command = new ListObjectsV2Command({
+        Bucket: this.bucket,
+        Prefix: `${this.prefix}data/`,
+        ContinuationToken: continuationToken
+      });
+      const response = await this.client.send(command);
+      if (response.Contents) {
+        for (const obj of response.Contents) {
+          const key = obj.Key;
+          const relPath = key.slice(`${this.prefix}data/`.length);
+          if (relPath.endsWith(".ndjson")) {
+            files.push(relPath);
+          }
+        }
+      }
+      continuationToken = response.IsTruncated ? response.NextContinuationToken : void 0;
+    } while (continuationToken);
+    return files.sort();
+  }
+  async fileExists(path) {
+    const key = this.getObjectKey(path);
+    try {
+      const command = new HeadObjectCommand({
+        Bucket: this.bucket,
+        Key: key
+      });
+      await this.client.send(command);
+      return true;
+    } catch (error) {
+      if (error.name === "NotFound" || error.$metadata?.httpStatusCode === 404) {
+        return false;
+      }
+      throw error;
+    }
+  }
+};
+
+// src/commands/sync.ts
+function createBackend(config) {
+  const sync = config.sync;
+  if (!sync) return null;
+  if (sync.backend === "github") {
+    if (!sync.repo) return null;
+    const token = loadCredential(`github/${sync.repo}/token`);
+    if (!token) return null;
+    return new GitSyncBackend({
+      repo: sync.repo,
+      token,
+      cacheDir: join5(AIUSAGE_DIR, "sync-repo")
+    });
+  }
+  if (sync.backend === "s3") {
+    if (!sync.bucket) return null;
+    const accessKeyId = loadCredential(`s3/${sync.bucket}/accessKeyId`);
+    const secretAccessKey = loadCredential(`s3/${sync.bucket}/secretAccessKey`);
+    if (!accessKeyId || !secretAccessKey) return null;
+    return new S3SyncBackend({
+      bucket: sync.bucket,
+      prefix: sync.prefix ?? "aiusage/",
+      accessKeyId,
+      secretAccessKey,
+      endpoint: sync.endpoint,
+      region: sync.region
+    });
+  }
+  return null;
+}
+function failedResult(error) {
+  return { status: "failed", pulledCount: 0, uploadedCount: 0, mergedCount: 0, error };
+}
+function blockedResult(error) {
+  return { status: "blocked_pending_consent", pulledCount: 0, uploadedCount: 0, mergedCount: 0, error };
+}
+async function runSync(db, options) {
+  const config = loadConfig();
+  if (!config?.sync) {
+    return failedResult('Cloud sync not configured. Run "aiusage init" first.');
+  }
+  const state = getState(AIUSAGE_DIR);
+  if (!state?.syncConsentAt || !state?.syncConsentTarget) {
+    setState(AIUSAGE_DIR, { lastSyncStatus: "blocked_pending_consent" });
+    return blockedResult('Sync consent not provided. Run "aiusage init" to approve.');
+  }
+  const consentConfig = buildConsentConfig(config);
+  if (!consentConfig) {
+    return failedResult("Invalid sync configuration.");
+  }
+  if (!verifyConsent(state.syncConsentTarget, consentConfig)) {
+    setState(AIUSAGE_DIR, { lastSyncStatus: "blocked_pending_consent" });
+    return blockedResult('Sync configuration has changed since last approval. Run "aiusage init" to re-approve.');
+  }
+  const backend = createBackend(config);
+  if (!backend) {
+    return failedResult("Could not create sync backend. Check credentials.");
+  }
+  const orchestrator = new SyncOrchestrator(db, backend, {
+    deviceInstanceId: state.deviceInstanceId,
+    consentVerified: true,
+    onProgress: options?.onProgress
+  });
+  const startedAt = Date.now();
+  const result = await orchestrator.sync();
+  const now = Date.now();
+  setState(AIUSAGE_DIR, {
+    lastSyncAt: now,
+    lastSyncStatus: result.status === "ok" ? "ok" : result.status,
+    lastSyncError: result.error,
+    lastSyncTarget: `${config.sync.backend}:${config.sync.repo ?? config.sync.bucket}`,
+    lastSyncUploaded: result.uploadedCount,
+    lastSyncPulled: result.pulledCount,
+    lastSyncDurationMs: now - startedAt
+  });
+  return result;
+}
+
+// src/sync/runtime.ts
+var SyncRuntimeController = class {
+  runSyncFn;
+  getPersistedState;
+  current = { isRunning: false };
+  constructor(options) {
+    this.runSyncFn = options.runSync;
+    this.getPersistedState = options.getPersistedState;
+  }
+  start() {
+    if (this.current.isRunning) {
+      return {
+        accepted: false,
+        alreadyRunning: true,
+        status: this.getStatus()
+      };
+    }
+    this.current = {
+      isRunning: true,
+      startedAt: Date.now()
+    };
+    setImmediate(() => {
+      void this.runInBackground();
+    });
+    return {
+      accepted: true,
+      alreadyRunning: false,
+      status: this.getStatus()
+    };
+  }
+  getStatus() {
+    const persisted = this.getPersistedState();
+    return {
+      ...this.current,
+      lastSyncAt: persisted?.lastSyncAt,
+      lastSyncStatus: persisted?.lastSyncStatus,
+      lastSyncError: persisted?.lastSyncError,
+      lastSyncTarget: persisted?.lastSyncTarget,
+      lastSyncUploaded: persisted?.lastSyncUploaded,
+      lastSyncPulled: persisted?.lastSyncPulled,
+      lastSyncDurationMs: persisted?.lastSyncDurationMs
+    };
+  }
+  async runInBackground() {
+    try {
+      await this.runSyncFn({
+        onProgress: (progress) => {
+          this.current = {
+            ...this.current,
+            isRunning: true,
+            phase: progress.phase,
+            currentPath: progress.currentPath,
+            completedFiles: progress.completedFiles,
+            totalFiles: progress.totalFiles,
+            pulledCount: progress.pulledCount,
+            uploadedCount: progress.uploadedCount
+          };
+        }
+      });
+    } finally {
+      this.current = { isRunning: false };
+    }
+  }
+};
+
+// src/commands/serve.ts
+var MIME_TYPES = {
+  ".html": "text/html",
+  ".js": "application/javascript",
+  ".css": "text/css",
+  ".json": "application/json",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2"
+};
+function serve(options) {
+  const config = loadConfig();
+  if (config?.priceOverrides) {
+    for (const [model, entry] of Object.entries(config.priceOverrides)) {
+      setPriceOverride(model, entry);
+    }
+  }
+  const syncRuntime = new SyncRuntimeController({
+    runSync: (runtimeOptions) => runSync(options.db, runtimeOptions).then(() => void 0),
+    getPersistedState: () => getState(AIUSAGE_DIR)
+  });
+  const apiServer = createApiServer(options.db, {
+    currentDeviceInstanceId: getState(AIUSAGE_DIR)?.deviceInstanceId,
+    onRefresh: () => runParse(options.db),
+    onSyncStart: () => syncRuntime.start(),
+    getSyncStatus: () => syncRuntime.getStatus()
+  });
+  const webBuildDir = join6(dirname(fileURLToPath(import.meta.url)), "web");
+  const server = http2.createServer(async (req, res) => {
+    const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
+    if (url.pathname.startsWith("/api/")) {
+      apiServer.emit("request", req, res);
+      return;
+    }
+    if (existsSync5(webBuildDir)) {
+      let filePath = join6(webBuildDir, url.pathname);
+      try {
+        if (statSync2(filePath).isDirectory()) {
+          filePath = join6(filePath, "index.html");
+        }
+      } catch {
+      }
+      if (!existsSync5(filePath)) {
+        filePath = join6(webBuildDir, "index.html");
+      }
+      try {
+        const content = readFileSync5(filePath);
+        const ext = extname2(filePath);
+        const contentType = MIME_TYPES[ext] ?? "application/octet-stream";
+        res.writeHead(200, { "Content-Type": contentType });
+        res.end(content);
+        return;
+      } catch {
+      }
+    }
+    res.writeHead(404, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: { code: "NOT_FOUND", message: "Web dashboard not found. Reinstall the package: npm install -g aiusage" } }));
+  });
+  server.listen(options.port, "0.0.0.0", () => {
+    console.log(`aiusage serve listening on http://localhost:${options.port}`);
+  });
+  process.on("SIGINT", () => {
+    console.log("\nShutting down...");
+    server.close(() => {
+      process.exit(0);
+    });
+  });
+  process.on("SIGTERM", () => {
+    server.close(() => {
+      process.exit(0);
+    });
+  });
+}
+
+// src/commands/init.ts
+import { platform as platform3 } 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(),
+      retentionDays: existingConfig?.retentionDays ?? 180,
+      parseInterval: existingConfig?.parseInterval ?? 60,
+      dashboardPollInterval: existingConfig?.dashboardPollInterval ?? 30,
+      credentials: existingConfig?.credentials
+    };
+    saveConfig(config);
+    return { success: true, message: "Configuration saved without cloud sync." };
+  }
+  if (options.backend === "github") {
+    if (!options.repo) {
+      return { success: false, message: "GitHub repository is required (format: username/repo-name)." };
+    }
+    if (!options.token) {
+      return { success: false, message: "GitHub Personal Access Token is required." };
+    }
+    const config = {
+      sync: {
+        backend: "github",
+        repo: options.repo,
+        credentialRef: `keychain://aiusage/github/${options.repo}`
+      },
+      device: options.device ?? existingConfig?.device,
+      platform: existingConfig?.platform ?? platform3(),
+      retentionDays: existingConfig?.retentionDays ?? 180,
+      parseInterval: existingConfig?.parseInterval ?? 60,
+      dashboardPollInterval: existingConfig?.dashboardPollInterval ?? 30,
+      credentials: {
+        ...existingConfig?.credentials,
+        [`github/${options.repo}/token`]: options.token
+      }
+    };
+    const consentConfig = buildConsentConfig(config);
+    if (!consentConfig) {
+      return { success: false, message: "Failed to build consent configuration." };
+    }
+    const fingerprint = generateConsentFingerprint(consentConfig);
+    saveConfig(config);
+    setState(AIUSAGE_DIR, {
+      syncConsentAt: Date.now(),
+      syncConsentTarget: fingerprint
+    });
+    return {
+      success: true,
+      message: `GitHub sync configured: ${options.repo}
+Consent recorded for schema v1.`
+    };
+  }
+  if (options.backend === "s3") {
+    if (!options.bucket) {
+      return { success: false, message: "S3 bucket name is required." };
+    }
+    if (!options.accessKeyId || !options.secretAccessKey) {
+      return { success: false, message: "S3 access key ID and secret access key are required." };
+    }
+    const prefix = options.prefix ?? "aiusage/";
+    if (!prefix || prefix === "/") {
+      return { success: false, message: "S3 prefix must not be empty or point to bucket root." };
+    }
+    const config = {
+      sync: {
+        backend: "s3",
+        bucket: options.bucket,
+        prefix,
+        endpoint: options.endpoint,
+        region: options.region ?? "auto",
+        credentialRef: `keychain://aiusage/s3/${options.bucket}`
+      },
+      device: options.device ?? existingConfig?.device,
+      platform: existingConfig?.platform ?? platform3(),
+      retentionDays: existingConfig?.retentionDays ?? 180,
+      parseInterval: existingConfig?.parseInterval ?? 60,
+      dashboardPollInterval: existingConfig?.dashboardPollInterval ?? 30,
+      credentials: {
+        ...existingConfig?.credentials,
+        [`s3/${options.bucket}/accessKeyId`]: options.accessKeyId,
+        [`s3/${options.bucket}/secretAccessKey`]: options.secretAccessKey
+      }
+    };
+    const consentConfig = buildConsentConfig(config);
+    if (!consentConfig) {
+      return { success: false, message: "Failed to build consent configuration." };
+    }
+    const fingerprint = generateConsentFingerprint(consentConfig);
+    saveConfig(config);
+    setState(AIUSAGE_DIR, {
+      syncConsentAt: Date.now(),
+      syncConsentTarget: fingerprint
+    });
+    return {
+      success: true,
+      message: `S3 sync configured: ${options.bucket}/${prefix}
+Consent recorded for schema v1.`
+    };
+  }
+  return { success: false, message: "Unknown backend." };
+}
+
+// src/commands/summary.ts
+function generateSummary(db, options) {
+  const currentId = options?.currentDeviceInstanceId;
+  const device = options?.device;
+  let totalsSql;
+  let totalsParams = {};
+  let byToolSql;
+  let byToolParams = {};
+  const localOnlyFilter = "AND source_file NOT LIKE 'synced/%'";
+  const toolWhere = options?.tool ? "AND tool = @tool" : "";
+  const toolParam = options?.tool ? { tool: options.tool } : {};
+  if (currentId && !device) {
+    totalsSql = `
+      SELECT
+        COALESCE(SUM(input_tokens + output_tokens + cache_read_tokens + cache_write_tokens + thinking_tokens), 0) AS totalTokens,
+        COALESCE(SUM(cost), 0) AS totalCost,
+        COUNT(*) AS recordCount
+      FROM (
+        SELECT input_tokens, output_tokens, cache_read_tokens, cache_write_tokens, thinking_tokens, cost FROM records WHERE 1=1 ${localOnlyFilter} ${toolWhere}
+        UNION ALL
+        SELECT input_tokens, output_tokens, cache_read_tokens, cache_write_tokens, thinking_tokens, cost FROM synced_records WHERE device_instance_id != @currentId ${toolWhere}
+      )`;
+    totalsParams = { currentId, ...toolParam };
+    byToolSql = `
+      SELECT tool,
+             SUM(input_tokens + output_tokens + cache_read_tokens + cache_write_tokens + thinking_tokens) AS tokens,
+             SUM(cost) AS cost
+      FROM (
+        SELECT tool, input_tokens, output_tokens, cache_read_tokens, cache_write_tokens, thinking_tokens, cost FROM records WHERE 1=1 ${localOnlyFilter} ${toolWhere}
+        UNION ALL
+        SELECT tool, input_tokens, output_tokens, cache_read_tokens, cache_write_tokens, thinking_tokens, cost FROM synced_records WHERE device_instance_id != @currentId ${toolWhere}
+      )
+      GROUP BY tool ORDER BY cost DESC`;
+    byToolParams = { currentId, ...toolParam };
+  } else if (currentId && device && device !== currentId) {
+    totalsSql = `
+      SELECT
+        COALESCE(SUM(input_tokens + output_tokens + cache_read_tokens + cache_write_tokens + thinking_tokens), 0) AS totalTokens,
+        COALESCE(SUM(cost), 0) AS totalCost,
+        COUNT(*) AS recordCount
+      FROM synced_records WHERE device_instance_id = @device ${toolWhere}`;
+    totalsParams = { device, ...toolParam };
+    byToolSql = `
+      SELECT tool,
+             SUM(input_tokens + output_tokens + cache_read_tokens + cache_write_tokens + thinking_tokens) AS tokens,
+             SUM(cost) AS cost
+      FROM synced_records WHERE device_instance_id = @device ${toolWhere}
+      GROUP BY tool ORDER BY cost DESC`;
+    byToolParams = { device, ...toolParam };
+  } else {
+    totalsSql = `
+      SELECT
+        COALESCE(SUM(input_tokens + output_tokens + cache_read_tokens + cache_write_tokens + thinking_tokens), 0) AS totalTokens,
+        COALESCE(SUM(cost), 0) AS totalCost,
+        COUNT(*) AS recordCount
+      FROM records WHERE 1=1 ${currentId ? localOnlyFilter : ""} ${toolWhere}`;
+    totalsParams = { ...toolParam };
+    byToolSql = `
+      SELECT tool,
+             SUM(input_tokens + output_tokens + cache_read_tokens + cache_write_tokens + thinking_tokens) AS tokens,
+             SUM(cost) AS cost
+      FROM records WHERE 1=1 ${currentId ? localOnlyFilter : ""} ${toolWhere}
+      GROUP BY tool ORDER BY cost DESC`;
+    byToolParams = { ...toolParam };
+  }
+  const totals = db.prepare(totalsSql).get(totalsParams);
+  const byToolRows = db.prepare(byToolSql).all(byToolParams);
+  const byTool = {};
+  for (const row of byToolRows) {
+    byTool[row.tool] = { tokens: row.tokens, cost: row.cost };
+  }
+  const toolCallStats = getToolCallStats(db);
+  let deviceCount = 1;
+  let deviceLabel = null;
+  if (currentId) {
+    const localDevices = db.prepare("SELECT DISTINCT device_instance_id FROM records").all();
+    const syncedDevices = db.prepare("SELECT DISTINCT device_instance_id FROM synced_records WHERE device_instance_id != ?").all(currentId);
+    const allDeviceIds = /* @__PURE__ */ new Set([...localDevices.map((d) => d.device_instance_id), ...syncedDevices.map((d) => d.device_instance_id)]);
+    deviceCount = allDeviceIds.size;
+    if (device) {
+      const row = db.prepare("SELECT device FROM synced_records WHERE device_instance_id = ? LIMIT 1").get(device);
+      deviceLabel = row?.device ?? device;
+    }
+  }
+  return {
+    totalTokens: totals.totalTokens,
+    totalCost: totals.totalCost,
+    recordCount: totals.recordCount,
+    byTool,
+    topToolCalls: toolCallStats.slice(0, 3),
+    deviceCount,
+    deviceLabel
+  };
+}
+
+// src/commands/status.ts
+import { statSync as statSync3, existsSync as existsSync6 } from "fs";
+import { join as join7 } from "path";
+function formatFileSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function getDatabasePath(db) {
+  const row = db.prepare("PRAGMA database_list").get();
+  if (!row?.file) return ":memory:";
+  return row.file;
+}
+function generateStatus(db) {
+  const state = getState(AIUSAGE_DIR);
+  const recordCount = db.prepare("SELECT COUNT(*) as count FROM records").get().count;
+  const dbPath = getDatabasePath(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");
+  let databaseSize = "0 B";
+  if (existsSync6(sizePath)) {
+    try {
+      const stat2 = statSync3(sizePath);
+      databaseSize = formatFileSize(stat2.size);
+    } catch {
+    }
+  }
+  return {
+    version: "0.0.1",
+    deviceName: state?.deviceInstanceId?.slice(0, 8) ?? "unknown",
+    dbPath,
+    databaseSize,
+    schemaVersion,
+    tableCount,
+    viewCount,
+    recordCount,
+    syncStatus: state?.lastSyncStatus ?? "not_configured",
+    lastSyncAt: state?.lastSyncAt
+  };
+}
+
+// src/commands/export.ts
+function exportData(db, format) {
+  const records = db.prepare("SELECT * FROM records").all();
+  if (format === "csv") {
+    const headers = "timestamp,tool,model,provider,input_tokens,output_tokens,cache_read_tokens,cache_write_tokens,thinking_tokens,cost,cost_source,session_id,device,device_instance_id";
+    const rows = records.map((r) => {
+      const ts = new Date(r.ts).toISOString();
+      return `${ts},${r.tool},${r.model},${r.provider},${r.input_tokens},${r.output_tokens},${r.cache_read_tokens},${r.cache_write_tokens},${r.thinking_tokens},${r.cost},${r.cost_source},${r.session_id},${r.device},${r.device_instance_id}`;
+    });
+    return [headers, ...rows].join("\n");
+  }
+  if (format === "json") {
+    const data = records.map((r) => ({
+      timestamp: new Date(r.ts).toISOString(),
+      tool: r.tool,
+      model: r.model,
+      provider: r.provider,
+      inputTokens: r.input_tokens,
+      outputTokens: r.output_tokens,
+      cacheReadTokens: r.cache_read_tokens,
+      cacheWriteTokens: r.cache_write_tokens,
+      thinkingTokens: r.thinking_tokens,
+      cost: r.cost,
+      costSource: r.cost_source,
+      sessionId: r.session_id,
+      device: r.device,
+      deviceInstanceId: r.device_instance_id
+    }));
+    return JSON.stringify(data, null, 2);
+  }
+  const lines = records.map((r) => JSON.stringify({
+    id: r.id,
+    ts: r.ts,
+    tool: r.tool,
+    model: r.model,
+    provider: r.provider,
+    inputTokens: r.input_tokens,
+    outputTokens: r.output_tokens,
+    cacheReadTokens: r.cache_read_tokens,
+    cacheWriteTokens: r.cache_write_tokens,
+    thinkingTokens: r.thinking_tokens,
+    cost: r.cost,
+    costSource: r.cost_source,
+    sessionKey: r.session_id,
+    device: r.device,
+    deviceInstanceId: r.device_instance_id,
+    updatedAt: r.updated_at
+  }));
+  return lines.join("\n");
+}
+
+// src/commands/clean.ts
+function cleanOldData(db, days) {
+  const cutoff = Date.now() - days * 864e5;
+  const recordsResult = db.prepare("DELETE FROM records WHERE ts < ?").run(cutoff);
+  const deletedCount = recordsResult.changes;
+  const syncedResult = db.prepare("DELETE FROM synced_records WHERE ts < ?").run(cutoff);
+  const deletedSyncedCount = syncedResult.changes;
+  const orphanResult = db.prepare("DELETE FROM tool_calls WHERE record_id IS NULL AND ts < ?").run(cutoff);
+  const deletedOrphanToolCalls = orphanResult.changes;
+  return {
+    deletedCount,
+    deletedSyncedCount,
+    deletedOrphanToolCalls
+  };
+}
+
+// src/commands/recalc.ts
+var BATCH_SIZE = 1e3;
+function recalcPricing(db) {
+  let updatedCount = 0;
+  let skippedCount = 0;
+  let lastId = "";
+  const updateStmt = db.prepare("UPDATE records SET cost = ?, updated_at = ? WHERE id = ?");
+  while (true) {
+    const records = db.prepare(
+      "SELECT id, model, input_tokens, output_tokens, cache_read_tokens, cache_write_tokens, thinking_tokens, cost, cost_source FROM records WHERE id > ? ORDER BY id LIMIT ?"
+    ).all(lastId, BATCH_SIZE);
+    if (records.length === 0) break;
+    for (const record of records) {
+      if (record.cost_source !== "pricing") {
+        skippedCount++;
+        continue;
+      }
+      const newCost = calculateCost(record.model, {
+        inputTokens: record.input_tokens,
+        outputTokens: record.output_tokens,
+        cacheReadTokens: record.cache_read_tokens,
+        cacheWriteTokens: record.cache_write_tokens,
+        thinkingTokens: record.thinking_tokens
+      });
+      if (newCost !== record.cost) {
+        updateStmt.run(newCost, Date.now(), record.id);
+        updatedCount++;
+      }
+    }
+    lastId = records[records.length - 1].id;
+  }
+  return { updatedCount, skippedCount };
+}
+
+// src/db/index.ts
+import Database2 from "better-sqlite3";
+import { mkdirSync as mkdirSync2 } from "fs";
+import { dirname as dirname2 } from "path";
+
+// src/db/schema.ts
+function applyPragmas(db) {
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  db.pragma("busy_timeout = 5000");
+}
+function createReadonlyViews(db) {
+  db.exec(`
+    CREATE VIEW IF NOT EXISTS v_usage_records AS
+    SELECT
+      id,
+      datetime(ts / 1000, 'unixepoch') || '.' || printf('%03d', ts % 1000) || 'Z' AS timestamp,
+      ts,
+      tool,
+      model,
+      provider,
+      input_tokens,
+      output_tokens,
+      cache_read_tokens,
+      cache_write_tokens,
+      thinking_tokens,
+      (input_tokens + output_tokens + cache_read_tokens + cache_write_tokens + thinking_tokens) AS total_tokens,
+      cost,
+      cost_source,
+      session_id,
+      source_file,
+      device,
+      device_instance_id,
+      ingested_at,
+      synced_at,
+      updated_at
+    FROM records;
+
+    CREATE VIEW IF NOT EXISTS v_tool_calls AS
+    SELECT
+      tc.id,
+      tc.record_id,
+      tc.name,
+      tc.tool AS tool_call_tool,
+      datetime(tc.ts / 1000, 'unixepoch') || '.' || printf('%03d', tc.ts % 1000) || 'Z' AS timestamp,
+      tc.ts,
+      tc.call_index,
+      r.tool,
+      r.model,
+      r.provider,
+      r.session_id,
+      r.source_file,
+      r.device,
+      r.device_instance_id
+    FROM tool_calls tc
+    LEFT JOIN records r ON r.id = tc.record_id;
+
+    CREATE VIEW IF NOT EXISTS v_sessions AS
+    SELECT
+      session_id,
+      tool,
+      model,
+      provider,
+      device,
+      device_instance_id,
+      COUNT(*) AS record_count,
+      MIN(ts) AS first_ts,
+      datetime(MIN(ts) / 1000, 'unixepoch') || '.' || printf('%03d', MIN(ts) % 1000) || 'Z' AS first_timestamp,
+      MAX(ts) AS last_ts,
+      datetime(MAX(ts) / 1000, 'unixepoch') || '.' || printf('%03d', MAX(ts) % 1000) || 'Z' AS last_timestamp,
+      SUM(input_tokens) AS input_tokens,
+      SUM(output_tokens) AS output_tokens,
+      SUM(cache_read_tokens) AS cache_read_tokens,
+      SUM(cache_write_tokens) AS cache_write_tokens,
+      SUM(thinking_tokens) AS thinking_tokens,
+      SUM(input_tokens + output_tokens + cache_read_tokens + cache_write_tokens + thinking_tokens) AS total_tokens,
+      SUM(cost) AS total_cost
+    FROM records
+    GROUP BY session_id, tool, model, provider, device, device_instance_id;
+  `);
+}
+function createSchemaVersionTable(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS schema_version (
+      version     INTEGER PRIMARY KEY,
+      applied_at  TEXT DEFAULT (datetime('now'))
+    )
+  `);
+}
+function createV1Schema(db) {
+  db.exec(`
+    CREATE TABLE records (
+      id                TEXT PRIMARY KEY,
+      ts                INTEGER NOT NULL,
+      ingested_at       INTEGER NOT NULL,
+      synced_at         INTEGER,
+      updated_at        INTEGER NOT NULL,
+      line_offset       INTEGER NOT NULL,
+      tool              TEXT NOT NULL,
+      model             TEXT NOT NULL,
+      provider          TEXT NOT NULL,
+      input_tokens      INTEGER DEFAULT 0,
+      output_tokens     INTEGER DEFAULT 0,
+      cache_read_tokens INTEGER DEFAULT 0,
+      cache_write_tokens INTEGER DEFAULT 0,
+      thinking_tokens   INTEGER DEFAULT 0,
+      cost              REAL DEFAULT 0,
+      cost_source       TEXT NOT NULL DEFAULT 'pricing',
+      session_id        TEXT NOT NULL,
+      source_file       TEXT NOT NULL,
+      device            TEXT NOT NULL,
+      device_instance_id TEXT NOT NULL
+    );
+
+    CREATE TABLE synced_records (
+      id                TEXT PRIMARY KEY,
+      ts                INTEGER NOT NULL,
+      tool              TEXT NOT NULL,
+      model             TEXT NOT NULL,
+      provider          TEXT NOT NULL,
+      input_tokens      INTEGER DEFAULT 0,
+      output_tokens     INTEGER DEFAULT 0,
+      cache_read_tokens INTEGER DEFAULT 0,
+      cache_write_tokens INTEGER DEFAULT 0,
+      thinking_tokens   INTEGER DEFAULT 0,
+      cost              REAL DEFAULT 0,
+      cost_source       TEXT NOT NULL DEFAULT 'pricing',
+      session_key       TEXT NOT NULL,
+      device            TEXT NOT NULL,
+      device_instance_id TEXT NOT NULL,
+      platform          TEXT NOT NULL DEFAULT '',
+      updated_at        INTEGER NOT NULL
+    );
+
+    CREATE TABLE sync_tombstones (
+      id                TEXT NOT NULL,
+      device_scope      TEXT NOT NULL,
+      deleted_at        INTEGER NOT NULL,
+      reason            TEXT NOT NULL,
+      PRIMARY KEY (id, device_scope)
+    );
+
+    CREATE TABLE tool_calls (
+      id          TEXT PRIMARY KEY,
+      record_id   TEXT REFERENCES records(id) ON DELETE CASCADE,
+      tool        TEXT,
+      name        TEXT NOT NULL,
+      ts          INTEGER NOT NULL,
+      call_index  INTEGER DEFAULT 0
+    );
+
+    CREATE INDEX idx_records_ts         ON records(ts DESC);
+    CREATE INDEX idx_records_ingested   ON records(ingested_at DESC);
+    CREATE INDEX idx_records_updated    ON records(updated_at DESC);
+    CREATE INDEX idx_records_tool       ON records(tool);
+    CREATE INDEX idx_records_model      ON records(model);
+    CREATE INDEX idx_records_session    ON records(session_id);
+    CREATE INDEX idx_records_source     ON records(source_file);
+    CREATE INDEX idx_records_cost_source ON records(cost_source);
+    CREATE INDEX idx_synced_records_ts      ON synced_records(ts DESC);
+    CREATE INDEX idx_synced_records_tool    ON synced_records(tool);
+    CREATE INDEX idx_synced_records_model   ON synced_records(model);
+    CREATE INDEX idx_synced_records_session ON synced_records(session_key);
+    CREATE INDEX idx_synced_records_device  ON synced_records(device);
+    CREATE INDEX idx_synced_records_updated ON synced_records(updated_at DESC);
+    CREATE INDEX idx_sync_tombstones_deleted_at ON sync_tombstones(deleted_at DESC);
+    CREATE INDEX idx_tombstones_device_scope ON sync_tombstones(device_scope);
+    CREATE INDEX idx_tc_record_id       ON tool_calls(record_id);
+    CREATE INDEX idx_tc_name            ON tool_calls(name);
+    CREATE INDEX idx_tc_ts              ON tool_calls(ts DESC);
+  `);
+}
+
+// src/db/migrations/v1.ts
+function migrateV1(db) {
+  createV1Schema(db);
+  db.prepare("INSERT INTO schema_version (version) VALUES (1)").run();
+}
+
+// src/db/migrations/v2.ts
+function migrateV2(db) {
+  const columns = db.prepare("PRAGMA table_info('synced_records')").all();
+  if (!columns.some((column) => column.name === "platform")) {
+    db.exec(`ALTER TABLE synced_records ADD COLUMN platform TEXT NOT NULL DEFAULT ''`);
+  }
+  db.prepare("INSERT INTO schema_version (version) VALUES (2)").run();
+}
+
+// src/db/migrations/v3.ts
+function migrateV3(db) {
+  createReadonlyViews(db);
+  db.prepare("INSERT INTO schema_version (version) VALUES (3)").run();
+}
+
+// src/db/migrations/v4.ts
+function migrateV4(db) {
+  const columns = db.prepare("PRAGMA table_info('records')").all();
+  if (!columns.some((c) => c.name === "platform")) {
+    db.exec(`ALTER TABLE records ADD COLUMN platform TEXT NOT NULL DEFAULT ''`);
+  }
+  db.prepare("INSERT INTO schema_version (version) VALUES (4)").run();
+}
+
+// src/db/migrations/index.ts
+var MIGRATIONS = [
+  { version: 1, migrate: migrateV1 },
+  { version: 2, migrate: migrateV2 },
+  { version: 3, migrate: migrateV3 },
+  { version: 4, migrate: migrateV4 }
+];
+function runMigrations(db) {
+  createSchemaVersionTable(db);
+  const currentVersion = db.prepare(
+    "SELECT version FROM schema_version ORDER BY version DESC LIMIT 1"
+  ).get();
+  const current = currentVersion?.version ?? 0;
+  for (const migration of MIGRATIONS) {
+    if (migration.version > current) {
+      db.transaction(() => {
+        migration.migrate(db);
+      })();
+    }
+  }
+}
+
+// src/db/index.ts
+function initializeDatabase(db) {
+  applyPragmas(db);
+  runMigrations(db);
+}
+function createDatabase(path) {
+  mkdirSync2(dirname2(path), { recursive: true, mode: 448 });
+  const db = new Database2(path);
+  initializeDatabase(db);
+  return db;
+}
+
+// src/cli.ts
+import { join as join8 } from "path";
+var DB_PATH = join8(AIUSAGE_DIR, "cache.db");
+var program = new Command();
+program.name("aiusage").version("1.0.1").description("CLI tool for AI usage statistics");
+program.action(() => {
+  const db = createDatabase(DB_PATH);
+  const state = getState(AIUSAGE_DIR);
+  const summary = generateSummary(db, {
+    currentDeviceInstanceId: state?.deviceInstanceId
+  });
+  if (summary.deviceCount > 1) {
+    console.log(`\u8BBE\u5907\uFF1A\u5168\u90E8\uFF08${summary.deviceCount} \u53F0\u8BBE\u5907\u5728\u7EBF\uFF09`);
+  }
+  console.log(`Total Tokens: ${summary.totalTokens.toLocaleString()}`);
+  console.log(`Total Cost:   $${summary.totalCost.toFixed(4)}`);
+  console.log(`Records:      ${summary.recordCount}`);
+  if (Object.keys(summary.byTool).length > 0) {
+    console.log("\nBy Tool:");
+    for (const [tool, stats] of Object.entries(summary.byTool)) {
+      console.log(`  ${tool}: ${stats.tokens.toLocaleString()} tokens, $${stats.cost.toFixed(4)}`);
+    }
+  }
+  if (summary.topToolCalls.length > 0) {
+    console.log("\nTop Tool Calls:");
+    for (const tc of summary.topToolCalls) {
+      console.log(`  ${tc.name}: ${tc.count}`);
+    }
+  }
+  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)").action((options) => {
+  const db = createDatabase(DB_PATH);
+  const state = getState(AIUSAGE_DIR);
+  const summary = generateSummary(db, {
+    currentDeviceInstanceId: state?.deviceInstanceId,
+    device: options.device,
+    tool: options.tool
+  });
+  if (summary.deviceLabel) {
+    console.log(`\u8BBE\u5907\uFF1A${summary.deviceLabel}`);
+  } else if (summary.deviceCount > 1) {
+    console.log(`\u8BBE\u5907\uFF1A\u5168\u90E8\uFF08${summary.deviceCount} \u53F0\u8BBE\u5907\u5728\u7EBF\uFF09`);
+  }
+  console.log(`Total Tokens: ${summary.totalTokens.toLocaleString()}`);
+  console.log(`Total Cost:   $${summary.totalCost.toFixed(4)}`);
+  console.log(`Records:      ${summary.recordCount}`);
+  if (Object.keys(summary.byTool).length > 0) {
+    console.log("\nBy Tool:");
+    for (const [tool, stats] of Object.entries(summary.byTool)) {
+      console.log(`  ${tool}: ${stats.tokens.toLocaleString()} tokens, $${stats.cost.toFixed(4)}`);
+    }
+  }
+  db.close();
+});
+program.command("status").description("Show current status").action(() => {
+  const db = createDatabase(DB_PATH);
+  const status = generateStatus(db);
+  console.log(`Version:     ${status.version}`);
+  console.log(`Device:      ${status.deviceName}`);
+  console.log(`DB Path:     ${status.dbPath}`);
+  console.log(`Schema:      v${status.schemaVersion}`);
+  console.log(`Objects:     ${status.tableCount} tables, ${status.viewCount} views`);
+  console.log(`Records:     ${status.recordCount}`);
+  console.log(`DB Size:     ${status.databaseSize}`);
+  console.log(`Sync Status: ${status.syncStatus}`);
+  if (status.lastSyncAt) {
+    console.log(`Last Sync:   ${new Date(status.lastSyncAt).toISOString()}`);
+  }
+  db.close();
+});
+program.command("export").description("Export data").requiredOption("--format <format>", "Output format (csv|json|ndjson)").option("--range <range>", "Time range (day|week|month)").option("--from <date>", "Start date (YYYY-MM-DD)").option("--to <date>", "End date (YYYY-MM-DD)").option("-o, --output <file>", "Output file (default: stdout)").action((options) => {
+  const format = options.format;
+  if (!["csv", "json", "ndjson"].includes(format)) {
+    console.error("Invalid format. Use csv, json, or ndjson.");
+    process.exit(1);
+  }
+  const db = createDatabase(DB_PATH);
+  const data = exportData(db, format);
+  if (options.output) {
+    writeFileSync4(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)").action(async (options) => {
+  const db = createDatabase(DB_PATH);
+  try {
+    const result = await runParse(db, options.tool);
+    console.log(`Parsed ${result.parsedCount} records, ${result.toolCallCount} tool calls.`);
+    if (result.errors.length > 0) {
+      console.warn(`${result.errors.length} errors encountered.`);
+    }
+  } catch (e) {
+    console.error(`Parse failed: ${e instanceof Error ? e.message : e}`);
+    process.exit(1);
+  } finally {
+    db.close();
+  }
+});
+program.command("clean").description("Clean old data").option("--before <duration>", "Duration (e.g., 30d)", "180d").option("--remote", "Also clean remote data").option("--all-devices", "Clean all devices (with --remote)").option("--yes", "Skip confirmation").option("--approve-delete", "Approve delete permission upgrade").action((options) => {
+  const daysMatch = options.before.match(/^(\d+)d$/);
+  if (!daysMatch) {
+    console.error("Invalid duration format. Use e.g. 30d, 180d.");
+    process.exit(1);
+  }
+  const days = parseInt(daysMatch[1], 10);
+  const db = createDatabase(DB_PATH);
+  const result = cleanOldData(db, days);
+  console.log(`Deleted ${result.deletedCount} records, ${result.deletedSyncedCount} synced records, ${result.deletedOrphanToolCalls} orphan tool calls.`);
+  db.close();
+});
+program.command("recalc").description("Recalculate costs").option("--pricing", "Recalculate using latest pricing").action(() => {
+  const db = createDatabase(DB_PATH);
+  const result = recalcPricing(db);
+  console.log(`Updated ${result.updatedCount} records, skipped ${result.skippedCount}.`);
+  db.close();
+});
+program.command("serve").description("Start web dashboard").option("-p, --port <port>", "Port number", "3847").action((options) => {
+  const db = createDatabase(DB_PATH);
+  serve({ port: parseInt(options.port), db });
+});
+program.command("init").description("Configure cloud sync").option("--backend <backend>", "Sync backend (github|s3|skip)").option("--repo <repo>", "GitHub repository (format: username/repo-name)").option("--token <token>", "GitHub Personal Access Token").option("--bucket <bucket>", "S3 bucket name").option("--prefix <prefix>", "S3 object prefix", "aiusage/").option("--endpoint <endpoint>", "S3 endpoint URL").option("--region <region>", "S3 region", "auto").option("--access-key-id <id>", "S3 access key ID").option("--secret-access-key <key>", "S3 secret access key").option("--device <alias>", "Device alias").action((options) => {
+  const result = runInit(options);
+  if (result.success) {
+    console.log(`\u2713 ${result.message}`);
+  } else {
+    console.error(`\u2717 ${result.message}`);
+    process.exit(1);
+  }
+});
+program.command("sync").description("Sync data with cloud storage").action(async () => {
+  const db = createDatabase(DB_PATH);
+  const result = await runSync(db);
+  if (result.status === "ok") {
+    console.log(`\u2713 Sync complete \u2014 pulled: ${result.pulledCount}, merged: ${result.mergedCount}, uploaded: ${result.uploadedCount}`);
+  } else if (result.status === "blocked_pending_consent") {
+    console.error(`\u2717 ${result.error}`);
+    process.exit(1);
+  } else {
+    console.error(`\u2717 Sync failed: ${result.error}`);
+    process.exit(1);
+  }
+  db.close();
+});
+
+// src/index.ts
+program.parse(process.argv);