opencode-usage 0.3.1 → 0.4.0

package/dist/index.js

@@ -1,6 +1,5 @@
 #!/usr/bin/env bun
 // @bun
-var __require = import.meta.require;
 
 // src/cli.ts
 import { parseArgs as nodeParseArgs } from "util";
@@ -47,10 +46,8 @@ function parseArgs() {
         json: { type: "boolean", short: "j" },
         monthly: { type: "boolean", short: "m" },
         watch: { type: "boolean", short: "w" },
-        dashboard: { type: "boolean", short: "D" },
-        "codex-token": { type: "string" },
+        stats: { type: "boolean", short: "S" },
         config: { type: "string" },
-        token: { type: "string" },
         help: { type: "boolean", short: "h" }
       },
       strict: true
@@ -67,10 +64,8 @@ function parseArgs() {
       json: values.json,
       monthly: values.monthly,
       watch: values.watch,
-      dashboard: values.dashboard,
-      codexToken: values["codex-token"],
-      config: values.config,
-      configToken: values.token
+      stats: values.stats,
+      config: values.config
     };
   } catch (error) {
     if (error instanceof Error && error.message.includes("Unknown option")) {
@@ -88,236 +83,125 @@ opencode-usage - Track OpenCode AI coding assistant usage and costs
 Usage:
   bunx opencode-usage [options]
 
+Modes:
+  (default)               Interactive dashboard (Bun only)
+  -S, --stats             Stats table mode (works with Node.js too)
+
 Options:
   -p, --provider <name>   Filter by provider (anthropic, openai, google, opencode)
   -d, --days <n>          Show only last N days
   -s, --since <date>      Start date (YYYYMMDD, YYYY-MM-DD, or 7d/1w/1m)
   -u, --until <date>      End date (YYYYMMDD, YYYY-MM-DD, or 7d/1w/1m)
-  -j, --json              Output as JSON
-  -m, --monthly           Aggregate by month instead of day
-  -w, --watch             Watch mode - refresh every 5 minutes
-  -D, --dashboard         Dashboard mode - unified multi-source view (Bun only)
-      --codex-token <t>   Codex API token for quota display in dashboard
-      --config <cmd>      Config commands: set-codex-token, show
+  -j, --json              Output as JSON (stats mode only)
+  -m, --monthly           Aggregate by month (stats mode only)
+  -w, --watch             Watch mode - refresh every 5 minutes (stats mode only)
+      --config show       Show current configuration
   -h, --help              Show this help message
 
-Config Commands:
-  --config show                           Show current configuration
-  --config set-codex-token --token <tok>  Save Codex API token to config
+Codex Quota:
+  Dashboard auto-reads Codex auth from ~/.codex/auth.json.
+  Run 'codex login' to authenticate.
 
 Examples:
   bunx opencode-usage
-  bunx opencode-usage --provider anthropic
-  bunx opencode-usage -p openai -d 30
-  bunx opencode-usage --since 20251201 --until 20251231
-  bunx opencode-usage --since 7d
-  bunx opencode-usage --monthly --json
-  bunx opencode-usage --watch
-  bunx opencode-usage -w -d 1
-  bunx opencode-usage --dashboard
-  bunx opencode-usage --dashboard --codex-token <token>
+  bunx opencode-usage --stats
+  bunx opencode-usage --stats --provider anthropic
+  bunx opencode-usage --stats -p openai -d 30
+  bunx opencode-usage --stats --since 7d --monthly --json
+  bunx opencode-usage --stats -w -d 1
   bunx opencode-usage --config show
-  bunx opencode-usage --config set-codex-token --token sk-...
-
-How to get Codex token:
-  1. Open chatgpt.com in browser
-  2. Open DevTools (F12 or Cmd+Option+I)
-  3. Go to Network tab and reload page
-  4. Find request to 'backend-api/wham/usage'
-  5. Copy 'Authorization' header value (starts with 'Bearer ')
 `);
 }
 
 // src/loader.ts
-import { readdir, stat, readFile } from "fs/promises";
+import { Database } from "bun:sqlite";
 import { homedir } from "os";
 import { join } from "path";
-var isBun = typeof globalThis.Bun !== "undefined";
-var BATCH_SIZE = 1e4;
 function getOpenCodeStoragePath() {
   const xdgDataHome = process.env.XDG_DATA_HOME ?? join(homedir(), ".local", "share");
-  return join(xdgDataHome, "opencode", "storage");
+  return join(xdgDataHome, "opencode");
 }
-async function readJsonFile(filePath) {
-  const content = isBun ? await Bun.file(filePath).text() : await readFile(filePath, "utf-8");
-  return JSON.parse(content);
-}
-async function collectFilePaths(messagesDir) {
-  const sessionDirs = await readdir(messagesDir);
-  const pathArrays = await Promise.all(sessionDirs.map(async (sessionDir) => {
-    const sessionPath = join(messagesDir, sessionDir);
-    const st = await stat(sessionPath);
-    if (!st.isDirectory())
-      return [];
-    const files = await readdir(sessionPath);
-    return files.filter((f) => f.endsWith(".json")).map((f) => join(sessionPath, f));
-  }));
-  return pathArrays.flat();
+function openDb(dataPath) {
+  return new Database(join(dataPath, "opencode.db"), { readonly: true });
 }
-async function processInBatches(items, fn, batchSize) {
-  const results = [];
-  for (let i = 0;i < items.length; i += batchSize) {
-    const batch = items.slice(i, i + batchSize);
-    const batchResults = await Promise.all(batch.map(fn));
-    results.push(...batchResults);
+function rowToMessage(row) {
+  const data = JSON.parse(row.data);
+  return {
+    id: row.id,
+    sessionID: row.session_id,
+    ...data
+  };
+}
+function isValidMessage(msg, providerFilter) {
+  if (msg.role === "user")
+    return false;
+  if (!msg.tokens)
+    return false;
+  if (providerFilter) {
+    const providerId = msg.model?.providerID ?? msg.providerID ?? "unknown";
+    if (providerId.toLowerCase() !== providerFilter)
+      return false;
   }
-  return results;
+  return true;
 }
 async function loadRecentMessages(storagePath, hoursBack = 24, providerFilter) {
-  const messagesDir = join(storagePath, "message");
   const cutoffTime = Date.now() - hoursBack * 60 * 60 * 1000;
   try {
-    const sessionDirs = await readdir(messagesDir);
-    const recentFiles = [];
-    for (const sessionDir of sessionDirs) {
-      const sessionPath = join(messagesDir, sessionDir);
-      try {
-        const sessionStat = await stat(sessionPath);
-        if (!sessionStat.isDirectory())
-          continue;
-        if (sessionStat.mtimeMs < cutoffTime) {
-          continue;
-        }
-      } catch {
-        continue;
-      }
-      const files = await readdir(sessionPath);
-      const fileStats = await Promise.all(files.map(async (file) => {
-        if (!file.endsWith(".json"))
-          return null;
-        const filePath = join(sessionPath, file);
-        try {
-          const fileStat = await stat(filePath);
-          return { filePath, mtime: fileStat.mtimeMs };
-        } catch {
-          return null;
-        }
-      }));
-      for (const fileInfo of fileStats) {
-        if (fileInfo && fileInfo.mtime >= cutoffTime) {
-          recentFiles.push(fileInfo.filePath);
-        }
-      }
+    const db = openDb(storagePath);
+    try {
+      const rows = db.query(`SELECT id, session_id, time_created, data FROM message WHERE time_created >= ?`).all(cutoffTime);
+      return rows.map(rowToMessage).filter((msg) => isValidMessage(msg, providerFilter));
+    } finally {
+      db.close();
     }
-    const results = await processInBatches(recentFiles, async (filePath) => {
-      try {
-        return await readJsonFile(filePath);
-      } catch {
-        return null;
-      }
-    }, BATCH_SIZE);
-    return results.filter((msg) => {
-      if (!msg)
-        return false;
-      if (msg.role === "user")
-        return false;
-      if (!msg.tokens)
-        return false;
-      if (providerFilter) {
-        const providerId = msg.model?.providerID ?? msg.providerID ?? "unknown";
-        if (providerId.toLowerCase() !== providerFilter)
-          return false;
-      }
-      return true;
-    });
   } catch (err) {
     console.error(`Error reading recent messages: ${err}`);
     return [];
   }
 }
 async function loadMessages(storagePath, providerFilter) {
-  const messagesDir = join(storagePath, "message");
   try {
-    const filePaths = await collectFilePaths(messagesDir);
-    const results = await processInBatches(filePaths, async (filePath) => {
-      try {
-        return await readJsonFile(filePath);
-      } catch {
-        return null;
-      }
-    }, BATCH_SIZE);
-    return results.filter((msg) => {
-      if (!msg)
-        return false;
-      if (msg.role === "user")
-        return false;
-      if (!msg.tokens)
-        return false;
-      if (providerFilter) {
-        const providerId = msg.model?.providerID ?? msg.providerID ?? "unknown";
-        if (providerId.toLowerCase() !== providerFilter)
-          return false;
-      }
-      return true;
-    });
+    const db = openDb(storagePath);
+    try {
+      const rows = db.query(`SELECT id, session_id, time_created, data FROM message`).all();
+      return rows.map(rowToMessage).filter((msg) => isValidMessage(msg, providerFilter));
+    } finally {
+      db.close();
+    }
   } catch (err) {
-    console.error(`Error reading messages directory: ${err}`);
+    console.error(`Error reading messages from database: ${err}`);
     return [];
   }
 }
 function createCursor() {
-  return {
-    knownSessions: new Set,
-    fileCountPerSession: new Map,
-    lastTimestamp: 0
-  };
+  return { lastTimestamp: 0 };
 }
 async function loadMessagesIncremental(storagePath, cursor, providerFilter) {
-  const messagesDir = join(storagePath, "message");
-  const newMessages = [];
-  const newCursor = {
-    knownSessions: new Set(cursor.knownSessions),
-    fileCountPerSession: new Map(cursor.fileCountPerSession),
-    lastTimestamp: cursor.lastTimestamp
-  };
   try {
-    const sessionDirs = await readdir(messagesDir);
-    for (const sessionDir of sessionDirs) {
-      const sessionPath = join(messagesDir, sessionDir);
-      const st = await stat(sessionPath);
-      if (!st.isDirectory())
-        continue;
-      const files = await readdir(sessionPath);
-      const jsonFiles = files.filter((f) => f.endsWith(".json"));
-      const previousCount = cursor.fileCountPerSession.get(sessionDir) ?? 0;
-      if (jsonFiles.length > previousCount) {
-        const sortedFiles = jsonFiles.sort();
-        const newFiles = sortedFiles.slice(previousCount);
-        for (const file of newFiles) {
-          const filePath = join(sessionPath, file);
-          try {
-            const msg = await readJsonFile(filePath);
-            if (isValidMessage(msg, providerFilter)) {
-              newMessages.push(msg);
-              if (msg.time?.created && msg.time.created > newCursor.lastTimestamp) {
-                newCursor.lastTimestamp = msg.time.created;
-              }
-            }
-          } catch {}
+    const db = openDb(storagePath);
+    try {
+      const rows = db.query(`SELECT id, session_id, time_created, data FROM message WHERE time_created > ?`).all(cursor.lastTimestamp);
+      const messages = rows.map(rowToMessage).filter((msg) => isValidMessage(msg, providerFilter));
+      let maxTimestamp = cursor.lastTimestamp;
+      for (const row of rows) {
+        if (row.time_created > maxTimestamp) {
+          maxTimestamp = row.time_created;
         }
       }
-      newCursor.knownSessions.add(sessionDir);
-      newCursor.fileCountPerSession.set(sessionDir, jsonFiles.length);
+      return {
+        messages,
+        cursor: { lastTimestamp: maxTimestamp }
+      };
+    } finally {
+      db.close();
     }
-    return { messages: newMessages, cursor: newCursor };
   } catch (err) {
     console.error(`Error in incremental load: ${err}`);
-    return { messages: [], cursor: newCursor };
-  }
-}
-function isValidMessage(msg, providerFilter) {
-  if (!msg)
-    return false;
-  if (msg.role === "user")
-    return false;
-  if (!msg.tokens)
-    return false;
-  if (providerFilter) {
-    const providerId = msg.model?.providerID ?? msg.providerID ?? "unknown";
-    if (providerId.toLowerCase() !== providerFilter)
-      return false;
+    return {
+      messages: [],
+      cursor: { lastTimestamp: cursor.lastTimestamp }
+    };
   }
-  return true;
 }
 
 // src/pricing.ts
@@ -11251,8 +11135,8 @@ function convertToDebugSymbols(symbols) {
           const p99Width = Math.max(p99Header.length, ...allStats.map((s) => s.p99.toFixed(2).length));
           lines.push(`${nameHeader.padEnd(nameWidth)} | ${callsHeader.padStart(countWidth)} | ${totalHeader.padStart(totalWidth)} | ${avgHeader.padStart(avgWidth)} | ${minHeader.padStart(minWidth)} | ${maxHeader.padStart(maxWidth)} | ${medHeader.padStart(medianWidth)} | ${p90Header.padStart(p90Width)} | ${p99Header.padStart(p99Width)}`);
           lines.push(`${"-".repeat(nameWidth)}-+-${"-".repeat(countWidth)}-+-${"-".repeat(totalWidth)}-+-${"-".repeat(avgWidth)}-+-${"-".repeat(minWidth)}-+-${"-".repeat(maxWidth)}-+-${"-".repeat(medianWidth)}-+-${"-".repeat(p90Width)}-+-${"-".repeat(p99Width)}`);
-          allStats.forEach((stat2) => {
-            lines.push(`${stat2.name.padEnd(nameWidth)} | ${String(stat2.count).padStart(countWidth)} | ${stat2.total.toFixed(2).padStart(totalWidth)} | ${stat2.average.toFixed(2).padStart(avgWidth)} | ${stat2.min.toFixed(2).padStart(minWidth)} | ${stat2.max.toFixed(2).padStart(maxWidth)} | ${stat2.median.toFixed(2).padStart(medianWidth)} | ${stat2.p90.toFixed(2).padStart(p90Width)} | ${stat2.p99.toFixed(2).padStart(p99Width)}`);
+          allStats.forEach((stat) => {
+            lines.push(`${stat.name.padEnd(nameWidth)} | ${String(stat.count).padStart(countWidth)} | ${stat.total.toFixed(2).padStart(totalWidth)} | ${stat.average.toFixed(2).padStart(avgWidth)} | ${stat.min.toFixed(2).padStart(minWidth)} | ${stat.max.toFixed(2).padStart(maxWidth)} | ${stat.median.toFixed(2).padStart(medianWidth)} | ${stat.p90.toFixed(2).padStart(p90Width)} | ${stat.p99.toFixed(2).padStart(p99Width)}`);
           });
         }
         lines.push("-------------------------------------------------------------------------------------------------------------------------");
@@ -28182,13 +28066,13 @@ var render = async (node, rendererOrConfig = {}) => {
 };
 
 // src/quota-loader.ts
-import { readFile as readFile2 } from "fs/promises";
+import { readFile } from "fs/promises";
 import { homedir as homedir2 } from "os";
 import { join as join3 } from "path";
-var isBun2 = typeof globalThis.Bun !== "undefined";
-async function readJsonFile2(filePath) {
+var isBun = typeof globalThis.Bun !== "undefined";
+async function readJsonFile(filePath) {
   try {
-    const content = isBun2 ? await Bun.file(filePath).text() : await readFile2(filePath, "utf-8");
+    const content = isBun ? await Bun.file(filePath).text() : await readFile(filePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -28196,7 +28080,7 @@ async function readJsonFile2(filePath) {
 }
 async function loadMultiAccountQuota() {
   const path2 = join3(homedir2(), ".local/share/opencode/multi-account-state.json");
-  const state = await readJsonFile2(path2);
+  const state = await readJsonFile(path2);
   if (!state?.usage) {
     return [
       {
@@ -28247,7 +28131,7 @@ async function loadMultiAccountQuota() {
 }
 async function loadAntigravityQuota() {
   const path2 = join3(homedir2(), ".config/opencode/antigravity-accounts.json");
-  const data = await readJsonFile2(path2);
+  const data = await readJsonFile(path2);
   if (!data?.accounts?.length) {
     return [
       {
@@ -28302,15 +28186,38 @@ async function loadAntigravityQuota() {
 }
 
 // src/codex-client.ts
+import { readFile as readFile2 } from "fs/promises";
+import { homedir as homedir3 } from "os";
+import { join as join4 } from "path";
+var isBun2 = typeof globalThis.Bun !== "undefined";
 var CODEX_API_URL = "https://chatgpt.com/backend-api/wham/usage";
+var CODEX_AUTH_PATH = join4(homedir3(), ".codex", "auth.json");
+async function readCodexAuthToken() {
+  try {
+    const content = isBun2 ? await Bun.file(CODEX_AUTH_PATH).text() : await readFile2(CODEX_AUTH_PATH, "utf-8");
+    const auth = JSON.parse(content);
+    if (auth.OPENAI_API_KEY) {
+      return auth.OPENAI_API_KEY;
+    }
+    return auth.tokens?.access_token ?? undefined;
+  } catch {
+    return;
+  }
+}
+async function resolveCodexToken(explicitToken) {
+  if (explicitToken)
+    return explicitToken;
+  return readCodexAuthToken();
+}
 async function loadCodexQuota(token) {
-  if (!token) {
+  const resolvedToken = await resolveCodexToken(token);
+  if (!resolvedToken) {
     return [
       {
         source: "codex",
         label: "Codex",
         used: 0,
-        error: "No --codex-token provided"
+        error: "Not logged in. Run: codex login"
       }
     ];
   }
@@ -28318,17 +28225,18 @@ async function loadCodexQuota(token) {
     const response = await fetch(CODEX_API_URL, {
       method: "GET",
       headers: {
-        Authorization: `Bearer ${token}`,
+        Authorization: `Bearer ${resolvedToken}`,
         "Content-Type": "application/json"
       }
     });
     if (!response.ok) {
+      const hint = response.status === 401 ? " (token expired? Run: codex login)" : "";
       return [
         {
           source: "codex",
           label: "Codex",
           used: 0,
-          error: `API error: ${response.status}`
+          error: `API error: ${response.status}${hint}`
         }
       ];
     }
@@ -28463,9 +28371,9 @@ function UsageTable(props) {
     const windowedData = getWindowedData();
     let totalTokens = 0;
     let totalCost = 0;
-    windowedData.forEach(([_2, stat2]) => {
-      totalTokens += stat2.input + stat2.output;
-      totalCost += stat2.cost;
+    windowedData.forEach(([_2, stat]) => {
+      totalTokens += stat.input + stat.output;
+      totalCost += stat.cost;
     });
     return {
       tokens: totalTokens,
@@ -28543,10 +28451,10 @@ function UsageTable(props) {
       get each() {
         return statsArray();
       },
-      children: ([dateKey, stat2], index) => {
+      children: ([dateKey, stat], index) => {
         const isLast = index() === statsArray().length - 1;
         const isEven = index() % 2 === 0;
-        const providers = Array.from(stat2.providerStats.entries());
+        const providers = Array.from(stat.providerStats.entries());
         return [(() => {
           var _el$26 = createElement("box"), _el$27 = createElement("text"), _el$28 = createElement("span"), _el$29 = createElement("span"), _el$30 = createElement("span");
           insertNode(_el$26, _el$27);
@@ -28557,8 +28465,8 @@ function UsageTable(props) {
           setProp(_el$27, "overflow", "hidden");
           setProp(_el$27, "wrapMode", "none");
           insert(_el$28, () => padRight2(dateKey, 18));
-          insert(_el$29, () => padLeft2(formatNum(stat2.input + stat2.output), 13));
-          insert(_el$30, () => padLeft2(formatCost2(stat2.cost), 10));
+          insert(_el$29, () => padLeft2(formatNum(stat.input + stat.output), 13));
+          insert(_el$30, () => padLeft2(formatCost2(stat.cost), 10));
           effect((_p$) => {
             var _v$1 = providers.length > 0 ? 0.25 : 0.5, _v$10 = isEven ? COLORS.bg.secondary : COLORS.bg.accent, _v$11 = {
               fg: COLORS.text.primary,
@@ -29052,18 +28960,16 @@ function Dashboard(props) {
         error: `Load error: ${err}`
       });
     }
-    if (props.codexToken) {
-      try {
-        const codex = await loadCodexQuota(props.codexToken);
-        results.push(...codex);
-      } catch (err) {
-        results.push({
-          source: "codex",
-          label: "Codex",
-          used: 0,
-          error: `Load error: ${err}`
-        });
-      }
+    try {
+      const codex = await loadCodexQuota();
+      results.push(...codex);
+    } catch (err) {
+      results.push({
+        source: "codex",
+        label: "Codex",
+        used: 0,
+        error: `Load error: ${err}`
+      });
     }
     setQuotas(results);
   };
@@ -29199,9 +29105,6 @@ function Dashboard(props) {
 }
 async function runSolidDashboard(options) {
   await render(() => createComponent2(Dashboard, {
-    get codexToken() {
-      return options.codexToken;
-    },
     get providerFilter() {
       return options.providerFilter;
     },
@@ -29218,57 +29121,32 @@ async function runSolidDashboard(options) {
   });
 }
 
-// src/config.ts
+// src/config-commands.ts
 import { readFile as readFile3 } from "fs/promises";
-import { homedir as homedir3 } from "os";
-import { join as join4 } from "path";
-var isBun3 = typeof globalThis.Bun !== "undefined";
+import { homedir as homedir5 } from "os";
+import { join as join6 } from "path";
+
+// src/config.ts
+import { homedir as homedir4 } from "os";
+import { join as join5 } from "path";
 function getConfigPath() {
-  const configDir = process.env.XDG_CONFIG_HOME ?? join4(homedir3(), ".config");
-  return join4(configDir, "opencode-usage", "config.json");
-}
-async function loadConfig() {
-  try {
-    const configPath = getConfigPath();
-    const content = isBun3 ? await Bun.file(configPath).text() : await readFile3(configPath, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return {};
-  }
-}
-async function saveConfig(config) {
-  const configPath = getConfigPath();
-  const configDir = join4(configPath, "..");
-  const { mkdir, writeFile } = await import("fs/promises");
-  await mkdir(configDir, { recursive: true });
-  const content = JSON.stringify(config, null, 2) + `
-`;
-  if (isBun3) {
-    await Bun.write(configPath, content);
-  } else {
-    await writeFile(configPath, content, "utf-8");
-  }
+  const configDir = process.env.XDG_CONFIG_HOME ?? join5(homedir4(), ".config");
+  return join5(configDir, "opencode-usage", "config.json");
 }
 
 // src/config-commands.ts
-async function setCodexToken(token) {
-  const config = await loadConfig();
-  config.codexToken = token;
-  await saveConfig(config);
-  console.log(`\u2713 Codex token saved to ${getConfigPath()}`);
-}
+var CODEX_AUTH_PATH2 = join6(homedir5(), ".codex", "auth.json");
 async function showConfig() {
-  const config = await loadConfig();
   const configPath = getConfigPath();
   console.log(`
-Configuration file: ${configPath}
-`);
-  if (config.codexToken) {
-    const maskedToken = config.codexToken.substring(0, 8) + "..." + config.codexToken.substring(config.codexToken.length - 4);
-    console.log(`  codexToken: ${maskedToken}`);
-  } else {
-    console.log(`  codexToken: (not set)`);
-  }
+Configuration file: ${configPath}`);
+  let hasCodexAuth = false;
+  try {
+    const content = await readFile3(CODEX_AUTH_PATH2, "utf-8");
+    const auth = JSON.parse(content);
+    hasCodexAuth = !!auth.tokens?.access_token;
+  } catch {}
+  console.log(`  Codex auth: ${hasCodexAuth ? "~/.codex/auth.json (auto)" : "(not found \u2014 run: codex login)"}`);
   console.log();
 }
 
@@ -29323,37 +29201,13 @@ Loading OpenCode usage data from: ${options.storagePath}`);
   }
 }
 async function main2() {
-  const {
-    provider,
-    days,
-    since,
-    until,
-    json,
-    monthly,
-    watch,
-    dashboard,
-    codexToken,
-    config,
-    configToken
-  } = parseArgs();
+  const { provider, days, since, until, json, monthly, watch, stats, config } = parseArgs();
   if (config === "show") {
     await showConfig();
     return;
   }
-  if (config === "set-codex-token") {
-    if (!configToken) {
-      console.error("Error: --config set-codex-token requires --token <value>");
-      console.error("Usage: opencode-usage --config set-codex-token --token <token>");
-      process.exit(1);
-    }
-    await setCodexToken(configToken);
-    return;
-  }
-  const configData = await loadConfig();
-  const effectiveCodexToken = codexToken ?? configData.codexToken;
-  if (dashboard) {
+  if (!stats) {
     await runSolidDashboard({
-      codexToken: effectiveCodexToken,
       refreshInterval: 300,
       providerFilter: provider,
       initialDays: days
@@ -29391,4 +29245,4 @@ async function main2() {
 }
 main2().catch(console.error);
 
-//# debugId=2D8D06802834C82864756E2164756E21
+//# debugId=71CC1B06755E934764756E2164756E21