@cassius0924/dsh-usage-dashboard 0.3.1 → 0.4.0

package/lib/index.js

@@ -1,3 +1,8 @@
+// src/contract.ts
+var USAGE_WINDOW_DAYS = [7, 30, 90, 365];
+var SESSION_ID_PATTERN = /^[A-Za-z0-9_-]{1,128}$/;
+var isValidSessionId = (id) => SESSION_ID_PATTERN.test(id);
+
 // src/memo.ts
 function memoize(ttlMs, compute) {
   const state = { entry: void 0, inflight: void 0 };
@@ -159,6 +164,17 @@ async function fetchBalance(credentials) {
   };
 }
 var emptyBucket = () => ({ input: 0, output: 0, cache: 0, total: 0, cost: 0, calls: 0 });
+function bump(map, key, input, output, cache, cost) {
+  const bucket = map.get(key) ?? emptyBucket();
+  bucket.input += input;
+  bucket.output += output;
+  bucket.cache += cache;
+  bucket.total += input + output + cache;
+  bucket.cost += cost;
+  bucket.calls += 1;
+  map.set(key, bucket);
+}
+var emptyOverall = () => ({ ...emptyBucket(), reasoning: 0, cacheSavings: 0 });
 var SESSION_TOP_N = 6;
 function titleOf(events, id) {
   let title = "";
@@ -197,7 +213,8 @@ function summarize(dayMap, now) {
   };
 }
 function addUsageEvent(events, onEvent) {
-  if (events === void 0) return;
+  const result = { usageRecords: 0, skippedRecords: 0 };
+  if (events === void 0) return result;
   let provider = "";
   let model = "";
   for (const ev of events) {
@@ -212,15 +229,18 @@ function addUsageEvent(events, onEvent) {
     if (ev?.type !== "assistant/message") continue;
     const usage = ev.data?.usage;
     if (usage === void 0) continue;
-    const input = Number(usage.inputTokens) || 0;
-    const output = Number(usage.outputTokens) || 0;
-    const cache = Number(usage.cacheReadTokens) || 0;
-    const reasoning = Number(usage.reasoningTokens) || 0;
-    if (ev.time === void 0) continue;
+    const values = [usage.inputTokens, usage.outputTokens, usage.cacheReadTokens, usage.reasoningTokens].map((value) => value === void 0 ? 0 : Number(value));
+    if (typeof ev.time !== "number" || !Number.isFinite(ev.time) || values.some((value) => !Number.isFinite(value) || value < 0)) {
+      result.skippedRecords += 1;
+      continue;
+    }
+    const [input = 0, output = 0, cache = 0, reasoning = 0] = values;
     onEvent(ev.time, input, output, cache, reasoning, provider, model);
+    result.usageRecords += 1;
   }
+  return result;
 }
-async function fetchUsage(persistence) {
+async function fetchUsage(persistence, nowMs = Date.now()) {
   if (persistence === void 0) return { ok: false, error: "\u4F1A\u8BDD\u6301\u4E45\u5316\u670D\u52A1\u4E0D\u53EF\u7528" };
   let headers;
   try {
@@ -230,132 +250,189 @@ async function fetchUsage(persistence) {
   }
   const dayMap = /* @__PURE__ */ new Map();
   const hourMap = /* @__PURE__ */ new Map();
-  const overall = { ...emptyBucket(), reasoning: 0, cacheSavings: 0 };
+  const overall = emptyOverall();
   const modelTotals = /* @__PURE__ */ new Map();
   const modelDays = /* @__PURE__ */ new Map();
   const modelHours = /* @__PURE__ */ new Map();
   const sessions = [];
+  const coverage = {
+    scope: "local-dsh-session-logs",
+    listedSessions: 0,
+    scannedSessions: 0,
+    usageRecords: 0,
+    skippedRecords: 0,
+    failedSessions: 0,
+    earliestAt: null,
+    latestAt: null
+  };
   const peakSplit = {
     peak: { total: 0, cost: 0, calls: 0 },
     offPeak: { total: 0, cost: 0, calls: 0 },
     peakEraCost: 0,
     offPeakEraCost: 0
   };
-  const bump = (map, key, input, output, cache, cost) => {
-    const bucket = map.get(key) ?? emptyBucket();
+  const now = new Date(nowMs);
+  const dateBefore = (days) => new Date(now.getFullYear(), now.getMonth(), now.getDate() - days);
+  const windowAggregates = USAGE_WINDOW_DAYS.map((days) => ({
+    days,
+    startKey: dayKeyOf(dateBefore(days - 1)),
+    endKey: dayKeyOf(now),
+    dayMap: /* @__PURE__ */ new Map(),
+    hourMap: /* @__PURE__ */ new Map(),
+    overall: emptyOverall(),
+    modelTotals: /* @__PURE__ */ new Map(),
+    modelDays: /* @__PURE__ */ new Map(),
+    modelHours: /* @__PURE__ */ new Map(),
+    sessions: []
+  }));
+  const bumpOverall = (bucket, input, output, cache, reasoning, cost, cacheSavings) => {
     bucket.input += input;
     bucket.output += output;
     bucket.cache += cache;
+    bucket.reasoning += reasoning;
     bucket.total += input + output + cache;
     bucket.cost += cost;
+    bucket.cacheSavings += cacheSavings;
     bucket.calls += 1;
-    map.set(key, bucket);
   };
-  for (const header of headers) {
-    const sid = header.id ?? header.sessionId;
-    if (sid === void 0 || sid === "") continue;
+  const bumpModel = (totals, days, hours, modelKey, dayKey, hourKey, input, output, cache, cost) => {
+    bump(totals, modelKey, input, output, cache, cost);
+    let dayBuckets = days.get(modelKey);
+    if (dayBuckets === void 0) {
+      dayBuckets = /* @__PURE__ */ new Map();
+      days.set(modelKey, dayBuckets);
+    }
+    bump(dayBuckets, dayKey, input, output, cache, cost);
+    let hourBuckets = hours.get(modelKey);
+    if (hourBuckets === void 0) {
+      hourBuckets = /* @__PURE__ */ new Map();
+      hours.set(modelKey, hourBuckets);
+    }
+    bump(hourBuckets, hourKey, input, output, cache, cost);
+  };
+  const bumpSession = (session, time, total, cost) => {
+    session.total += total;
+    session.cost += cost;
+    session.calls += 1;
+    if (time > session.lastActive) session.lastActive = time;
+  };
+  const sessionIds = headers.map((header) => header.id ?? header.sessionId).filter((sid) => sid !== void 0 && sid !== "");
+  coverage.listedSessions = sessionIds.length;
+  for (const sid of sessionIds) {
     try {
       const { events } = await persistence.readFrom(sid, 0);
+      coverage.scannedSessions += 1;
       const session = { id: sid, title: "", total: 0, cost: 0, calls: 0, lastActive: 0 };
-      addUsageEvent(events, (time, input, output, cache, reasoning, provider, model) => {
+      const windowSessions = windowAggregates.map(() => ({ id: sid, title: "", total: 0, cost: 0, calls: 0, lastActive: 0 }));
+      const scanned = addUsageEvent(events, (time, input, output, cache, reasoning, provider, model) => {
+        if (coverage.earliestAt === null || time < coverage.earliestAt) coverage.earliestAt = time;
+        if (coverage.latestAt === null || time > coverage.latestAt) coverage.latestAt = time;
         const d = new Date(time);
         const dayKey = `${d.getFullYear()}-${pad2(d.getMonth() + 1)}-${pad2(d.getDate())}`;
         const hourKey = String(d.getHours());
         const modelKey = `${provider}/${model}`;
         const cost = costOf(time, model, input, cache, output);
+        const cacheSavings = cacheSavingOf(time, model, cache);
+        const eventTotal = input + output + cache;
         bump(dayMap, dayKey, input, output, cache, cost);
         bump(hourMap, hourKey, input, output, cache, cost);
-        bump(modelTotals, modelKey, input, output, cache, cost);
-        let days = modelDays.get(modelKey);
-        if (days === void 0) {
-          days = /* @__PURE__ */ new Map();
-          modelDays.set(modelKey, days);
-        }
-        bump(days, dayKey, input, output, cache, cost);
-        let hours = modelHours.get(modelKey);
-        if (hours === void 0) {
-          hours = /* @__PURE__ */ new Map();
-          modelHours.set(modelKey, hours);
+        bumpModel(modelTotals, modelDays, modelHours, modelKey, dayKey, hourKey, input, output, cache, cost);
+        bumpOverall(overall, input, output, cache, reasoning, cost, cacheSavings);
+        bumpSession(session, time, eventTotal, cost);
+        for (let i = 0; i < windowAggregates.length; i++) {
+          const aggregate = windowAggregates[i];
+          if (dayKey < aggregate.startKey || dayKey > aggregate.endKey) continue;
+          bump(aggregate.dayMap, dayKey, input, output, cache, cost);
+          bump(aggregate.hourMap, hourKey, input, output, cache, cost);
+          bumpModel(aggregate.modelTotals, aggregate.modelDays, aggregate.modelHours, modelKey, dayKey, hourKey, input, output, cache, cost);
+          bumpOverall(aggregate.overall, input, output, cache, reasoning, cost, cacheSavings);
+          bumpSession(windowSessions[i], time, eventTotal, cost);
         }
-        bump(hours, hourKey, input, output, cache, cost);
-        overall.input += input;
-        overall.output += output;
-        overall.cache += cache;
-        overall.reasoning += reasoning;
-        overall.total += input + output + cache;
-        overall.cost += cost;
-        overall.cacheSavings += cacheSavingOf(time, model, cache);
-        session.total += input + output + cache;
-        session.cost += cost;
-        session.calls += 1;
-        if (time > session.lastActive) session.lastActive = time;
         const window = isPeak(time) ? peakSplit.peak : peakSplit.offPeak;
-        window.total += input + output + cache;
+        window.total += eventTotal;
         window.cost += cost;
         window.calls += 1;
         peakSplit.peakEraCost += costUnderPeakEra(time, model, input, cache, output);
         peakSplit.offPeakEraCost += costUnderPeakEra(time, model, input, cache, output, true);
-        overall.calls += 1;
       });
+      coverage.usageRecords += scanned.usageRecords;
+      coverage.skippedRecords += scanned.skippedRecords;
       if (session.calls > 0) {
-        session.title = titleOf(events, sid);
+        const title = titleOf(events, sid);
+        session.title = title;
         sessions.push(session);
+        for (let i = 0; i < windowAggregates.length; i++) {
+          const windowSession = windowSessions[i];
+          if (windowSession.calls === 0) continue;
+          windowSession.title = title;
+          windowAggregates[i].sessions.push(windowSession);
+        }
       }
     } catch {
+      coverage.failedSessions += 1;
     }
   }
-  const daily = [];
-  for (let i = 29; i >= 0; i--) {
-    const d = new Date(Date.now() - i * 864e5);
-    const key = `${d.getFullYear()}-${pad2(d.getMonth() + 1)}-${pad2(d.getDate())}`;
-    const b = dayMap.get(key) ?? emptyBucket();
-    daily.push({ date: key, input: b.input, output: b.output, cache: b.cache, total: b.total, cost: b.cost, calls: b.calls });
-  }
-  const hourly = [];
-  for (let i = 0; i < 24; i++) {
-    const b = hourMap.get(String(i)) ?? emptyBucket();
-    hourly.push({ hour: i, total: b.total, cost: b.cost, calls: b.calls });
-  }
-  const heatmap = [];
-  for (let i = 83; i >= 0; i--) {
-    const d = new Date(Date.now() - i * 864e5);
-    const key = `${d.getFullYear()}-${pad2(d.getMonth() + 1)}-${pad2(d.getDate())}`;
-    const b = dayMap.get(key) ?? emptyBucket();
-    heatmap.push({ date: key, total: b.total, cost: b.cost, calls: b.calls });
-  }
-  const models = [];
-  for (const [modelKey, bucket] of modelTotals) {
-    const slash = modelKey.indexOf("/");
-    const provider = slash < 0 ? "" : modelKey.slice(0, slash);
-    const model = slash < 0 ? modelKey : modelKey.slice(slash + 1);
-    const days = modelDays.get(modelKey);
-    const hours = modelHours.get(modelKey);
-    const daily2 = [];
-    for (let i = 29; i >= 0; i--) {
-      const d = new Date(Date.now() - i * 864e5);
-      const key = `${d.getFullYear()}-${pad2(d.getMonth() + 1)}-${pad2(d.getDate())}`;
-      const b = days?.get(key) ?? emptyBucket();
-      daily2.push({ total: b.total, cost: b.cost, calls: b.calls });
+  const makeDaily = (map, count) => {
+    const result = [];
+    for (let i = count - 1; i >= 0; i--) {
+      const key = dayKeyOf(dateBefore(i));
+      const b = map.get(key) ?? emptyBucket();
+      result.push({ date: key, input: b.input, output: b.output, cache: b.cache, total: b.total, cost: b.cost, calls: b.calls });
     }
-    const hourly2 = [];
+    return result;
+  };
+  const makeHourly = (map) => {
+    const result = [];
     for (let i = 0; i < 24; i++) {
-      const b = hours?.get(String(i)) ?? emptyBucket();
-      hourly2.push({ total: b.total, cost: b.cost, calls: b.calls });
+      const b = map.get(String(i)) ?? emptyBucket();
+      result.push({ hour: i, total: b.total, cost: b.cost, calls: b.calls });
     }
-    models.push({
-      provider,
-      model,
-      input: bucket.input,
-      output: bucket.output,
-      cache: bucket.cache,
-      total: bucket.total,
-      cost: bucket.cost,
-      calls: bucket.calls,
-      daily: daily2,
-      hourly: hourly2
-    });
+    return result;
+  };
+  const makeModels = (totals, daysByModel, hoursByModel, dayCount) => {
+    const result = [];
+    for (const [modelKey, bucket] of totals) {
+      const slash = modelKey.indexOf("/");
+      const provider = slash < 0 ? "" : modelKey.slice(0, slash);
+      const model = slash < 0 ? modelKey : modelKey.slice(slash + 1);
+      const days = daysByModel.get(modelKey);
+      const hours = hoursByModel.get(modelKey);
+      const daily2 = makeDaily(days ?? /* @__PURE__ */ new Map(), dayCount).map((point) => ({ total: point.total, cost: point.cost, calls: point.calls }));
+      const hourly2 = makeHourly(hours ?? /* @__PURE__ */ new Map()).map((point) => ({ total: point.total, cost: point.cost, calls: point.calls }));
+      result.push({
+        provider,
+        model,
+        input: bucket.input,
+        output: bucket.output,
+        cache: bucket.cache,
+        total: bucket.total,
+        cost: bucket.cost,
+        calls: bucket.calls,
+        daily: daily2,
+        hourly: hourly2
+      });
+    }
+    result.sort((a, b) => b.total - a.total);
+    return result;
+  };
+  const daily = makeDaily(dayMap, 30);
+  const hourly = makeHourly(hourMap);
+  const heatmap = [];
+  for (let i = 363; i >= 0; i--) {
+    const key = dayKeyOf(dateBefore(i));
+    const b = dayMap.get(key) ?? emptyBucket();
+    heatmap.push({ date: key, total: b.total, cost: b.cost, calls: b.calls });
   }
-  models.sort((a, b) => b.total - a.total);
+  const models = makeModels(modelTotals, modelDays, modelHours, 30);
+  const windows = windowAggregates.map((aggregate) => ({
+    days: aggregate.days,
+    daily: makeDaily(aggregate.dayMap, aggregate.days),
+    hourly: makeHourly(aggregate.hourMap),
+    totals: { ...aggregate.overall },
+    models: makeModels(aggregate.modelTotals, aggregate.modelDays, aggregate.modelHours, aggregate.days),
+    sessions: [...aggregate.sessions].sort((a, b) => b.cost - a.cost).slice(0, SESSION_TOP_N),
+    sessionCount: aggregate.sessions.length
+  }));
   return {
     ok: true,
     data: {
@@ -363,11 +440,13 @@ async function fetchUsage(persistence) {
       hourly,
       heatmap,
       models,
-      summary: summarize(dayMap, /* @__PURE__ */ new Date()),
-      pricing: pricingInfo(Date.now()),
+      summary: summarize(dayMap, new Date(nowMs)),
+      pricing: pricingInfo(nowMs),
       peakSplit,
       sessions: [...sessions].sort((a, b) => b.cost - a.cost).slice(0, SESSION_TOP_N),
       sessionCount: sessions.length,
+      coverage,
+      windows,
       totals: {
         input: overall.input,
         output: overall.output,
@@ -381,6 +460,63 @@ async function fetchUsage(persistence) {
     }
   };
 }
+async function fetchSessionUsage(persistence, sessionId) {
+  if (persistence === void 0) return { ok: false, error: "\u4F1A\u8BDD\u6301\u4E45\u5316\u670D\u52A1\u4E0D\u53EF\u7528" };
+  if (typeof sessionId !== "string" || sessionId === "") return { ok: false, error: "\u7F3A\u5C11\u4F1A\u8BDD id" };
+  if (!isValidSessionId(sessionId)) return { ok: false, error: "\u4F1A\u8BDD id \u683C\u5F0F\u4E0D\u5408\u6CD5" };
+  let events;
+  try {
+    const result = await persistence.readFrom(sessionId, 0);
+    events = result.events;
+  } catch (err) {
+    return { ok: false, error: `\u8BFB\u53D6\u4F1A\u8BDD\u65E5\u5FD7\u5931\u8D25\uFF1A${errorMessage(err)}` };
+  }
+  const modelTotals = /* @__PURE__ */ new Map();
+  let total = 0;
+  let cost = 0;
+  let calls = 0;
+  let firstActive = null;
+  let lastActive = null;
+  addUsageEvent(events, (time, input, output, cache, _reasoning, provider, model) => {
+    const modelKey = `${provider}/${model}`;
+    const eventCost = costOf(time, model, input, cache, output);
+    const eventTotal = input + output + cache;
+    bump(modelTotals, modelKey, input, output, cache, eventCost);
+    total += eventTotal;
+    cost += eventCost;
+    calls += 1;
+    if (firstActive === null || time < firstActive) firstActive = time;
+    if (lastActive === null || time > lastActive) lastActive = time;
+  });
+  const models = [...modelTotals.entries()].map(([modelKey, bucket]) => {
+    const slash = modelKey.indexOf("/");
+    const provider = slash < 0 ? "" : modelKey.slice(0, slash);
+    const model = slash < 0 ? modelKey : modelKey.slice(slash + 1);
+    return {
+      provider,
+      model,
+      input: bucket.input,
+      output: bucket.output,
+      cache: bucket.cache,
+      total: bucket.total,
+      cost: bucket.cost,
+      calls: bucket.calls
+    };
+  }).sort((a, b) => b.cost - a.cost);
+  return {
+    ok: true,
+    data: {
+      sessionId,
+      title: titleOf(events, sessionId),
+      total,
+      cost,
+      calls,
+      firstActive,
+      lastActive,
+      models
+    }
+  };
+}
 
 // src/wire.ts
 function writeJson(res, status, body, headers) {
@@ -419,6 +555,15 @@ function apply(ctx) {
         const payload = await (force ? usageMemo.refresh() : usageMemo.get());
         const headers = payload.ok ? { "cache-control": `private, max-age=${Math.round(USAGE_TTL_MS / 1e3)}` } : { "cache-control": "no-store" };
         writeJson(res, 200, payload, headers);
+      } else if (pathname === "/api/dsh-usage-dashboard/session") {
+        const id = url.searchParams.get("id");
+        if (id === null || id.trim() === "" || !isValidSessionId(id)) {
+          const error = id === null || id.trim() === "" ? "\u7F3A\u5C11\u4F1A\u8BDD id" : "\u4F1A\u8BDD id \u683C\u5F0F\u4E0D\u5408\u6CD5";
+          writeJson(res, 400, { ok: false, error }, { "cache-control": "no-store" });
+          return;
+        }
+        const payload = await fetchSessionUsage(ctx.sessionPersistence, id);
+        writeJson(res, 200, payload, { "cache-control": "no-store" });
       } else {
         writeJson(res, 404, { ok: false, error: "not found" });
       }