@zhangferry-dev/tokendash 1.3.0 → 1.4.2

package/dist/electron-server.cjs

@@ -0,0 +1,2175 @@
+var __esbuild_import_meta_url = require("url").pathToFileURL(__filename).href;
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/server/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createApp: () => createApp,
+  main: () => main
+});
+module.exports = __toCommonJS(index_exports);
+var import_express = __toESM(require("express"), 1);
+var import_node_fs8 = require("node:fs");
+var import_node_url = require("node:url");
+var import_node_path8 = require("node:path");
+
+// src/server/cache.ts
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+var import_node_os = require("node:os");
+var DEFAULT_TTL = 5 * 60 * 1e3;
+var DISK_TTL = 60 * 60 * 1e3;
+var CACHE_DIR = (0, import_node_path.join)((0, import_node_os.tmpdir)(), "tokendash-cache");
+function diskPath(key) {
+  const safe = key.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return (0, import_node_path.join)(CACHE_DIR, `${safe}.json`);
+}
+var Cache = class {
+  store = /* @__PURE__ */ new Map();
+  get(key) {
+    const entry = this.store.get(key);
+    if (entry && Date.now() <= entry.expiresAt) {
+      return entry.data;
+    }
+    return null;
+  }
+  /** Get data even if stale (for stale-while-revalidate) */
+  getStale(key) {
+    const entry = this.store.get(key);
+    if (entry) return entry.data;
+    return this.readFromDisk(key);
+  }
+  set(key, data, ttl = DEFAULT_TTL) {
+    const entry = {
+      data,
+      expiresAt: Date.now() + ttl,
+      updatedAt: Date.now()
+    };
+    this.store.set(key, entry);
+    this.writeToDisk(key, entry);
+  }
+  clear() {
+    this.store.clear();
+  }
+  delete(key) {
+    return this.store.delete(key);
+  }
+  has(key) {
+    const entry = this.store.get(key);
+    if (!entry) return false;
+    if (Date.now() > entry.expiresAt) {
+      this.store.delete(key);
+      return false;
+    }
+    return true;
+  }
+  writeToDisk(key, entry) {
+    try {
+      if (!(0, import_node_fs.existsSync)(CACHE_DIR)) (0, import_node_fs.mkdirSync)(CACHE_DIR, { recursive: true });
+      (0, import_node_fs.writeFileSync)(diskPath(key), JSON.stringify(entry), "utf-8");
+    } catch {
+    }
+  }
+  readFromDisk(key) {
+    try {
+      const path = diskPath(key);
+      if (!(0, import_node_fs.existsSync)(path)) return null;
+      const raw = (0, import_node_fs.readFileSync)(path, "utf-8");
+      const entry = JSON.parse(raw);
+      if (Date.now() - entry.updatedAt < DISK_TTL) {
+        this.store.set(key, { ...entry, expiresAt: 0 });
+        return entry.data;
+      }
+    } catch {
+    }
+    return null;
+  }
+};
+var cache = new Cache();
+
+// src/shared/schemas.ts
+var import_zod = require("zod");
+var ModelBreakdownSchema = import_zod.z.object({
+  modelName: import_zod.z.string(),
+  inputTokens: import_zod.z.number().default(0),
+  outputTokens: import_zod.z.number().default(0),
+  cacheCreationTokens: import_zod.z.number().default(0),
+  cacheReadTokens: import_zod.z.number().default(0),
+  cost: import_zod.z.number().default(0)
+});
+var DailyEntrySchema = import_zod.z.object({
+  date: import_zod.z.string(),
+  inputTokens: import_zod.z.number().default(0),
+  outputTokens: import_zod.z.number().default(0),
+  cacheCreationTokens: import_zod.z.number().default(0),
+  cacheReadTokens: import_zod.z.number().default(0),
+  totalTokens: import_zod.z.number().default(0),
+  totalCost: import_zod.z.number().default(0),
+  modelsUsed: import_zod.z.array(import_zod.z.string()).default([]),
+  modelBreakdowns: import_zod.z.array(ModelBreakdownSchema).default([])
+});
+var TotalsSchema = import_zod.z.object({
+  inputTokens: import_zod.z.number().default(0),
+  outputTokens: import_zod.z.number().default(0),
+  cacheCreationTokens: import_zod.z.number().default(0),
+  cacheReadTokens: import_zod.z.number().default(0),
+  totalTokens: import_zod.z.number().default(0),
+  totalCost: import_zod.z.number().default(0)
+});
+var DailyResponseSchema = import_zod.z.object({
+  daily: import_zod.z.array(DailyEntrySchema).default([]),
+  totals: TotalsSchema
+});
+var ProjectEntrySchema = import_zod.z.object({
+  projectPath: import_zod.z.string(),
+  instances: import_zod.z.array(DailyEntrySchema).default([])
+});
+var ProjectsResponseSchema = import_zod.z.object({
+  projects: import_zod.z.record(import_zod.z.array(DailyEntrySchema).default([])).default({})
+});
+function validateDaily(data) {
+  return DailyResponseSchema.parse(data);
+}
+function validateProjects(data) {
+  return ProjectsResponseSchema.parse(data);
+}
+var BlockEntrySchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  startTime: import_zod.z.string(),
+  endTime: import_zod.z.string(),
+  actualEndTime: import_zod.z.string().nullable().default(null),
+  isActive: import_zod.z.boolean().default(false),
+  isGap: import_zod.z.boolean().default(false),
+  entries: import_zod.z.number().default(0),
+  tokenCounts: import_zod.z.object({
+    inputTokens: import_zod.z.number().default(0),
+    outputTokens: import_zod.z.number().default(0),
+    cacheCreationInputTokens: import_zod.z.number().default(0),
+    cacheReadInputTokens: import_zod.z.number().default(0)
+  }).default({ inputTokens: 0, outputTokens: 0, cacheCreationInputTokens: 0, cacheReadInputTokens: 0 }),
+  totalTokens: import_zod.z.number().default(0),
+  costUSD: import_zod.z.number().default(0),
+  models: import_zod.z.array(import_zod.z.string()).default([])
+});
+var BlocksResponseSchema = import_zod.z.object({
+  blocks: import_zod.z.array(BlockEntrySchema).default([])
+});
+function validateBlocks(data) {
+  return BlocksResponseSchema.parse(data);
+}
+var DailyCodeChangeSchema = import_zod.z.object({
+  date: import_zod.z.string(),
+  linesAdded: import_zod.z.number().default(0),
+  linesDeleted: import_zod.z.number().default(0),
+  netChange: import_zod.z.number().default(0),
+  filesModified: import_zod.z.number().default(0)
+});
+var ToolUsageEntrySchema = import_zod.z.object({
+  name: import_zod.z.string(),
+  count: import_zod.z.number().default(0)
+});
+var ProductivityKPIsSchema = import_zod.z.object({
+  avgLinesPerEdit: import_zod.z.number().default(0),
+  filesModifiedPerDay: import_zod.z.number().default(0),
+  addDeleteRatio: import_zod.z.number().default(0),
+  totalEdits: import_zod.z.number().default(0),
+  totalFilesModified: import_zod.z.number().default(0),
+  activeDaysWithEdits: import_zod.z.number().default(0)
+});
+var AnalyticsResponseSchema = import_zod.z.object({
+  codeChangeTrend: import_zod.z.array(DailyCodeChangeSchema).default([]),
+  toolUsageDistribution: import_zod.z.array(ToolUsageEntrySchema).default([]),
+  productivityKPIs: ProductivityKPIsSchema,
+  toolCallTrend: import_zod.z.array(import_zod.z.record(import_zod.z.union([import_zod.z.string(), import_zod.z.number()]))).default([])
+});
+function validateAnalytics(data) {
+  return AnalyticsResponseSchema.parse(data);
+}
+
+// src/server/codexParser.ts
+var import_node_fs2 = require("node:fs");
+var import_node_path2 = require("node:path");
+var import_node_os2 = require("node:os");
+var import_zod2 = require("zod");
+
+// src/server/codexPricing.ts
+var MODEL_PRICING = {
+  "gpt-5.4": {
+    inputPer1M: 2.5,
+    cachedInputPer1M: 0.25,
+    outputPer1M: 15
+  }
+};
+var DEFAULT_PRICING = {
+  inputPer1M: 2.5,
+  cachedInputPer1M: 0.25,
+  outputPer1M: 15
+};
+function calculateCost(tokens, models) {
+  const model = [...models][0] ?? "";
+  const pricing = MODEL_PRICING[model] ?? DEFAULT_PRICING;
+  const nonCachedInput = Math.max(tokens.inputTokens - tokens.cachedInputTokens, 0);
+  const cachedInput = Math.min(tokens.cachedInputTokens, tokens.inputTokens);
+  const outputTokens = tokens.outputTokens;
+  const inputCost = nonCachedInput / 1e6 * pricing.inputPer1M;
+  const cachedCost = cachedInput / 1e6 * pricing.cachedInputPer1M;
+  const outputCost = outputTokens / 1e6 * pricing.outputPer1M;
+  return inputCost + cachedCost + outputCost;
+}
+
+// src/server/codexParser.ts
+var TokenUsageSchema = import_zod2.z.object({
+  input_tokens: import_zod2.z.number().default(0),
+  cached_input_tokens: import_zod2.z.number().default(0),
+  output_tokens: import_zod2.z.number().default(0),
+  reasoning_output_tokens: import_zod2.z.number().default(0),
+  total_tokens: import_zod2.z.number().default(0)
+}).default({ input_tokens: 0, cached_input_tokens: 0, output_tokens: 0, reasoning_output_tokens: 0, total_tokens: 0 });
+var TokenCountInfoSchema = import_zod2.z.object({
+  total_token_usage: TokenUsageSchema,
+  last_token_usage: TokenUsageSchema
+}).nullable().default(null);
+var TokenCountPayloadSchema = import_zod2.z.object({
+  type: import_zod2.z.literal("token_count"),
+  info: TokenCountInfoSchema
+});
+function tokenUsageKey(usage) {
+  return [
+    usage.input_tokens,
+    usage.cached_input_tokens,
+    usage.output_tokens,
+    usage.reasoning_output_tokens,
+    usage.total_tokens
+  ].join(":");
+}
+function getSessionsDir() {
+  return (0, import_node_path2.join)((0, import_node_os2.homedir)(), ".codex", "sessions");
+}
+function scanCodexSessions() {
+  const sessionsDir = getSessionsDir();
+  const results = [];
+  function walk(dir) {
+    let entries;
+    try {
+      entries = (0, import_node_fs2.readdirSync)(dir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const full = (0, import_node_path2.join)(dir, entry);
+      let st;
+      try {
+        st = (0, import_node_fs2.statSync)(full);
+      } catch {
+        continue;
+      }
+      if (st.isDirectory()) {
+        walk(full);
+      } else if (entry.endsWith(".jsonl")) {
+        results.push(full);
+      }
+    }
+  }
+  walk(sessionsDir);
+  return results.sort();
+}
+function parseCodexSession(filepath) {
+  let content;
+  try {
+    content = (0, import_node_fs2.readFileSync)(filepath, "utf-8");
+  } catch {
+    return null;
+  }
+  const lines = content.split("\n");
+  let sessionId = "";
+  let cwd = "";
+  let model = "";
+  let createdAt = "";
+  const tokenEvents = [];
+  const seenTotalUsageSnapshots = /* @__PURE__ */ new Set();
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    let obj;
+    try {
+      obj = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    const type = obj.type;
+    if (type === "session_meta") {
+      const payload = obj.payload || {};
+      sessionId = payload.id || "";
+      cwd = payload.cwd || "";
+      createdAt = payload.timestamp || "";
+    }
+    if (type === "turn_context") {
+      const payload = obj.payload || {};
+      if (!model && payload.model) {
+        model = payload.model;
+      }
+    }
+    if (type === "event_msg") {
+      const payload = obj.payload || {};
+      if (payload.type === "token_count") {
+        const timestamp = obj.timestamp || "";
+        const parseResult = TokenCountPayloadSchema.safeParse(payload);
+        if (!parseResult.success) {
+          console.warn(`[codexParser] Schema validation failed in ${filepath}:`, parseResult.error.message);
+          continue;
+        }
+        const info = parseResult.data.info;
+        if (!info) continue;
+        const totalUsageKey = tokenUsageKey(info.total_token_usage);
+        if (seenTotalUsageSnapshots.has(totalUsageKey)) continue;
+        seenTotalUsageSnapshots.add(totalUsageKey);
+        const last = info.last_token_usage;
+        tokenEvents.push({
+          timestamp,
+          inputTokens: last.input_tokens,
+          cachedInputTokens: last.cached_input_tokens,
+          outputTokens: last.output_tokens,
+          reasoningOutputTokens: last.reasoning_output_tokens,
+          totalTokens: last.total_tokens
+        });
+      }
+    }
+  }
+  if (!sessionId) return null;
+  return { id: sessionId, cwd, model, createdAt, tokenEvents };
+}
+function parseAllSessions() {
+  return scanCodexSessions().map(parseCodexSession).filter((s) => s !== null);
+}
+var TZ_OFFSETS = {
+  "Asia/Shanghai": 8,
+  "Asia/Tokyo": 9,
+  "America/New_York": -5,
+  "America/Los_Angeles": -8,
+  "Europe/London": 0,
+  "UTC": 0
+};
+function getTzOffsetHours(tz) {
+  return TZ_OFFSETS[tz] ?? 8;
+}
+function toLocalISO(ts, tz) {
+  const d = new Date(ts);
+  return new Date(d.getTime() + getTzOffsetHours(tz) * 36e5);
+}
+function getDateKey(ts, tz) {
+  return toLocalISO(ts, tz).toISOString().slice(0, 10);
+}
+function getHourKey(ts, tz) {
+  const local = toLocalISO(ts, tz);
+  return local.toISOString().slice(0, 13).replace("T", " ") + ":00";
+}
+function getMonthKey(ts, tz) {
+  return getDateKey(ts, tz).slice(0, 7);
+}
+function extractProjectName(cwd) {
+  if (!cwd) return "unknown";
+  const parts = cwd.replace(/\/+$/, "").split("/");
+  return parts[parts.length - 1] || "unknown";
+}
+function emptyAcc() {
+  return { inputTokens: 0, cachedInputTokens: 0, outputTokens: 0, reasoningOutputTokens: 0, totalTokens: 0 };
+}
+function addAcc(a, ev) {
+  a.inputTokens += ev.inputTokens;
+  a.cachedInputTokens += ev.cachedInputTokens;
+  a.outputTokens += ev.outputTokens;
+  a.reasoningOutputTokens += ev.reasoningOutputTokens;
+  a.totalTokens += ev.totalTokens;
+}
+function mergeAcc(a, b) {
+  a.inputTokens += b.inputTokens;
+  a.cachedInputTokens += b.cachedInputTokens;
+  a.outputTokens += b.outputTokens;
+  a.reasoningOutputTokens += b.reasoningOutputTokens;
+  a.totalTokens += b.totalTokens;
+}
+function accToEntry(date, acc, models) {
+  const cost = calculateCost(acc, models);
+  return {
+    date,
+    inputTokens: acc.inputTokens,
+    outputTokens: acc.outputTokens,
+    cacheCreationTokens: 0,
+    cacheReadTokens: acc.cachedInputTokens,
+    totalTokens: acc.totalTokens,
+    totalCost: cost,
+    modelsUsed: [...models],
+    modelBreakdowns: buildModelBreakdowns(acc, models, cost)
+  };
+}
+function buildModelBreakdowns(acc, models, totalCost) {
+  const modelList = [...models];
+  if (modelList.length === 0) return [];
+  const costPerModel = totalCost / modelList.length;
+  return modelList.map((name) => ({
+    modelName: name,
+    inputTokens: acc.inputTokens,
+    outputTokens: acc.outputTokens,
+    cacheCreationTokens: 0,
+    cacheReadTokens: acc.cachedInputTokens,
+    cost: costPerModel
+  }));
+}
+function groupSessions(sessions, options) {
+  const tz = options.timezone || "Asia/Shanghai";
+  const grouped = /* @__PURE__ */ new Map();
+  for (const session of sessions) {
+    if (options.project && extractProjectName(session.cwd) !== options.project) continue;
+    for (const ev of session.tokenEvents) {
+      const evDate = new Date(ev.timestamp);
+      if (options.since && evDate < options.since) continue;
+      if (options.until && evDate > options.until) continue;
+      let key;
+      switch (options.groupBy) {
+        case "hour":
+          key = getHourKey(ev.timestamp, tz);
+          break;
+        case "month":
+          key = getMonthKey(ev.timestamp, tz);
+          break;
+        case "session":
+          key = session.id;
+          break;
+        case "project":
+          key = extractProjectName(session.cwd);
+          break;
+        default:
+          key = getDateKey(ev.timestamp, tz);
+          break;
+      }
+      if (!grouped.has(key)) {
+        grouped.set(key, { acc: emptyAcc(), models: /* @__PURE__ */ new Set() });
+      }
+      const entry = grouped.get(key);
+      addAcc(entry.acc, ev);
+      if (session.model) entry.models.add(session.model);
+    }
+  }
+  return grouped;
+}
+function getDailyResponse(options) {
+  const sessions = parseAllSessions();
+  const grouped = groupSessions(sessions, { groupBy: "day", ...options });
+  const daily = [];
+  const totalsAcc = emptyAcc();
+  for (const [date, { acc, models: models2 }] of grouped) {
+    daily.push(accToEntry(date, acc, models2));
+    mergeAcc(totalsAcc, acc);
+  }
+  daily.sort((a, b) => a.date.localeCompare(b.date));
+  const models = /* @__PURE__ */ new Set();
+  for (const s of sessions) if (s.model) models.add(s.model);
+  const totalCost = calculateCost(totalsAcc, models);
+  return {
+    daily,
+    totals: {
+      inputTokens: totalsAcc.inputTokens,
+      outputTokens: totalsAcc.outputTokens,
+      cacheCreationTokens: 0,
+      cacheReadTokens: totalsAcc.cachedInputTokens,
+      totalTokens: totalsAcc.totalTokens,
+      totalCost
+    }
+  };
+}
+function getProjectsResponse(options) {
+  const sessions = parseAllSessions();
+  const tz = options?.timezone || "Asia/Shanghai";
+  const projects = {};
+  for (const session of sessions) {
+    const projectName = extractProjectName(session.cwd);
+    const dailyMap = /* @__PURE__ */ new Map();
+    for (const ev of session.tokenEvents) {
+      const evDate = new Date(ev.timestamp);
+      if (options?.since && evDate < options.since) continue;
+      if (options?.until && evDate > options.until) continue;
+      const dayKey = getDateKey(ev.timestamp, tz);
+      if (!dailyMap.has(dayKey)) {
+        dailyMap.set(dayKey, { acc: emptyAcc(), models: /* @__PURE__ */ new Set() });
+      }
+      addAcc(dailyMap.get(dayKey).acc, ev);
+      if (session.model) dailyMap.get(dayKey).models.add(session.model);
+    }
+    if (!projects[projectName]) projects[projectName] = [];
+    for (const [date, { acc, models }] of dailyMap) {
+      projects[projectName].push(accToEntry(date, acc, models));
+    }
+  }
+  for (const key of Object.keys(projects)) {
+    projects[key].sort((a, b) => a.date.localeCompare(b.date));
+  }
+  return { projects };
+}
+function getBlocksResponse(options) {
+  const sessions = parseAllSessions();
+  const grouped = groupSessions(sessions, { groupBy: "hour", ...options });
+  const blocks = [];
+  let idx = 0;
+  for (const [hourKey, { acc, models }] of grouped) {
+    const cost = calculateCost(acc, models);
+    const [datePart, timePart] = hourKey.split(" ");
+    const hour = timePart.split(":")[0];
+    blocks.push({
+      id: `codex-hour-${idx}`,
+      startTime: `${datePart}T${hour}:00:00`,
+      endTime: `${datePart}T${hour}:59:59`,
+      actualEndTime: null,
+      isActive: false,
+      isGap: false,
+      entries: acc.totalTokens > 0 ? 1 : 0,
+      tokenCounts: {
+        inputTokens: acc.inputTokens,
+        outputTokens: acc.outputTokens,
+        cacheCreationInputTokens: 0,
+        cacheReadInputTokens: acc.cachedInputTokens
+      },
+      totalTokens: acc.totalTokens,
+      costUSD: cost,
+      models: [...models]
+    });
+    idx++;
+  }
+  blocks.sort((a, b) => a.startTime.localeCompare(b.startTime));
+  return { blocks };
+}
+
+// src/server/openclawParser.ts
+var import_node_fs3 = require("node:fs");
+var import_node_path3 = require("node:path");
+var import_node_os3 = require("node:os");
+function getOpenClawDirs() {
+  const home = (0, import_node_os3.homedir)();
+  return [
+    (0, import_node_path3.join)(home, ".openclaw"),
+    (0, import_node_path3.join)(home, ".clawdbot"),
+    // legacy name 1
+    (0, import_node_path3.join)(home, ".moltbot"),
+    // legacy name 2
+    (0, import_node_path3.join)(home, ".moldbot")
+    // legacy name 3
+  ];
+}
+function isOpenClawAccessible() {
+  for (const dir of getOpenClawDirs()) {
+    try {
+      (0, import_node_fs3.accessSync)((0, import_node_path3.join)(dir, "agents"), import_node_fs3.constants.R_OK);
+      return true;
+    } catch {
+    }
+  }
+  return false;
+}
+function scanOpenClawSessions() {
+  const refs = [];
+  for (const baseDir of getOpenClawDirs()) {
+    const agentsDir = (0, import_node_path3.join)(baseDir, "agents");
+    let agentEntries;
+    try {
+      agentEntries = (0, import_node_fs3.readdirSync)(agentsDir);
+    } catch {
+      continue;
+    }
+    for (const agentEntry of agentEntries) {
+      const sessionsDir = (0, import_node_path3.join)(agentsDir, agentEntry, "sessions");
+      const indexedPaths = /* @__PURE__ */ new Set();
+      const indexPath = (0, import_node_path3.join)(sessionsDir, "sessions.json");
+      try {
+        const raw = (0, import_node_fs3.readFileSync)(indexPath, "utf-8");
+        const index = JSON.parse(raw);
+        for (const entry of Object.values(index)) {
+          if (!entry.sessionId) continue;
+          let sessionPath;
+          if (entry.sessionFile) {
+            const filePath = entry.sessionFile;
+            if (filePath.startsWith("/")) {
+              if (!getOpenClawDirs().some((dir) => filePath.startsWith(dir))) continue;
+              sessionPath = filePath;
+            } else {
+              sessionPath = (0, import_node_path3.join)(sessionsDir, filePath);
+            }
+          } else {
+            sessionPath = (0, import_node_path3.join)(sessionsDir, `${entry.sessionId}.jsonl`);
+          }
+          indexedPaths.add(sessionPath);
+          refs.push({ sessionId: entry.sessionId, sessionFile: sessionPath, agentId: agentEntry });
+        }
+      } catch {
+      }
+      let files;
+      try {
+        files = (0, import_node_fs3.readdirSync)(sessionsDir);
+      } catch {
+        continue;
+      }
+      for (const f of files) {
+        if (!f.endsWith(".jsonl")) continue;
+        const fullPath = (0, import_node_path3.join)(sessionsDir, f);
+        if (indexedPaths.has(fullPath)) continue;
+        const sessionId = f.replace(/\.jsonl.*$/, "");
+        refs.push({ sessionId, sessionFile: fullPath, agentId: agentEntry });
+      }
+    }
+  }
+  return refs;
+}
+var sessionCache = /* @__PURE__ */ new Map();
+function parseOpenClawSession(ref) {
+  let fileMtimeMs = 0;
+  try {
+    fileMtimeMs = (0, import_node_fs3.statSync)(ref.sessionFile).mtimeMs;
+  } catch {
+  }
+  const cached = sessionCache.get(ref.sessionFile);
+  if (cached && cached.mtime === fileMtimeMs) {
+    return cached.result;
+  }
+  let content;
+  try {
+    content = (0, import_node_fs3.readFileSync)(ref.sessionFile, "utf-8");
+  } catch {
+    return null;
+  }
+  const tokenEvents = [];
+  let currentModel = "";
+  let currentProvider = "";
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    let obj;
+    try {
+      obj = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    const type = obj.type;
+    if (type === "model_change") {
+      if (obj.modelId) currentModel = obj.modelId;
+      if (obj.provider) currentProvider = obj.provider;
+      continue;
+    }
+    if (type === "custom" && obj.customType === "model-snapshot") {
+      const data = obj.data || {};
+      if (data.modelId) currentModel = data.modelId;
+      if (data.provider) currentProvider = data.provider;
+      continue;
+    }
+    if (type === "message") {
+      const msg = obj.message || {};
+      if (msg.role !== "assistant") continue;
+      const usage = msg.usage || {};
+      if (!usage) continue;
+      const model = (msg.model || currentModel || "").trim();
+      const provider = (msg.provider || currentProvider || "").trim();
+      if (!model) continue;
+      if (model) currentModel = model;
+      if (provider) currentProvider = provider;
+      const input = Number(usage.input ?? 0);
+      const output = Number(usage.output ?? 0);
+      const cacheRead = Number(usage.cacheRead ?? 0);
+      const cacheWrite = Number(usage.cacheWrite ?? 0);
+      const costObj = usage.cost || {};
+      const cost = Number(costObj.total ?? 0);
+      const timestampMs = Number(msg.timestamp ?? fileMtimeMs);
+      tokenEvents.push({
+        timestampMs,
+        inputTokens: Math.max(0, input),
+        outputTokens: Math.max(0, output),
+        cacheReadTokens: Math.max(0, cacheRead),
+        cacheWriteTokens: Math.max(0, cacheWrite),
+        totalTokens: Math.max(0, input + output + cacheRead),
+        cost: Math.max(0, cost),
+        model: `${provider}/${model}`
+      });
+    }
+  }
+  if (tokenEvents.length === 0) {
+    sessionCache.set(ref.sessionFile, { mtime: fileMtimeMs, result: null });
+    return null;
+  }
+  const result = { id: ref.sessionId, agentId: ref.agentId, tokenEvents };
+  sessionCache.set(ref.sessionFile, { mtime: fileMtimeMs, result });
+  return result;
+}
+function parseAllOpenClawSessions() {
+  return scanOpenClawSessions().map(parseOpenClawSession).filter((s) => s !== null);
+}
+var TZ_OFFSETS2 = {
+  "Asia/Shanghai": 8,
+  "Asia/Tokyo": 9,
+  "America/New_York": -5,
+  "America/Los_Angeles": -8,
+  "Europe/London": 0,
+  "UTC": 0
+};
+function getTzOffsetHours2(tz) {
+  return TZ_OFFSETS2[tz] ?? 8;
+}
+function msToLocalDate(ms, tz) {
+  return new Date(ms + getTzOffsetHours2(tz) * 36e5);
+}
+function getDateKey2(ms, tz) {
+  return msToLocalDate(ms, tz).toISOString().slice(0, 10);
+}
+function getHourKey2(ms, tz) {
+  const d = msToLocalDate(ms, tz);
+  return d.toISOString().slice(0, 13).replace("T", " ") + ":00";
+}
+function emptyAcc2() {
+  return { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, totalTokens: 0, cost: 0 };
+}
+function addEvent(acc, ev) {
+  acc.inputTokens += ev.inputTokens;
+  acc.outputTokens += ev.outputTokens;
+  acc.cacheReadTokens += ev.cacheReadTokens;
+  acc.cacheWriteTokens += ev.cacheWriteTokens;
+  acc.totalTokens += ev.totalTokens;
+  acc.cost += ev.cost;
+}
+function mergeAcc2(a, b) {
+  a.inputTokens += b.inputTokens;
+  a.outputTokens += b.outputTokens;
+  a.cacheReadTokens += b.cacheReadTokens;
+  a.cacheWriteTokens += b.cacheWriteTokens;
+  a.totalTokens += b.totalTokens;
+  a.cost += b.cost;
+}
+function accToEntry2(date, acc, models) {
+  const modelList = [...models];
+  const costPerModel = modelList.length > 0 ? acc.cost / modelList.length : 0;
+  return {
+    date,
+    inputTokens: acc.inputTokens,
+    outputTokens: acc.outputTokens,
+    cacheCreationTokens: acc.cacheWriteTokens,
+    cacheReadTokens: acc.cacheReadTokens,
+    totalTokens: acc.totalTokens,
+    totalCost: acc.cost,
+    modelsUsed: modelList,
+    modelBreakdowns: modelList.map((name) => ({
+      modelName: name,
+      inputTokens: acc.inputTokens,
+      outputTokens: acc.outputTokens,
+      cacheCreationTokens: acc.cacheWriteTokens,
+      cacheReadTokens: acc.cacheReadTokens,
+      cost: costPerModel
+    }))
+  };
+}
+function getDailyResponse2(options) {
+  const sessions = parseAllOpenClawSessions();
+  const tz = options?.timezone || "Asia/Shanghai";
+  const grouped = /* @__PURE__ */ new Map();
+  const totalsAcc = emptyAcc2();
+  for (const session of sessions) {
+    if (options?.project && session.agentId !== options.project) continue;
+    for (const ev of session.tokenEvents) {
+      if (options?.since && ev.timestampMs < options.since.getTime()) continue;
+      if (options?.until && ev.timestampMs > options.until.getTime()) continue;
+      const key = getDateKey2(ev.timestampMs, tz);
+      if (!grouped.has(key)) grouped.set(key, { acc: emptyAcc2(), models: /* @__PURE__ */ new Set() });
+      const entry = grouped.get(key);
+      addEvent(entry.acc, ev);
+      entry.models.add(ev.model);
+    }
+  }
+  const daily = [];
+  for (const [date, { acc, models }] of grouped) {
+    daily.push(accToEntry2(date, acc, models));
+    mergeAcc2(totalsAcc, acc);
+  }
+  daily.sort((a, b) => a.date.localeCompare(b.date));
+  return {
+    daily,
+    totals: {
+      inputTokens: totalsAcc.inputTokens,
+      outputTokens: totalsAcc.outputTokens,
+      cacheCreationTokens: totalsAcc.cacheWriteTokens,
+      cacheReadTokens: totalsAcc.cacheReadTokens,
+      totalTokens: totalsAcc.totalTokens,
+      totalCost: totalsAcc.cost
+    }
+  };
+}
+function getProjectsResponse2(options) {
+  const sessions = parseAllOpenClawSessions();
+  const tz = options?.timezone || "Asia/Shanghai";
+  const projects = {};
+  for (const session of sessions) {
+    const projectName = session.agentId;
+    const dailyMap = /* @__PURE__ */ new Map();
+    for (const ev of session.tokenEvents) {
+      if (options?.since && ev.timestampMs < options.since.getTime()) continue;
+      if (options?.until && ev.timestampMs > options.until.getTime()) continue;
+      const dayKey = getDateKey2(ev.timestampMs, tz);
+      if (!dailyMap.has(dayKey)) dailyMap.set(dayKey, { acc: emptyAcc2(), models: /* @__PURE__ */ new Set() });
+      addEvent(dailyMap.get(dayKey).acc, ev);
+      dailyMap.get(dayKey).models.add(ev.model);
+    }
+    if (!projects[projectName]) projects[projectName] = [];
+    for (const [date, { acc, models }] of dailyMap) {
+      projects[projectName].push(accToEntry2(date, acc, models));
+    }
+  }
+  for (const key of Object.keys(projects)) {
+    projects[key].sort((a, b) => a.date.localeCompare(b.date));
+  }
+  return { projects };
+}
+function getBlocksResponse2(options) {
+  const sessions = parseAllOpenClawSessions();
+  const tz = options?.timezone || "Asia/Shanghai";
+  const grouped = /* @__PURE__ */ new Map();
+  for (const session of sessions) {
+    if (options?.project && session.agentId !== options.project) continue;
+    for (const ev of session.tokenEvents) {
+      if (options?.since && ev.timestampMs < options.since.getTime()) continue;
+      if (options?.until && ev.timestampMs > options.until.getTime()) continue;
+      const key = getHourKey2(ev.timestampMs, tz);
+      if (!grouped.has(key)) grouped.set(key, { acc: emptyAcc2(), models: /* @__PURE__ */ new Set() });
+      addEvent(grouped.get(key).acc, ev);
+      grouped.get(key).models.add(ev.model);
+    }
+  }
+  const blocks = [];
+  let idx = 0;
+  for (const [hourKey, { acc, models }] of grouped) {
+    const [datePart, timePart] = hourKey.split(" ");
+    const hour = timePart.split(":")[0];
+    blocks.push({
+      id: `openclaw-hour-${idx}`,
+      startTime: `${datePart}T${hour}:00:00`,
+      endTime: `${datePart}T${hour}:59:59`,
+      actualEndTime: null,
+      isActive: false,
+      isGap: false,
+      entries: acc.totalTokens > 0 ? 1 : 0,
+      tokenCounts: {
+        inputTokens: acc.inputTokens,
+        outputTokens: acc.outputTokens,
+        cacheCreationInputTokens: acc.cacheWriteTokens,
+        cacheReadInputTokens: acc.cacheReadTokens
+      },
+      totalTokens: acc.totalTokens,
+      costUSD: acc.cost,
+      models: [...models]
+    });
+    idx++;
+  }
+  blocks.sort((a, b) => a.startTime.localeCompare(b.startTime));
+  return { blocks };
+}
+
+// src/server/opencodeParser.ts
+var import_node_fs4 = require("node:fs");
+var import_node_child_process = require("node:child_process");
+var import_node_path4 = require("node:path");
+var import_node_os4 = require("node:os");
+var OPENCODE_DB = (0, import_node_path4.join)((0, import_node_os4.homedir)(), ".local", "share", "opencode", "opencode.db");
+function isOpencodeAccessible() {
+  return (0, import_node_fs4.existsSync)(OPENCODE_DB);
+}
+function queryOpenCodeDB(sql) {
+  return (0, import_node_child_process.execSync)(`sqlite3 -json "${OPENCODE_DB}" "${sql}"`, {
+    encoding: "utf-8",
+    maxBuffer: 50 * 1024 * 1024,
+    timeout: 1e4
+  });
+}
+function parseAllOpenCodeEvents(project) {
+  let sql = `SELECT data FROM message WHERE json_extract(data, '$.role') = 'assistant'`;
+  if (project) {
+    sql += ` AND json_extract(data, '$.path.cwd') = '${project.replace(/'/g, "''")}'`;
+  }
+  let raw;
+  try {
+    raw = queryOpenCodeDB(sql);
+  } catch {
+    return [];
+  }
+  let rows;
+  try {
+    rows = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+  const events = [];
+  for (const row of rows) {
+    let data;
+    try {
+      data = JSON.parse(row.data);
+    } catch {
+      continue;
+    }
+    const tokens = data.tokens || {};
+    const cache2 = tokens.cache || {};
+    const time = data.time || {};
+    const path = data.path || {};
+    const input = Number(tokens.input ?? 0);
+    const output = Number(tokens.output ?? 0);
+    const cacheRead = Number(cache2.read ?? 0);
+    const cacheWrite = Number(cache2.write ?? 0);
+    if (input === 0 && output === 0 && cacheRead === 0 && cacheWrite === 0) continue;
+    events.push({
+      timestampMs: Number(time.created ?? 0),
+      inputTokens: Math.max(0, input),
+      outputTokens: Math.max(0, output),
+      cacheReadTokens: Math.max(0, cacheRead),
+      cacheWriteTokens: Math.max(0, cacheWrite),
+      totalTokens: Math.max(0, input + output + cacheRead),
+      cost: Math.max(0, Number(data.cost ?? 0)),
+      model: String(data.modelID ?? "unknown"),
+      project: String(path.cwd ?? "")
+    });
+  }
+  return events;
+}
+var TZ_OFFSETS3 = {
+  "Asia/Shanghai": 8,
+  "Asia/Tokyo": 9,
+  "America/New_York": -5,
+  "America/Los_Angeles": -8,
+  "Europe/London": 0,
+  "UTC": 0
+};
+function getTzOffsetHours3(tz) {
+  return TZ_OFFSETS3[tz] ?? 8;
+}
+function msToLocalDate2(ms, tz) {
+  return new Date(ms + getTzOffsetHours3(tz) * 36e5);
+}
+function getDateKey3(ms, tz) {
+  return msToLocalDate2(ms, tz).toISOString().slice(0, 10);
+}
+function getHourKey3(ms, tz) {
+  const d = msToLocalDate2(ms, tz);
+  return d.toISOString().slice(0, 13).replace("T", " ") + ":00";
+}
+function emptyAcc3() {
+  return { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, totalTokens: 0, cost: 0 };
+}
+function addEvent2(acc, ev) {
+  acc.inputTokens += ev.inputTokens;
+  acc.outputTokens += ev.outputTokens;
+  acc.cacheReadTokens += ev.cacheReadTokens;
+  acc.cacheWriteTokens += ev.cacheWriteTokens;
+  acc.totalTokens += ev.totalTokens;
+  acc.cost += ev.cost;
+}
+function getDailyResponse3(options) {
+  const events = parseAllOpenCodeEvents(options?.project);
+  const tz = options?.timezone || "Asia/Shanghai";
+  const grouped = /* @__PURE__ */ new Map();
+  for (const ev of events) {
+    const key = getDateKey3(ev.timestampMs, tz);
+    if (!grouped.has(key)) grouped.set(key, { totals: emptyAcc3(), models: /* @__PURE__ */ new Map() });
+    const g = grouped.get(key);
+    addEvent2(g.totals, ev);
+    if (!g.models.has(ev.model)) {
+      g.models.set(ev.model, { inputTokens: 0, outputTokens: 0, cacheCreationTokens: 0, cacheReadTokens: 0, cost: 0 });
+    }
+    const m = g.models.get(ev.model);
+    m.inputTokens += ev.inputTokens;
+    m.outputTokens += ev.outputTokens;
+    m.cacheCreationTokens += ev.cacheWriteTokens;
+    m.cacheReadTokens += ev.cacheReadTokens;
+    m.cost += ev.cost;
+  }
+  const totalsAcc = emptyAcc3();
+  const daily = [];
+  for (const [date, g] of grouped) {
+    mergeAcc3(totalsAcc, g.totals);
+    const modelList = [...g.models.keys()];
+    daily.push({
+      date,
+      inputTokens: g.totals.inputTokens,
+      outputTokens: g.totals.outputTokens,
+      cacheCreationTokens: g.totals.cacheWriteTokens,
+      cacheReadTokens: g.totals.cacheReadTokens,
+      totalTokens: g.totals.totalTokens,
+      totalCost: g.totals.cost,
+      modelsUsed: modelList,
+      modelBreakdowns: modelList.map((name) => {
+        const m = g.models.get(name);
+        return {
+          modelName: name,
+          inputTokens: m.inputTokens,
+          outputTokens: m.outputTokens,
+          cacheCreationTokens: m.cacheCreationTokens,
+          cacheReadTokens: m.cacheReadTokens,
+          cost: m.cost
+        };
+      })
+    });
+  }
+  daily.sort((a, b) => a.date.localeCompare(b.date));
+  return {
+    daily,
+    totals: {
+      inputTokens: totalsAcc.inputTokens,
+      outputTokens: totalsAcc.outputTokens,
+      cacheCreationTokens: totalsAcc.cacheWriteTokens,
+      cacheReadTokens: totalsAcc.cacheReadTokens,
+      totalTokens: totalsAcc.totalTokens,
+      totalCost: totalsAcc.cost
+    }
+  };
+}
+function mergeAcc3(a, b) {
+  a.inputTokens += b.inputTokens;
+  a.outputTokens += b.outputTokens;
+  a.cacheReadTokens += b.cacheReadTokens;
+  a.cacheWriteTokens += b.cacheWriteTokens;
+  a.totalTokens += b.totalTokens;
+  a.cost += b.cost;
+}
+function getProjectsResponse3(options) {
+  const events = parseAllOpenCodeEvents();
+  const tz = options?.timezone || "Asia/Shanghai";
+  const projects = {};
+  for (const ev of events) {
+    const projectName = ev.project || "unknown";
+    const dayKey = getDateKey3(ev.timestampMs, tz);
+    if (!projects[projectName]) projects[projectName] = [];
+    let dayEntry = projects[projectName].find((d) => d.date === dayKey);
+    if (!dayEntry) {
+      dayEntry = {
+        date: dayKey,
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheCreationTokens: 0,
+        cacheReadTokens: 0,
+        totalTokens: 0,
+        totalCost: 0,
+        modelsUsed: [],
+        modelBreakdowns: []
+      };
+      projects[projectName].push(dayEntry);
+    }
+    dayEntry.inputTokens += ev.inputTokens;
+    dayEntry.outputTokens += ev.outputTokens;
+    dayEntry.cacheCreationTokens += ev.cacheWriteTokens;
+    dayEntry.cacheReadTokens += ev.cacheReadTokens;
+    dayEntry.totalTokens += ev.totalTokens;
+    dayEntry.totalCost += ev.cost;
+    if (!dayEntry.modelsUsed.includes(ev.model)) {
+      dayEntry.modelsUsed.push(ev.model);
+    }
+    let breakdown = dayEntry.modelBreakdowns.find((b) => b.modelName === ev.model);
+    if (!breakdown) {
+      breakdown = {
+        modelName: ev.model,
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheCreationTokens: 0,
+        cacheReadTokens: 0,
+        cost: 0
+      };
+      dayEntry.modelBreakdowns.push(breakdown);
+    }
+    breakdown.inputTokens += ev.inputTokens;
+    breakdown.outputTokens += ev.outputTokens;
+    breakdown.cacheCreationTokens += ev.cacheWriteTokens;
+    breakdown.cacheReadTokens += ev.cacheReadTokens;
+    breakdown.cost += ev.cost;
+  }
+  for (const key of Object.keys(projects)) {
+    projects[key].sort((a, b) => a.date.localeCompare(b.date));
+  }
+  return { projects };
+}
+function getBlocksResponse3(options) {
+  const events = parseAllOpenCodeEvents(options?.project);
+  const tz = options?.timezone || "Asia/Shanghai";
+  const grouped = /* @__PURE__ */ new Map();
+  for (const ev of events) {
+    const key = getHourKey3(ev.timestampMs, tz);
+    if (!grouped.has(key)) grouped.set(key, { acc: emptyAcc3(), models: /* @__PURE__ */ new Set() });
+    addEvent2(grouped.get(key).acc, ev);
+    grouped.get(key).models.add(ev.model);
+  }
+  const blocks = [];
+  let idx = 0;
+  for (const [hourKey, { acc, models }] of grouped) {
+    const [datePart, timePart] = hourKey.split(" ");
+    const hour = timePart.split(":")[0];
+    blocks.push({
+      id: `opencode-hour-${idx}`,
+      startTime: `${datePart}T${hour}:00:00`,
+      endTime: `${datePart}T${hour}:59:59`,
+      actualEndTime: null,
+      isActive: false,
+      isGap: false,
+      entries: acc.totalTokens > 0 ? 1 : 0,
+      tokenCounts: {
+        inputTokens: acc.inputTokens,
+        outputTokens: acc.outputTokens,
+        cacheCreationInputTokens: acc.cacheWriteTokens,
+        cacheReadInputTokens: acc.cacheReadTokens
+      },
+      totalTokens: acc.totalTokens,
+      costUSD: acc.cost,
+      models: [...models]
+    });
+    idx++;
+  }
+  blocks.sort((a, b) => a.startTime.localeCompare(b.startTime));
+  return { blocks };
+}
+
+// src/server/claudeJsonlParser.ts
+var import_node_fs5 = require("node:fs");
+var import_node_path5 = require("node:path");
+var import_node_os5 = require("node:os");
+var MODEL_PRICING2 = {
+  // Claude 4.6
+  "claude-opus-4-6": { inputPer1M: 15, cacheReadPer1M: 1.5, outputPer1M: 75 },
+  "claude-sonnet-4-6": { inputPer1M: 3, cacheReadPer1M: 0.3, outputPer1M: 15 },
+  // Claude 4.5
+  "claude-sonnet-4-5-20250514": { inputPer1M: 3, cacheReadPer1M: 0.3, outputPer1M: 15 },
+  "claude-haiku-4-5-20251001": { inputPer1M: 0.8, cacheReadPer1M: 0.08, outputPer1M: 4 },
+  // Older Claude models
+  "claude-3-5-sonnet-20241022": { inputPer1M: 3, cacheReadPer1M: 0.3, outputPer1M: 15 },
+  "claude-3-5-haiku-20241022": { inputPer1M: 0.8, cacheReadPer1M: 0.08, outputPer1M: 4 },
+  "claude-3-opus-20240229": { inputPer1M: 15, cacheReadPer1M: 1.5, outputPer1M: 75 },
+  "claude-3-haiku-20240307": { inputPer1M: 0.25, cacheReadPer1M: 0.03, outputPer1M: 1.25 }
+};
+var DEFAULT_PRICING2 = { inputPer1M: 3, cacheReadPer1M: 0.3, outputPer1M: 15 };
+function getPricing(model) {
+  if (MODEL_PRICING2[model]) return MODEL_PRICING2[model];
+  const lower = model.toLowerCase();
+  for (const key of Object.keys(MODEL_PRICING2)) {
+    if (lower.startsWith(key) || lower.includes(key)) return MODEL_PRICING2[key];
+  }
+  return DEFAULT_PRICING2;
+}
+function calculateCost2(inputTokens, cacheReadTokens, outputTokens, model) {
+  const p = getPricing(model);
+  const nonCachedInput = Math.max(inputTokens - cacheReadTokens, 0);
+  return nonCachedInput / 1e6 * p.inputPer1M + cacheReadTokens / 1e6 * p.cacheReadPer1M + outputTokens / 1e6 * p.outputPer1M;
+}
+var CLAUDE_PROJECTS_DIR = (0, import_node_path5.join)((0, import_node_os5.homedir)(), ".claude", "projects");
+var fileCache = /* @__PURE__ */ new Map();
+function extractProjectName2(dirName) {
+  const parts = dirName.replace(/^-/, "").split("-");
+  return parts[parts.length - 1] || dirName;
+}
+function matchesProject(dirName, filter) {
+  return extractProjectName2(dirName) === extractProjectName2(filter);
+}
+function findJsonlFiles(dir) {
+  const results = [];
+  try {
+    const entries = (0, import_node_fs5.readdirSync)(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        results.push(...findJsonlFiles((0, import_node_path5.join)(dir, entry.name)));
+      } else if (entry.name.endsWith(".jsonl")) {
+        results.push((0, import_node_path5.join)(dir, entry.name));
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+function parseAllSessions2(project) {
+  if (!(0, import_node_fs5.existsSync)(CLAUDE_PROJECTS_DIR)) return [];
+  const results = [];
+  const projectDirs = (0, import_node_fs5.readdirSync)(CLAUDE_PROJECTS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+  for (const dirName of projectDirs) {
+    if (project && !matchesProject(dirName, project)) continue;
+    const dirPath = (0, import_node_path5.join)(CLAUDE_PROJECTS_DIR, dirName);
+    const files = findJsonlFiles(dirPath);
+    for (const filePath of files) {
+      let mtime = 0;
+      try {
+        mtime = (0, import_node_fs5.statSync)(filePath).mtimeMs;
+      } catch {
+      }
+      const cached = fileCache.get(filePath);
+      if (cached && cached.mtime === mtime) {
+        results.push(...cached.entries);
+        continue;
+      }
+      const entries = [];
+      let content;
+      try {
+        content = (0, import_node_fs5.readFileSync)(filePath, "utf-8");
+      } catch {
+        continue;
+      }
+      for (const line of content.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        let obj;
+        try {
+          obj = JSON.parse(trimmed);
+        } catch {
+          continue;
+        }
+        if (obj.type !== "assistant" || !obj.message) continue;
+        const msg = obj.message;
+        const usage = msg.usage || {};
+        const inputTokens = usage.input_tokens || 0;
+        const outputTokens = usage.output_tokens || 0;
+        const cacheCreationTokens = usage.cache_creation_input_tokens || 0;
+        const cacheReadTokens = usage.cache_read_input_tokens || 0;
+        const totalTokens = inputTokens + outputTokens + cacheReadTokens;
+        if (totalTokens === 0) continue;
+        entries.push({
+          timestamp: obj.timestamp,
+          model: msg.model || "unknown",
+          inputTokens,
+          outputTokens,
+          cacheCreationTokens,
+          cacheReadTokens,
+          projectDir: dirName
+        });
+      }
+      fileCache.set(filePath, { mtime, entries });
+      results.push(...entries);
+    }
+  }
+  return results;
+}
+var TZ_OFFSETS4 = {
+  "Asia/Shanghai": 8,
+  "Asia/Tokyo": 9,
+  "America/New_York": -5,
+  "America/Los_Angeles": -8,
+  "Europe/London": 0,
+  "UTC": 0
+};
+function getDateKey4(timestamp, tz) {
+  const offset = (TZ_OFFSETS4[tz] ?? 8) * 36e5;
+  const d = new Date(new Date(timestamp).getTime() + offset);
+  return `${d.getUTCFullYear()}-${String(d.getUTCMonth() + 1).padStart(2, "0")}-${String(d.getUTCDate()).padStart(2, "0")}`;
+}
+function getHourKey4(timestamp, tz) {
+  const offset = (TZ_OFFSETS4[tz] ?? 8) * 36e5;
+  const d = new Date(new Date(timestamp).getTime() + offset);
+  const yyyy = d.getUTCFullYear();
+  const mm = String(d.getUTCMonth() + 1).padStart(2, "0");
+  const dd = String(d.getUTCDate()).padStart(2, "0");
+  const hh = String(d.getUTCHours()).padStart(2, "0");
+  return `${yyyy}-${mm}-${dd}T${hh}`;
+}
+function toDailyEntry(agg) {
+  const modelBreakdowns = [...agg.models.entries()].map(([modelName, m]) => ({
+    modelName,
+    inputTokens: m.input,
+    outputTokens: m.output,
+    cacheCreationTokens: m.cacheCreation,
+    cacheReadTokens: m.cacheRead,
+    cost: m.cost
+  }));
+  return {
+    date: agg.date,
+    inputTokens: agg.inputTokens,
+    outputTokens: agg.outputTokens,
+    cacheCreationTokens: agg.cacheCreationTokens,
+    cacheReadTokens: agg.cacheReadTokens,
+    totalTokens: agg.totalTokens,
+    totalCost: Math.round(agg.totalCost * 1e4) / 1e4,
+    modelsUsed: [...agg.models.keys()],
+    modelBreakdowns
+  };
+}
+var DEFAULT_TZ = "Asia/Shanghai";
+function getDailyResponse4(project, tz = DEFAULT_TZ) {
+  const entries = parseAllSessions2(project);
+  const dayMap = /* @__PURE__ */ new Map();
+  for (const e of entries) {
+    const date = getDateKey4(e.timestamp, tz);
+    if (!dayMap.has(date)) {
+      dayMap.set(date, {
+        date,
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheCreationTokens: 0,
+        cacheReadTokens: 0,
+        totalTokens: 0,
+        totalCost: 0,
+        models: /* @__PURE__ */ new Map()
+      });
+    }
+    const agg = dayMap.get(date);
+    agg.inputTokens += e.inputTokens;
+    agg.outputTokens += e.outputTokens;
+    agg.cacheCreationTokens += e.cacheCreationTokens;
+    agg.cacheReadTokens += e.cacheReadTokens;
+    agg.totalTokens += e.inputTokens + e.outputTokens + e.cacheReadTokens;
+    const cost = calculateCost2(e.inputTokens, e.cacheReadTokens, e.outputTokens, e.model);
+    agg.totalCost += cost;
+    if (!agg.models.has(e.model)) {
+      agg.models.set(e.model, { input: 0, output: 0, cacheCreation: 0, cacheRead: 0, cost: 0 });
+    }
+    const m = agg.models.get(e.model);
+    m.input += e.inputTokens;
+    m.output += e.outputTokens;
+    m.cacheCreation += e.cacheCreationTokens;
+    m.cacheRead += e.cacheReadTokens;
+    m.cost += cost;
+  }
+  const daily = [...dayMap.values()].sort((a, b) => a.date.localeCompare(b.date)).map(toDailyEntry);
+  const totals = daily.reduce((acc, d) => ({
+    inputTokens: acc.inputTokens + d.inputTokens,
+    outputTokens: acc.outputTokens + d.outputTokens,
+    cacheCreationTokens: acc.cacheCreationTokens + d.cacheCreationTokens,
+    cacheReadTokens: acc.cacheReadTokens + d.cacheReadTokens,
+    totalTokens: acc.totalTokens + d.totalTokens,
+    totalCost: acc.totalCost + d.totalCost
+  }), { inputTokens: 0, outputTokens: 0, cacheCreationTokens: 0, cacheReadTokens: 0, totalTokens: 0, totalCost: 0 });
+  return { daily, totals };
+}
+function getProjectsResponse4(tz = DEFAULT_TZ) {
+  const entries = parseAllSessions2();
+  const projectMap = /* @__PURE__ */ new Map();
+  for (const e of entries) {
+    const date = getDateKey4(e.timestamp, tz);
+    const projectName = e.projectDir;
+    if (!projectMap.has(projectName)) {
+      projectMap.set(projectName, /* @__PURE__ */ new Map());
+    }
+    const dayMap = projectMap.get(projectName);
+    if (!dayMap.has(date)) {
+      dayMap.set(date, {
+        date,
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheCreationTokens: 0,
+        cacheReadTokens: 0,
+        totalTokens: 0,
+        totalCost: 0,
+        models: /* @__PURE__ */ new Map()
+      });
+    }
+    const agg = dayMap.get(date);
+    agg.inputTokens += e.inputTokens;
+    agg.outputTokens += e.outputTokens;
+    agg.cacheCreationTokens += e.cacheCreationTokens;
+    agg.cacheReadTokens += e.cacheReadTokens;
+    agg.totalTokens += e.inputTokens + e.outputTokens + e.cacheReadTokens;
+    const cost = calculateCost2(e.inputTokens, e.cacheReadTokens, e.outputTokens, e.model);
+    agg.totalCost += cost;
+    if (!agg.models.has(e.model)) {
+      agg.models.set(e.model, { input: 0, output: 0, cacheCreation: 0, cacheRead: 0, cost: 0 });
+    }
+    const m = agg.models.get(e.model);
+    m.input += e.inputTokens;
+    m.output += e.outputTokens;
+    m.cacheCreation += e.cacheCreationTokens;
+    m.cacheRead += e.cacheReadTokens;
+    m.cost += cost;
+  }
+  const projects = {};
+  for (const [projectName, dayMap] of projectMap) {
+    projects[projectName] = [...dayMap.values()].sort((a, b) => a.date.localeCompare(b.date)).map(toDailyEntry);
+  }
+  return { projects };
+}
+function getBlocksResponse4(project, tz = DEFAULT_TZ) {
+  const entries = parseAllSessions2(project);
+  const hourMap = /* @__PURE__ */ new Map();
+  for (const e of entries) {
+    const hourKey = getHourKey4(e.timestamp, tz);
+    if (!hourMap.has(hourKey)) {
+      hourMap.set(hourKey, {
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheCreationTokens: 0,
+        cacheReadTokens: 0,
+        costUSD: 0,
+        models: /* @__PURE__ */ new Set()
+      });
+    }
+    const bucket = hourMap.get(hourKey);
+    bucket.inputTokens += e.inputTokens;
+    bucket.outputTokens += e.outputTokens;
+    bucket.cacheCreationTokens += e.cacheCreationTokens;
+    bucket.cacheReadTokens += e.cacheReadTokens;
+    bucket.costUSD += calculateCost2(e.inputTokens, e.cacheReadTokens, e.outputTokens, e.model);
+    bucket.models.add(e.model);
+  }
+  const blocks = [];
+  let idx = 0;
+  for (const [hourKey, bucket] of hourMap) {
+    const totalTokens = bucket.inputTokens + bucket.outputTokens + bucket.cacheReadTokens;
+    blocks.push({
+      id: `claude-${idx}`,
+      startTime: `${hourKey}:00:00`,
+      endTime: `${hourKey}:59:59`,
+      actualEndTime: null,
+      isActive: false,
+      isGap: false,
+      entries: totalTokens > 0 ? 1 : 0,
+      tokenCounts: {
+        inputTokens: bucket.inputTokens,
+        outputTokens: bucket.outputTokens,
+        cacheCreationInputTokens: bucket.cacheCreationTokens,
+        cacheReadInputTokens: bucket.cacheReadTokens
+      },
+      totalTokens,
+      costUSD: Math.round(bucket.costUSD * 1e4) / 1e4,
+      models: [...bucket.models]
+    });
+    idx++;
+  }
+  blocks.sort((a, b) => a.startTime.localeCompare(b.startTime));
+  return { blocks };
+}
+
+// src/server/routes/daily.ts
+async function getDaily(req, res) {
+  const agent = req.query.agent || "claude";
+  const cacheKey = `daily:${agent}`;
+  try {
+    const cached = cache.get(cacheKey);
+    if (cached) {
+      res.json(cached);
+      return;
+    }
+    const stale = cache.getStale(cacheKey);
+    if (stale) {
+      refreshDailyCache(agent, cacheKey);
+      res.json(stale);
+      return;
+    }
+    const data = await fetchDailyData(agent);
+    cache.set(cacheKey, data);
+    res.json(data);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.error("Error fetching daily data:", error);
+    res.status(502).json({
+      error: `Failed to fetch daily data from ${agent}`,
+      hint: message
+    });
+  }
+}
+function fetchDailyData(agent) {
+  if (agent === "codex") {
+    return Promise.resolve(getDailyResponse());
+  } else if (agent === "openclaw") {
+    return Promise.resolve(validateDaily(getDailyResponse2()));
+  } else if (agent === "opencode") {
+    return Promise.resolve(validateDaily(getDailyResponse3()));
+  } else {
+    return Promise.resolve(validateDaily(getDailyResponse4()));
+  }
+}
+function refreshDailyCache(agent, cacheKey) {
+  fetchDailyData(agent).then((data) => cache.set(cacheKey, data)).catch((err) => console.error("Background refresh failed (daily):", err));
+}
+
+// src/server/routes/monthly.ts
+async function getMonthly(req, res) {
+  const agent = req.query.agent || "claude";
+  const cacheKey = `monthly:${agent}`;
+  try {
+    const cached = cache.get(cacheKey);
+    if (cached) {
+      res.json(cached);
+      return;
+    }
+    const stale = cache.getStale(cacheKey);
+    if (stale) {
+      res.json(stale);
+      return;
+    }
+    let data;
+    if (agent === "codex") {
+      data = validateDaily(getDailyResponse());
+    } else if (agent === "openclaw") {
+      data = validateDaily(getDailyResponse2());
+    } else {
+      data = validateDaily(getDailyResponse4());
+    }
+    cache.set(cacheKey, data);
+    res.json(data);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.error("Error fetching monthly data:", error);
+    res.status(502).json({
+      error: "Failed to fetch monthly data",
+      hint: message
+    });
+  }
+}
+
+// src/server/routes/session.ts
+async function getSession(req, res) {
+  const agent = req.query.agent || "claude";
+  const cacheKey = `session:${agent}`;
+  try {
+    const cached = cache.get(cacheKey);
+    if (cached) {
+      res.json(cached);
+      return;
+    }
+    const stale = cache.getStale(cacheKey);
+    if (stale) {
+      res.json(stale);
+      return;
+    }
+    let data;
+    if (agent === "codex") {
+      data = validateDaily(getDailyResponse());
+    } else if (agent === "openclaw") {
+      data = validateDaily(getDailyResponse2());
+    } else {
+      data = validateDaily(getDailyResponse4());
+    }
+    cache.set(cacheKey, data);
+    res.json(data);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.error("Error fetching session data:", error);
+    res.status(502).json({
+      error: "Failed to fetch session data",
+      hint: message
+    });
+  }
+}
+
+// src/server/routes/projects.ts
+async function getProjects(req, res) {
+  const agent = req.query.agent || "claude";
+  const cacheKey = `projects:${agent}`;
+  try {
+    const cached = cache.get(cacheKey);
+    if (cached) {
+      res.json(cached);
+      return;
+    }
+    const stale = cache.getStale(cacheKey);
+    if (stale) {
+      refreshProjectsCache(agent, cacheKey);
+      res.json(stale);
+      return;
+    }
+    const data = fetchProjectsData(agent);
+    cache.set(cacheKey, data);
+    res.json(data);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.error("Error fetching projects data:", error);
+    res.status(502).json({
+      error: `Failed to fetch projects data from ${agent}`,
+      hint: message
+    });
+  }
+}
+function fetchProjectsData(agent) {
+  if (agent === "codex") {
+    return getProjectsResponse();
+  } else if (agent === "openclaw") {
+    return validateProjects(getProjectsResponse2());
+  } else if (agent === "opencode") {
+    return validateProjects(getProjectsResponse3());
+  } else {
+    return validateProjects(getProjectsResponse4());
+  }
+}
+function refreshProjectsCache(agent, cacheKey) {
+  Promise.resolve().then(() => {
+    const data = fetchProjectsData(agent);
+    cache.set(cacheKey, data);
+  }).catch((err) => console.error("Background refresh failed (projects):", err));
+}
+
+// src/server/routes/blocks.ts
+async function getBlocks(req, res) {
+  const agent = req.query.agent || "claude";
+  const project = req.query.project || void 0;
+  try {
+    const cacheKey = `blocks:${agent}:${project || "all"}`;
+    const cached = cache.get(cacheKey);
+    if (cached) {
+      res.json(cached);
+      return;
+    }
+    const stale = cache.getStale(cacheKey);
+    if (stale) {
+      refreshBlocksCache(agent, project, cacheKey);
+      res.json(stale);
+      return;
+    }
+    const data = fetchBlocksData(agent, project);
+    cache.set(cacheKey, data);
+    res.json(data);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.error("Error fetching blocks data:", error);
+    res.status(502).json({
+      error: "Failed to fetch blocks data",
+      hint: message
+    });
+  }
+}
+function fetchBlocksData(agent, project) {
+  if (agent === "openclaw") {
+    return validateBlocks(getBlocksResponse2({ project: project || null }));
+  } else if (agent === "opencode") {
+    return validateBlocks(getBlocksResponse3({ project: project || null }));
+  } else if (agent === "codex") {
+    return validateBlocks(getBlocksResponse({ project: project || null }));
+  } else {
+    return validateBlocks(getBlocksResponse4(project || null));
+  }
+}
+function refreshBlocksCache(agent, project, cacheKey) {
+  Promise.resolve().then(() => {
+    const data = fetchBlocksData(agent, project);
+    cache.set(cacheKey, data);
+  }).catch((err) => console.error("Background refresh failed (blocks):", err));
+}
+
+// src/server/analyticsParser.ts
+var import_node_fs6 = require("node:fs");
+var import_node_path6 = require("node:path");
+var import_node_os6 = require("node:os");
+var TZ_OFFSETS5 = {
+  "Asia/Shanghai": 8,
+  "Asia/Tokyo": 9,
+  "America/New_York": -5,
+  "America/Los_Angeles": -8,
+  "Europe/London": 0,
+  "UTC": 0
+};
+function getDateKey5(ms, tz) {
+  const offset = (TZ_OFFSETS5[tz] ?? 8) * 36e5;
+  const d = new Date(ms + offset);
+  return `${d.getUTCFullYear()}-${String(d.getUTCMonth() + 1).padStart(2, "0")}-${String(d.getUTCDate()).padStart(2, "0")}`;
+}
+function normalizeToolName(name) {
+  const lower = name.toLowerCase();
+  if (lower.startsWith("mcp__")) {
+    const parts = name.split("__");
+    const serverPart = parts.length >= 3 ? parts[2] : "mcp";
+    return `MCP:${serverPart}`;
+  }
+  const mapping = {
+    "exec": "Bash",
+    "read": "Read",
+    "edit": "Edit",
+    "write": "Write"
+  };
+  return mapping[lower] || name;
+}
+function countLines(text) {
+  if (!text) return 0;
+  return text.split("\n").length;
+}
+var CLAUDE_PROJECTS_DIR2 = (0, import_node_path6.join)((0, import_node_os6.homedir)(), ".claude", "projects");
+function extractProjectName3(dirName) {
+  const parts = dirName.replace(/^-/, "").split("-");
+  return parts[parts.length - 1] || dirName;
+}
+function matchesProject2(dirName, filter) {
+  return extractProjectName3(dirName) === extractProjectName3(filter);
+}
+var claudeSessionCache = /* @__PURE__ */ new Map();
+function extractClaudeToolCalls(project) {
+  if (!(0, import_node_fs6.existsSync)(CLAUDE_PROJECTS_DIR2)) return [];
+  const results = [];
+  const projectDirs = (0, import_node_fs6.readdirSync)(CLAUDE_PROJECTS_DIR2, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+  for (const dirName of projectDirs) {
+    if (project && !matchesProject2(dirName, project)) continue;
+    const dirPath = (0, import_node_path6.join)(CLAUDE_PROJECTS_DIR2, dirName);
+    let files;
+    try {
+      files = (0, import_node_fs6.readdirSync)(dirPath).filter((f) => f.endsWith(".jsonl"));
+    } catch {
+      continue;
+    }
+    for (const file of files) {
+      const filePath = (0, import_node_path6.join)(dirPath, file);
+      let mtime = 0;
+      try {
+        mtime = (0, import_node_fs6.statSync)(filePath).mtimeMs;
+      } catch {
+      }
+      const cached = claudeSessionCache.get(filePath);
+      if (cached && cached.mtime === mtime) {
+        results.push(...cached.toolCalls);
+        continue;
+      }
+      const toolCalls = [];
+      let content;
+      try {
+        content = (0, import_node_fs6.readFileSync)(filePath, "utf-8");
+      } catch {
+        continue;
+      }
+      for (const line of content.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        let obj;
+        try {
+          obj = JSON.parse(trimmed);
+        } catch {
+          continue;
+        }
+        if (obj.type !== "assistant" || !obj.message) continue;
+        const msg = obj.message;
+        const timestamp = new Date(obj.timestamp).getTime();
+        const content_arr = msg.content;
+        if (!content_arr) continue;
+        for (const item of content_arr) {
+          if (item.type !== "tool_use") continue;
+          const toolName = normalizeToolName(item.name);
+          const input = item.input || {};
+          let linesAdded = 0;
+          let linesDeleted = 0;
+          const filePath2 = input.file_path || void 0;
+          if (toolName === "Edit") {
+            linesDeleted = countLines(input.old_string || "");
+            linesAdded = countLines(input.new_string || "");
+          } else if (toolName === "Write") {
+            linesAdded = countLines(input.content || "");
+          }
+          toolCalls.push({ toolName, timestamp, filePath: filePath2, linesAdded, linesDeleted });
+        }
+      }
+      claudeSessionCache.set(filePath, { mtime, toolCalls });
+      results.push(...toolCalls);
+    }
+  }
+  return results;
+}
+var openclawSessionCache = /* @__PURE__ */ new Map();
+function extractOpenClawToolCalls(project) {
+  const results = [];
+  const refs = scanOpenClawSessions();
+  for (const ref of refs) {
+    if (project && ref.agentId !== project) continue;
+    let mtime = 0;
+    try {
+      mtime = (0, import_node_fs6.statSync)(ref.sessionFile).mtimeMs;
+    } catch {
+    }
+    const cached = openclawSessionCache.get(ref.sessionFile);
+    if (cached && cached.mtime === mtime) {
+      results.push(...cached.toolCalls);
+      continue;
+    }
+    const toolCalls = [];
+    let content;
+    try {
+      content = (0, import_node_fs6.readFileSync)(ref.sessionFile, "utf-8");
+    } catch {
+      continue;
+    }
+    for (const line of content.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      let obj;
+      try {
+        obj = JSON.parse(trimmed);
+      } catch {
+        continue;
+      }
+      if (obj.type !== "message") continue;
+      const msg = obj.message;
+      if (msg.role !== "assistant") continue;
+      const timestamp = Number(msg.timestamp ?? 0);
+      const content_arr = msg.content;
+      if (!content_arr) continue;
+      for (const item of content_arr) {
+        if (item.type !== "toolCall") continue;
+        const toolName = normalizeToolName(item.name);
+        const args = item.arguments || {};
+        let linesAdded = 0;
+        let linesDeleted = 0;
+        const filePath2 = args.path || void 0;
+        if (toolName === "Edit") {
+          linesDeleted = countLines(args.oldText || "");
+          linesAdded = countLines(args.newText || "");
+        } else if (toolName === "Write") {
+          linesAdded = countLines(args.content || "");
+        }
+        toolCalls.push({ toolName, timestamp, filePath: filePath2, linesAdded, linesDeleted });
+      }
+    }
+    openclawSessionCache.set(ref.sessionFile, { mtime, toolCalls });
+    results.push(...toolCalls);
+  }
+  return results;
+}
+function computeAnalytics(toolCalls, timezone = "Asia/Shanghai") {
+  const changeMap = /* @__PURE__ */ new Map();
+  for (const tc of toolCalls) {
+    if (tc.linesAdded === 0 && tc.linesDeleted === 0) continue;
+    const key = getDateKey5(tc.timestamp, timezone);
+    if (!changeMap.has(key)) changeMap.set(key, { added: 0, deleted: 0, files: /* @__PURE__ */ new Set() });
+    const entry = changeMap.get(key);
+    entry.added += tc.linesAdded;
+    entry.deleted += tc.linesDeleted;
+    if (tc.filePath) entry.files.add(tc.filePath);
+  }
+  const codeChangeTrend = [];
+  for (const [date, { added, deleted, files }] of changeMap) {
+    codeChangeTrend.push({ date, linesAdded: added, linesDeleted: deleted, netChange: added - deleted, filesModified: files.size });
+  }
+  codeChangeTrend.sort((a, b) => a.date.localeCompare(b.date));
+  const toolCountMap = /* @__PURE__ */ new Map();
+  for (const tc of toolCalls) {
+    toolCountMap.set(tc.toolName, (toolCountMap.get(tc.toolName) || 0) + 1);
+  }
+  const toolUsageDistribution = [...toolCountMap.entries()].map(([name, count]) => ({ name, count })).sort((a, b) => b.count - a.count);
+  const editCalls = toolCalls.filter((tc) => tc.toolName === "Edit" || tc.toolName === "Write");
+  const totalEdits = editCalls.length;
+  const totalLinesChanged = editCalls.reduce((s, tc) => s + tc.linesAdded + tc.linesDeleted, 0);
+  const totalLinesAdded = editCalls.reduce((s, tc) => s + tc.linesAdded, 0);
+  const totalLinesDeleted = editCalls.reduce((s, tc) => s + tc.linesDeleted, 0);
+  const uniqueFiles = new Set(editCalls.filter((tc) => tc.filePath).map((tc) => tc.filePath));
+  const editDates = new Set(editCalls.map((tc) => getDateKey5(tc.timestamp, timezone)));
+  const productivityKPIs = {
+    avgLinesPerEdit: totalEdits > 0 ? Math.round(totalLinesChanged / totalEdits) : 0,
+    filesModifiedPerDay: editDates.size > 0 ? Math.round(uniqueFiles.size / editDates.size) : 0,
+    addDeleteRatio: totalLinesDeleted > 0 ? Math.round(totalLinesAdded / totalLinesDeleted * 100) / 100 : totalLinesAdded > 0 ? 1 : 0,
+    totalEdits,
+    totalFilesModified: uniqueFiles.size,
+    activeDaysWithEdits: editDates.size
+  };
+  const trendMap = /* @__PURE__ */ new Map();
+  for (const tc of toolCalls) {
+    const date = getDateKey5(tc.timestamp, timezone);
+    if (!trendMap.has(date)) trendMap.set(date, /* @__PURE__ */ new Map());
+    const dayMap = trendMap.get(date);
+    dayMap.set(tc.toolName, (dayMap.get(tc.toolName) || 0) + 1);
+  }
+  const toolCallTrend = [];
+  for (const [date, dayMap] of trendMap) {
+    const entry = { date };
+    for (const [tool, count] of dayMap) {
+      entry[tool] = count;
+    }
+    toolCallTrend.push(entry);
+  }
+  toolCallTrend.sort((a, b) => a.date.localeCompare(b.date));
+  return { codeChangeTrend, toolUsageDistribution, productivityKPIs, toolCallTrend };
+}
+
+// src/server/routes/analytics.ts
+var EMPTY_ANALYTICS = {
+  codeChangeTrend: [],
+  toolUsageDistribution: [],
+  productivityKPIs: { avgLinesPerEdit: 0, filesModifiedPerDay: 0, addDeleteRatio: 0, totalEdits: 0, totalFilesModified: 0, activeDaysWithEdits: 0 },
+  toolCallTrend: []
+};
+async function getAnalytics(req, res) {
+  const agent = req.query.agent || "claude";
+  const project = req.query.project || void 0;
+  if (agent === "codex" || agent === "opencode") {
+    res.json(EMPTY_ANALYTICS);
+    return;
+  }
+  try {
+    const cacheKey = `analytics:${agent}:${project || "all"}`;
+    const cached = cache.get(cacheKey);
+    if (cached) {
+      res.json(cached);
+      return;
+    }
+    const toolCalls = agent === "openclaw" ? extractOpenClawToolCalls(project || null) : extractClaudeToolCalls(project || null);
+    const data = computeAnalytics(toolCalls);
+    const validated = validateAnalytics(data);
+    cache.set(cacheKey, validated);
+    res.json(validated);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.error("Error fetching analytics:", error);
+    res.status(502).json({
+      error: `Failed to fetch analytics from ${agent}`,
+      hint: message
+    });
+  }
+}
+
+// src/server/agentDetection.ts
+var import_node_fs7 = require("node:fs");
+var import_node_path7 = require("node:path");
+var import_node_os7 = require("node:os");
+var CLAUDE_PROJECTS_DIR3 = (0, import_node_path7.join)((0, import_node_os7.homedir)(), ".claude", "projects");
+var CODEX_SESSIONS_DIR = (0, import_node_path7.join)((0, import_node_os7.homedir)(), ".codex", "sessions");
+function isClaudeCodeAvailable() {
+  if (!(0, import_node_fs7.existsSync)(CLAUDE_PROJECTS_DIR3)) return false;
+  try {
+    const dirs = (0, import_node_fs7.readdirSync)(CLAUDE_PROJECTS_DIR3, { withFileTypes: true });
+    return dirs.some((d) => d.isDirectory());
+  } catch {
+    return false;
+  }
+}
+function isCodexAvailable() {
+  return (0, import_node_fs7.existsSync)(CODEX_SESSIONS_DIR);
+}
+function isOpencodeAvailable() {
+  return (0, import_node_fs7.existsSync)((0, import_node_path7.join)((0, import_node_os7.homedir)(), ".local", "share", "opencode", "opencode.db"));
+}
+function detectAvailableAgents() {
+  return {
+    claude: isClaudeCodeAvailable(),
+    codex: isCodexAvailable(),
+    opencode: isOpencodeAvailable()
+  };
+}
+
+// src/server/routes/api.ts
+function getAgents(_req, res) {
+  try {
+    const agents = detectAvailableAgents();
+    const available = [];
+    if (agents.claude) available.push("claude");
+    if (agents.codex) available.push("codex");
+    if (isOpenClawAccessible()) available.push("openclaw");
+    if (isOpencodeAccessible()) available.push("opencode");
+    res.json({ available, default: available[0] || null });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    res.status(500).json({ error: "Failed to detect agents", hint: message });
+  }
+}
+function registerApiRoutes(router) {
+  router.get("/agents", getAgents);
+  router.get("/daily", getDaily);
+  router.get("/monthly", getMonthly);
+  router.get("/session", getSession);
+  router.get("/projects", getProjects);
+  router.get("/blocks", getBlocks);
+  router.get("/analytics", getAnalytics);
+}
+
+// src/server/index.ts
+var import_open = __toESM(require("open"), 1);
+var CLI_USAGE = [
+  "Usage:",
+  "  tokendash",
+  "  tokendash --version",
+  "  tokendash --port <number> [--no-open]",
+  "  tokendash --tray [--port <number>]"
+].join("\n");
+function getPackageVersion() {
+  const __filename = (0, import_node_url.fileURLToPath)(__esbuild_import_meta_url);
+  const __dirname = (0, import_node_path8.dirname)(__filename);
+  const packageJson = JSON.parse((0, import_node_fs8.readFileSync)((0, import_node_path8.join)(__dirname, "..", "..", "package.json"), "utf8"));
+  return packageJson.version ?? "unknown";
+}
+function exitWithCliError(message) {
+  console.error(message);
+  console.error(`
+${CLI_USAGE}`);
+  process.exit(1);
+}
+function parseCliArgs() {
+  const args = process.argv.slice(2);
+  const result = {};
+  if (args.length === 1 && (args[0] === "--version" || args[0] === "-v")) {
+    result.showVersion = true;
+    return result;
+  }
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--version" || arg === "-v") {
+      exitWithCliError("The --version flag must be used by itself.");
+    }
+    if (arg === "--port") {
+      if (i + 1 >= args.length) {
+        exitWithCliError("Missing value for --port.");
+      }
+      const value = parseInt(args[i + 1], 10);
+      if (!Number.isInteger(value) || value <= 0) {
+        exitWithCliError(`Invalid port value: ${args[i + 1]}`);
+      }
+      result.port = value;
+      i++;
+    } else if (arg === "--no-open") {
+      result.noOpen = true;
+    } else if (arg === "--tray") {
+      result.tray = true;
+    } else {
+      exitWithCliError(`Unsupported argument: ${arg}`);
+    }
+  }
+  return result;
+}
+async function ensureUsageSupportAvailable() {
+  try {
+    const agents = detectAvailableAgents();
+    if (!agents.claude && !agents.codex) {
+      console.error("Error: No AI coding assistant data found.");
+      console.error("\nDetails: Could not find Claude Code (~/.claude/projects/) or Codex (~/.codex/sessions/) data.");
+      console.error("Please install at least one of: Claude Code or Codex CLI.");
+      return false;
+    }
+    if (agents.claude) console.log("  \u2713 Claude Code detected");
+    if (agents.codex) console.log("  \u2713 Codex detected");
+    return true;
+  } catch (error) {
+    console.error("Error: failed to detect available AI coding assistants");
+    console.error("\nDetails:", error instanceof Error ? error.message : error);
+    return false;
+  }
+}
+function resolvePort(value) {
+  return Number.isInteger(value) && value && value > 0 ? value : 3456;
+}
+function listen(app, port) {
+  return new Promise((resolve, reject) => {
+    const server = app.listen(port);
+    const handleListening = () => {
+      cleanup();
+      resolve(server);
+    };
+    const handleError = (error) => {
+      cleanup();
+      reject(error);
+    };
+    const cleanup = () => {
+      server.off("listening", handleListening);
+      server.off("error", handleError);
+    };
+    server.once("listening", handleListening);
+    server.once("error", handleError);
+  });
+}
+async function listenWithPortFallback(app, preferredPort) {
+  let port = preferredPort;
+  for (let attempt = 0; attempt < 20; attempt++, port++) {
+    try {
+      const server = await listen(app, port);
+      return { server, port, usedFallback: port !== preferredPort };
+    } catch (error) {
+      const err = error;
+      if (err.code !== "EADDRINUSE") {
+        throw error;
+      }
+    }
+  }
+  throw new Error(`Could not find an available port starting from ${preferredPort}`);
+}
+function createApp(_port, baseDir) {
+  const app = (0, import_express.default)();
+  const router = import_express.default.Router();
+  registerApiRoutes(router);
+  app.use("/api", router);
+  const _baseDir = baseDir ?? (0, import_node_path8.dirname)((0, import_node_url.fileURLToPath)(__esbuild_import_meta_url));
+  const isProduction = baseDir ? true : __esbuild_import_meta_url.includes("dist/");
+  const popoverPath = isProduction ? (0, import_node_path8.join)(_baseDir, "client", "popover.html") : (0, import_node_path8.join)(_baseDir, "..", "..", "public", "popover.html");
+  app.get("/popover.html", (_req, res) => {
+    res.sendFile(popoverPath);
+  });
+  if (isProduction) {
+    const clientPath = (0, import_node_path8.join)(_baseDir, "client");
+    const clientIndexPath = (0, import_node_path8.join)(clientPath, "index.html");
+    app.use(import_express.default.static(clientPath));
+    app.use("{*path}", (_req, res) => {
+      res.sendFile(clientIndexPath);
+    });
+  }
+  return app;
+}
+async function main() {
+  const args = parseCliArgs();
+  if (args.showVersion) {
+    console.log(getPackageVersion());
+    return;
+  }
+  const version = getPackageVersion();
+  const preferredPort = resolvePort(args.port ?? (process.env.PORT ? parseInt(process.env.PORT, 10) : void 0));
+  if (args.tray) {
+    if (process.platform !== "darwin") {
+      console.error("Error: --tray is only supported on macOS.");
+      process.exit(1);
+    }
+    console.log(`Starting tokendash v${version} in tray mode...`);
+    const { default: electronPath } = await import("electron");
+    const { spawn } = await import("node:child_process");
+    const child = spawn(electronPath, ["."], {
+      env: {
+        ...process.env,
+        TOKENDASH_PORT: String(preferredPort),
+        TOKENDASH_TRAY: "1"
+      },
+      stdio: "inherit"
+    });
+    child.on("close", (code) => process.exit(code ?? 0));
+    process.on("SIGTERM", () => child.kill("SIGTERM"));
+    return;
+  }
+  const shouldOpenBrowser = !args.noOpen;
+  console.log(`Starting tokendash v${version}...`);
+  console.log(`Checking local usage data sources...`);
+  const isUsageSupportAvailable = await ensureUsageSupportAvailable();
+  if (!isUsageSupportAvailable) {
+    process.exit(1);
+  }
+  const app = createApp(preferredPort);
+  const { server, port, usedFallback } = await listenWithPortFallback(app, preferredPort);
+  if (usedFallback) {
+    console.warn(`tokendash detected that port ${preferredPort} is already in use, switched to http://localhost:${port}`);
+  }
+  console.log(`tokendash running on http://localhost:${port}`);
+  console.log(`API available at http://localhost:${port}/api`);
+  const isProduction = __esbuild_import_meta_url.includes("dist/");
+  if (isProduction) {
+    console.log("Serving production build");
+  } else {
+    console.log('Development mode - use "npm run dev" for full dev experience');
+  }
+  if (shouldOpenBrowser) {
+    setTimeout(() => {
+      console.log("Opening dashboard in your browser...");
+      (0, import_open.default)(`http://localhost:${port}`).catch((err) => {
+        console.warn("Could not open browser:", err.message);
+      });
+    }, 100);
+  } else {
+    console.log("Browser auto-open disabled (--no-open)");
+  }
+  process.on("SIGTERM", () => {
+    server.close(() => {
+      console.log("Server closed");
+      process.exit(0);
+    });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createApp,
+  main
+});
+//# sourceMappingURL=electron-server.cjs.map