@chrysb/alphaclaw 0.4.2 → 0.4.4

package/lib/server/db/usage/shared.js

@@ -0,0 +1,139 @@
+const { deriveCostBreakdown } = require("./pricing");
+
+const kDefaultSessionLimit = 50;
+const kMaxSessionLimit = 200;
+const kDefaultDays = 30;
+const kDefaultMaxPoints = 100;
+const kMaxMaxPoints = 1000;
+const kDayMs = 24 * 60 * 60 * 1000;
+const kUtcTimeZone = "UTC";
+const kDayKeyFormatterCache = new Map();
+
+const coerceInt = (value, fallbackValue = 0) => {
+  const parsed = Number.parseInt(String(value ?? ""), 10);
+  return Number.isFinite(parsed) ? parsed : fallbackValue;
+};
+
+const clampInt = (value, minValue, maxValue, fallbackValue) =>
+  Math.min(maxValue, Math.max(minValue, coerceInt(value, fallbackValue)));
+
+const normalizeTimeZone = (value) => {
+  const raw = String(value || "").trim();
+  if (!raw) return kUtcTimeZone;
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: raw });
+    return raw;
+  } catch {
+    return kUtcTimeZone;
+  }
+};
+
+const getDayKeyFormatter = (timeZone) => {
+  if (kDayKeyFormatterCache.has(timeZone)) {
+    return kDayKeyFormatterCache.get(timeZone);
+  }
+  const formatter = new Intl.DateTimeFormat("en-US", {
+    timeZone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+  });
+  kDayKeyFormatterCache.set(timeZone, formatter);
+  return formatter;
+};
+
+const toTimeZoneDayKey = (timestampMs, timeZone) => {
+  const parts = getDayKeyFormatter(timeZone).formatToParts(new Date(timestampMs));
+  const year = parts.find((part) => part.type === "year")?.value || "0000";
+  const month = parts.find((part) => part.type === "month")?.value || "01";
+  const day = parts.find((part) => part.type === "day")?.value || "01";
+  return `${year}-${month}-${day}`;
+};
+
+const toDayKey = (timestampMs) => new Date(timestampMs).toISOString().slice(0, 10);
+
+const getPeriodRange = (days, timeZone = kUtcTimeZone) => {
+  const now = Date.now();
+  const safeDays = clampInt(days, 1, 3650, kDefaultDays);
+  const startMs = now - safeDays * kDayMs;
+  const normalizedTimeZone = normalizeTimeZone(timeZone);
+  const startDay = normalizedTimeZone === kUtcTimeZone
+    ? toDayKey(startMs)
+    : toTimeZoneDayKey(startMs, normalizedTimeZone);
+  return { now, safeDays, startDay, timeZone: normalizedTimeZone };
+};
+
+const getUsageMetricsFromEventRow = (row) => {
+  const inputTokens = coerceInt(row.input_tokens);
+  const outputTokens = coerceInt(row.output_tokens);
+  const cacheReadTokens = coerceInt(row.cache_read_tokens);
+  const cacheWriteTokens = coerceInt(row.cache_write_tokens);
+  const totalTokens =
+    coerceInt(row.total_tokens) ||
+    inputTokens + outputTokens + cacheReadTokens + cacheWriteTokens;
+  const cost = deriveCostBreakdown({
+    inputTokens,
+    outputTokens,
+    cacheReadTokens,
+    cacheWriteTokens,
+    model: row.model,
+  });
+  return {
+    inputTokens,
+    outputTokens,
+    cacheReadTokens,
+    cacheWriteTokens,
+    totalTokens,
+    ...cost,
+  };
+};
+
+const parseAgentAndSourceFromSessionRef = (sessionRef) => {
+  const raw = String(sessionRef || "").trim();
+  if (!raw) {
+    return { agent: "unknown", source: "chat" };
+  }
+  const parts = raw.split(":");
+  const agent =
+    parts[0] === "agent" && String(parts[1] || "").trim()
+      ? String(parts[1] || "").trim()
+      : "unknown";
+  const source = parts.includes("hook")
+    ? "hooks"
+    : parts.includes("cron")
+      ? "cron"
+      : "chat";
+  return { agent, source };
+};
+
+const downsamplePoints = (points, maxPoints) => {
+  if (points.length <= maxPoints) return points;
+  const stride = Math.ceil(points.length / maxPoints);
+  const sampled = [];
+  for (let index = 0; index < points.length; index += stride) {
+    sampled.push(points[index]);
+  }
+  const lastPoint = points[points.length - 1];
+  if (sampled[sampled.length - 1]?.timestamp !== lastPoint.timestamp) {
+    sampled.push(lastPoint);
+  }
+  return sampled;
+};
+
+module.exports = {
+  kDefaultSessionLimit,
+  kMaxSessionLimit,
+  kDefaultDays,
+  kDefaultMaxPoints,
+  kMaxMaxPoints,
+  kDayMs,
+  kUtcTimeZone,
+  coerceInt,
+  clampInt,
+  toTimeZoneDayKey,
+  toDayKey,
+  getPeriodRange,
+  getUsageMetricsFromEventRow,
+  parseAgentAndSourceFromSessionRef,
+  downsamplePoints,
+};

package/lib/server/db/usage/summary.js

@@ -0,0 +1,280 @@
+const {
+  kDefaultDays,
+  kDayMs,
+  kUtcTimeZone,
+  coerceInt,
+  toDayKey,
+  toTimeZoneDayKey,
+  getPeriodRange,
+  getUsageMetricsFromEventRow,
+  parseAgentAndSourceFromSessionRef,
+} = require("./shared");
+
+const getAgentCostDistribution = ({
+  eventsRows = [],
+  startDay = "",
+  timeZone = kUtcTimeZone,
+}) => {
+  const byAgent = new Map();
+  const ensureAgentBucket = (agent) => {
+    if (byAgent.has(agent)) return byAgent.get(agent);
+    const bucket = {
+      agent,
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheReadTokens: 0,
+      cacheWriteTokens: 0,
+      totalTokens: 0,
+      totalCost: 0,
+      turnCount: 0,
+      sourceBreakdown: {
+        chat: {
+          source: "chat",
+          inputTokens: 0,
+          outputTokens: 0,
+          cacheReadTokens: 0,
+          cacheWriteTokens: 0,
+          totalTokens: 0,
+          totalCost: 0,
+          turnCount: 0,
+        },
+        hooks: {
+          source: "hooks",
+          inputTokens: 0,
+          outputTokens: 0,
+          cacheReadTokens: 0,
+          cacheWriteTokens: 0,
+          totalTokens: 0,
+          totalCost: 0,
+          turnCount: 0,
+        },
+        cron: {
+          source: "cron",
+          inputTokens: 0,
+          outputTokens: 0,
+          cacheReadTokens: 0,
+          cacheWriteTokens: 0,
+          totalTokens: 0,
+          totalCost: 0,
+          turnCount: 0,
+        },
+      },
+    };
+    byAgent.set(agent, bucket);
+    return bucket;
+  };
+
+  for (const eventRow of eventsRows) {
+    const timestamp = coerceInt(eventRow.timestamp);
+    const dayKey = timeZone === kUtcTimeZone
+      ? toDayKey(timestamp)
+      : toTimeZoneDayKey(timestamp, timeZone);
+    if (dayKey < startDay) continue;
+
+    const metrics = getUsageMetricsFromEventRow(eventRow);
+    const sessionRef = String(eventRow.session_key || eventRow.session_id || "");
+    const { agent, source } = parseAgentAndSourceFromSessionRef(sessionRef);
+    const agentBucket = ensureAgentBucket(agent);
+    const sourceBucket = agentBucket.sourceBreakdown[source];
+
+    agentBucket.inputTokens += metrics.inputTokens;
+    agentBucket.outputTokens += metrics.outputTokens;
+    agentBucket.cacheReadTokens += metrics.cacheReadTokens;
+    agentBucket.cacheWriteTokens += metrics.cacheWriteTokens;
+    agentBucket.totalTokens += metrics.totalTokens;
+    agentBucket.totalCost += metrics.totalCost;
+    agentBucket.turnCount += 1;
+
+    sourceBucket.inputTokens += metrics.inputTokens;
+    sourceBucket.outputTokens += metrics.outputTokens;
+    sourceBucket.cacheReadTokens += metrics.cacheReadTokens;
+    sourceBucket.cacheWriteTokens += metrics.cacheWriteTokens;
+    sourceBucket.totalTokens += metrics.totalTokens;
+    sourceBucket.totalCost += metrics.totalCost;
+    sourceBucket.turnCount += 1;
+  }
+
+  const agents = Array.from(byAgent.values())
+    .map((bucket) => ({
+      agent: bucket.agent,
+      inputTokens: bucket.inputTokens,
+      outputTokens: bucket.outputTokens,
+      cacheReadTokens: bucket.cacheReadTokens,
+      cacheWriteTokens: bucket.cacheWriteTokens,
+      totalTokens: bucket.totalTokens,
+      totalCost: bucket.totalCost,
+      turnCount: bucket.turnCount,
+      sourceBreakdown: ["chat", "hooks", "cron"].map(
+        (source) => bucket.sourceBreakdown[source],
+      ),
+    }))
+    .sort((a, b) => b.totalCost - a.totalCost);
+
+  return {
+    agents,
+    totals: agents.reduce(
+      (acc, agentBucket) => {
+        acc.totalCost += Number(agentBucket.totalCost || 0);
+        acc.totalTokens += Number(agentBucket.totalTokens || 0);
+        acc.turnCount += Number(agentBucket.turnCount || 0);
+        return acc;
+      },
+      { totalCost: 0, totalTokens: 0, turnCount: 0 },
+    ),
+  };
+};
+
+const getDailySummary = ({ database, days = kDefaultDays, timeZone = kUtcTimeZone } = {}) => {
+  const { now, safeDays, startDay, timeZone: normalizedTimeZone } = getPeriodRange(
+    days,
+    timeZone,
+  );
+  const lookbackMs = now - (safeDays + 2) * kDayMs;
+  const eventsRows = database
+    .prepare(`
+      SELECT
+        timestamp,
+        session_id,
+        session_key,
+        provider,
+        model,
+        input_tokens,
+        output_tokens,
+        cache_read_tokens,
+        cache_write_tokens,
+        total_tokens
+      FROM usage_events
+      WHERE timestamp >= $lookbackMs
+      ORDER BY timestamp ASC
+    `)
+    .all({ $lookbackMs: lookbackMs });
+  const byDateModel = new Map();
+  for (const eventRow of eventsRows) {
+    const timestamp = coerceInt(eventRow.timestamp);
+    const dayKey = normalizedTimeZone === kUtcTimeZone
+      ? toDayKey(timestamp)
+      : toTimeZoneDayKey(timestamp, normalizedTimeZone);
+    if (dayKey < startDay) continue;
+    const model = String(eventRow.model || "unknown");
+    const mapKey = `${dayKey}\u0000${model}`;
+    if (!byDateModel.has(mapKey)) {
+      byDateModel.set(mapKey, {
+        date: dayKey,
+        model,
+        provider: String(eventRow.provider || "unknown"),
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadTokens: 0,
+        cacheWriteTokens: 0,
+        totalTokens: 0,
+        turnCount: 0,
+        totalCost: 0,
+        inputCost: 0,
+        outputCost: 0,
+        cacheReadCost: 0,
+        cacheWriteCost: 0,
+        pricingFound: false,
+      });
+    }
+    const aggregate = byDateModel.get(mapKey);
+    const metrics = getUsageMetricsFromEventRow(eventRow);
+    aggregate.inputTokens += metrics.inputTokens;
+    aggregate.outputTokens += metrics.outputTokens;
+    aggregate.cacheReadTokens += metrics.cacheReadTokens;
+    aggregate.cacheWriteTokens += metrics.cacheWriteTokens;
+    aggregate.totalTokens += metrics.totalTokens;
+    aggregate.turnCount += 1;
+    aggregate.totalCost += metrics.totalCost;
+    aggregate.inputCost += metrics.inputCost;
+    aggregate.outputCost += metrics.outputCost;
+    aggregate.cacheReadCost += metrics.cacheReadCost;
+    aggregate.cacheWriteCost += metrics.cacheWriteCost;
+    aggregate.pricingFound = aggregate.pricingFound || metrics.pricingFound;
+    if (!aggregate.provider && eventRow.provider) {
+      aggregate.provider = String(eventRow.provider || "unknown");
+    }
+  }
+  const enriched = Array.from(byDateModel.values()).sort((a, b) => {
+    if (a.date === b.date) return b.totalTokens - a.totalTokens;
+    return a.date.localeCompare(b.date);
+  });
+  const costByAgent = getAgentCostDistribution({
+    eventsRows,
+    startDay,
+    timeZone: normalizedTimeZone,
+  });
+  const byDate = new Map();
+  for (const row of enriched) {
+    if (!byDate.has(row.date)) byDate.set(row.date, []);
+    byDate.get(row.date).push({
+      model: row.model,
+      provider: row.provider,
+      inputTokens: row.inputTokens,
+      outputTokens: row.outputTokens,
+      cacheReadTokens: row.cacheReadTokens,
+      cacheWriteTokens: row.cacheWriteTokens,
+      totalTokens: row.totalTokens,
+      turnCount: row.turnCount,
+      totalCost: row.totalCost,
+      inputCost: row.inputCost,
+      outputCost: row.outputCost,
+      cacheReadCost: row.cacheReadCost,
+      cacheWriteCost: row.cacheWriteCost,
+      pricingFound: row.pricingFound,
+    });
+  }
+  const daily = [];
+  const totals = {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0,
+    totalTokens: 0,
+    totalCost: 0,
+    turnCount: 0,
+    modelCount: 0,
+  };
+  for (const [date, modelRows] of byDate.entries()) {
+    const aggregate = modelRows.reduce(
+      (acc, row) => ({
+        inputTokens: acc.inputTokens + row.inputTokens,
+        outputTokens: acc.outputTokens + row.outputTokens,
+        cacheReadTokens: acc.cacheReadTokens + row.cacheReadTokens,
+        cacheWriteTokens: acc.cacheWriteTokens + row.cacheWriteTokens,
+        totalTokens: acc.totalTokens + row.totalTokens,
+        totalCost: acc.totalCost + row.totalCost,
+        turnCount: acc.turnCount + row.turnCount,
+      }),
+      {
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadTokens: 0,
+        cacheWriteTokens: 0,
+        totalTokens: 0,
+        totalCost: 0,
+        turnCount: 0,
+      },
+    );
+    daily.push({ date, ...aggregate, models: modelRows });
+    totals.inputTokens += aggregate.inputTokens;
+    totals.outputTokens += aggregate.outputTokens;
+    totals.cacheReadTokens += aggregate.cacheReadTokens;
+    totals.cacheWriteTokens += aggregate.cacheWriteTokens;
+    totals.totalTokens += aggregate.totalTokens;
+    totals.totalCost += aggregate.totalCost;
+    totals.turnCount += aggregate.turnCount;
+    totals.modelCount += modelRows.length;
+  }
+  return {
+    updatedAt: Date.now(),
+    days: safeDays,
+    timeZone: normalizedTimeZone,
+    daily,
+    totals,
+    costByAgent,
+  };
+};
+
+module.exports = {
+  getDailySummary,
+};

package/lib/server/db/usage/timeseries.js

@@ -0,0 +1,64 @@
+const {
+  kDefaultMaxPoints,
+  kMaxMaxPoints,
+  coerceInt,
+  clampInt,
+  getUsageMetricsFromEventRow,
+  downsamplePoints,
+} = require("./shared");
+
+const getSessionTimeSeries = ({
+  database,
+  sessionId,
+  maxPoints = kDefaultMaxPoints,
+}) => {
+  const safeSessionRef = String(sessionId || "").trim();
+  if (!safeSessionRef) return { sessionId: safeSessionRef, points: [] };
+  const rows = database
+    .prepare(`
+      SELECT
+        timestamp,
+        session_key,
+        session_id,
+        model,
+        input_tokens,
+        output_tokens,
+        cache_read_tokens,
+        cache_write_tokens,
+        total_tokens
+      FROM usage_events
+      WHERE COALESCE(NULLIF(session_key, ''), NULLIF(session_id, '')) = $sessionRef
+      ORDER BY timestamp ASC
+    `)
+    .all({ $sessionRef: safeSessionRef });
+  let cumulativeTokens = 0;
+  let cumulativeCost = 0;
+  const points = rows.map((row) => {
+    const metrics = getUsageMetricsFromEventRow(row);
+    cumulativeTokens += metrics.totalTokens;
+    cumulativeCost += metrics.totalCost;
+    return {
+      timestamp: coerceInt(row.timestamp),
+      sessionKey: String(row.session_key || ""),
+      rawSessionId: String(row.session_id || ""),
+      model: String(row.model || ""),
+      inputTokens: metrics.inputTokens,
+      outputTokens: metrics.outputTokens,
+      cacheReadTokens: metrics.cacheReadTokens,
+      cacheWriteTokens: metrics.cacheWriteTokens,
+      totalTokens: metrics.totalTokens,
+      cost: metrics.totalCost,
+      cumulativeTokens,
+      cumulativeCost,
+    };
+  });
+  const safeMaxPoints = clampInt(maxPoints, 10, kMaxMaxPoints, kDefaultMaxPoints);
+  return {
+    sessionId: safeSessionRef,
+    points: downsamplePoints(points, safeMaxPoints),
+  };
+};
+
+module.exports = {
+  getSessionTimeSeries,
+};

package/lib/server/{watchdog-db.js → db/watchdog/index.js}

@@ -1,6 +1,7 @@
 const fs = require("fs");
 const path = require("path");
 const { DatabaseSync } = require("node:sqlite");
+const { createSchema } = require("./schema");
 
 let db = null;
 let pruneTimer = null;
@@ -14,24 +15,6 @@ const ensureDb = () => {
   return db;
 };
 
-const createSchema = (database) => {
-  database.exec(`
-    CREATE TABLE IF NOT EXISTS watchdog_events (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      event_type TEXT NOT NULL,
-      source TEXT NOT NULL,
-      status TEXT NOT NULL,
-      details TEXT,
-      correlation_id TEXT,
-      created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now'))
-    );
-  `);
-  database.exec(`
-    CREATE INDEX IF NOT EXISTS idx_watchdog_events_ts
-    ON watchdog_events(created_at DESC);
-  `);
-};
-
 const initWatchdogDb = ({ rootDir, pruneDays = 30 }) => {
   const dbDir = path.join(rootDir, "db");
   fs.mkdirSync(dbDir, { recursive: true });

package/lib/server/db/watchdog/schema.js

@@ -0,0 +1,21 @@
+const createSchema = (database) => {
+  database.exec(`
+    CREATE TABLE IF NOT EXISTS watchdog_events (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      event_type TEXT NOT NULL,
+      source TEXT NOT NULL,
+      status TEXT NOT NULL,
+      details TEXT,
+      correlation_id TEXT,
+      created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now'))
+    );
+  `);
+  database.exec(`
+    CREATE INDEX IF NOT EXISTS idx_watchdog_events_ts
+    ON watchdog_events(created_at DESC);
+  `);
+};
+
+module.exports = {
+  createSchema,
+};

package/lib/server/{webhooks-db.js → db/webhooks/index.js}

@@ -1,6 +1,7 @@
 const fs = require("fs");
 const path = require("path");
 const { DatabaseSync } = require("node:sqlite");
+const { createSchema } = require("./schema");
 
 let db = null;
 let pruneTimer = null;
@@ -14,28 +15,6 @@ const ensureDb = () => {
   return db;
 };
 
-const createSchema = (database) => {
-  database.exec(`
-    CREATE TABLE IF NOT EXISTS webhook_requests (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      hook_name TEXT NOT NULL,
-      method TEXT,
-      headers TEXT,
-      payload TEXT,
-      payload_truncated INTEGER DEFAULT 0,
-      payload_size INTEGER,
-      source_ip TEXT,
-      gateway_status INTEGER,
-      gateway_body TEXT,
-      created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now'))
-    );
-  `);
-  database.exec(`
-    CREATE INDEX IF NOT EXISTS idx_webhook_requests_hook_ts
-    ON webhook_requests(hook_name, created_at DESC);
-  `);
-};
-
 const initWebhooksDb = ({ rootDir, pruneDays = 30 }) => {
   const dbDir = path.join(rootDir, "db");
   fs.mkdirSync(dbDir, { recursive: true });

package/lib/server/db/webhooks/schema.js

@@ -0,0 +1,25 @@
+const createSchema = (database) => {
+  database.exec(`
+    CREATE TABLE IF NOT EXISTS webhook_requests (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      hook_name TEXT NOT NULL,
+      method TEXT,
+      headers TEXT,
+      payload TEXT,
+      payload_truncated INTEGER DEFAULT 0,
+      payload_size INTEGER,
+      source_ip TEXT,
+      gateway_status INTEGER,
+      gateway_body TEXT,
+      created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now'))
+    );
+  `);
+  database.exec(`
+    CREATE INDEX IF NOT EXISTS idx_webhook_requests_hook_ts
+    ON webhook_requests(hook_name, created_at DESC);
+  `);
+};
+
+module.exports = {
+  createSchema,
+};

package/lib/server/routes/browse/index.js

@@ -156,6 +156,35 @@ const registerBrowseRoutes = ({ app, fs, kRootDir }) => {
     }
   });
 
+  app.get("/api/browse/download", (req, res) => {
+    const resolvedPath = resolveSafePath(
+      req.query.path,
+      kRootResolved,
+      kRootWithSep,
+      kRootDisplayName,
+    );
+    if (!resolvedPath.ok) {
+      return res.status(400).json({ ok: false, error: resolvedPath.error });
+    }
+    try {
+      const stats = fs.statSync(resolvedPath.absolutePath);
+      if (!stats.isFile()) {
+        return res.status(400).json({ ok: false, error: "Path is not a file" });
+      }
+      const fileName = path.basename(resolvedPath.relativePath || resolvedPath.absolutePath);
+      return res.download(resolvedPath.absolutePath, fileName, (error) => {
+        if (!error || res.headersSent) return;
+        return res
+          .status(500)
+          .json({ ok: false, error: error.message || "Could not download file" });
+      });
+    } catch (error) {
+      return res
+        .status(500)
+        .json({ ok: false, error: error.message || "Could not download file" });
+    }
+  });
+
   app.get("/api/browse/git-summary", async (req, res) => {
     try {
       const envRepoSlug = parseGithubRepoSlug(

package/lib/server.js

@@ -30,19 +30,19 @@ const {
   getRequestById,
   getHookSummaries,
   deleteRequestsByHook,
-} = require("./server/webhooks-db");
+} = require("./server/db/webhooks");
 const {
   initWatchdogDb,
   insertWatchdogEvent,
   getRecentEvents,
-} = require("./server/watchdog-db");
+} = require("./server/db/watchdog");
 const {
   initUsageDb,
   getDailySummary,
   getSessionsList,
   getSessionDetail,
   getSessionTimeSeries,
-} = require("./server/usage-db");
+} = require("./server/db/usage");
 const { createWebhookMiddleware } = require("./server/webhook-middleware");
 const {
   readEnvFile,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chrysb/alphaclaw",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "publishConfig": {
     "access": "public"
   },