vibestats 1.3.14 → 1.4.1

package/README.md

@@ -8,6 +8,7 @@ AI coding stats CLI for **Claude Code** and **OpenAI Codex**. Track your usage a
 npm install -g vibestats
 # or run directly
 npx vibestats
+npx vibestats codex
 ```
 
 ## Usage
@@ -15,6 +16,9 @@ npx vibestats
 ```bash
 # Usage stats (default)
 vibestats              # Daily usage table
+vibestats claude       # Claude-compatible usage
+vibestats codex        # Codex CLI usage
+vibestats all          # Combined local sources
 vibestats --monthly    # Monthly aggregation
 vibestats --model      # Aggregate by model
 vibestats --total      # Show only totals
@@ -65,10 +69,15 @@ vibestats --claude-limits
 
 ### Data Source
 
-| Flag | Description |
-|------|-------------|
+| Command or flag | Description |
+|-----------------|-------------|
+| `vibestats claude` | Claude-compatible local usage |
+| `vibestats codex` | OpenAI Codex only |
+| `vibestats all` | All supported local sources combined |
 | `--codex` | OpenAI Codex only |
 | `--combined` | Claude + Codex combined |
+| `vibestats usage codex --total` | Codex total usage table |
+| `vibestats limits codex` | Codex local limit windows |
 
 ### Config
 
@@ -99,7 +108,7 @@ Creates `~/.vibestats.json`:
 
 | Source | Location |
 |--------|----------|
-| Claude Code | `~/.claude/projects/**/*.jsonl` |
+| Claude-compatible | Claude Code, OpenCode, and Factory Droid local usage |
 | OpenAI Codex | `~/.codex/sessions/*.jsonl` |
 
 Additional Claude diagnostic files:
@@ -125,10 +134,13 @@ Additional Claude diagnostic files:
 
 Visit [vibestats.wolfai.dev](https://vibestats.wolfai.dev) to view shares in the browser.
 
+- [vibestats.wolfai.dev/docs](https://vibestats.wolfai.dev/docs)
 - [vibestats.wolfai.dev/wrapped](https://vibestats.wolfai.dev/wrapped)
 - [vibestats.wolfai.dev/activity](https://vibestats.wolfai.dev/activity)
 - [vibestats.wolfai.dev/changelog](https://vibestats.wolfai.dev/changelog)
 
+The hosted web app runs from the VPS deployment defined by `docker-compose.vps.yml` and `packages/web/Dockerfile`, behind Traefik at `vibestats.wolfai.dev`.
+
 ## License
 
 MIT

package/dist/index.js

@@ -1036,7 +1036,7 @@ async function writeUsageCacheFile(cache) {
   await fs.rename(tmpPath, cachePath);
 }
 function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 async function withUsageCacheLock(task) {
   const lockPath = `${getUsageCachePath()}.lock`;
@@ -2373,9 +2373,9 @@ function aggregateBySession(entries) {
   }
   return Array.from(sessionMap.entries()).filter(([, data]) => data.totalTokens > 0).map(([sessionId, data]) => {
     const date = data.firstTimestamp ? toLocalDateString3(data.firstTimestamp) : "unknown";
-    const shortId = data.displaySessionId.slice(0, 12);
+    const shortId2 = data.displaySessionId.slice(0, 12);
     return {
-      key: `${date} ${shortId}`,
+      key: `${date} ${shortId2}`,
       inputTokens: data.inputTokens,
       outputTokens: data.outputTokens,
       cacheWriteTokens: data.cacheWriteTokens,
@@ -3666,6 +3666,359 @@ async function inspectClaudeUsage(claudeDir = getClaudeDir2()) {
   };
 }
 
+// src/shared/args.ts
+var modelFamilyArgs = {
+  claude: {
+    type: "boolean",
+    description: "Show only Claude family stats across local usage sources",
+    default: false
+  },
+  kimi: {
+    type: "boolean",
+    description: "Show only Kimi family stats across local usage sources",
+    default: false
+  },
+  minimax: {
+    type: "boolean",
+    description: "Show only MiniMax family stats across local usage sources",
+    default: false
+  }
+};
+function getSelectedModelFamilies(args) {
+  const families = [];
+  if (args.claude === true) families.push("claude");
+  if (args.kimi === true) families.push("kimi");
+  if (args.minimax === true) families.push("minimax");
+  return families;
+}
+var cacheArgs = {
+  "no-cache": {
+    type: "boolean",
+    description: "Bypass the persistent local usage cache for this run",
+    default: false
+  },
+  "refresh-cache": {
+    type: "boolean",
+    description: "Rebuild the persistent local usage cache before showing stats",
+    default: false
+  }
+};
+function getUsageCacheOptions(args) {
+  return {
+    useCache: args["no-cache"] !== true,
+    refreshCache: args["refresh-cache"] === true
+  };
+}
+
+// src/dashboard/assets-path.ts
+import { fileURLToPath } from "url";
+import { dirname as dirname2, resolve, join as join5 } from "path";
+import { existsSync } from "fs";
+function resolveDashboardAssets(importMetaUrl) {
+  const here = dirname2(fileURLToPath(importMetaUrl));
+  const candidates = [
+    // Published tarball (tsup single-file bundle): here === .../dist, assets at .../dist/web
+    resolve(here, "web"),
+    // Same tarball layout but caller is nested one deeper (e.g. dist/commands/...)
+    resolve(here, "..", "web"),
+    // Monorepo dev with tsx from packages/cli/src/dashboard/...
+    resolve(here, "..", "..", "..", "web", ".next-static"),
+    // Monorepo dev with tsx from packages/cli/src/commands/...
+    resolve(here, "..", "..", "web", ".next-static")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(join5(candidate, "index.html"))) return candidate;
+  }
+  throw new Error(
+    `dashboard assets not found. Tried:
+` + candidates.map((c) => `  - ${c}`).join("\n") + `
+Run \`pnpm --filter web build:static\` first.`
+  );
+}
+
+// src/dashboard/payloads.ts
+import { randomBytes } from "crypto";
+var MAX_INLINE_BYTES = 6e3;
+var STUB_BASE = "http://local";
+function extractEncodedQuery(urlWithQuery) {
+  const url = new URL(urlWithQuery);
+  const query = url.search.replace(/^\?/, "");
+  return query || null;
+}
+function shortId() {
+  return randomBytes(6).toString("hex");
+}
+function inlineOrFallback(paramKey, payload, inlineQuery, out) {
+  if (!payload || !inlineQuery) return;
+  if (Buffer.byteLength(inlineQuery, "utf-8") <= MAX_INLINE_BYTES) {
+    out.hubParams.set(paramKey, inlineQuery);
+    return;
+  }
+  const id = shortId();
+  out.jsonStore.set(id, JSON.stringify(payload));
+  out.hubParams.set(paramKey, `json:${id}`);
+}
+function buildDashboardPayloads(input) {
+  const out = {
+    hubParams: new URLSearchParams(),
+    jsonStore: /* @__PURE__ */ new Map()
+  };
+  if (input.usage) {
+    const full = encodeUsageToUrl(input.usage, STUB_BASE);
+    inlineOrFallback("u", input.usage, extractEncodedQuery(full), out);
+  }
+  if (input.wrapped) {
+    const full = encodeStatsToUrl(input.wrapped, STUB_BASE);
+    inlineOrFallback("w", input.wrapped, extractEncodedQuery(full), out);
+  }
+  if (input.activity) {
+    const full = encodeActivityToUrl(input.activity, STUB_BASE);
+    inlineOrFallback("a", input.activity, extractEncodedQuery(full), out);
+  }
+  return out;
+}
+
+// src/dashboard/open-browser.ts
+import { spawn } from "child_process";
+import { platform } from "os";
+function openInBrowser(url) {
+  const os = platform();
+  const cmd = os === "darwin" ? "open" : os === "win32" ? "cmd" : "xdg-open";
+  const args = os === "win32" ? ["/c", "start", "", url] : [url];
+  try {
+    const child = spawn(cmd, args, { stdio: "ignore", detached: true });
+    child.on("error", () => {
+    });
+    child.unref();
+  } catch {
+  }
+}
+
+// src/dashboard/server.ts
+import { createServer as createServer2 } from "http";
+import { readFile } from "fs/promises";
+import { existsSync as existsSync2, realpathSync, statSync } from "fs";
+import { extname, join as join6, normalize, resolve as resolve2, sep } from "path";
+
+// src/dashboard/port.ts
+import { createServer, createConnection } from "net";
+async function findFreePort(start, end) {
+  for (let port = start; port <= end; port++) {
+    if (await isPortFree(port)) return port;
+  }
+  throw new Error(`no free port available in range ${start}-${end}`);
+}
+function isPortFree(port) {
+  return isConnectable(port).then((connectable) => {
+    if (connectable) return false;
+    return isBindable(port);
+  });
+}
+function isConnectable(port) {
+  return new Promise((resolve3) => {
+    const socket = createConnection({ port, host: "127.0.0.1" });
+    const done = (result) => {
+      socket.removeAllListeners();
+      socket.destroy();
+      resolve3(result);
+    };
+    socket.once("connect", () => done(true));
+    socket.once("error", () => done(false));
+    const timer = setTimeout(() => done(false), 250);
+    timer.unref();
+  });
+}
+function isBindable(port) {
+  return new Promise((resolve3) => {
+    const server = createServer();
+    const onError = () => {
+      server.removeListener("listening", onListening);
+      resolve3(false);
+    };
+    const onListening = () => {
+      server.removeListener("error", onError);
+      server.close(() => {
+        resolve3(true);
+      });
+    };
+    server.on("error", onError);
+    server.on("listening", onListening);
+    server.listen(port, "127.0.0.1");
+  });
+}
+
+// src/dashboard/server.ts
+var MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "application/javascript; charset=utf-8",
+  ".mjs": "application/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".txt": "text/plain; charset=utf-8",
+  ".map": "application/json; charset=utf-8"
+};
+async function startDashboardServer(options) {
+  const root = realpathSync(resolve2(options.assetsDir));
+  const preferred = options.preferredPort ?? 8080;
+  const port = await findFreePort(preferred, preferred + 20);
+  const server = createServer2(async (req, res) => {
+    try {
+      const url = new URL(req.url || "/", `http://127.0.0.1:${port}`);
+      let pathname = url.pathname;
+      const dataMatch = /^\/data\/([A-Za-z0-9_-]+)\.json$/.exec(pathname);
+      if (dataMatch) {
+        const body2 = options.jsonStore.get(dataMatch[1]);
+        if (!body2) {
+          res.statusCode = 404;
+          res.end("not found");
+          return;
+        }
+        res.setHeader("Content-Type", "application/json; charset=utf-8");
+        res.setHeader("Cache-Control", "no-store");
+        res.end(body2);
+        return;
+      }
+      if (pathname === "/") pathname = "/index.html";
+      if (pathname !== "/index.html" && pathname.endsWith("/")) {
+        pathname = pathname.slice(0, -1);
+      }
+      const safePath = normalize(join6(root, pathname));
+      if (!safePath.startsWith(root + sep) && safePath !== root) {
+        res.statusCode = 400;
+        res.end("bad request");
+        return;
+      }
+      let filePath = safePath;
+      const sibling = filePath + ".html";
+      if (existsSync2(filePath) && statSync(filePath).isFile()) {
+      } else if (existsSync2(sibling) && statSync(sibling).isFile()) {
+        filePath = sibling;
+      } else if (existsSync2(filePath) && statSync(filePath).isDirectory()) {
+        filePath = join6(filePath, "index.html");
+      }
+      let realFilePath;
+      try {
+        realFilePath = realpathSync(filePath);
+      } catch {
+        res.statusCode = 404;
+        res.end("not found");
+        return;
+      }
+      if (!realFilePath.startsWith(root + sep) && realFilePath !== root) {
+        res.statusCode = 400;
+        res.end("bad request");
+        return;
+      }
+      if (!existsSync2(realFilePath) || !statSync(realFilePath).isFile()) {
+        res.statusCode = 404;
+        res.end("not found");
+        return;
+      }
+      const ext = extname(realFilePath).toLowerCase();
+      const mime = MIME[ext] || "application/octet-stream";
+      const body = await readFile(realFilePath);
+      if (pathname.startsWith("/_next/static/")) {
+        res.setHeader("Cache-Control", "public, max-age=31536000, immutable");
+      } else {
+        res.setHeader("Cache-Control", "no-cache");
+      }
+      res.setHeader("Content-Type", mime);
+      res.setHeader("Content-Length", String(body.length));
+      res.end(body);
+    } catch (err) {
+      console.error("[dashboard] server error:", err);
+      res.statusCode = 500;
+      res.end("internal error");
+    }
+  });
+  await new Promise((resolveFn, rejectFn) => {
+    const onError = (err) => rejectFn(err);
+    server.once("error", onError);
+    server.listen(port, "127.0.0.1", () => {
+      server.removeListener("error", onError);
+      resolveFn();
+    });
+  });
+  return {
+    server,
+    port,
+    async close() {
+      await Promise.race([
+        new Promise(
+          (resolveFn, rejectFn) => server.close((err) => err ? rejectFn(err) : resolveFn())
+        ),
+        new Promise((resolveFn) => {
+          const t = setTimeout(resolveFn, 2e3);
+          t.unref();
+        })
+      ]);
+    }
+  };
+}
+
+// src/commands/dashboard.ts
+async function runDashboard(args, config) {
+  void config;
+  const families = getSelectedModelFamilies(args);
+  const scopeLabel = formatModelFamilyLabel(families);
+  const cacheOptions = getUsageCacheOptions(args);
+  const codexOnly = args.codex;
+  const combined = args.combined;
+  const [usage, activity, data] = await Promise.all([
+    loadUsageStats({
+      aggregation: "daily",
+      codexOnly,
+      combined,
+      families,
+      scopeLabel,
+      ...cacheOptions
+    }),
+    loadActivityStats({ codexOnly, combined, families, scopeLabel, ...cacheOptions }),
+    loadData({ codexOnly, combined, families, scopeLabel, ...cacheOptions })
+  ]);
+  validateData(data, { codexOnly, combined, families, scopeLabel, ...cacheOptions });
+  let wrapped = null;
+  if (combined) {
+    const c = data.claude ? computeWrappedStats(data.claude) : null;
+    const x = data.codex ? computeCodexWrappedStats(data.codex) : null;
+    wrapped = combineWrappedStats(c, x);
+  } else if (codexOnly) {
+    wrapped = data.codex ? computeCodexWrappedStats(data.codex) : null;
+  } else {
+    wrapped = data.claude ? computeWrappedStats(data.claude) : null;
+  }
+  const activityPayload = activity ? buildActivityArtifact(activity, "tokens", 365).payload : null;
+  const { hubParams, jsonStore } = buildDashboardPayloads({
+    usage: usage ?? null,
+    wrapped,
+    activity: activityPayload
+  });
+  const assetsDir = resolveDashboardAssets(import.meta.url);
+  const server = await startDashboardServer({ assetsDir, jsonStore });
+  const url = `http://127.0.0.1:${server.port}/dashboard/?${hubParams.toString()}`;
+  const orange = "\x1B[38;5;208m";
+  const reset = "\x1B[0m";
+  console.log(`${orange}vibestats dashboard${reset} \u2192 ${url}`);
+  console.log("Press Ctrl+C to stop.");
+  openInBrowser(url);
+  await new Promise((resolveFn) => {
+    const shutdown = async () => {
+      await server.close();
+      resolveFn();
+    };
+    process.once("SIGINT", shutdown);
+    process.once("SIGTERM", shutdown);
+  });
+}
+
 // src/cli-intent.ts
 var COMMANDS = /* @__PURE__ */ new Set(["usage", "limits", "limit", "pace"]);
 var SCOPES = /* @__PURE__ */ new Set(["claude", "codex", "all", "combined"]);
@@ -3856,8 +4209,8 @@ function applyCliIntent(args, intent) {
 // src/limits/claude.ts
 import { execFile as execFile2 } from "child_process";
 import { randomUUID } from "crypto";
-import { dirname as dirname2 } from "path";
-import { fileURLToPath } from "url";
+import { dirname as dirname3 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/limits/pace.ts
 var PACE_EPSILON_PERCENT = 1;
@@ -4207,7 +4560,7 @@ function isClaudePromptReady(text) {
   return /Claude Code v\d+\.\d+\.\d+/.test(normalized) && (normalized.includes("\u276F") || normalized.includes(">"));
 }
 function execFileCommand(command, args, options = {}) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve3, reject) => {
     execFile2(
       command,
       [...args],
@@ -4221,18 +4574,18 @@ function execFileCommand(command, args, options = {}) {
           reject(error);
           return;
         }
-        resolve({ stdout, stderr });
+        resolve3({ stdout, stderr });
       }
     );
   });
 }
 function sleep2(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 function resolveDefaultClaudeUsageCwd() {
   const envCwd = process.env.VIBESTATS_CLAUDE_USAGE_CWD ?? process.env.VIBESTATS_USAGE_CWD;
   if (envCwd?.trim()) return envCwd;
-  return dirname2(fileURLToPath(import.meta.url));
+  return dirname3(fileURLToPath2(import.meta.url));
 }
 async function captureUsageWithTmux(options) {
   const sessionName = `${TMUX_SESSION_PREFIX}-${randomUUID().replaceAll("-", "").slice(0, 16)}`;
@@ -4329,7 +4682,7 @@ async function fetchClaudeLimits(options = {}) {
 }
 
 // src/limits/codex.ts
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 function clampPercent3(value) {
   const numeric = typeof value === "number" ? value : Number(value);
   if (!Number.isFinite(numeric)) return 0;
@@ -4462,8 +4815,8 @@ var JsonRpcClient = class {
       method,
       ...params === void 0 ? {} : { params }
     };
-    const promise = new Promise((resolve, reject) => {
-      this.pending.set(id, { resolve, reject });
+    const promise = new Promise((resolve3, reject) => {
+      this.pending.set(id, { resolve: resolve3, reject });
     });
     try {
       this.child.stdin.write(`${JSON.stringify(message)}
@@ -4543,7 +4896,7 @@ function scriptArgsForCodexStatus(command) {
 async function fetchCodexStatusFallback(options = {}) {
   const command = options.command || "codex";
   const timeoutMs = options.timeoutMs ?? 8e3;
-  const child = spawn("script", scriptArgsForCodexStatus(command), {
+  const child = spawn2("script", scriptArgsForCodexStatus(command), {
     stdio: ["ignore", "pipe", "pipe"],
     env: process.env
   });
@@ -4556,19 +4909,19 @@ async function fetchCodexStatusFallback(options = {}) {
   child.stderr.on("data", (chunk) => {
     output += chunk;
   });
-  await new Promise((resolve) => {
+  await new Promise((resolve3) => {
     const timer = setTimeout(() => {
       child.kill("SIGTERM");
-      resolve();
+      resolve3();
     }, timeoutMs);
     timer.unref();
     child.on("error", () => {
       clearTimeout(timer);
-      resolve();
+      resolve3();
     });
     child.on("exit", () => {
       clearTimeout(timer);
-      resolve();
+      resolve3();
     });
   });
   const windows = parseCodexStatusText(output);
@@ -4591,7 +4944,7 @@ async function fetchCodexStatusFallback(options = {}) {
 async function fetchCodexLimits(options = {}) {
   const command = options.command || "codex";
   const timeoutMs = options.timeoutMs ?? 8e3;
-  const child = spawn(command, ["-s", "read-only", "-a", "untrusted", "app-server"], {
+  const child = spawn2(command, ["-s", "read-only", "-a", "untrusted", "app-server"], {
     stdio: ["pipe", "pipe", "pipe"],
     env: process.env
   });
@@ -4756,10 +5109,10 @@ function displayUsageLimits(limits, options = {}) {
 }
 
 // src/config.ts
-import { readFileSync, existsSync, writeFileSync } from "fs";
+import { readFileSync, existsSync as existsSync3, writeFileSync } from "fs";
 import { homedir as homedir5 } from "os";
-import { join as join5 } from "path";
-var CONFIG_PATH = join5(homedir5(), ".vibestats.json");
+import { join as join7 } from "path";
+var CONFIG_PATH = join7(homedir5(), ".vibestats.json");
 var DEFAULT_CONFIG = {
   baseUrl: "https://vibestats.wolfai.dev",
   outputFormat: "normal",
@@ -4769,7 +5122,7 @@ var DEFAULT_CONFIG = {
   hideCost: false
 };
 function loadConfig() {
-  if (!existsSync(CONFIG_PATH)) {
+  if (!existsSync3(CONFIG_PATH)) {
     return DEFAULT_CONFIG;
   }
   try {
@@ -4792,7 +5145,7 @@ function mergeConfig(defaults, user) {
   };
 }
 function initConfig() {
-  if (existsSync(CONFIG_PATH)) {
+  if (existsSync3(CONFIG_PATH)) {
     console.log(`Config file already exists at ${CONFIG_PATH}`);
     return;
   }
@@ -4822,50 +5175,6 @@ function resolveOptions(cliArgs, config) {
   };
 }
 
-// src/shared/args.ts
-var modelFamilyArgs = {
-  claude: {
-    type: "boolean",
-    description: "Show only Claude family stats across local usage sources",
-    default: false
-  },
-  kimi: {
-    type: "boolean",
-    description: "Show only Kimi family stats across local usage sources",
-    default: false
-  },
-  minimax: {
-    type: "boolean",
-    description: "Show only MiniMax family stats across local usage sources",
-    default: false
-  }
-};
-function getSelectedModelFamilies(args) {
-  const families = [];
-  if (args.claude === true) families.push("claude");
-  if (args.kimi === true) families.push("kimi");
-  if (args.minimax === true) families.push("minimax");
-  return families;
-}
-var cacheArgs = {
-  "no-cache": {
-    type: "boolean",
-    description: "Bypass the persistent local usage cache for this run",
-    default: false
-  },
-  "refresh-cache": {
-    type: "boolean",
-    description: "Rebuild the persistent local usage cache before showing stats",
-    default: false
-  }
-};
-function getUsageCacheOptions(args) {
-  return {
-    useCache: args["no-cache"] !== true,
-    refreshCache: args["refresh-cache"] === true
-  };
-}
-
 // src/index.ts
 function printCommandHelp(error) {
   console.error(`Error: ${error}`);
@@ -4874,6 +5183,9 @@ function printCommandHelp(error) {
   console.error("  vibestats limits all");
   console.error("  vibestats limits claude");
   console.error("  vibestats limits codex");
+  console.error("  vibestats claude");
+  console.error("  vibestats codex");
+  console.error("  vibestats all");
   console.error("  vibestats usage all");
   console.error("  vibestats usage --combined --daily");
   console.error("  vibestats usage codex --total");
@@ -5023,7 +5335,7 @@ async function publishArtifactWithFallback(artifact, baseUrl, fallbackUrl, prefe
 var main = defineCommand({
   meta: {
     name: "vibestats",
-    version: "1.3.14",
+    version: "1.4.1",
     description: "AI coding stats - usage tracking and annual wrapped for Claude Code & Codex"
   },
   args: {
@@ -5160,6 +5472,11 @@ var main = defineCommand({
       description: "Show current config location and values",
       default: false
     },
+    dashboard: {
+      type: "boolean",
+      description: "Open a local web dashboard with usage, activity, and wrapped views",
+      default: false
+    },
     "claude-system": {
       type: "boolean",
       description: "Inspect ~/.claude.json account and app state",
@@ -5200,6 +5517,10 @@ var main = defineCommand({
       await runLiveLimits(normalizedArgs, config);
       return;
     }
+    if (normalizedArgs.dashboard) {
+      await runDashboard(normalizedArgs, config);
+      return;
+    }
     if (normalizedArgs.activity) {
       await runActivity(normalizedArgs, config);
     } else if (normalizedArgs.wrapped) {