@chrysb/alphaclaw 0.6.0 → 0.6.2-beta.0

package/lib/server/cron-service.js

@@ -0,0 +1,461 @@
+const fs = require("fs");
+const path = require("path");
+const { parseJsonValueFromNoisyOutput } = require("./utils/json");
+const { deriveCostBreakdown } = require("./cost-utils");
+
+const kCronStoreFile = "jobs.json";
+const kCronRunsDir = "runs";
+const kMaxRunsLimit = 200;
+const kDefaultRunsLimit = 20;
+
+const toFiniteNumber = (value, fallback = 0) => {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : fallback;
+};
+
+const sanitizeCronJobId = (jobId = "") => {
+  const trimmed = String(jobId || "").trim();
+  if (!trimmed) throw new Error("Job id is required");
+  if (trimmed.includes("/") || trimmed.includes("\\") || trimmed.includes("\0")) {
+    throw new Error("Invalid job id");
+  }
+  return trimmed;
+};
+
+const normalizeRunStatus = (value = "all") => {
+  const normalized = String(value || "all").trim().toLowerCase();
+  if (["ok", "error", "skipped", "all"].includes(normalized)) return normalized;
+  return "all";
+};
+
+const normalizeDeliveryStatus = (value = "all") => {
+  const normalized = String(value || "all").trim().toLowerCase();
+  if (
+    ["delivered", "not-delivered", "unknown", "not-requested", "all"].includes(
+      normalized,
+    )
+  ) {
+    return normalized;
+  }
+  return "all";
+};
+
+const readJsonFile = (filePath) => {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+};
+
+const normalizeJobs = (storeValue) => {
+  if (!storeValue || typeof storeValue !== "object") return [];
+  if (!Array.isArray(storeValue.jobs)) return [];
+  return storeValue.jobs
+    .filter((job) => job && typeof job === "object")
+    .map((job) => ({
+      ...job,
+      id: String(job.id || "").trim(),
+      name: String(job.name || "").trim(),
+      enabled: job.enabled !== false,
+      state: job.state && typeof job.state === "object" ? job.state : {},
+      payload: job.payload && typeof job.payload === "object" ? job.payload : {},
+      delivery: job.delivery && typeof job.delivery === "object" ? job.delivery : {},
+      schedule: job.schedule && typeof job.schedule === "object" ? job.schedule : {},
+    }))
+    .filter((job) => job.id);
+};
+
+const readCronStore = ({ cronDir }) => {
+  const storePath = path.join(cronDir, kCronStoreFile);
+  const parsed = readJsonFile(storePath);
+  return {
+    storePath,
+    version: 1,
+    jobs: normalizeJobs(parsed),
+  };
+};
+
+const sortJobs = (jobs = [], { sortBy = "nextRunAtMs", sortDir = "asc" } = {}) => {
+  const direction = String(sortDir || "asc").toLowerCase() === "desc" ? -1 : 1;
+  const readSortable = (job) => {
+    if (sortBy === "name") return String(job?.name || "").toLowerCase();
+    if (sortBy === "updatedAtMs") return toFiniteNumber(job?.updatedAtMs, 0);
+    return toFiniteNumber(job?.state?.nextRunAtMs, Number.MAX_SAFE_INTEGER);
+  };
+  return [...jobs].sort((a, b) => {
+    const aValue = readSortable(a);
+    const bValue = readSortable(b);
+    if (aValue === bValue) return 0;
+    return aValue > bValue ? direction : -direction;
+  });
+};
+
+const paginate = (items = [], { limit = 200, offset = 0 } = {}) => {
+  const safeLimit = Math.max(1, Math.min(200, Number.parseInt(String(limit), 10) || 200));
+  const safeOffset = Math.max(0, Number.parseInt(String(offset), 10) || 0);
+  const total = items.length;
+  const entries = items.slice(safeOffset, safeOffset + safeLimit);
+  const nextOffset = safeOffset + entries.length;
+  return {
+    entries,
+    total,
+    offset: safeOffset,
+    limit: safeLimit,
+    hasMore: nextOffset < total,
+    nextOffset: nextOffset < total ? nextOffset : null,
+  };
+};
+
+const parseRunLogLine = (line, jobId) => {
+  if (!line) return null;
+  try {
+    const value = JSON.parse(line);
+    if (!value || typeof value !== "object") return null;
+    if (String(value.action || "") !== "finished") return null;
+    if (String(value.jobId || "") !== jobId) return null;
+    const ts = toFiniteNumber(value.ts, 0);
+    if (!ts) return null;
+    return {
+      ts,
+      jobId,
+      action: "finished",
+      status: value.status,
+      error: value.error,
+      summary: value.summary,
+      delivered:
+        typeof value.delivered === "boolean" ? value.delivered : undefined,
+      deliveryStatus: value.deliveryStatus,
+      deliveryError: value.deliveryError,
+      sessionId: value.sessionId,
+      sessionKey: value.sessionKey,
+      runAtMs: value.runAtMs,
+      durationMs: value.durationMs,
+      nextRunAtMs: value.nextRunAtMs,
+      model: value.model,
+      provider: value.provider,
+      usage:
+        value.usage && typeof value.usage === "object" ? value.usage : undefined,
+    };
+  } catch {
+    return null;
+  }
+};
+
+const readTokenValue = (source = {}, keys = []) => {
+  for (const key of keys) {
+    const numericValue = Number(source?.[key]);
+    if (Number.isFinite(numericValue) && numericValue >= 0) {
+      return numericValue;
+    }
+  }
+  return 0;
+};
+
+const enrichRunEntryEstimatedCost = (entry = {}) => {
+  const usage = entry?.usage;
+  if (!usage || typeof usage !== "object") return entry;
+  const existingEstimatedCost = Number(
+    usage?.estimatedCost ?? usage?.estimated_cost ?? entry?.estimatedCost ?? entry?.estimated_cost,
+  );
+  if (Number.isFinite(existingEstimatedCost) && existingEstimatedCost >= 0) {
+    return {
+      ...entry,
+      estimatedCost: existingEstimatedCost,
+      usage: {
+        ...usage,
+        estimatedCost: existingEstimatedCost,
+      },
+    };
+  }
+  const inputTokens = readTokenValue(usage, ["input_tokens", "inputTokens"]);
+  const outputTokens = readTokenValue(usage, ["output_tokens", "outputTokens"]);
+  const cacheReadTokens = readTokenValue(usage, ["cache_read_tokens", "cacheReadTokens"]);
+  const cacheWriteTokens = readTokenValue(usage, ["cache_write_tokens", "cacheWriteTokens"]);
+  if (inputTokens <= 0 && outputTokens <= 0 && cacheReadTokens <= 0 && cacheWriteTokens <= 0) {
+    return entry;
+  }
+  const model = String(entry?.model || usage?.model || "").trim();
+  if (!model) return entry;
+  const breakdown = deriveCostBreakdown({
+    inputTokens,
+    outputTokens,
+    cacheReadTokens,
+    cacheWriteTokens,
+    provider: String(entry?.provider || "").trim(),
+    model,
+  });
+  if (!breakdown.pricingFound) {
+    return {
+      ...entry,
+      usage: {
+        ...usage,
+        pricingFound: false,
+      },
+    };
+  }
+  return {
+    ...entry,
+    estimatedCost: breakdown.totalCost,
+    usage: {
+      ...usage,
+      estimatedCost: breakdown.totalCost,
+      pricingFound: true,
+    },
+  };
+};
+
+const readJobRuns = ({
+  runsDir,
+  jobId,
+  limit = kDefaultRunsLimit,
+  offset = 0,
+  status = "all",
+  deliveryStatus = "all",
+  sortDir = "desc",
+  query = "",
+}) => {
+  const safeJobId = sanitizeCronJobId(jobId);
+  const runLogPath = path.join(runsDir, `${safeJobId}.jsonl`);
+  const raw = fs.existsSync(runLogPath) ? fs.readFileSync(runLogPath, "utf8") : "";
+  const lines = String(raw || "")
+    .split("\n")
+    .map((line) => line.trim())
+    .filter(Boolean);
+  const entries = lines
+    .map((line) => parseRunLogLine(line, safeJobId))
+    .filter(Boolean);
+
+  const normalizedStatus = normalizeRunStatus(status);
+  const normalizedDeliveryStatus = normalizeDeliveryStatus(deliveryStatus);
+  const queryText = String(query || "").trim().toLowerCase();
+
+  const filtered = entries.filter((entry) => {
+    if (normalizedStatus !== "all" && String(entry.status || "") !== normalizedStatus) {
+      return false;
+    }
+    const entryDelivery = String(entry.deliveryStatus || "not-requested");
+    if (
+      normalizedDeliveryStatus !== "all" &&
+      entryDelivery !== normalizedDeliveryStatus
+    ) {
+      return false;
+    }
+    if (!queryText) return true;
+    const searchable = [
+      String(entry.summary || ""),
+      String(entry.error || ""),
+      String(entry.model || ""),
+      String(entry.provider || ""),
+    ]
+      .join(" ")
+      .toLowerCase();
+    return searchable.includes(queryText);
+  });
+
+  filtered.sort((a, b) => {
+    if (sortDir === "asc") return a.ts - b.ts;
+    return b.ts - a.ts;
+  });
+
+  const page = paginate(filtered, {
+    limit: Math.max(1, Math.min(kMaxRunsLimit, Number.parseInt(String(limit), 10) || kDefaultRunsLimit)),
+    offset,
+  });
+  return {
+    runLogPath,
+    entries: page.entries,
+    total: page.total,
+    offset: page.offset,
+    limit: page.limit,
+    hasMore: page.hasMore,
+    nextOffset: page.nextOffset,
+  };
+};
+
+const shellEscapeArg = (value) => `'${String(value || "").replace(/'/g, `'\\''`)}'`;
+
+const parseCommandJson = (rawOutput) => {
+  const parsed = parseJsonValueFromNoisyOutput(rawOutput);
+  if (parsed && typeof parsed === "object") return parsed;
+  return null;
+};
+
+const createCronService = ({
+  clawCmd,
+  OPENCLAW_DIR,
+  getSessionUsageByKeyPattern,
+}) => {
+  const cronDir = path.join(OPENCLAW_DIR, "cron");
+  const runsDir = path.join(cronDir, kCronRunsDir);
+
+  const listJobs = ({ sortBy = "nextRunAtMs", sortDir = "asc" } = {}) => {
+    const store = readCronStore({ cronDir });
+    const jobs = sortJobs(store.jobs, { sortBy, sortDir });
+    return {
+      storePath: store.storePath,
+      jobs,
+    };
+  };
+
+  const getStatus = () => {
+    const { storePath, jobs } = listJobs({ sortBy: "nextRunAtMs", sortDir: "asc" });
+    const enabledJobs = jobs.filter((job) => job.enabled !== false);
+    const nextWakeAtMs = enabledJobs.reduce((lowestValue, job) => {
+      const candidate = toFiniteNumber(job?.state?.nextRunAtMs, 0);
+      if (!candidate) return lowestValue;
+      if (!lowestValue) return candidate;
+      return Math.min(lowestValue, candidate);
+    }, 0);
+    return {
+      enabled: true,
+      storePath,
+      jobs: jobs.length,
+      enabledJobs: enabledJobs.length,
+      nextWakeAtMs: nextWakeAtMs || null,
+    };
+  };
+
+  const runCommand = async (command, { timeoutMs = 30000 } = {}) => {
+    const result = await clawCmd(command, { quiet: true, timeoutMs });
+    if (!result?.ok) {
+      const message = String(result?.stderr || result?.stdout || "Command failed").trim();
+      throw new Error(message || "Command failed");
+    }
+    return {
+      raw: result.stdout || "",
+      parsed: parseCommandJson(result.stdout || ""),
+    };
+  };
+
+  const runJobNow = async (jobId) => {
+    const safeJobId = sanitizeCronJobId(jobId);
+    const command = `cron run ${shellEscapeArg(safeJobId)} --json`;
+    return runCommand(command, { timeoutMs: 600000 });
+  };
+
+  const setJobEnabled = async ({ jobId, enabled }) => {
+    const safeJobId = sanitizeCronJobId(jobId);
+    const action = enabled ? "enable" : "disable";
+    const command = `cron ${action} ${shellEscapeArg(safeJobId)} --json`;
+    return runCommand(command, { timeoutMs: 60000 });
+  };
+
+  const updateJobPrompt = async ({ jobId, message }) => {
+    const safeJobId = sanitizeCronJobId(jobId);
+    const command = `cron edit ${shellEscapeArg(safeJobId)} --message ${shellEscapeArg(message || "")} --json`;
+    return runCommand(command, { timeoutMs: 60000 });
+  };
+
+  const getJobRuns = ({
+    jobId,
+    limit = kDefaultRunsLimit,
+    offset = 0,
+    status = "all",
+    deliveryStatus = "all",
+    sortDir = "desc",
+    query = "",
+  }) => {
+    const runs = readJobRuns({
+      runsDir,
+      jobId,
+      limit,
+      offset,
+      status,
+      deliveryStatus,
+      sortDir,
+      query,
+    });
+    return {
+      ...runs,
+      entries: runs.entries.map((entry) => enrichRunEntryEstimatedCost(entry)),
+    };
+  };
+
+  const getJobUsage = ({ jobId, sinceMs = 0 }) => {
+    const safeJobId = sanitizeCronJobId(jobId);
+    const keyPattern = `%:cron:${safeJobId}%`;
+    return getSessionUsageByKeyPattern({
+      keyPattern,
+      sinceMs: toFiniteNumber(sinceMs, 0),
+    });
+  };
+
+  const getBulkJobUsage = ({ sinceMs = 0 } = {}) => {
+    const { jobs } = listJobs({ sortBy: "name", sortDir: "asc" });
+    const safeSinceMs = toFiniteNumber(sinceMs, 0);
+    const byJobId = {};
+    jobs.forEach((job) => {
+      const usage = getJobUsage({ jobId: job.id, sinceMs: safeSinceMs }) || {};
+      const totals = usage?.totals || {};
+      const runCount = toFiniteNumber(totals.runCount, 0);
+      const totalTokens = toFiniteNumber(totals.totalTokens, 0);
+      const totalCost = toFiniteNumber(totals.totalCost, 0);
+      byJobId[job.id] = {
+        totalTokens,
+        totalCost,
+        runCount,
+        avgTokensPerRun: runCount > 0 ? Math.round(totalTokens / runCount) : 0,
+      };
+    });
+    return {
+      sinceMs: safeSinceMs,
+      byJobId,
+    };
+  };
+
+  const getBulkJobRuns = ({
+    sinceMs = 0,
+    limitPerJob = kDefaultRunsLimit,
+    status = "all",
+    deliveryStatus = "all",
+    sortDir = "desc",
+    query = "",
+  } = {}) => {
+    const { jobs } = listJobs({ sortBy: "name", sortDir: "asc" });
+    const safeSinceMs = toFiniteNumber(sinceMs, 0);
+    const safeLimitPerJob = Math.max(
+      1,
+      Math.min(kMaxRunsLimit, Number.parseInt(String(limitPerJob), 10) || kDefaultRunsLimit),
+    );
+    const byJobId = {};
+    jobs.forEach((job) => {
+      const runs = getJobRuns({
+        jobId: job.id,
+        limit: safeLimitPerJob,
+        offset: 0,
+        status,
+        deliveryStatus,
+        sortDir,
+        query,
+      });
+      const filteredEntries = safeSinceMs > 0
+        ? runs.entries.filter((entry) => toFiniteNumber(entry?.ts, 0) >= safeSinceMs)
+        : runs.entries;
+      byJobId[job.id] = {
+        entries: filteredEntries,
+        total: filteredEntries.length,
+      };
+    });
+    return {
+      sinceMs: safeSinceMs,
+      byJobId,
+    };
+  };
+
+  return {
+    listJobs,
+    getStatus,
+    runJobNow,
+    setJobEnabled,
+    updateJobPrompt,
+    getJobRuns,
+    getJobUsage,
+    getBulkJobUsage,
+    getBulkJobRuns,
+  };
+};
+
+module.exports = {
+  createCronService,
+};

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

@@ -1,11 +1,11 @@
 const fs = require("fs");
 const path = require("path");
 const { DatabaseSync } = require("node:sqlite");
+const { kGlobalModelPricing, deriveCostBreakdown } = require("../../cost-utils");
 const { ensureSchema } = require("./schema");
 const { getDailySummary } = require("./summary");
 const { getSessionsList, getSessionDetail } = require("./sessions");
 const { getSessionTimeSeries } = require("./timeseries");
-const { kGlobalModelPricing } = require("./pricing");
 
 let db = null;
 let usageDbPath = "";
@@ -24,6 +24,104 @@ const initUsageDb = ({ rootDir }) => {
   return { path: usageDbPath };
 };
 
+const getSessionUsageByKeyPattern = ({ keyPattern = "", sinceMs = 0 } = {}) => {
+  const database = ensureDb();
+  const normalizedPattern = String(keyPattern || "").trim();
+  if (!normalizedPattern) {
+    return {
+      totals: {
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadTokens: 0,
+        cacheWriteTokens: 0,
+        totalTokens: 0,
+        totalCost: 0,
+        eventCount: 0,
+        runCount: 0,
+      },
+      modelBreakdown: [],
+    };
+  }
+
+  const rows = database
+    .prepare(
+      `
+        SELECT
+          COALESCE(model, '') AS model,
+          COALESCE(provider, '') AS provider,
+          COUNT(*) AS event_count,
+          COUNT(DISTINCT COALESCE(NULLIF(session_key, ''), NULLIF(session_id, ''))) AS run_count,
+          SUM(COALESCE(input_tokens, 0)) AS input_tokens,
+          SUM(COALESCE(output_tokens, 0)) AS output_tokens,
+          SUM(COALESCE(cache_read_tokens, 0)) AS cache_read_tokens,
+          SUM(COALESCE(cache_write_tokens, 0)) AS cache_write_tokens,
+          SUM(COALESCE(total_tokens, 0)) AS total_tokens
+        FROM usage_events
+        WHERE session_key LIKE $keyPattern
+          AND ($sinceMs <= 0 OR timestamp >= $sinceMs)
+        GROUP BY model, provider
+        ORDER BY total_tokens DESC
+      `,
+    )
+    .all({
+      $keyPattern: normalizedPattern,
+      $sinceMs: Number.isFinite(Number(sinceMs)) ? Number(sinceMs) : 0,
+    });
+  const modelBreakdown = rows.map((row) => {
+    const inputTokens = Number(row.input_tokens || 0);
+    const outputTokens = Number(row.output_tokens || 0);
+    const cacheReadTokens = Number(row.cache_read_tokens || 0);
+    const cacheWriteTokens = Number(row.cache_write_tokens || 0);
+    const totalTokens = Number(row.total_tokens || 0);
+    const costBreakdown = deriveCostBreakdown({
+      inputTokens,
+      outputTokens,
+      cacheReadTokens,
+      cacheWriteTokens,
+      provider: String(row.provider || ""),
+      model: String(row.model || ""),
+    });
+    return {
+      model: String(row.model || ""),
+      provider: String(row.provider || ""),
+      eventCount: Number(row.event_count || 0),
+      runCount: Number(row.run_count || 0),
+      inputTokens,
+      outputTokens,
+      cacheReadTokens,
+      cacheWriteTokens,
+      totalTokens,
+      totalCost: costBreakdown.totalCost,
+      pricingFound: costBreakdown.pricingFound,
+    };
+  });
+
+  const totals = modelBreakdown.reduce(
+    (accumulator, row) => ({
+      inputTokens: accumulator.inputTokens + row.inputTokens,
+      outputTokens: accumulator.outputTokens + row.outputTokens,
+      cacheReadTokens: accumulator.cacheReadTokens + row.cacheReadTokens,
+      cacheWriteTokens: accumulator.cacheWriteTokens + row.cacheWriteTokens,
+      totalTokens: accumulator.totalTokens + row.totalTokens,
+      totalCost: accumulator.totalCost + row.totalCost,
+      eventCount: accumulator.eventCount + row.eventCount,
+      runCount: accumulator.runCount + row.runCount,
+    }),
+    {
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheReadTokens: 0,
+      cacheWriteTokens: 0,
+      totalTokens: 0,
+      totalCost: 0,
+      eventCount: 0,
+      runCount: 0,
+    },
+  );
+
+  return { totals, modelBreakdown };
+};
+
 module.exports = {
   initUsageDb,
   getDailySummary: (options = {}) => getDailySummary({ database: ensureDb(), ...options }),
@@ -31,5 +129,6 @@ module.exports = {
   getSessionDetail: (options = {}) => getSessionDetail({ database: ensureDb(), ...options }),
   getSessionTimeSeries: (options = {}) =>
     getSessionTimeSeries({ database: ensureDb(), ...options }),
+  getSessionUsageByKeyPattern,
   kGlobalModelPricing,
 };

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

@@ -1,83 +1 @@
-const kTokensPerMillion = 1_000_000;
-const kLongContextThresholdTokens = 200_000;
-const kGlobalModelPricing = {
-  "claude-opus-4-6": {
-    input: (tokens) => (tokens > kLongContextThresholdTokens ? 10.0 : 5.0),
-    output: (tokens) => (tokens > kLongContextThresholdTokens ? 37.5 : 25.0),
-  },
-  "claude-sonnet-4-6": { input: 3.0, output: 15.0 },
-  "claude-haiku-4-6": { input: 0.8, output: 4.0 },
-  "gpt-5": { input: 1.25, output: 10.0 },
-  "gpt-5.4": { input: 2.5, output: 10.0 },
-  "gpt-5.1-codex": { input: 2.5, output: 10.0 },
-  "gpt-5.3-codex": { input: 2.5, output: 10.0 },
-  "gpt-4.1": { input: 2.0, output: 8.0 },
-  "gpt-4o": { input: 2.5, output: 10.0 },
-  "gpt-4o-mini": { input: 0.15, output: 0.6 },
-  "gemini-3.1-pro-preview": { input: 2.0, output: 12.0 },
-  "gemini-3-flash-preview": { input: 0.5, output: 3.0 },
-  "gemini-2.0-flash": { input: 0.1, output: 0.4 },
-};
-
-const toInt = (value, fallbackValue = 0) => {
-  const parsed = Number.parseInt(String(value ?? ""), 10);
-  return Number.isFinite(parsed) ? parsed : fallbackValue;
-};
-
-const resolvePricing = (model) => {
-  const normalized = String(model || "").toLowerCase();
-  if (!normalized) return null;
-  const exact = kGlobalModelPricing[normalized];
-  if (exact) return exact;
-  const matchKey = Object.keys(kGlobalModelPricing).find((key) =>
-    normalized.includes(key),
-  );
-  return matchKey ? kGlobalModelPricing[matchKey] : null;
-};
-
-const resolvePerMillionRate = (rate, tokens) => {
-  if (typeof rate === "function") {
-    return Number(rate(toInt(tokens)));
-  }
-  return Number(rate || 0);
-};
-
-const deriveCostBreakdown = ({
-  inputTokens = 0,
-  outputTokens = 0,
-  cacheReadTokens = 0,
-  cacheWriteTokens = 0,
-  model = "",
-}) => {
-  const pricing = resolvePricing(model);
-  if (!pricing) {
-    return {
-      inputCost: 0,
-      outputCost: 0,
-      cacheReadCost: 0,
-      cacheWriteCost: 0,
-      totalCost: 0,
-      pricingFound: false,
-    };
-  }
-  const inputRate = resolvePerMillionRate(pricing.input, inputTokens);
-  const outputRate = resolvePerMillionRate(pricing.output, outputTokens);
-  const inputCost = (inputTokens / kTokensPerMillion) * inputRate;
-  const outputCost = (outputTokens / kTokensPerMillion) * outputRate;
-  const cacheReadCost = 0;
-  const cacheWriteRate = resolvePerMillionRate(pricing.input, cacheWriteTokens);
-  const cacheWriteCost = (cacheWriteTokens / kTokensPerMillion) * cacheWriteRate;
-  return {
-    inputCost,
-    outputCost,
-    cacheReadCost,
-    cacheWriteCost,
-    totalCost: inputCost + outputCost + cacheReadCost + cacheWriteCost,
-    pricingFound: true,
-  };
-};
-
-module.exports = {
-  kGlobalModelPricing,
-  deriveCostBreakdown,
-};
+module.exports = require("../../cost-utils");

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

@@ -6,7 +6,10 @@ const {
   getUsageMetricsFromEventRow,
 } = require("./shared");
 
-const getSessionsList = ({ database, limit = kDefaultSessionLimit } = {}) => {
+const getSessionsList = ({
+  database,
+  limit = kDefaultSessionLimit,
+} = {}) => {
   const safeLimit = clampInt(limit, 1, kMaxSessionLimit, kDefaultSessionLimit);
   const rows = database
     .prepare(`

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

@@ -1,4 +1,4 @@
-const { deriveCostBreakdown } = require("./pricing");
+const { deriveCostBreakdown } = require("../../cost-utils");
 
 const kDefaultSessionLimit = 50;
 const kMaxSessionLimit = 200;
@@ -76,6 +76,7 @@ const getUsageMetricsFromEventRow = (row) => {
     outputTokens,
     cacheReadTokens,
     cacheWriteTokens,
+    provider: row.provider,
     model: row.model,
   });
   return {

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

@@ -124,7 +124,11 @@ const getAgentCostDistribution = ({
   };
 };
 
-const getDailySummary = ({ database, days = kDefaultDays, timeZone = kUtcTimeZone } = {}) => {
+const getDailySummary = ({
+  database,
+  days = kDefaultDays,
+  timeZone = kUtcTimeZone,
+} = {}) => {
   const { now, safeDays, startDay, timeZone: normalizedTimeZone } = getPeriodRange(
     days,
     timeZone,