@vibe-cafe/vibe-usage 0.13.0 → 0.13.2

package/README.md

@@ -62,6 +62,7 @@ npx @vibe-cafe/vibe-usage help --all   # Full help (plain `help` shows the short
 
 The versioned `quota` JSON contract is designed for local desktop clients. `discover` only checks ordinary app, config-directory, and executable presence signals: it does not open credentials or use the network. `fetch` invokes only products explicitly named with `--product`, and one provider failure does not prevent results for the others.
 
+- A quota result may carry a machine-readable `emptyReason` (`limitReached` / `noWindow` / `notEntitled` / `sessionWithoutPlanLimits`) alongside the human `message`; it is additive within schema v1, so clients that do not know it ignore it, and it says *why* there was no window instead of leaving the caller to parse prose. OpenCode Go sets `notEntitled` for a key without the Go subscription.
 - **Kimi Code** reads the official OAuth file from `$KIMI_CODE_HOME/credentials/kimi-code.json` (otherwise `~/.kimi-code/credentials/kimi-code.json`) and falls back to the legacy `$KIMI_SHARE_DIR` / `~/.kimi` location — the first login that exists wins. It calls `https://api.kimi.com/coding/v1/usages` and supports both the current 2.x response and the legacy quota response. When the short-lived access token is close to expiry, it uses Kimi's standard OAuth refresh flow and atomically rotates the official credential with owner-only permissions. Refreshes are serialized across Vibe Usage processes and re-check the file before writing so a concurrent Kimi CLI refresh wins safely.
 - **ZCode / GLM Coding Plan** accepts only a caller-supplied regional key: `BIGMODEL_API_KEY` calls the domestic `https://open.bigmodel.cn/api/monitor/usage/quota/limit`, while the existing `Z_AI_API_KEY` keeps using `https://api.z.ai/api/monitor/usage/quota/limit`. If both are present, the explicitly named BigModel key wins. It does not read ZCode's private OAuth state.
 - **Grok** reads at most the final 2 MiB of the official CLI's ordinary `$GROK_HOME/logs/unified.jsonl` (default `~/.grok/logs/unified.jsonl`). It accepts only the structured `billing: fetched credits config` event and projects the current utilization, period bounds, subscription tier, and event timestamp. It performs no network request, reads no credentials, and never returns or retains other log fields.
@@ -92,7 +93,7 @@ Quota results are never uploaded or added to incremental sync state. Credential-
 | pi | `~/.pi/agent/sessions/` or `$PI_CODING_AGENT_DIR/sessions/`, plus the session directory Pi itself was pointed at via `PI_CODING_AGENT_SESSION_DIR` or `sessionDir` in `~/.pi/agent/settings.json`, plus explicitly added `pi-coding-agent` roots for stores only reachable through `pi --session <file>` (fixture/relocation override: `VIBE_USAGE_PI_SESSION_DIRS`). Cache writes are included in input usage; reasoning is read from Pi's `usage.reasoning` (legacy `usage.reasoningTokens` still accepted) and split out of the inclusive output total |
 | Qwen Code | `~/.qwen/tmp/` |
 | Kimi Code | Current `<home>/sessions/wd_<slug>_<hash>/session_<id>/agents/<agent>/wire.jsonl` (`usage.record` deltas, including retry/compaction scope and cache creation; main/subagent wires form one session), with project names from `session_index.jsonl`. Every home with that layout is scanned: the CLI home (`$KIMI_CODE_HOME`, else `~/.kimi-code`) plus the Kimi Work desktop app's embedded runtime home (`<Electron userData>/kimi-desktop/daimon-share/daimon/runtime/kimi-code/home`), which the app never writes into the CLI home; legacy `~/.kimi/sessions/` is parsed alongside (`kimi migrate` never carries usage over, so both stores are always merged) |
-| MiniMax Code (mcode) | `$MCODE_HOME/v2/sqlite/runtime-state.sqlite` (default `~/.minimax/v2/sqlite/runtime-state.sqlite`; fixture override: `VIBE_USAGE_MCODE_DB`). Reads only allow-listed token ledger fields and session workspace/project paths, uses basename-only projects, folds cache writes into input, keeps cache reads and reasoning separate, and never selects raw/message JSON payloads. WAL/lock reads use a disposable snapshot; malformed or incompatible databases are skipped to preserve incremental state. |
+| MiniMax Code (mcode) | `$MCODE_HOME/v2/sqlite/runtime-state.sqlite` (default `~/.minimax/v2/sqlite/runtime-state.sqlite`; also reads the roots the CLI relocates to — `$MINIMAX_DATA_DIR` / `$MAVIS_DATA_DIR`, each `~/.minimax-<profile>`, the pre-npm `~/.minimax-code` user-data dir and the pre-rename `~/.mavis` home — and merges them, dropping rows a store only holds as a copy; fixture override: `VIBE_USAGE_MCODE_DB`). Reads only allow-listed token ledger fields and session workspace/project paths, uses basename-only projects, folds cache writes into input, keeps cache reads and reasoning separate, and never selects raw/message JSON payloads. WAL/lock reads use a disposable snapshot; malformed or incompatible databases are skipped to preserve incremental state (a broken extra store is reported as a warning instead of blanking the live one). |
 | MiMoCode | `$MIMOCODE_HOME/data/mimocode.db`, `$XDG_DATA_HOME/mimocode/mimocode.db`, or `~/.local/share/mimocode/mimocode.db` (SQLite; exact input, output, reasoning, and cache-read tokens from assistant messages; honors `MIMOCODE_DB`; cache-write tokens are included in input usage) |
 | Amp | `~/.local/share/amp/threads/`; cache-creation tokens are included in input usage |
 | Droid | `~/.factory/sessions/` |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibe-cafe/vibe-usage",
-  "version": "0.13.0",
+  "version": "0.13.2",
   "description": "Track your AI coding tool token usage and sync to vibecafe.ai",
   "type": "module",
   "scripts": {

package/src/daemon-service.js

@@ -141,9 +141,11 @@ const PRESERVED_SERVICE_ENV = [
   'KIRO_CLI_SESSIONS_DIR',
   'KIRO_SESSIONS_DIR',
   'KIRO_USER_PATH',
+  'MAVIS_DATA_DIR',
   'MCODE_HOME',
   'MIMOCODE_HOME',
   'MIMOCODE_DB',
+  'MINIMAX_DATA_DIR',
   'PI_CONFIG_DIR',
   'PI_CODING_AGENT_DIR',
   'PI_CODING_AGENT_SESSION_DIR',

package/src/parsers/mcode.js

@@ -6,7 +6,7 @@ import {
   isSqliteUnavailableError,
   sqliteUnavailableError,
 } from './sqlite.js';
-import { getMcodeDbPath } from '../tools.js';
+import { getMcodeDbPath, getMcodeDbPaths } from '../tools.js';
 
 const SOURCE = 'mcode';
 
@@ -47,7 +47,8 @@ const USAGE_SQL = `
 /**
  * Resolve the mcode runtime-state SQLite database. Mirrors the precedence used
  * by sibling tools (MiMoCode, DimAgent): explicit env var wins, then a
- * tool-specific HOME, then the default layout.
+ * tool-specific HOME (MCODE_HOME), then the mcode CLI's own relocation
+ * variables (MINIMAX_DATA_DIR / MAVIS_DATA_DIR), then the default layout.
  *
  * Defaults to `<homedir()>/.minimax/v2/sqlite/runtime-state.sqlite`, which is
  * where the mcode CLI keeps its WAL database on macOS / Linux.
@@ -56,6 +57,16 @@ export function resolveMcodeDbPath(env = process.env) {
   return getMcodeDbPath(env);
 }
 
+/**
+ * Every mcode store worth reading: the resolved default above, plus a
+ * `~/.minimax-<profile>` per active profile, the pre-npm `~/.minimax-code`
+ * and the pre-rename `~/.mavis` homes (and their profiles) when they hold a
+ * runtime-state database.
+ */
+export function resolveMcodeDbPaths(env = process.env, home) {
+  return getMcodeDbPaths(env, home);
+}
+
 /**
  * Token count (ms vs seconds). The mcode runtime writes ts as integer
  * milliseconds — confirmed against the live schema (`typeof(ts)=integer`,
@@ -89,92 +100,116 @@ function dbHasColumns(dbPath, table, columns) {
 }
 
 export async function parse() {
-  const dbPath = resolveMcodeDbPath();
-  if (!existsSync(dbPath)) return { buckets: [], sessions: [] };
-
-  // Schema guard: every allow-listed column must exist. If the mcode
-  // runtime ever renames / drops a column, fail soft (skipped) so the
-  // incremental sync keeps the last good upload state for this source.
-  let schemaOk;
-  try {
-    schemaOk =
-      dbHasColumns(dbPath, 'local_runtime_token_usage', TOKEN_COLUMNS) &&
-      dbHasColumns(dbPath, 'local_runtime_sessions', SESSION_COLUMNS);
-  } catch (err) {
-    if (isSqliteUnavailableError(err)) throw sqliteUnavailableError('mcode');
-    return { buckets: [], sessions: [], skipped: true };
-  }
-  if (!schemaOk) {
-    return { buckets: [], sessions: [], skipped: true };
-  }
-
-  // Read tokens and session project metadata from one statement/snapshot.
-  let usageRows;
-  try {
-    usageRows = queryDbJsonSnapshotOnLock(dbPath, USAGE_SQL, {
-      tempPrefix: 'vibe-usage-mcode',
-    });
-  } catch (err) {
-    if (isSqliteUnavailableError(err)) throw sqliteUnavailableError('mcode');
-    return { buckets: [], sessions: [], skipped: true };
-  }
+  const dbPaths = getMcodeDbPaths();
+  // The first store that exists is the one the running CLI would use; schema
+  // or read failures there keep the fail-soft contract below. Later stores are
+  // best-effort extras (profiles, pre-npm / pre-rename homes) and a broken one
+  // must not suppress the live store.
+  const primary = dbPaths.find(path => existsSync(path));
 
   const entries = [];
+  const warnings = [];
+  // mcode's own migration can COPY a relocated legacy tree into ~/.minimax, so
+  // both copies exist. Collapse rows that reappear unchanged in a later store;
+  // duplicates inside one store are left alone — there they are the ledger.
+  const seenAcrossStores = new Set();
+
+  for (const dbPath of dbPaths) {
+    if (!existsSync(dbPath)) continue;
+    const isPrimary = dbPath === primary;
+
+    // Schema guard: every allow-listed column must exist. If the mcode
+    // runtime ever renames / drops a column, fail soft (skipped) so the
+    // incremental sync keeps the last good upload state for this source.
+    let schemaOk;
+    try {
+      schemaOk =
+        dbHasColumns(dbPath, 'local_runtime_token_usage', TOKEN_COLUMNS) &&
+        dbHasColumns(dbPath, 'local_runtime_sessions', SESSION_COLUMNS);
+    } catch (err) {
+      if (isSqliteUnavailableError(err)) throw sqliteUnavailableError('mcode');
+      schemaOk = false;
+    }
+    if (!schemaOk) {
+      if (isPrimary) return { buckets: [], sessions: [], skipped: true };
+      warnings.push(`MiniMax Code: 跳过结构不兼容的数据库 ${dbPath}`);
+      continue;
+    }
 
-  for (const row of usageRows) {
-    const sessionId = row.session_id != null ? String(row.session_id) : '';
-    if (!sessionId) continue;
-    const ts = tsToDate(row.ts);
-    if (!ts) continue;
-
-    // MCode stores output and reasoning as separate counters. Its own
-    // summary code computes total = input + output + reasoning, so do not
-    // subtract reasoning from output here.
-    const inputRaw = toNonNegative(row.input_tokens);
-    const cacheWrite = toNonNegative(row.cache_write_tokens);
-    const outputRaw = toNonNegative(row.output_tokens);
-    const reasoningRaw = toNonNegative(row.reasoning_tokens);
-    const cacheRead = toNonNegative(row.cache_read_tokens);
-
-    const inputTokens = inputRaw + cacheWrite;
-    const reasoningOutputTokens = reasoningRaw;
-    const outputTokens = outputRaw;
-    const cachedInputTokens = cacheRead;
-
-    if (
-      inputTokens +
-        outputTokens +
-        cachedInputTokens +
-        reasoningOutputTokens ===
-      0
-    ) {
+    // Read tokens and session project metadata from one statement/snapshot.
+    let usageRows;
+    try {
+      usageRows = queryDbJsonSnapshotOnLock(dbPath, USAGE_SQL, {
+        tempPrefix: 'vibe-usage-mcode',
+      });
+    } catch (err) {
+      if (isSqliteUnavailableError(err)) throw sqliteUnavailableError('mcode');
+      if (isPrimary) return { buckets: [], sessions: [], skipped: true };
+      warnings.push(`MiniMax Code: 无法读取 ${dbPath}，已跳过: ${err.message}`);
       continue;
     }
 
-    const projectPath = row.project_workspace_dir || row.workspace_dir;
-    const project = projectPath ? projectFromPath(String(projectPath)) : 'unknown';
-    const model = row.model != null && String(row.model).trim()
-      ? String(row.model).trim()
-      : 'unknown';
-
-    entries.push({
-      source: SOURCE,
-      model,
-      project,
-      timestamp: ts,
-      inputTokens,
-      outputTokens,
-      cachedInputTokens,
-      reasoningOutputTokens,
-    });
+    const identitiesInStore = new Set();
+    for (const row of usageRows) {
+      // Identity covers every selected column; only a byte-identical ledger
+      // row can collapse, and only against an earlier store.
+      const identity = JSON.stringify(row);
+      if (seenAcrossStores.has(identity)) continue;
+      identitiesInStore.add(identity);
+
+      const sessionId = row.session_id != null ? String(row.session_id) : '';
+      if (!sessionId) continue;
+      const ts = tsToDate(row.ts);
+      if (!ts) continue;
+
+      // MCode stores output and reasoning as separate counters. Its own
+      // summary code computes total = input + output + reasoning, so do not
+      // subtract reasoning from output here.
+      const inputRaw = toNonNegative(row.input_tokens);
+      const cacheWrite = toNonNegative(row.cache_write_tokens);
+      const outputRaw = toNonNegative(row.output_tokens);
+      const reasoningRaw = toNonNegative(row.reasoning_tokens);
+      const cacheRead = toNonNegative(row.cache_read_tokens);
+
+      const inputTokens = inputRaw + cacheWrite;
+      const reasoningOutputTokens = reasoningRaw;
+      const outputTokens = outputRaw;
+      const cachedInputTokens = cacheRead;
+
+      if (
+        inputTokens +
+          outputTokens +
+          cachedInputTokens +
+          reasoningOutputTokens ===
+        0
+      ) {
+        continue;
+      }
+
+      const projectPath = row.project_workspace_dir || row.workspace_dir;
+      const project = projectPath ? projectFromPath(String(projectPath)) : 'unknown';
+      const model = row.model != null && String(row.model).trim()
+        ? String(row.model).trim()
+        : 'unknown';
+
+      entries.push({
+        source: SOURCE,
+        model,
+        project,
+        timestamp: ts,
+        inputTokens,
+        outputTokens,
+        cachedInputTokens,
+        reasoningOutputTokens,
+      });
+    }
+    for (const identity of identitiesInStore) seenAcrossStores.add(identity);
   }
 
   return {
     buckets: aggregateToBuckets(entries),
-    // The token ledger contains assistant usage rows only. Reconstructing
-    // user prompts would require reading message payloads, which this parser
-    // deliberately never selects, so mcode emits buckets only like Alma.
     sessions: [],
+    ...(warnings.length > 0 ? { warnings } : {}),
   };
 }
 

package/src/quotas/providers/opencode-go.js

@@ -184,10 +184,13 @@ export async function fetchOpenCodeGoQuota({
       }), token);
     }
     if (response.status === 403) {
-      // A valid OpenCode key without an active Go subscription.
+      // A valid OpenCode key without an active Go subscription. The reason
+      // travels machine-readably so a client can say "not subscribed" instead
+      // of showing a neutral empty state.
       return attachCacheScope(quotaResult({
         id: PRODUCT_ID,
         status: 'no_data',
+        emptyReason: 'notEntitled',
         message: 'OpenCode Go subscription is not active',
         fetchedAt: now,
       }), token);

package/src/quotas/schema.js

@@ -15,6 +15,19 @@ export const FETCHABLE_QUOTA_PRODUCT_IDS = Object.freeze([
   'opencode-go',
 ]);
 
+/**
+ * Machine-readable "why there was no window" values, shared with the desktop
+ * clients' `EmptyReason` (macOS `RateLimit.swift`) and additive within schema
+ * v1: a client that does not know the field ignores it, and a client that does
+ * can render the reason instead of a neutral empty state.
+ */
+export const QUOTA_EMPTY_REASONS = Object.freeze([
+  'limitReached',
+  'noWindow',
+  'notEntitled',
+  'sessionWithoutPlanLimits',
+]);
+
 const FETCH_STATUSES = new Set([
   'ok',
   'no_data',
@@ -129,6 +142,7 @@ export function quotaResult({
   dataAsOf = fetchedAt,
   message,
   source = 'live',
+  emptyReason,
 }) {
   if (!FETCHABLE_QUOTA_PRODUCT_IDS.includes(id)) {
     throw new TypeError(`unsupported quota product: ${id}`);
@@ -147,6 +161,12 @@ export function quotaResult({
   if (normalizedDataAsOf) result.dataAsOf = normalizedDataAsOf;
   if (typeof planLabel === 'string' && planLabel.trim()) result.planLabel = planLabel.trim();
   if (typeof message === 'string' && message.trim()) result.message = message.trim();
+  if (emptyReason !== undefined && emptyReason !== null) {
+    if (!QUOTA_EMPTY_REASONS.includes(emptyReason)) {
+      throw new TypeError(`invalid quota emptyReason: ${emptyReason}`);
+    }
+    result.emptyReason = emptyReason;
+  }
   return result;
 }
 

package/src/tools.js

@@ -1,4 +1,4 @@
-import { existsSync, readdirSync, statSync } from 'node:fs';
+import { existsSync, readdirSync, realpathSync, statSync } from 'node:fs';
 import { delimiter, dirname, isAbsolute, join, posix, resolve, win32 } from 'node:path';
 import { homedir } from 'node:os';
 import { getOpenCodeStores } from './opencode-roots.js';
@@ -176,15 +176,75 @@ export function findDshDataDirs() {
   return [getDshSessionsDir()].filter(existsSync);
 }
 
-/** mcode runtime database: VIBE_USAGE_MCODE_DB wins, then MCODE_HOME, then ~/.minimax. */
+const MCODE_DB_RELATIVE = join('v2', 'sqlite', 'runtime-state.sqlite');
+
+// Data-root variables the mcode CLI itself resolves, in its own precedence.
+// MCODE_HOME stays first as vibe-usage's pre-existing fixture override, then
+// the two public relocation variables from the mcode README.
+const MCODE_ROOT_ENV = ['MCODE_HOME', 'MINIMAX_DATA_DIR', 'MAVIS_DATA_DIR'];
+
+function mcodeRootFromEnv(env) {
+  for (const key of MCODE_ROOT_ENV) {
+    const value = env[key]?.trim();
+    if (!value) continue;
+    if (!isAbsolute(value)) {
+      throw new Error(`${key} must be an absolute path, got: ${JSON.stringify(value)}`);
+    }
+    return value;
+  }
+  return null;
+}
+
+/** mcode runtime database: VIBE_USAGE_MCODE_DB wins, then MCODE_HOME / MINIMAX_DATA_DIR / MAVIS_DATA_DIR, then ~/.minimax. */
 export function getMcodeDbPath(env = process.env, home = homedir()) {
   const override = env.VIBE_USAGE_MCODE_DB?.trim();
   if (override) return isAbsolute(override) ? override : resolve(override);
-  if (env.MCODE_HOME && !isAbsolute(env.MCODE_HOME)) {
-    throw new Error(`MCODE_HOME must be an absolute path, got: ${JSON.stringify(env.MCODE_HOME)}`);
+  const root = mcodeRootFromEnv(env) || join(home, '.minimax');
+  return join(root, MCODE_DB_RELATIVE);
+}
+
+/**
+ * Every mcode runtime database worth parsing.
+ *
+ * The mcode CLI relocates its whole data root with MINIMAX_DATA_DIR /
+ * MAVIS_DATA_DIR, scopes it to ~/.minimax-<profile> when a profile is active,
+ * and earlier source builds kept user data at ~/.minimax-code; the pre-rename
+ * home (~/.mavis) stays readable through the CLI's own compat link. Reading
+ * only ~/.minimax silently misses every session written in those layouts.
+ *
+ * Explicit roots keep returning their single unresolved path so a missing
+ * file still yields an empty result; the default layout only returns stores
+ * that exist, deduplicated by physical file so a compat symlink cannot make
+ * the same ledger count twice.
+ */
+export function getMcodeDbPaths(env = process.env, home = homedir()) {
+  if (env.VIBE_USAGE_MCODE_DB?.trim() || mcodeRootFromEnv(env)) return [getMcodeDbPath(env, home)];
+  const candidates = [
+    join(home, '.minimax'),
+    join(home, '.minimax-code'),
+    join(home, '.mavis'),
+  ];
+  try {
+    const profiles = readdirSync(home, { withFileTypes: true })
+      .filter(entry => entry.isDirectory() && /^\.(?:minimax|mavis)-.+$/.test(entry.name))
+      .map(entry => join(home, entry.name))
+      .sort();
+    candidates.push(...profiles);
+  } catch {
+    // Unreadable home directory: fall back to the default layout below.
+  }
+  const paths = [];
+  const seen = new Set();
+  for (const dir of candidates) {
+    const dbPath = join(dir, MCODE_DB_RELATIVE);
+    if (!existsSync(dbPath)) continue;
+    let identity = dbPath;
+    try { identity = realpathSync(dbPath); } catch { /* keep the literal path */ }
+    if (seen.has(identity)) continue;
+    seen.add(identity);
+    paths.push(dbPath);
   }
-  const root = env.MCODE_HOME || join(home, '.minimax');
-  return join(root, 'v2', 'sqlite', 'runtime-state.sqlite');
+  return paths;
 }
 
 // Devin (CLI and Desktop share one agent backend) keeps all sessions in a
@@ -417,7 +477,7 @@ export const TOOLS = [
     name: 'MiniMax Code',
     id: 'mcode',
     dataDir: join(homedir(), '.minimax', 'v2', 'sqlite', 'runtime-state.sqlite'),
-    detectDataDirs: () => [getMcodeDbPath()].filter(existsSync),
+    detectDataDirs: () => getMcodeDbPaths().filter(existsSync),
   },
   {
     name: 'MiMoCode',