@zhangferry-dev/tokendash 1.4.2 → 1.6.0

package/dist/electron-server.cjs

@@ -32,7 +32,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   createApp: () => createApp,
-  main: () => main
+  main: () => main,
+  resolveStaticAssetBaseDir: () => resolveStaticAssetBaseDir
 });
 module.exports = __toCommonJS(index_exports);
 var import_express = __toESM(require("express"), 1);
@@ -254,20 +255,24 @@ var TokenUsageSchema = import_zod2.z.object({
 }).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
+  last_token_usage: TokenUsageSchema.optional()
 }).nullable().default(null);
 var TokenCountPayloadSchema = import_zod2.z.object({
   type: import_zod2.z.literal("token_count"),
   info: TokenCountInfoSchema
 });
-function tokenUsageKey(usage) {
-  return [
-    usage.input_tokens,
-    usage.cached_input_tokens,
-    usage.output_tokens,
-    usage.reasoning_output_tokens,
-    usage.total_tokens
-  ].join(":");
+function 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");
@@ -313,7 +318,9 @@ function parseCodexSession(filepath) {
   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;
@@ -347,18 +354,40 @@ function parseCodexSession(filepath) {
         }
         const info = parseResult.data.info;
         if (!info) continue;
-        const totalUsageKey = tokenUsageKey(info.total_token_usage);
+        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;
-        tokenEvents.push({
+        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,
-          inputTokens: last.input_tokens,
-          cachedInputTokens: last.cached_input_tokens,
-          outputTokens: last.output_tokens,
-          reasoningOutputTokens: last.reasoning_output_tokens,
-          totalTokens: last.total_tokens
-        });
+          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);
       }
     }
   }
@@ -408,6 +437,12 @@ function addAcc(a, ev) {
   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;
@@ -415,32 +450,41 @@ function mergeAcc(a, b) {
   a.reasoningOutputTokens += b.reasoningOutputTokens;
   a.totalTokens += b.totalTokens;
 }
-function accToEntry(date, acc, models) {
-  const cost = calculateCost(acc, models);
+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: acc.inputTokens,
-    outputTokens: acc.outputTokens,
+    inputTokens: display.inputTokens,
+    outputTokens: display.outputTokens,
     cacheCreationTokens: 0,
-    cacheReadTokens: acc.cachedInputTokens,
-    totalTokens: acc.totalTokens,
-    totalCost: cost,
-    modelsUsed: [...models],
-    modelBreakdowns: buildModelBreakdowns(acc, models, cost)
+    cacheReadTokens: display.cachedInputTokens,
+    totalTokens: display.totalTokens,
+    totalCost,
+    modelsUsed: modelNames,
+    modelBreakdowns
   };
 }
-function buildModelBreakdowns(acc, models, totalCost) {
-  const modelList = [...models];
-  if (modelList.length === 0) return [];
-  const costPerModel = totalCost / modelList.length;
-  return modelList.map((name) => ({
-    modelName: name,
-    inputTokens: acc.inputTokens,
-    outputTokens: acc.outputTokens,
-    cacheCreationTokens: 0,
-    cacheReadTokens: acc.cachedInputTokens,
-    cost: costPerModel
-  }));
+function 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";
@@ -470,32 +514,32 @@ function groupSessions(sessions, options) {
           break;
       }
       if (!grouped.has(key)) {
-        grouped.set(key, { acc: emptyAcc(), models: /* @__PURE__ */ new Set() });
+        grouped.set(key, { acc: emptyAcc(), models: /* @__PURE__ */ new Map() });
       }
-      const entry = grouped.get(key);
-      addAcc(entry.acc, ev);
-      if (session.model) entry.models.add(session.model);
+      addAccToBucket(grouped.get(key), ev, session.model);
     }
   }
   return grouped;
 }
-function getDailyResponse(options) {
-  const sessions = parseAllSessions();
+function buildDailyResponse(sessions, options) {
   const grouped = groupSessions(sessions, { groupBy: "day", ...options });
   const daily = [];
   const totalsAcc = emptyAcc();
-  for (const [date, { acc, models: models2 }] of grouped) {
-    daily.push(accToEntry(date, acc, models2));
+  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 models = /* @__PURE__ */ new Set();
-  for (const s of sessions) if (s.model) models.add(s.model);
-  const totalCost = calculateCost(totalsAcc, models);
+  const totalCost = buildModelBreakdowns(totalModels).reduce((sum, model) => sum + model.cost, 0);
   return {
     daily,
     totals: {
-      inputTokens: totalsAcc.inputTokens,
+      inputTokens: displayInputTokens(totalsAcc.inputTokens, totalsAcc.cachedInputTokens),
       outputTokens: totalsAcc.outputTokens,
       cacheCreationTokens: 0,
       cacheReadTokens: totalsAcc.cachedInputTokens,
@@ -504,41 +548,37 @@ function getDailyResponse(options) {
     }
   };
 }
-function getProjectsResponse(options) {
-  const sessions = parseAllSessions();
+function buildProjectsResponse(sessions, options) {
   const tz = options?.timezone || "Asia/Shanghai";
-  const projects = {};
+  const projectGroups = /* @__PURE__ */ new Map();
   for (const session of sessions) {
     const projectName = extractProjectName(session.cwd);
-    const dailyMap = /* @__PURE__ */ new Map();
+    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 Set() });
+        dailyMap.set(dayKey, { acc: emptyAcc(), models: /* @__PURE__ */ new Map() });
       }
-      addAcc(dailyMap.get(dayKey).acc, ev);
-      if (session.model) dailyMap.get(dayKey).models.add(session.model);
-    }
-    if (!projects[projectName]) projects[projectName] = [];
-    for (const [date, { acc, models }] of dailyMap) {
-      projects[projectName].push(accToEntry(date, acc, models));
+      addAccToBucket(dailyMap.get(dayKey), ev, session.model);
     }
   }
-  for (const key of Object.keys(projects)) {
-    projects[key].sort((a, b) => a.date.localeCompare(b.date));
+  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 getBlocksResponse(options) {
-  const sessions = parseAllSessions();
+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 = calculateCost(acc, models);
+    const cost = buildModelBreakdowns(models).reduce((sum, model) => sum + model.cost, 0);
     const [datePart, timePart] = hourKey.split(" ");
     const hour = timePart.split(":")[0];
     blocks.push({
@@ -550,20 +590,29 @@ function getBlocksResponse(options) {
       isGap: false,
       entries: acc.totalTokens > 0 ? 1 : 0,
       tokenCounts: {
-        inputTokens: acc.inputTokens,
+        inputTokens: displayInputTokens(acc.inputTokens, acc.cachedInputTokens),
         outputTokens: acc.outputTokens,
         cacheCreationInputTokens: 0,
         cacheReadInputTokens: acc.cachedInputTokens
       },
       totalTokens: acc.totalTokens,
       costUSD: cost,
-      models: [...models]
+      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");
@@ -1154,18 +1203,18 @@ var import_node_path5 = require("node:path");
 var import_node_os5 = require("node:os");
 var MODEL_PRICING2 = {
   // Claude 4.6
-  "claude-opus-4-6": { inputPer1M: 15, cacheReadPer1M: 1.5, outputPer1M: 75 },
-  "claude-sonnet-4-6": { inputPer1M: 3, cacheReadPer1M: 0.3, outputPer1M: 15 },
+  "claude-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, cacheReadPer1M: 0.3, outputPer1M: 15 },
-  "claude-haiku-4-5-20251001": { inputPer1M: 0.8, cacheReadPer1M: 0.08, outputPer1M: 4 },
+  "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, cacheReadPer1M: 0.3, outputPer1M: 15 },
-  "claude-3-5-haiku-20241022": { inputPer1M: 0.8, cacheReadPer1M: 0.08, outputPer1M: 4 },
-  "claude-3-opus-20240229": { inputPer1M: 15, cacheReadPer1M: 1.5, outputPer1M: 75 },
-  "claude-3-haiku-20240307": { inputPer1M: 0.25, cacheReadPer1M: 0.03, outputPer1M: 1.25 }
+  "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, cacheReadPer1M: 0.3, outputPer1M: 15 };
+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();
@@ -1174,16 +1223,55 @@ function getPricing(model) {
   }
   return DEFAULT_PRICING2;
 }
-function calculateCost2(inputTokens, cacheReadTokens, outputTokens, model) {
+function calculateCost2(inputTokens, cacheReadTokens, outputTokens, model, cacheCreationTokens = 0) {
   const p = getPricing(model);
-  const nonCachedInput = Math.max(inputTokens - cacheReadTokens, 0);
-  return nonCachedInput / 1e6 * p.inputPer1M + cacheReadTokens / 1e6 * p.cacheReadPer1M + outputTokens / 1e6 * p.outputPer1M;
+  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) {
-  const parts = dirName.replace(/^-/, "").split("-");
-  return parts[parts.length - 1] || 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);
@@ -1245,7 +1333,7 @@ function parseAllSessions2(project) {
         const outputTokens = usage.output_tokens || 0;
         const cacheCreationTokens = usage.cache_creation_input_tokens || 0;
         const cacheReadTokens = usage.cache_read_input_tokens || 0;
-        const totalTokens = inputTokens + outputTokens + cacheReadTokens;
+        const totalTokens = totalClaudeTokens(inputTokens, outputTokens, cacheCreationTokens, cacheReadTokens);
         if (totalTokens === 0) continue;
         entries.push({
           timestamp: obj.timestamp,
@@ -1329,8 +1417,8 @@ function getDailyResponse4(project, tz = DEFAULT_TZ) {
     agg.outputTokens += e.outputTokens;
     agg.cacheCreationTokens += e.cacheCreationTokens;
     agg.cacheReadTokens += e.cacheReadTokens;
-    agg.totalTokens += e.inputTokens + e.outputTokens + e.cacheReadTokens;
-    const cost = calculateCost2(e.inputTokens, e.cacheReadTokens, e.outputTokens, e.model);
+    agg.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 });
@@ -1358,7 +1446,7 @@ function getProjectsResponse4(tz = DEFAULT_TZ) {
   const projectMap = /* @__PURE__ */ new Map();
   for (const e of entries) {
     const date = getDateKey4(e.timestamp, tz);
-    const projectName = e.projectDir;
+    const projectName = extractProjectName2(e.projectDir);
     if (!projectMap.has(projectName)) {
       projectMap.set(projectName, /* @__PURE__ */ new Map());
     }
@@ -1380,8 +1468,8 @@ function getProjectsResponse4(tz = DEFAULT_TZ) {
     agg.outputTokens += e.outputTokens;
     agg.cacheCreationTokens += e.cacheCreationTokens;
     agg.cacheReadTokens += e.cacheReadTokens;
-    agg.totalTokens += e.inputTokens + e.outputTokens + e.cacheReadTokens;
-    const cost = calculateCost2(e.inputTokens, e.cacheReadTokens, e.outputTokens, e.model);
+    agg.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 });
@@ -1419,13 +1507,13 @@ function getBlocksResponse4(project, tz = DEFAULT_TZ) {
     bucket.outputTokens += e.outputTokens;
     bucket.cacheCreationTokens += e.cacheCreationTokens;
     bucket.cacheReadTokens += e.cacheReadTokens;
-    bucket.costUSD += calculateCost2(e.inputTokens, e.cacheReadTokens, e.outputTokens, e.model);
+    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 = bucket.inputTokens + bucket.outputTokens + bucket.cacheReadTokens;
+    const totalTokens = totalClaudeTokens(bucket.inputTokens, bucket.outputTokens, bucket.cacheCreationTokens, bucket.cacheReadTokens);
     blocks.push({
       id: `claude-${idx}`,
       startTime: `${hourKey}:00:00`,
@@ -1693,9 +1781,46 @@ function countLines(text) {
   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) {
-  const parts = dirName.replace(/^-/, "").split("-");
-  return parts[parts.length - 1] || 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);
@@ -1880,6 +2005,21 @@ function computeAnalytics(toolCalls, timezone = "Asia/Shanghai") {
     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 };
 }
 
@@ -2048,11 +2188,11 @@ function resolvePort(value) {
   return Number.isInteger(value) && value && value > 0 ? value : 3456;
 }
 function listen(app, port) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const server = app.listen(port);
     const handleListening = () => {
       cleanup();
-      resolve(server);
+      resolve2(server);
     };
     const handleError = (error) => {
       cleanup();
@@ -2081,16 +2221,29 @@ async function listenWithPortFallback(app, preferredPort) {
   }
   throw new Error(`Could not find an available port starting from ${preferredPort}`);
 }
+function resolveStaticAssetBaseDir(moduleUrl = __esbuild_import_meta_url, baseDir) {
+  if (baseDir) return { baseDir: (0, import_node_path8.resolve)(baseDir), isProduction: true };
+  const moduleDir = (0, import_node_path8.dirname)((0, import_node_url.fileURLToPath)(moduleUrl));
+  const isProduction = moduleUrl.includes("/dist/");
+  if (!isProduction) return { baseDir: (0, import_node_path8.resolve)(moduleDir), isProduction: false };
+  if ((0, import_node_path8.basename)(moduleDir) === "server") {
+    return { baseDir: (0, import_node_path8.resolve)((0, import_node_path8.dirname)(moduleDir)), isProduction: true };
+  }
+  return { baseDir: (0, import_node_path8.resolve)(moduleDir), isProduction: true };
+}
 function createApp(_port, baseDir) {
   const app = (0, import_express.default)();
   const router = import_express.default.Router();
   registerApiRoutes(router);
   app.use("/api", router);
-  const _baseDir = baseDir ?? (0, import_node_path8.dirname)((0, import_node_url.fileURLToPath)(__esbuild_import_meta_url));
-  const isProduction = baseDir ? true : __esbuild_import_meta_url.includes("dist/");
+  const { baseDir: _baseDir, isProduction } = resolveStaticAssetBaseDir(__esbuild_import_meta_url, baseDir);
   const popoverPath = isProduction ? (0, import_node_path8.join)(_baseDir, "client", "popover.html") : (0, import_node_path8.join)(_baseDir, "..", "..", "public", "popover.html");
-  app.get("/popover.html", (_req, res) => {
-    res.sendFile(popoverPath);
+  app.get("/popover.html", (_req, res, next) => {
+    if (!(0, import_node_fs8.existsSync)(popoverPath)) {
+      next();
+      return;
+    }
+    res.type("html").send((0, import_node_fs8.readFileSync)(popoverPath, "utf8"));
   });
   if (isProduction) {
     const clientPath = (0, import_node_path8.join)(_baseDir, "client");
@@ -2170,6 +2323,7 @@ async function main() {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   createApp,
-  main
+  main,
+  resolveStaticAssetBaseDir
 });
 //# sourceMappingURL=electron-server.cjs.map