@zhangferry-dev/tokendash 1.6.0 → 1.6.2

package/dist/daemon.cjs

@@ -0,0 +1,3306 @@
+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 __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
+));
+
+// src/server/index.ts
+var import_express = __toESM(require("express"), 1);
+var import_node_fs13 = require("node:fs");
+var import_node_url = require("node:url");
+var import_node_path13 = 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.optional()
+}).nullable().default(null);
+var TokenCountPayloadSchema = import_zod2.z.object({
+  type: import_zod2.z.literal("token_count"),
+  info: TokenCountInfoSchema
+});
+function subtractTokenUsage(current, previous) {
+  return {
+    timestamp: "",
+    inputTokens: Math.max(0, current.input_tokens - (previous?.input_tokens ?? 0)),
+    cachedInputTokens: Math.max(0, current.cached_input_tokens - (previous?.cached_input_tokens ?? 0)),
+    outputTokens: Math.max(0, current.output_tokens - (previous?.output_tokens ?? 0)),
+    reasoningOutputTokens: Math.max(0, current.reasoning_output_tokens - (previous?.reasoning_output_tokens ?? 0)),
+    totalTokens: Math.max(0, current.total_tokens - (previous?.total_tokens ?? 0))
+  };
+}
+function displayInputTokens(inputTokens, cachedInputTokens) {
+  return Math.max(0, inputTokens - cachedInputTokens);
+}
+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 = [];
+  let previousTotalUsage = null;
+  const seenTotalUsageSnapshots = /* @__PURE__ */ new Set();
+  const seenUsageEvents = /* @__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 = [
+          info.total_token_usage.input_tokens,
+          info.total_token_usage.cached_input_tokens,
+          info.total_token_usage.output_tokens,
+          info.total_token_usage.reasoning_output_tokens,
+          info.total_token_usage.total_tokens
+        ].join(":");
+        if (seenTotalUsageSnapshots.has(totalUsageKey)) continue;
+        seenTotalUsageSnapshots.add(totalUsageKey);
+        const last = info.last_token_usage ?? info.total_token_usage;
+        const rawEvent = info.last_token_usage ? subtractTokenUsage(last, null) : subtractTokenUsage(last, previousTotalUsage);
+        previousTotalUsage = info.total_token_usage;
+        if (rawEvent.inputTokens === 0 && rawEvent.cachedInputTokens === 0 && rawEvent.outputTokens === 0 && rawEvent.reasoningOutputTokens === 0) {
+          continue;
+        }
+        const event = {
+          ...rawEvent,
+          timestamp,
+          cachedInputTokens: Math.min(rawEvent.cachedInputTokens, rawEvent.inputTokens)
+        };
+        const eventKey = [
+          timestamp,
+          model,
+          event.inputTokens,
+          event.cachedInputTokens,
+          event.outputTokens,
+          event.reasoningOutputTokens,
+          event.totalTokens
+        ].join(":");
+        if (seenUsageEvents.has(eventKey)) {
+          continue;
+        }
+        seenUsageEvents.add(eventKey);
+        tokenEvents.push(event);
+      }
+    }
+  }
+  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 displayAcc(acc) {
+  return {
+    ...acc,
+    inputTokens: displayInputTokens(acc.inputTokens, acc.cachedInputTokens)
+  };
+}
+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 addAccToBucket(bucket, ev, model) {
+  addAcc(bucket.acc, ev);
+  if (!model) return;
+  if (!bucket.models.has(model)) bucket.models.set(model, emptyAcc());
+  addAcc(bucket.models.get(model), ev);
+}
+function accToEntry(date, acc, modelAccs) {
+  const display = displayAcc(acc);
+  const modelNames = [...modelAccs.keys()];
+  const modelBreakdowns = buildModelBreakdowns(modelAccs);
+  const totalCost = modelBreakdowns.reduce((sum, model) => sum + model.cost, 0);
+  return {
+    date,
+    inputTokens: display.inputTokens,
+    outputTokens: display.outputTokens,
+    cacheCreationTokens: 0,
+    cacheReadTokens: display.cachedInputTokens,
+    totalTokens: display.totalTokens,
+    totalCost,
+    modelsUsed: modelNames,
+    modelBreakdowns
+  };
+}
+function buildModelBreakdowns(modelAccs) {
+  return [...modelAccs.entries()].map(([modelName, acc]) => {
+    const display = displayAcc(acc);
+    return {
+      modelName,
+      inputTokens: display.inputTokens,
+      outputTokens: display.outputTokens,
+      cacheCreationTokens: 0,
+      cacheReadTokens: display.cachedInputTokens,
+      cost: calculateCost(acc, /* @__PURE__ */ new Set([modelName]))
+    };
+  });
+}
+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 Map() });
+      }
+      addAccToBucket(grouped.get(key), ev, session.model);
+    }
+  }
+  return grouped;
+}
+function buildDailyResponse(sessions, options) {
+  const grouped = groupSessions(sessions, { groupBy: "day", ...options });
+  const daily = [];
+  const totalsAcc = emptyAcc();
+  const totalModels = /* @__PURE__ */ new Map();
+  for (const [date, { acc, models }] of grouped) {
+    daily.push(accToEntry(date, acc, models));
+    mergeAcc(totalsAcc, acc);
+    for (const [model, modelAcc] of models) {
+      if (!totalModels.has(model)) totalModels.set(model, emptyAcc());
+      mergeAcc(totalModels.get(model), modelAcc);
+    }
+  }
+  daily.sort((a, b) => a.date.localeCompare(b.date));
+  const totalCost = buildModelBreakdowns(totalModels).reduce((sum, model) => sum + model.cost, 0);
+  return {
+    daily,
+    totals: {
+      inputTokens: displayInputTokens(totalsAcc.inputTokens, totalsAcc.cachedInputTokens),
+      outputTokens: totalsAcc.outputTokens,
+      cacheCreationTokens: 0,
+      cacheReadTokens: totalsAcc.cachedInputTokens,
+      totalTokens: totalsAcc.totalTokens,
+      totalCost
+    }
+  };
+}
+function buildProjectsResponse(sessions, options) {
+  const tz = options?.timezone || "Asia/Shanghai";
+  const projectGroups = /* @__PURE__ */ new Map();
+  for (const session of sessions) {
+    const projectName = extractProjectName(session.cwd);
+    if (options?.project && projectName !== options.project) continue;
+    if (!projectGroups.has(projectName)) projectGroups.set(projectName, /* @__PURE__ */ new Map());
+    const dailyMap = projectGroups.get(projectName);
+    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 Map() });
+      }
+      addAccToBucket(dailyMap.get(dayKey), ev, session.model);
+    }
+  }
+  const projects = {};
+  for (const [projectName, dailyMap] of projectGroups) {
+    projects[projectName] = [...dailyMap.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([date, { acc, models }]) => accToEntry(date, acc, models));
+  }
+  return { projects };
+}
+function buildBlocksResponse(sessions, options) {
+  const grouped = groupSessions(sessions, { groupBy: "hour", ...options });
+  const blocks = [];
+  let idx = 0;
+  for (const [hourKey, { acc, models }] of grouped) {
+    const cost = buildModelBreakdowns(models).reduce((sum, model) => sum + model.cost, 0);
+    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: displayInputTokens(acc.inputTokens, acc.cachedInputTokens),
+        outputTokens: acc.outputTokens,
+        cacheCreationInputTokens: 0,
+        cacheReadInputTokens: acc.cachedInputTokens
+      },
+      totalTokens: acc.totalTokens,
+      costUSD: cost,
+      models: [...models.keys()]
+    });
+    idx++;
+  }
+  blocks.sort((a, b) => a.startTime.localeCompare(b.startTime));
+  return { blocks };
+}
+function getDailyResponse(options) {
+  return buildDailyResponse(parseAllSessions(), options);
+}
+function getProjectsResponse(options) {
+  return buildProjectsResponse(parseAllSessions(), options);
+}
+function getBlocksResponse(options) {
+  return buildBlocksResponse(parseAllSessions(), options);
+}
+
+// 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, cacheCreationPer1M: 18.75, cacheReadPer1M: 1.5, outputPer1M: 75 },
+  "claude-sonnet-4-6": { inputPer1M: 3, cacheCreationPer1M: 3.75, cacheReadPer1M: 0.3, outputPer1M: 15 },
+  // Claude 4.5
+  "claude-sonnet-4-5-20250514": { inputPer1M: 3, cacheCreationPer1M: 3.75, cacheReadPer1M: 0.3, outputPer1M: 15 },
+  "claude-haiku-4-5-20251001": { inputPer1M: 0.8, cacheCreationPer1M: 1, cacheReadPer1M: 0.08, outputPer1M: 4 },
+  // Older Claude models
+  "claude-3-5-sonnet-20241022": { inputPer1M: 3, cacheCreationPer1M: 3.75, cacheReadPer1M: 0.3, outputPer1M: 15 },
+  "claude-3-5-haiku-20241022": { inputPer1M: 0.8, cacheCreationPer1M: 1, cacheReadPer1M: 0.08, outputPer1M: 4 },
+  "claude-3-opus-20240229": { inputPer1M: 15, cacheCreationPer1M: 18.75, cacheReadPer1M: 1.5, outputPer1M: 75 },
+  "claude-3-haiku-20240307": { inputPer1M: 0.25, cacheCreationPer1M: 0.3, cacheReadPer1M: 0.03, outputPer1M: 1.25 }
+};
+var DEFAULT_PRICING2 = { inputPer1M: 3, cacheCreationPer1M: 3.75, 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, cacheCreationTokens = 0) {
+  const p = getPricing(model);
+  return inputTokens / 1e6 * p.inputPer1M + cacheCreationTokens / 1e6 * p.cacheCreationPer1M + cacheReadTokens / 1e6 * p.cacheReadPer1M + outputTokens / 1e6 * p.outputPer1M;
+}
+function totalClaudeTokens(inputTokens, outputTokens, cacheCreationTokens, cacheReadTokens) {
+  return inputTokens + outputTokens + cacheCreationTokens + cacheReadTokens;
+}
+var CLAUDE_PROJECTS_DIR = (0, import_node_path5.join)((0, import_node_os5.homedir)(), ".claude", "projects");
+var fileCache = /* @__PURE__ */ new Map();
+var projectNameCache = /* @__PURE__ */ new Map();
+function extractProjectName2(dirName) {
+  if (!dirName.startsWith("-")) return dirName;
+  const cached = projectNameCache.get(dirName);
+  if (cached) return cached;
+  const segments = dirName.replace(/^-/, "").split("-").filter(Boolean);
+  if (segments.length === 0) {
+    projectNameCache.set(dirName, dirName);
+    return dirName;
+  }
+  if (segments.length === 1) {
+    projectNameCache.set(dirName, segments[0]);
+    return segments[0];
+  }
+  let bestName = segments[segments.length - 1];
+  for (let splitAt = segments.length - 1; splitAt >= 1; splitAt--) {
+    const parentSegments = segments.slice(0, splitAt);
+    const candidateName = segments.slice(splitAt).join("-");
+    let parentPath = "/";
+    let valid = true;
+    for (const seg of parentSegments) {
+      const regular = (0, import_node_path5.join)(parentPath, seg);
+      const hidden = (0, import_node_path5.join)(parentPath, "." + seg);
+      if ((0, import_node_fs5.existsSync)(regular)) {
+        parentPath = regular;
+      } else if ((0, import_node_fs5.existsSync)(hidden)) {
+        parentPath = hidden;
+      } else {
+        valid = false;
+        break;
+      }
+    }
+    if (!valid) continue;
+    if ((0, import_node_fs5.existsSync)((0, import_node_path5.join)(parentPath, candidateName)) || (0, import_node_fs5.existsSync)((0, import_node_path5.join)(parentPath, "." + candidateName))) {
+      bestName = candidateName;
+      break;
+    }
+  }
+  projectNameCache.set(dirName, bestName);
+  return bestName;
+}
+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 = totalClaudeTokens(inputTokens, outputTokens, cacheCreationTokens, 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 += totalClaudeTokens(e.inputTokens, e.outputTokens, e.cacheCreationTokens, e.cacheReadTokens);
+    const cost = calculateCost2(e.inputTokens, e.cacheReadTokens, e.outputTokens, e.model, e.cacheCreationTokens);
+    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 = extractProjectName2(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 += totalClaudeTokens(e.inputTokens, e.outputTokens, e.cacheCreationTokens, e.cacheReadTokens);
+    const cost = calculateCost2(e.inputTokens, e.cacheReadTokens, e.outputTokens, e.model, e.cacheCreationTokens);
+    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, e.cacheCreationTokens);
+    bucket.models.add(e.model);
+  }
+  const blocks = [];
+  let idx = 0;
+  for (const [hourKey, bucket] of hourMap) {
+    const totalTokens = totalClaudeTokens(bucket.inputTokens, bucket.outputTokens, bucket.cacheCreationTokens, 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");
+var projectNameCache2 = /* @__PURE__ */ new Map();
+function extractProjectName3(dirName) {
+  if (!dirName.startsWith("-")) return dirName;
+  const cached = projectNameCache2.get(dirName);
+  if (cached) return cached;
+  const segments = dirName.replace(/^-/, "").split("-").filter(Boolean);
+  if (segments.length === 0) {
+    projectNameCache2.set(dirName, dirName);
+    return dirName;
+  }
+  if (segments.length === 1) {
+    projectNameCache2.set(dirName, segments[0]);
+    return segments[0];
+  }
+  let bestName = segments[segments.length - 1];
+  for (let splitAt = segments.length - 1; splitAt >= 1; splitAt--) {
+    const parentSegments = segments.slice(0, splitAt);
+    const candidateName = segments.slice(splitAt).join("-");
+    let parentPath = "/";
+    let valid = true;
+    for (const seg of parentSegments) {
+      const regular = (0, import_node_path6.join)(parentPath, seg);
+      const hidden = (0, import_node_path6.join)(parentPath, "." + seg);
+      if ((0, import_node_fs6.existsSync)(regular)) {
+        parentPath = regular;
+      } else if ((0, import_node_fs6.existsSync)(hidden)) {
+        parentPath = hidden;
+      } else {
+        valid = false;
+        break;
+      }
+    }
+    if (!valid) continue;
+    if ((0, import_node_fs6.existsSync)((0, import_node_path6.join)(parentPath, candidateName)) || (0, import_node_fs6.existsSync)((0, import_node_path6.join)(parentPath, "." + candidateName))) {
+      bestName = candidateName;
+      break;
+    }
+  }
+  projectNameCache2.set(dirName, bestName);
+  return bestName;
+}
+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));
+  if (toolCallTrend.length > 0) {
+    const allTools = /* @__PURE__ */ new Set();
+    for (const entry of toolCallTrend) {
+      for (const key of Object.keys(entry)) {
+        if (key !== "date") allTools.add(key);
+      }
+    }
+    for (const entry of toolCallTrend) {
+      for (const tool of allTools) {
+        if (entry[tool] === void 0) {
+          entry[tool] = 0;
+        }
+      }
+    }
+  }
+  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/quota/adapter.ts
+var QuotaError = class extends Error {
+  status;
+  constructor(status) {
+    const msg = "message" in status && status.message ? status.message : "";
+    super(msg ? `${status.state}: ${msg}` : status.state);
+    this.name = "QuotaError";
+    this.status = status;
+  }
+};
+var QuotaAdapterRegistry = class {
+  adapters = /* @__PURE__ */ new Map();
+  register(adapter) {
+    this.adapters.set(adapter.provider, adapter);
+  }
+  get(provider) {
+    return this.adapters.get(provider);
+  }
+  list() {
+    return Array.from(this.adapters.values());
+  }
+};
+function baseSnapshot(provider, displayName, opts = {}) {
+  return {
+    provider,
+    displayName,
+    planName: opts.planName,
+    fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    freshness: "live",
+    windows: opts.windows ?? []
+  };
+}
+
+// src/server/quota/cache.ts
+var QuotaCache = class {
+  constructor(ttlMs = 6e4) {
+    this.ttlMs = ttlMs;
+  }
+  store = /* @__PURE__ */ new Map();
+  /** Fresh cached snapshot, or null if expired / absent. */
+  getFresh(provider) {
+    const entry = this.store.get(provider);
+    if (!entry) return null;
+    if (Date.now() > entry.expiresAt) return null;
+    return { ...entry.snapshot, freshness: "cached" };
+  }
+  /** Last successful snapshot regardless of TTL (for stale-while-revalidate). */
+  getStale(provider) {
+    const entry = this.store.get(provider);
+    if (!entry) return null;
+    return { ...entry.snapshot, freshness: "stale" };
+  }
+  set(snapshot) {
+    this.store.set(snapshot.provider, {
+      snapshot,
+      expiresAt: Date.now() + this.ttlMs,
+      updatedAt: Date.now()
+    });
+  }
+  clear(provider) {
+    if (provider) this.store.delete(provider);
+    else this.store.clear();
+  }
+};
+
+// src/server/quota/schemas.ts
+var import_zod3 = require("zod");
+var QuotaWindowSchema = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  label: import_zod3.z.string(),
+  usedPercent: import_zod3.z.number().min(0).max(100).default(0),
+  remainingPercent: import_zod3.z.number().min(0).max(100).default(0),
+  used: import_zod3.z.number().optional(),
+  limit: import_zod3.z.number().optional(),
+  durationMins: import_zod3.z.number().optional(),
+  resetsAt: import_zod3.z.string().optional(),
+  isUnlimited: import_zod3.z.boolean().optional(),
+  modelName: import_zod3.z.string().optional()
+});
+var QuotaProviderStatusSchema = import_zod3.z.object({
+  state: import_zod3.z.enum([
+    "ok",
+    "auth_failed",
+    "not_configured",
+    "upstream_unavailable",
+    "rate_limited",
+    "malformed_response",
+    "timed_out",
+    "error"
+  ]),
+  message: import_zod3.z.string().optional(),
+  category: import_zod3.z.string().optional()
+});
+var QuotaSnapshotSchema = import_zod3.z.object({
+  provider: import_zod3.z.enum(["codex", "claude", "glm", "minimax", "kimi"]),
+  displayName: import_zod3.z.string(),
+  planName: import_zod3.z.string().optional(),
+  fetchedAt: import_zod3.z.string(),
+  freshness: import_zod3.z.enum(["live", "cached", "stale"]),
+  windows: import_zod3.z.array(QuotaWindowSchema).default([]),
+  status: QuotaProviderStatusSchema
+});
+var QuotaResponseSchema = import_zod3.z.object({
+  providers: import_zod3.z.array(QuotaSnapshotSchema).default([])
+});
+function validateQuotaSnapshot(data) {
+  return QuotaSnapshotSchema.parse(data);
+}
+
+// src/server/quota/quotaService.ts
+var QuotaService = class {
+  constructor(registry2, cache2 = new QuotaCache(), configuredCache = null, fetchTimeoutMs = 8e3) {
+    this.registry = registry2;
+    this.cache = cache2;
+    this.configuredCache = configuredCache;
+    this.fetchTimeoutMs = fetchTimeoutMs;
+  }
+  /** Cap concurrent upstream calls so a slow provider can't block the others. */
+  fetchTimeoutMs;
+  /** In-flight promises keyed by provider id, to dedupe concurrent requests. */
+  inflight = /* @__PURE__ */ new Map();
+  /**
+   * List provider ids that are configured locally. Cheap (no network).
+   * The dashboard only shows these — not-configured providers are excluded.
+   */
+  async discover() {
+    const all = this.registry.list();
+    const checks = await Promise.all(
+      all.map(async (a) => ({ id: a.provider, configured: await safeIsConfigured(a) }))
+    );
+    return checks.filter((c) => c.configured).map((c) => c.id);
+  }
+  /**
+   * Fetch one provider's snapshot. Fresh if available; stale-but-retained
+   * on failure; never throws (errors become structured statuses).
+   */
+  async fetchOne(provider) {
+    const fresh = this.cache.getFresh(provider);
+    if (fresh) return fresh;
+    const adapter = this.registry.get(provider);
+    if (!adapter) return null;
+    let p = this.inflight.get(provider);
+    if (!p) {
+      p = this.fetchWithTimeout(adapter).finally(() => this.inflight.delete(provider));
+      this.inflight.set(provider, p);
+    }
+    return p;
+  }
+  /**
+   * Fetch all configured providers concurrently. Partial success: one
+   * provider's failure never breaks the others. Order = registry order.
+   */
+  async fetchAll() {
+    const ids = this.configuredCache ?? await this.discover();
+    const byId = /* @__PURE__ */ new Map();
+    const snapshots = await Promise.all(ids.map((id) => this.fetchOne(id)));
+    for (const adapter of this.registry.list()) {
+      const snap = snapshots.find((s) => s?.provider === adapter.provider);
+      if (snap) byId.set(adapter.provider, snap);
+    }
+    return { providers: this.registry.list().map((a) => byId.get(a.provider)).filter((s) => !!s) };
+  }
+  /** Force a refresh of all configured providers, bypassing the cache. */
+  async refreshAll() {
+    this.configuredCache?.forEach(() => {
+    });
+    for (const adapter of this.registry.list()) {
+      this.cache.clear(adapter.provider);
+    }
+    return this.fetchAll();
+  }
+  async fetchWithTimeout(adapter) {
+    try {
+      const snapshot = await withTimeout(adapter.fetch(), this.fetchTimeoutMs, adapter.provider);
+      const validated = validateQuotaSnapshot(snapshot);
+      this.cache.set(validated);
+      return validated;
+    } catch (err) {
+      return this.handleFailure(adapter, err);
+    }
+  }
+  handleFailure(adapter, err) {
+    let status;
+    if (err instanceof QuotaError) {
+      status = err.status;
+    } else if (err instanceof TimeoutError) {
+      status = { state: "timed_out", message: `upstream did not respond within ${this.fetchTimeoutMs}ms` };
+    } else {
+      status = { state: "error", message: redact(err), category: "unexpected" };
+    }
+    const stale = this.cache.getStale(adapter.provider);
+    if (stale) {
+      return { ...stale, freshness: "stale", status };
+    }
+    return {
+      provider: adapter.provider,
+      displayName: adapter.displayName,
+      fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      freshness: "stale",
+      windows: [],
+      status
+    };
+  }
+};
+var TimeoutError = class extends Error {
+  constructor(provider) {
+    super(`quota fetch timed out: ${provider}`);
+    this.name = "TimeoutError";
+  }
+};
+function withTimeout(p, ms, provider) {
+  return new Promise((resolve2, reject) => {
+    const timer = setTimeout(() => reject(new TimeoutError(provider)), ms);
+    p.then(
+      (v) => {
+        clearTimeout(timer);
+        resolve2(v);
+      },
+      (e) => {
+        clearTimeout(timer);
+        reject(e);
+      }
+    );
+  });
+}
+async function safeIsConfigured(adapter) {
+  try {
+    return await adapter.isConfigured();
+  } catch {
+    return false;
+  }
+}
+function redact(err) {
+  const msg = err instanceof Error ? err.message : String(err);
+  return msg.replace(/(sk-[A-Za-z0-9_-]{6,})[A-Za-z0-9_-]*/g, "$1\u2026").replace(/(Bearer\s+)[A-Za-z0-9._-]+/gi, "$1\u2026").slice(0, 200);
+}
+
+// src/server/quota/adapters/codex.ts
+var import_node_fs8 = require("node:fs");
+var import_node_path8 = require("node:path");
+var import_node_os8 = require("node:os");
+var import_node_child_process2 = require("node:child_process");
+
+// src/server/quota/helpers.ts
+function unixToIso(unix) {
+  if (unix === null || unix === void 0 || unix === "") return void 0;
+  const n = typeof unix === "string" ? parseInt(unix, 10) : unix;
+  if (!Number.isFinite(n) || n <= 0) return void 0;
+  const ms = n > 1e12 ? n : n * 1e3;
+  return new Date(ms).toISOString();
+}
+function clampPercent(v) {
+  if (!Number.isFinite(v)) return 0;
+  return Math.max(0, Math.min(100, v));
+}
+function round1(v) {
+  return Math.round(v * 10) / 10;
+}
+function windowFromPercent(id, label, usedPercent, opts = {}) {
+  const used = round1(clampPercent(usedPercent));
+  return {
+    id,
+    label,
+    usedPercent: used,
+    remainingPercent: round1(100 - used),
+    durationMins: opts.durationMins,
+    resetsAt: opts.resetsAt,
+    used: opts.used,
+    limit: opts.limit,
+    modelName: opts.modelName,
+    isUnlimited: opts.isUnlimited
+  };
+}
+function windowFromCounts(id, label, used, limit, opts = {}) {
+  if (limit <= 0) {
+    return { id, label, usedPercent: 0, remainingPercent: 100, used, limit, isUnlimited: true, ...opts };
+  }
+  const pct = round1(clampPercent(used / limit * 100));
+  return {
+    id,
+    label,
+    usedPercent: pct,
+    remainingPercent: round1(100 - pct),
+    used,
+    limit,
+    ...opts
+  };
+}
+async function fetchJsonWithTimeout(url, opts = {}) {
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), opts.timeoutMs ?? 8e3);
+  try {
+    const res = await fetch(url, { headers: opts.headers, signal: ctrl.signal });
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new HttpError(res.status, body.slice(0, 200));
+    }
+    return await res.json();
+  } finally {
+    clearTimeout(timer);
+  }
+}
+var HttpError = class extends Error {
+  constructor(status, body) {
+    super(`HTTP ${status}`);
+    this.status = status;
+    this.body = body;
+    this.name = "HttpError";
+  }
+};
+function classifyHttpError(err) {
+  if (err.status === 401 || err.status === 403) {
+    return { state: "auth_failed", message: "credential rejected by provider" };
+  }
+  if (err.status === 429) {
+    return { state: "rate_limited", message: "provider throttled the request" };
+  }
+  return { state: "upstream_unavailable", message: `provider returned HTTP ${err.status}` };
+}
+
+// src/server/quota/adapters/codex.ts
+function codexHome() {
+  return process.env.CODEX_HOME || (0, import_node_path8.join)((0, import_node_os8.homedir)(), ".codex");
+}
+var codexAdapter = {
+  provider: "codex",
+  displayName: "OpenAI Codex",
+  async isConfigured() {
+    if ((0, import_node_fs8.existsSync)((0, import_node_path8.join)(codexHome(), "auth.json"))) return true;
+    return await codexBinaryAvailable();
+  },
+  async fetch() {
+    const result = await queryRateLimits();
+    const buckets = result.rateLimitsByLimitId ?? (result.rateLimits ? { primary: result.rateLimits } : {});
+    const windows = [];
+    for (const [key, bucket] of Object.entries(buckets)) {
+      if (bucket.primary) {
+        windows.push(windowFromPercent(`codex_${key}_primary`, labelForBucket(key, "primary", bucket), bucket.primary.usedPercent ?? 0, {
+          durationMins: bucket.primary.windowDurationMins,
+          resetsAt: unixToIso(bucket.primary.resetsAt)
+        }));
+      }
+      if (bucket.secondary) {
+        windows.push(windowFromPercent(`codex_${key}_secondary`, labelForBucket(key, "secondary", bucket), bucket.secondary.usedPercent ?? 0, {
+          durationMins: bucket.secondary.windowDurationMins,
+          resetsAt: unixToIso(bucket.secondary.resetsAt)
+        }));
+      }
+    }
+    const snap = baseSnapshot("codex", "OpenAI Codex", {
+      planName: result.planType ? capitalize(result.planType) : void 0,
+      windows
+    });
+    return { ...snap, status: { state: "ok" } };
+  }
+};
+function labelForBucket(key, tier, bucket) {
+  const dur = tier === "primary" ? bucket.primary?.windowDurationMins : bucket.secondary?.windowDurationMins;
+  const durLabel = dur ? durationLabel(dur) : capitalize(tier);
+  const who = bucket.limitName || (key && key !== "primary" ? key : "");
+  return who ? `${capitalize(who)} \xB7 ${durLabel}` : durLabel;
+}
+function durationLabel(mins) {
+  if (mins >= 10080) return "Weekly";
+  if (mins >= 1440) return `${Math.round(mins / 1440)}-Day`;
+  if (mins >= 60) return `${Math.round(mins / 60)}-Hour`;
+  return `${mins}m`;
+}
+function capitalize(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+async function queryRateLimits() {
+  if (!await codexBinaryAvailable()) {
+    throw new QuotaError({ state: "not_configured", message: "codex CLI not found on PATH" });
+  }
+  const proc = (0, import_node_child_process2.spawn)("codex", ["app-server"], { stdio: ["pipe", "pipe", "pipe"] });
+  const client = new JsonRpcClient(proc);
+  try {
+    await client.request("initialize", {
+      protocolVersion: "2025-03-26",
+      clientInfo: { name: "tokendash", version: "1.0.0" }
+    });
+    client.notify("initialized", {});
+    const res = await client.request("account/rateLimits/read", {});
+    return res;
+  } catch (err) {
+    throw toQuotaError(err);
+  } finally {
+    client.dispose();
+    try {
+      proc.kill("SIGKILL");
+    } catch {
+    }
+  }
+}
+function toQuotaError(err) {
+  const msg = err instanceof Error ? err.message : String(err);
+  if (/not found|ENOENT|spawn/i.test(msg)) {
+    return new QuotaError({ state: "not_configured", message: "codex app-server unavailable" });
+  }
+  if (/401|403|unauthor|auth/i.test(msg)) {
+    return new QuotaError({ state: "auth_failed", message: "codex session not authenticated" });
+  }
+  return new QuotaError({ state: "upstream_unavailable", message: msg.slice(0, 200) });
+}
+var JsonRpcClient = class {
+  constructor(proc) {
+    this.proc = proc;
+    proc.stdout.setEncoding("utf8");
+    proc.stdout.on("data", (chunk) => this.onData(chunk));
+    proc.on("error", (err) => this.failAll(err));
+    proc.on("close", () => this.failAll(new Error("codex app-server closed unexpectedly")));
+  }
+  id = 0;
+  buffer = "";
+  pending = /* @__PURE__ */ new Map();
+  disposed = false;
+  request(method, params) {
+    if (this.disposed) return Promise.reject(new Error("client disposed"));
+    const id = ++this.id;
+    const msg = JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n";
+    return new Promise((resolve2, reject) => {
+      this.pending.set(id, { resolve: resolve2, reject });
+      this.proc.stdin.write(msg, (err) => {
+        if (err) reject(err instanceof Error ? err : new Error(String(err)));
+      });
+    });
+  }
+  notify(method, params) {
+    if (this.disposed) return;
+    const msg = JSON.stringify({ jsonrpc: "2.0", method, params }) + "\n";
+    this.proc.stdin.write(msg, () => {
+    });
+  }
+  dispose() {
+    this.disposed = true;
+    this.failAll(new Error("disposed"));
+  }
+  onData(chunk) {
+    this.buffer += chunk;
+    let idx;
+    while ((idx = this.buffer.indexOf("\n")) >= 0) {
+      const line = this.buffer.slice(0, idx).trim();
+      this.buffer = this.buffer.slice(idx + 1);
+      if (!line) continue;
+      let msg;
+      try {
+        msg = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (msg.id === void 0) continue;
+      const entry = this.pending.get(msg.id);
+      if (!entry) continue;
+      this.pending.delete(msg.id);
+      if (msg.error) entry.reject(new Error(msg.error.message || "codex JSON-RPC error"));
+      else entry.resolve(msg.result);
+    }
+  }
+  failAll(err) {
+    for (const [, entry] of this.pending) entry.reject(err);
+    this.pending.clear();
+  }
+};
+var cachedCodexPath;
+async function codexBinaryAvailable() {
+  if (cachedCodexPath !== void 0) return cachedCodexPath !== null;
+  return new Promise((resolve2) => {
+    const proc = (0, import_node_child_process2.spawn)("which", ["codex"], { stdio: ["ignore", "pipe", "ignore"] });
+    let out = "";
+    proc.stdout.on("data", (c) => {
+      out += c;
+    });
+    proc.on("close", () => {
+      cachedCodexPath = out.trim() || null;
+      resolve2(cachedCodexPath !== null);
+    });
+    proc.on("error", () => {
+      cachedCodexPath = null;
+      resolve2(false);
+    });
+  });
+}
+
+// src/server/quota/adapters/claude.ts
+var import_node_fs9 = require("node:fs");
+var import_node_path9 = require("node:path");
+var import_node_os9 = require("node:os");
+var import_node_child_process3 = require("node:child_process");
+var claudeAdapter = {
+  provider: "claude",
+  displayName: "Claude Code",
+  async isConfigured() {
+    const token = readClaudeToken();
+    return !!token;
+  },
+  async fetch() {
+    const token = readClaudeToken();
+    if (!token) {
+      throw new QuotaError({ state: "not_configured", message: "no Claude Code OAuth credential found" });
+    }
+    let data;
+    try {
+      data = await fetchJsonWithTimeout("https://api.anthropic.com/api/oauth/usage", {
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "anthropic-beta": "oauth-2025-04-20",
+          "Content-Type": "application/json"
+        }
+      });
+    } catch (err) {
+      throw classifyFetchError(err);
+    }
+    const windows = [];
+    if (data.five_hour) {
+      windows.push(windowFromPercent("five_hour", "5-Hour Window", data.five_hour.utilization ?? 0, {
+        durationMins: 300,
+        resetsAt: normalizeIso(data.five_hour.resets_at)
+      }));
+    }
+    if (data.seven_day) {
+      windows.push(windowFromPercent("seven_day", "Weekly", data.seven_day.utilization ?? 0, {
+        durationMins: 10080,
+        resetsAt: normalizeIso(data.seven_day.resets_at)
+      }));
+    }
+    if (data.seven_day_opus?.utilization !== void 0 && data.seven_day_opus?.utilization !== null) {
+      windows.push(windowFromPercent("seven_day_opus", "Weekly \xB7 Opus", data.seven_day_opus.utilization, {
+        durationMins: 10080,
+        resetsAt: normalizeIso(data.seven_day_opus.resets_at)
+      }));
+    }
+    const snap = baseSnapshot("claude", "Claude Code", { windows });
+    return { ...snap, status: { state: "ok" } };
+  }
+};
+function classifyFetchError(err) {
+  if (err instanceof HttpError) {
+    const c = classifyHttpError(err);
+    return new QuotaError(c);
+  }
+  const msg = err instanceof Error ? err.message : String(err);
+  return new QuotaError({ state: "upstream_unavailable", message: msg.slice(0, 200) });
+}
+function normalizeIso(s) {
+  return s ? new Date(s).toISOString() : void 0;
+}
+function readClaudeToken() {
+  if (process.platform === "darwin") {
+    const token = readFromKeychain();
+    if (token) return token;
+  }
+  const configDir = process.env.CLAUDE_CONFIG_DIR || (0, import_node_path9.join)((0, import_node_os9.homedir)(), ".claude");
+  const credPath = (0, import_node_path9.join)(configDir, ".credentials.json");
+  if ((0, import_node_fs9.existsSync)(credPath)) {
+    try {
+      const parsed = JSON.parse((0, import_node_fs9.readFileSync)(credPath, "utf8"));
+      return parsed?.claudeAiOauth?.accessToken ?? null;
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function readFromKeychain() {
+  const candidates = ["Claude Code-credentials"];
+  try {
+    const list = (0, import_node_child_process3.execFileSync)("security", ["dump-keychain"], { stdio: ["ignore", "pipe", "ignore"], encoding: "utf8" });
+    for (const m of list.matchAll(/"srvname"<blob>="([^"]*Claude Code-credentials[^"]*)"/g)) {
+      if (m[1] && !candidates.includes(m[1])) candidates.push(m[1]);
+    }
+  } catch {
+  }
+  for (const name of candidates) {
+    try {
+      const raw = (0, import_node_child_process3.execFileSync)("security", ["find-generic-password", "-s", name, "-w"], {
+        stdio: ["ignore", "pipe", "ignore"],
+        encoding: "utf8"
+      }).trim();
+      if (!raw) continue;
+      try {
+        const parsed = JSON.parse(raw);
+        return parsed?.claudeAiOauth?.accessToken ?? null;
+      } catch {
+        return raw;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+
+// src/server/quota/adapters/glm.ts
+var import_node_fs11 = require("node:fs");
+var import_node_path11 = require("node:path");
+var import_node_os11 = require("node:os");
+
+// src/server/quota/credentialsFile.ts
+var import_node_fs10 = require("node:fs");
+var import_node_path10 = require("node:path");
+var import_node_os10 = require("node:os");
+function readStoredCredential(provider) {
+  try {
+    const path = (0, import_node_path10.join)((0, import_node_os10.homedir)(), ".tokendash", "credentials.json");
+    if (!(0, import_node_fs10.existsSync)(path)) return null;
+    const all = JSON.parse((0, import_node_fs10.readFileSync)(path, "utf8"));
+    const entry = all?.[provider];
+    if (entry && typeof entry === "object" && typeof entry.apiKey === "string") {
+      const apiKey = entry.apiKey;
+      if (!apiKey) return null;
+      const baseUrl = entry.baseUrl;
+      return { apiKey, baseUrl: typeof baseUrl === "string" ? baseUrl : void 0 };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+// src/server/quota/adapters/glm.ts
+var glmAdapter = {
+  provider: "glm",
+  displayName: "GLM Coding Plan",
+  async isConfigured() {
+    return !!resolveCredential();
+  },
+  async fetch() {
+    const cred = resolveCredential();
+    if (!cred) {
+      throw new QuotaError({ state: "not_configured", message: "set ZAI_API_KEY or ZHIPU_API_KEY" });
+    }
+    let data;
+    try {
+      data = await fetchJsonWithTimeout(`${cred.base}/api/monitor/usage/quota/limit`, {
+        headers: {
+          // GLM wants the raw key, NOT "Bearer <key>".
+          Authorization: cred.key,
+          "Accept-Language": "en-US,en",
+          "Content-Type": "application/json"
+        }
+      });
+    } catch (err) {
+      throw classifyFetchError2(err);
+    }
+    if (!data?.success && data?.code !== 200) {
+      throw new QuotaError({ state: "upstream_unavailable", message: data?.msg || "GLM quota request failed" });
+    }
+    const limits = data.data?.limits ?? [];
+    const windows = [];
+    const tokenLimits = limits.filter((l) => l.type === "TOKENS_LIMIT" && typeof l.percentage === "number").sort((a, b) => (a.nextResetTime ?? 0) - (b.nextResetTime ?? 0));
+    tokenLimits.forEach((l, i) => {
+      const isShort = i === 0;
+      windows.push(windowFromPercent(
+        isShort ? "glm_5h" : "glm_weekly",
+        isShort ? "5-Hour Window" : "Weekly",
+        l.percentage ?? 0,
+        { durationMins: isShort ? 300 : 10080, resetsAt: unixToIso(l.nextResetTime) }
+      ));
+    });
+    const timeLimit = limits.find((l) => l.type === "TIME_LIMIT");
+    if (timeLimit && typeof timeLimit.usage === "number") {
+      windows.push(windowFromCounts(
+        "glm_mcp_monthly",
+        "MCP \xB7 Monthly",
+        timeLimit.currentValue ?? 0,
+        timeLimit.usage
+      ));
+    }
+    const snap = baseSnapshot("glm", "GLM Coding Plan", {
+      planName: data.data?.level ? capitalize2(data.data.level) : void 0,
+      windows
+    });
+    return { ...snap, status: { state: "ok" } };
+  }
+};
+function classifyFetchError2(err) {
+  if (err instanceof HttpError) {
+    const c = classifyHttpError(err);
+    return new QuotaError(c);
+  }
+  const msg = err instanceof Error ? err.message : String(err);
+  return new QuotaError({ state: "upstream_unavailable", message: msg.slice(0, 200) });
+}
+function resolveCredential() {
+  const stored = readStoredCredential("glm");
+  if (stored) return { key: stored.apiKey, base: stored.baseUrl || "https://open.bigmodel.cn" };
+  const zai = envOrConfig("ZAI_API_KEY");
+  if (zai) return { key: zai, base: envOrConfig("ZAI_BASE_URL") || "https://api.z.ai" };
+  const zhipu = envOrConfig("ZHIPU_API_KEY");
+  if (zhipu) return { key: zhipu, base: envOrConfig("ZHIPU_BASE_URL") || "https://open.bigmodel.cn" };
+  const anthropicBase = envOrConfig("ANTHROPIC_BASE_URL");
+  if (anthropicBase && isGlmHost(anthropicBase)) {
+    const origin = originOf(anthropicBase);
+    const token = envOrConfig("ANTHROPIC_AUTH_TOKEN") || envOrConfig("ANTHROPIC_API_KEY");
+    if (origin && token) return { key: token, base: origin };
+  }
+  return null;
+}
+function isGlmHost(url) {
+  const h = url.toLowerCase();
+  return h.includes("bigmodel.cn") || h.includes("z.ai");
+}
+function originOf(url) {
+  try {
+    const u = new URL(url);
+    return `${u.protocol}//${u.host}`;
+  } catch {
+    return null;
+  }
+}
+var claudeSettingsEnv;
+function envOrConfig(key) {
+  if (process.env[key]) return process.env[key];
+  if (claudeSettingsEnv === void 0) claudeSettingsEnv = loadClaudeSettingsEnv();
+  return claudeSettingsEnv?.[key];
+}
+function loadClaudeSettingsEnv() {
+  const configDir = process.env.CLAUDE_CONFIG_DIR || (0, import_node_path11.join)((0, import_node_os11.homedir)(), ".claude");
+  try {
+    const path = (0, import_node_path11.join)(configDir, "settings.json");
+    if (!(0, import_node_fs11.existsSync)(path)) return null;
+    const parsed = JSON.parse((0, import_node_fs11.readFileSync)(path, "utf8"));
+    return parsed?.env && typeof parsed.env === "object" ? parsed.env : null;
+  } catch {
+    return null;
+  }
+}
+function capitalize2(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+
+// src/server/quota/adapters/minimax.ts
+var minimaxAdapter = {
+  provider: "minimax",
+  displayName: "MiniMax Coding Plan",
+  async isConfigured() {
+    return !!resolveCredential2();
+  },
+  async fetch() {
+    const cred = resolveCredential2();
+    if (!cred) {
+      throw new QuotaError({ state: "not_configured", message: "set MINIMAX_API_KEY (Subscription Key)" });
+    }
+    let data;
+    try {
+      data = await fetchJsonWithTimeout(`${cred.base}/v1/token_plan/remains`, {
+        headers: {
+          Authorization: `Bearer ${cred.key}`,
+          "Content-Type": "application/json"
+        }
+      });
+    } catch (err) {
+      throw classifyFetchError3(err);
+    }
+    if (data.base_resp?.status_code && data.base_resp.status_code !== 0) {
+      throw new QuotaError({
+        state: "upstream_unavailable",
+        message: data.base_resp.status_msg || `MiniMax error ${data.base_resp.status_code}`
+      });
+    }
+    const windows = [];
+    for (const m of data.model_remains ?? []) {
+      const model = m.model_name ?? "MiniMax";
+      const intervalTotal = m.current_interval_total_count ?? 0;
+      const intervalRemaining = m.current_interval_usage_count ?? 0;
+      if (intervalTotal > 0) {
+        windows.push(windowFromCounts(
+          `minimax_5h_${model}`,
+          `5-Hour \xB7 ${model}`,
+          Math.max(0, intervalTotal - intervalRemaining),
+          intervalTotal,
+          { durationMins: 300, resetsAt: unixToIso(m.end_time) }
+        ));
+      }
+      const weeklyTotal = m.current_weekly_total_count ?? 0;
+      const weeklyRemaining = m.current_weekly_usage_count ?? 0;
+      if (weeklyTotal > 0) {
+        windows.push(windowFromCounts(
+          `minimax_weekly_${model}`,
+          `Weekly \xB7 ${model}`,
+          Math.max(0, weeklyTotal - weeklyRemaining),
+          weeklyTotal,
+          { durationMins: 10080 }
+        ));
+      }
+    }
+    const snap = baseSnapshot("minimax", "MiniMax Coding Plan", { windows });
+    return { ...snap, status: { state: "ok" } };
+  }
+};
+function classifyFetchError3(err) {
+  if (err instanceof HttpError) {
+    const c = classifyHttpError(err);
+    return new QuotaError(c);
+  }
+  const msg = err instanceof Error ? err.message : String(err);
+  return new QuotaError({ state: "upstream_unavailable", message: msg.slice(0, 200) });
+}
+function resolveCredential2() {
+  const stored = readStoredCredential("minimax");
+  if (stored) {
+    const region2 = (process.env.MINIMAX_REGION || "").toLowerCase();
+    const base2 = stored.baseUrl || (region2 === "cn" ? "https://www.minimaxi.com" : "https://www.minimax.io");
+    return { key: stored.apiKey, base: base2 };
+  }
+  const key = process.env.MINIMAX_API_KEY || process.env.MINIMAX_SUBSCRIPTION_KEY;
+  if (!key) return null;
+  const region = (process.env.MINIMAX_REGION || "").toLowerCase();
+  const base = region === "cn" ? process.env.MINIMAX_BASE_URL || "https://www.minimaxi.com" : process.env.MINIMAX_BASE_URL || "https://www.minimax.io";
+  return { key, base };
+}
+
+// src/server/quota/adapters/kimi.ts
+var import_node_fs12 = require("node:fs");
+var import_node_path12 = require("node:path");
+var import_node_os12 = require("node:os");
+var KIMI_CLIENT_ID = "17e5f671-d194-4dfb-9706-5516cb48c098";
+var KIMI_BASE = "https://api.kimi.com/coding/v1";
+var KIMI_AUTH = "https://auth.kimi.com/api/oauth/token";
+var kimiAdapter = {
+  provider: "kimi",
+  displayName: "Kimi Code",
+  async isConfigured() {
+    const cred = readCredentials();
+    return !!cred && !!cred.access_token;
+  },
+  async fetch() {
+    const credPath = credentialsPath();
+    let cred = readCredentials();
+    if (!cred || !cred.access_token) {
+      throw new QuotaError({ state: "not_configured", message: "run `kimi` to log in first" });
+    }
+    const nowSec = Math.floor(Date.now() / 1e3);
+    if (cred.expires_at && cred.expires_at - nowSec < 300 && cred.refresh_token) {
+      cred = await refreshToken(credPath, cred.refresh_token).catch(() => cred);
+    }
+    let data;
+    try {
+      data = await fetchJsonWithTimeout(`${KIMI_BASE}/usages`, {
+        headers: {
+          Authorization: `Bearer ${cred.access_token}`,
+          Accept: "application/json"
+        }
+      });
+    } catch (err) {
+      throw classifyFetchError4(err);
+    }
+    const windows = [];
+    if (data.usage) {
+      const { used, limit } = toCounts(data.usage);
+      if (limit > 0) {
+        windows.push(windowFromCounts("kimi_weekly", "Weekly", used, limit, {
+          durationMins: 10080,
+          resetsAt: normalizeIso2(data.usage.resetTime)
+        }));
+      }
+    }
+    for (let i = 0; i < (data.limits?.length ?? 0); i++) {
+      const entry = data.limits[i];
+      const detail = entry?.detail;
+      if (!detail) continue;
+      const { used, limit } = toCounts(detail);
+      if (limit <= 0) continue;
+      const mins = minutesForWindow(entry?.window);
+      windows.push(windowFromCounts(`kimi_limit_${i}`, mins ? `${durationLabel2(mins)} Window` : `Window ${i + 1}`, used, limit, {
+        durationMins: mins,
+        resetsAt: normalizeIso2(detail.resetTime)
+      }));
+    }
+    const snap = baseSnapshot("kimi", "Kimi Code", {
+      planName: data.user?.membership?.level ? prettifyLevel(data.user.membership.level) : void 0,
+      windows
+    });
+    return { ...snap, status: { state: "ok" } };
+  }
+};
+function classifyFetchError4(err) {
+  if (err instanceof HttpError) {
+    const c = classifyHttpError(err);
+    return new QuotaError(c);
+  }
+  const msg = err instanceof Error ? err.message : String(err);
+  return new QuotaError({ state: "upstream_unavailable", message: msg.slice(0, 200) });
+}
+function toCounts(detail) {
+  const limit = toNumber(detail.limit);
+  const remaining = toNumber(detail.remaining);
+  if (limit <= 0) return { used: 0, limit: 0 };
+  return { used: Math.max(0, limit - remaining), limit };
+}
+function toNumber(v) {
+  if (v === void 0 || v === null) return 0;
+  const n = typeof v === "string" ? parseFloat(v) : v;
+  return Number.isFinite(n) ? n : 0;
+}
+function minutesForWindow(window) {
+  if (!window?.duration) return void 0;
+  const unit = (window.timeUnit || "").toUpperCase();
+  if (unit.includes("HOUR")) return window.duration * 60;
+  if (unit.includes("DAY")) return window.duration * 1440;
+  return window.duration;
+}
+function durationLabel2(mins) {
+  if (mins >= 10080) return "Weekly";
+  if (mins >= 1440) return `${Math.round(mins / 1440)}-Day`;
+  if (mins >= 60) return `${Math.round(mins / 60)}-Hour`;
+  return `${mins}m`;
+}
+function normalizeIso2(s) {
+  return s ? new Date(s).toISOString() : void 0;
+}
+function prettifyLevel(level) {
+  return level.replace(/^LEVEL_/, "").toLowerCase().replace(/(^|_)(\w)/g, (_, __, c) => " " + c.toUpperCase()).trim();
+}
+function kimiDataDir() {
+  return process.env.KIMI_DATA_DIR || (0, import_node_path12.join)((0, import_node_os12.homedir)(), ".kimi");
+}
+function credentialsPath() {
+  return (0, import_node_path12.join)(kimiDataDir(), "credentials", "kimi-code.json");
+}
+function readCredentials() {
+  const stored = readStoredCredential("kimi");
+  if (stored?.apiKey) {
+    return { access_token: stored.apiKey, token_type: "Bearer" };
+  }
+  const path = credentialsPath();
+  if (!(0, import_node_fs12.existsSync)(path)) return null;
+  try {
+    return JSON.parse((0, import_node_fs12.readFileSync)(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+async function refreshToken(credPath, refreshToken2) {
+  const body = new URLSearchParams({
+    client_id: KIMI_CLIENT_ID,
+    grant_type: "refresh_token",
+    refresh_token: refreshToken2
+  });
+  const res = await fetch(KIMI_AUTH, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body
+  });
+  if (!res.ok) throw new Error(`token refresh failed: HTTP ${res.status}`);
+  const tokens = await res.json();
+  const updated = {
+    access_token: tokens.access_token,
+    refresh_token: tokens.refresh_token || refreshToken2,
+    expires_at: Math.floor(Date.now() / 1e3) + (tokens.expires_in ?? 3600),
+    token_type: tokens.token_type || "Bearer"
+  };
+  try {
+    (0, import_node_fs12.writeFileSync)(credPath, JSON.stringify(updated, null, 2), "utf8");
+  } catch {
+  }
+  return updated;
+}
+
+// src/server/quota/index.ts
+var registry = new QuotaAdapterRegistry();
+registry.register(claudeAdapter);
+registry.register(codexAdapter);
+registry.register(glmAdapter);
+registry.register(minimaxAdapter);
+registry.register(kimiAdapter);
+var quotaCache = new QuotaCache();
+var quotaService = new QuotaService(registry, quotaCache);
+
+// src/server/routes/api.ts
+async function getQuota(_req, res) {
+  const force = _req.query.refresh === "1" || _req.query.refresh === "true";
+  try {
+    const data = force ? await quotaService.refreshAll() : await quotaService.fetchAll();
+    res.json(data);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    res.status(500).json({ error: "Failed to fetch quota", hint: message });
+  }
+}
+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 getAppInfo(info) {
+  return (req, res) => {
+    const host = req.get("host");
+    res.json({
+      ...info,
+      dashboardUrl: host ? `${req.protocol}://${host}` : info.dashboardUrl
+    });
+  };
+}
+function registerApiRoutes(router, appInfo) {
+  router.get("/app-info", getAppInfo(appInfo));
+  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);
+  router.get("/quota", getQuota);
+}
+
+// src/server/index.ts
+var CLI_USAGE = [
+  "Usage:",
+  "  tokendash",
+  "  tokendash --version",
+  "  tokendash --port <number> [--no-open]",
+  "  tokendash --tray [--port <number>]"
+].join("\n");
+var PACKAGE_NAME = "@zhangferry-dev/tokendash";
+function getPackageVersion() {
+  const __filename = (0, import_node_url.fileURLToPath)(__esbuild_import_meta_url);
+  const __dirname = (0, import_node_path13.dirname)(__filename);
+  const packageJsonPaths = [
+    (0, import_node_path13.join)(__dirname, "..", "..", "package.json"),
+    // dist/server/index.js
+    (0, import_node_path13.join)(__dirname, "..", "package.json")
+    // bundled server entrypoint
+  ];
+  for (const packageJsonPath of packageJsonPaths) {
+    if (!(0, import_node_fs13.existsSync)(packageJsonPath)) continue;
+    const packageJson = JSON.parse((0, import_node_fs13.readFileSync)(packageJsonPath, "utf8"));
+    if (packageJson.version) return packageJson.version;
+  }
+  return "unknown";
+}
+function resolvePort(value) {
+  return Number.isInteger(value) && value && value > 0 ? value : 3456;
+}
+function resolveStaticAssetBaseDir(moduleUrl = __esbuild_import_meta_url, baseDir) {
+  if (baseDir) return { baseDir: (0, import_node_path13.resolve)(baseDir), isProduction: true };
+  const moduleDir = (0, import_node_path13.dirname)((0, import_node_url.fileURLToPath)(moduleUrl));
+  const isProduction = moduleUrl.includes("/dist/");
+  if (!isProduction) return { baseDir: (0, import_node_path13.resolve)(moduleDir), isProduction: false };
+  if ((0, import_node_path13.basename)(moduleDir) === "server") {
+    return { baseDir: (0, import_node_path13.resolve)((0, import_node_path13.dirname)(moduleDir)), isProduction: true };
+  }
+  return { baseDir: (0, import_node_path13.resolve)(moduleDir), isProduction: true };
+}
+function createApp(_port, baseDir) {
+  const app = (0, import_express.default)();
+  const router = import_express.default.Router();
+  registerApiRoutes(router, {
+    packageName: PACKAGE_NAME,
+    version: getPackageVersion(),
+    dashboardUrl: `http://localhost:${resolvePort(_port)}`
+  });
+  app.use("/api", router);
+  const { baseDir: _baseDir, isProduction } = resolveStaticAssetBaseDir(__esbuild_import_meta_url, baseDir);
+  const popoverPath = isProduction ? (0, import_node_path13.join)(_baseDir, "client", "popover.html") : (0, import_node_path13.join)(_baseDir, "..", "..", "public", "popover.html");
+  app.get("/popover.html", (_req, res, next) => {
+    if (!(0, import_node_fs13.existsSync)(popoverPath)) {
+      next();
+      return;
+    }
+    res.type("html").send((0, import_node_fs13.readFileSync)(popoverPath, "utf8"));
+  });
+  if (isProduction) {
+    const clientPath = (0, import_node_path13.join)(_baseDir, "client");
+    const clientIndexPath = (0, import_node_path13.join)(clientPath, "index.html");
+    app.use(import_express.default.static(clientPath));
+    app.use("{*path}", (_req, res) => {
+      res.sendFile(clientIndexPath);
+    });
+  }
+  return app;
+}
+
+// src/server/daemon.ts
+var import_node_http = __toESM(require("node:http"), 1);
+var import_node_fs14 = require("node:fs");
+var import_node_path14 = require("node:path");
+var import_node_os13 = require("node:os");
+var DATA_DIR = (0, import_node_path14.join)((0, import_node_os13.homedir)(), ".tokendash");
+var PID_FILE = (0, import_node_path14.join)(DATA_DIR, "daemon.pid");
+var PORT_FILE = (0, import_node_path14.join)(DATA_DIR, "daemon.port");
+function ensureDataDir() {
+  if (!(0, import_node_fs14.existsSync)(DATA_DIR)) (0, import_node_fs14.mkdirSync)(DATA_DIR, { recursive: true });
+}
+function writePidFile() {
+  ensureDataDir();
+  (0, import_node_fs14.writeFileSync)(PID_FILE, String(process.pid), "utf8");
+}
+function writePortFile(port) {
+  ensureDataDir();
+  (0, import_node_fs14.writeFileSync)(PORT_FILE, String(port), "utf8");
+}
+function cleanupFiles() {
+  try {
+    if ((0, import_node_fs14.existsSync)(PID_FILE)) (0, import_node_fs14.unlinkSync)(PID_FILE);
+  } catch (_) {
+  }
+  try {
+    if ((0, import_node_fs14.existsSync)(PORT_FILE)) (0, import_node_fs14.unlinkSync)(PORT_FILE);
+  } catch (_) {
+  }
+}
+function resolvePort2() {
+  const args = process.argv.slice(2);
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--port" && i + 1 < args.length) {
+      const v = parseInt(args[i + 1], 10);
+      if (Number.isInteger(v) && v > 0) return v;
+    }
+  }
+  const envPort = process.env.TOKENDASH_PORT ? parseInt(process.env.TOKENDASH_PORT, 10) : 0;
+  if (Number.isInteger(envPort) && envPort > 0) return envPort;
+  return 3456;
+}
+function listen(app, port) {
+  return new Promise((resolve2, reject) => {
+    const server = app.listen(port);
+    const onListen = () => {
+      cleanup();
+      resolve2(server);
+    };
+    const onError = (err) => {
+      cleanup();
+      reject(err);
+    };
+    const cleanup = () => {
+      server.off("listening", onListen);
+      server.off("error", onError);
+    };
+    server.once("listening", onListen);
+    server.once("error", onError);
+  });
+}
+async function listenWithFallback(app, preferredPort) {
+  let port = preferredPort;
+  for (let attempt = 0; attempt < 20; attempt++, port++) {
+    try {
+      const server = await listen(app, port);
+      return { server, port };
+    } catch (error) {
+      const err = error;
+      if (err.code !== "EADDRINUSE") throw error;
+    }
+  }
+  throw new Error(`No available port starting from ${preferredPort}`);
+}
+function killStaleDaemon() {
+  if (!(0, import_node_fs14.existsSync)(PID_FILE)) return false;
+  try {
+    const pid = parseInt((0, import_node_fs14.readFileSync)(PID_FILE, "utf8").trim(), 10);
+    if (!Number.isInteger(pid) || pid <= 0) return false;
+    process.kill(pid, 0);
+    process.kill(pid, "SIGTERM");
+    const deadline = Date.now() + 2e3;
+    while (Date.now() < deadline) {
+      try {
+        process.kill(pid, 0);
+      } catch {
+        break;
+      }
+    }
+    return true;
+  } catch {
+    cleanupFiles();
+    return false;
+  }
+}
+async function main() {
+  killStaleDaemon();
+  const preferredPort = resolvePort2();
+  const distDir = (0, import_node_path14.join)(__esbuild_import_meta_url.replace("file://", ""), "..");
+  const app = createApp(preferredPort, distDir);
+  const { server, port } = await listenWithFallback(app, preferredPort);
+  writePidFile();
+  writePortFile(port);
+  try {
+    const agentsRes = await new Promise((resolve2, reject) => {
+      import_node_http.default.get(`http://127.0.0.1:${port}/api/agents`, (res) => {
+        let body = "";
+        res.on("data", (chunk) => {
+          body += chunk;
+        });
+        res.on("end", () => {
+          try {
+            resolve2(JSON.parse(body));
+          } catch (e) {
+            reject(e);
+          }
+        });
+      }).on("error", reject);
+    });
+    const agents = agentsRes?.available ?? ["claude"];
+    await Promise.all(agents.map((agent) => new Promise((resolve2) => {
+      import_node_http.default.get(`http://127.0.0.1:${port}/api/daily?agent=${agent}`, (res) => {
+        res.resume();
+        res.on("end", () => resolve2());
+      }).on("error", () => resolve2());
+    })));
+  } catch (_) {
+  }
+  const shutdown = () => {
+    cleanupFiles();
+    server.close(() => process.exit(0));
+    setTimeout(() => process.exit(0), 5e3);
+  };
+  process.on("SIGTERM", shutdown);
+  process.on("SIGINT", shutdown);
+  process.on("uncaughtException", (err) => {
+    console.error("[tokendash-daemon] uncaught:", err);
+    shutdown();
+  });
+}
+main().catch((err) => {
+  console.error("[tokendash-daemon] fatal:", err);
+  cleanupFiles();
+  process.exit(1);
+});
+//# sourceMappingURL=daemon.cjs.map