@vibe-cafe/vibe-usage 0.13.1 → 0.13.2

package/README.md

@@ -93,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.1",
+  "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/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',