opencode-usage 0.3.3 → 0.4.1

package/README.md

@@ -87,13 +87,13 @@ opencode-usage --provider anthropic --since 7d --json
 
 ## How It Works
 
-This tool reads OpenCode session data from:
+This tool reads OpenCode session data from the SQLite database (`opencode.db`):
 
-- Linux: `~/.local/share/opencode/storage/`
-- macOS: `~/.local/share/opencode/storage/`
-- Windows: `%LOCALAPPDATA%/opencode/storage/`
+- Linux: `~/.local/share/opencode/opencode.db`
+- macOS: `~/.local/share/opencode/opencode.db`
+- Windows: `%LOCALAPPDATA%/opencode/opencode.db`
 
-It aggregates token usage by day and calculates estimated costs based on current API pricing.
+Requires OpenCode v1.2.0+ (SQLite storage). It aggregates token usage by day and calculates estimated costs based on current API pricing.
 
 ## Note on Costs
 

package/dist/index.js

@@ -114,195 +114,94 @@ Examples:
 }
 
 // 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
@@ -11236,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("-------------------------------------------------------------------------------------------------------------------------");
@@ -28167,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;
@@ -28181,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 [
       {
@@ -28232,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 [
       {
@@ -28287,15 +28186,15 @@ async function loadAntigravityQuota() {
 }
 
 // src/codex-client.ts
-import { readFile as readFile3 } from "fs/promises";
+import { readFile as readFile2 } from "fs/promises";
 import { homedir as homedir3 } from "os";
 import { join as join4 } from "path";
-var isBun3 = typeof globalThis.Bun !== "undefined";
+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 = isBun3 ? await Bun.file(CODEX_AUTH_PATH).text() : await readFile3(CODEX_AUTH_PATH, "utf-8");
+    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;
@@ -28472,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,
@@ -28552,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);
@@ -28566,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,
@@ -29223,7 +29122,7 @@ async function runSolidDashboard(options) {
 }
 
 // src/config-commands.ts
-import { readFile as readFile4 } from "fs/promises";
+import { readFile as readFile3 } from "fs/promises";
 import { homedir as homedir5 } from "os";
 import { join as join6 } from "path";
 
@@ -29243,7 +29142,7 @@ async function showConfig() {
 Configuration file: ${configPath}`);
   let hasCodexAuth = false;
   try {
-    const content = await readFile4(CODEX_AUTH_PATH2, "utf-8");
+    const content = await readFile3(CODEX_AUTH_PATH2, "utf-8");
     const auth = JSON.parse(content);
     hasCodexAuth = !!auth.tokens?.access_token;
   } catch {}
@@ -29346,4 +29245,4 @@ async function main2() {
 }
 main2().catch(console.error);
 
-//# debugId=4F3AFA8CCC597E5564756E2164756E21
+//# debugId=71CC1B06755E934764756E2164756E21