@vibe-cafe/vibe-usage 0.10.4 → 0.10.6

package/README.md

@@ -31,6 +31,7 @@ npx @vibe-cafe/vibe-usage              # Init (first run, browser login) or sync
 npx @vibe-cafe/vibe-usage init         # Re-run setup via browser login
 npx @vibe-cafe/vibe-usage init --manual-key <vbu_...>   # Skip browser, use pre-issued key (CI/headless)
 npx @vibe-cafe/vibe-usage sync         # Manual sync
+npx @vibe-cafe/vibe-usage sync --extra-codex-home /path/to/.codex  # Add another Codex Home for this run only
 npx @vibe-cafe/vibe-usage summary       # Print last 7 days as markdown (cost / tokens / by model / by project)
 npx @vibe-cafe/vibe-usage summary --days N  # Same, over the last N days (1-90)
 npx @vibe-cafe/vibe-usage daemon       # Continuous sync (every 30m, foreground)
@@ -50,17 +51,19 @@ npx @vibe-cafe/vibe-usage status       # Show config & detected tools
 
 | Tool | Data Location |
 |------|---------------|
-| Claude Code | `~/.claude/projects/` (tokens + sessions), `~/.claude/transcripts/` (sessions only); also scans `$CLAUDE_CONFIG_DIR` and data-bearing `~/.claude-*` profiles, selects the most complete duplicate session, and streams logs so large active sessions are not silently omitted. Cache creation tokens are included in input usage. |
-| Codex CLI | `$CODEX_HOME/sessions/` and `$CODEX_HOME/archived_sessions/` (default `~/.codex`); a versioned local index avoids re-reading unchanged rollouts and reads only safe append tails for ordinary sessions, while fork/sub-agent replay matching, duplicate suppression, and live/archive deduplication retain their existing semantics |
+| Claude Code + Claude Desktop Code/Cowork | Claude Code data in `~/.claude/projects/` (tokens + sessions) and `~/.claude/transcripts/` (sessions only), plus Claude Desktop Cowork's per-session `.claude/projects/` directories. Also scans `$CLAUDE_CONFIG_DIR` and data-bearing `~/.claude-*` profiles. All variants use the existing `claude-code` source; the parser selects the most complete copy of each session so shared/copied transcripts are not counted twice. Logs are streamed and cache creation tokens are included in input usage. |
+| Codex CLI | `$CODEX_HOME/sessions/` and `$CODEX_HOME/archived_sessions/` (default `~/.codex`), plus an optional temporary `--extra-codex-home` or manually persisted `codexExtraHome`; a versioned local index avoids re-reading unchanged rollouts and reads only safe append tails for ordinary sessions, while fork/sub-agent replay matching, duplicate suppression, and live/archive/cross-root deduplication retain their existing semantics |
 | Grok | `$GROK_HOME/sessions/<encoded-cwd>/<session-id>/` (default `~/.grok`); token usage from `updates.jsonl` `turn_completed.usage` (per-model `modelUsage`, cache reads, reasoning); project from `summary.json` cwd; honors `GROK_HOME` |
 | GitHub Copilot CLI | `~/.copilot/session-state/*/events.jsonl` |
 | Cursor | `state.vscdb` (SQLite, reads `cursorAuth/accessToken`, fetches CSV from `cursor.com`); cloud data is stamped with a fixed `cursor-cloud` hostname so multi-machine setups don't double-count |
+| DimAgent | `$DIMCODE_HOME/dimcode.sqlite` (default `~/.dimcode/v2/dimcode.sqlite`); exact usage from `usage_ledger`, with forked ledger/history copies deduplicated |
 | Gemini CLI | `~/.gemini/tmp/<project_hash>/chats/session-*.jsonl` (current line-delimited format) and legacy `session-*.json`; recurses into nested subagent sessions |
 | OpenCode | `~/.local/share/opencode/opencode.db` (SQLite, `json_extract` query) |
 | OpenClaw | `~/.openclaw/agents/`, `~/.openclaw-<profile>/agents/` (profile deployments) |
 | pi | `~/.pi/agent/sessions/` |
 | Qwen Code | `~/.qwen/tmp/` |
 | Kimi Code | Current `~/.kimi-code/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), data root resolved via `$KIMI_CODE_HOME` like the CLI itself, with project names from `session_index.jsonl`; legacy `~/.kimi/sessions/` is parsed alongside (`kimi migrate` never carries usage over, so both stores are always merged) |
+| 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/` |
 | Droid | `~/.factory/sessions/` |
 | Hermes | `~/.hermes/state.db` + `~/.hermes/profiles/<name>/state.db` (SQLite, multi-profile) |
@@ -147,6 +150,7 @@ Config stored at `~/.vibe-usage/config.json` (dev: `config.dev.json`).
 | `apiKey` | Your API key (starts with `vbu_`) |
 | `apiUrl` | Server URL (default: `https://vibecafe.ai`) |
 | `hostname` | Stable device name for usage tracking (set at init, reused across syncs) |
+| `codexExtraHome` | Optional additional Codex Home scanned together with `$CODEX_HOME` / `~/.codex` |
 
 The `hostname` is captured once during `init` and reused for all future syncs. This prevents macOS mDNS hostname changes (e.g., `MacBook-Pro` → `MacBook-Pro-2`) from creating duplicate device entries. To change it manually:
 

package/package.json

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

package/src/claude-roots.js

@@ -2,6 +2,9 @@ import { existsSync, readdirSync, realpathSync, statSync } from 'node:fs';
 import { delimiter, join } from 'node:path';
 import { homedir } from 'node:os';
 
+const MAX_DESKTOP_DISCOVERY_DEPTH = 8;
+const DESKTOP_NON_SESSION_DIRS = new Set(['rpm', 'skills']);
+
 function expandHome(value) {
   const trimmed = value.trim().replace(/[/\\]+$/, '');
   if (trimmed === '~') return homedir();
@@ -15,18 +18,95 @@ function hasClaudeData(root) {
   return existsSync(join(root, 'projects')) || existsSync(join(root, 'transcripts'));
 }
 
+function defaultClaudeDesktopDataDir() {
+  if (process.platform === 'darwin') {
+    return join(homedir(), 'Library', 'Application Support', 'Claude');
+  }
+  if (process.platform === 'win32') {
+    const appData = process.env.APPDATA?.trim();
+    return appData
+      ? join(expandHome(appData), 'Claude')
+      : join(homedir(), 'AppData', 'Roaming', 'Claude');
+  }
+  const configHome = process.env.XDG_CONFIG_HOME?.trim();
+  return join(configHome ? expandHome(configHome) : join(homedir(), '.config'), 'Claude');
+}
+
+function getClaudeDesktopDataDirs() {
+  const override = process.env.VIBE_USAGE_CLAUDE_DESKTOP_DIRS?.trim();
+  return override
+    ? override.split(delimiter).map(expandHome).filter(Boolean)
+    : [defaultClaudeDesktopDataDir()];
+}
+
+function discoverDesktopRoots(dir, depth, roots, onWarning) {
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch (err) {
+    if (err?.code !== 'ENOENT') {
+      onWarning(`Claude Desktop: cannot read directory ${dir}: ${err.message}`);
+    }
+    return;
+  }
+
+  // Once a session root is found, do not descend into the user's Cowork files.
+  // Those directories can be large and are unrelated to Claude's transcript.
+  const claudeEntry = entries.find(
+    (entry) => entry.name === '.claude' && entry.isDirectory(),
+  );
+  if (claudeEntry) {
+    roots.push(join(dir, claudeEntry.name));
+    return;
+  }
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (DESKTOP_NON_SESSION_DIRS.has(entry.name)) continue;
+    const candidate = join(dir, entry.name);
+    if (depth < MAX_DESKTOP_DISCOVERY_DEPTH) {
+      discoverDesktopRoots(candidate, depth + 1, roots, onWarning);
+    }
+  }
+}
+
+/**
+ * Find the private Claude Code state roots created for Claude Desktop Cowork.
+ * Desktop Code itself uses the normal ~/.claude root, while Cowork isolates
+ * each local-agent session below the Electron user-data directory.
+ */
+export function findClaudeDesktopRoots(
+  desktopDataDirs = getClaudeDesktopDataDirs(),
+  onWarning = () => {},
+) {
+  const roots = [];
+  for (const dataDir of desktopDataDirs) {
+    discoverDesktopRoots(
+      join(dataDir, 'local-agent-mode-sessions'),
+      0,
+      roots,
+      onWarning,
+    );
+  }
+  return roots;
+}
+
 /**
- * Return every Claude Code state root visible from this process.
+ * Return every Claude Code-compatible state root visible from this process.
  *
  * In addition to the default and CLAUDE_CONFIG_DIR, discover the documented
  * multi-profile convention (~/.claude-work, ~/.claude-personal, ...). This is
  * important for launchd/systemd and GUI processes, which commonly do not
  * inherit the shell environment used to launch Claude Code.
  *
- * VIBE_USAGE_CLAUDE_DIRS is a test/diagnostic override. It replaces discovery
- * with a path.delimiter-separated root list.
+ * Claude Desktop Code uses the default Claude Code root. Cowork creates a
+ * private .claude root per local-agent session, so those roots are discovered
+ * recursively under the app's user-data directory.
+ *
+ * VIBE_USAGE_CLAUDE_DIRS is a test/diagnostic override. It replaces all normal
+ * and Desktop discovery with a path.delimiter-separated root list.
  */
-export function getClaudeRoots() {
+export function getClaudeRoots({ onWarning = () => {} } = {}) {
   const override = process.env.VIBE_USAGE_CLAUDE_DIRS?.trim();
   const roots = override
     ? override.split(delimiter).map(expandHome).filter(Boolean)
@@ -47,6 +127,8 @@ export function getClaudeRoots() {
     } catch {
       // The default/configured roots remain usable if home discovery fails.
     }
+
+    roots.push(...findClaudeDesktopRoots(getClaudeDesktopDataDirs(), onWarning));
   }
 
   const seen = new Set();

package/src/codex-roots.js

@@ -0,0 +1,46 @@
+import { statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+
+function normalizeHomePath(value) {
+  const trimmed = value.trim();
+  if (trimmed === '~') return homedir();
+  if (trimmed.startsWith('~/') || trimmed.startsWith('~\\')) {
+    return resolve(homedir(), trimmed.slice(2));
+  }
+  return resolve(trimmed);
+}
+
+export function primaryCodexHome() {
+  const configured = process.env.CODEX_HOME?.trim();
+  return configured ? normalizeHomePath(configured) : join(homedir(), '.codex');
+}
+
+export function resolveCodexHomes(extraCodexHome) {
+  const roots = [primaryCodexHome()];
+  if (extraCodexHome?.trim()) roots.push(normalizeHomePath(extraCodexHome));
+  return [...new Set(roots)];
+}
+
+export function codexSessionDirs(codexHome) {
+  return [
+    join(codexHome, 'sessions'),
+    join(codexHome, 'archived_sessions'),
+  ];
+}
+
+function isDirectory(path) {
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+export function validateExtraCodexHome(value) {
+  const path = normalizeHomePath(value);
+  return {
+    ok: isDirectory(path) && codexSessionDirs(path).some(isDirectory),
+    path,
+  };
+}

package/src/daemon-service.js

@@ -56,10 +56,25 @@ function escapeXml(value) {
     .replace(/'/g, ''');
 }
 
-export function generateSystemdUnit(nodePath, binPath, claudeConfigDir = process.env.CLAUDE_CONFIG_DIR?.trim()) {
-  const claudeEnvironment = claudeConfigDir
-    ? `Environment="CLAUDE_CONFIG_DIR=${escapeSystemdEnvironment(claudeConfigDir)}"\n`
-    : '';
+const PRESERVED_SERVICE_ENV = ['MIMOCODE_HOME', 'MIMOCODE_DB', 'XDG_DATA_HOME'];
+
+function serviceEnvironment(claudeConfigDir, env) {
+  const values = {
+    CLAUDE_CONFIG_DIR: claudeConfigDir,
+    ...Object.fromEntries(PRESERVED_SERVICE_ENV.map(key => [key, env[key]?.trim()])),
+  };
+  return Object.entries(values).filter(([, value]) => value);
+}
+
+export function generateSystemdUnit(
+  nodePath,
+  binPath,
+  claudeConfigDir = process.env.CLAUDE_CONFIG_DIR?.trim(),
+  env = process.env,
+) {
+  const environment = serviceEnvironment(claudeConfigDir, env)
+    .map(([key, value]) => `Environment="${key}=${escapeSystemdEnvironment(value)}"\n`)
+    .join('');
   return `[Unit]
 Description=VibeCafe Usage Tracker
 After=network.target
@@ -70,18 +85,23 @@ ExecStart=${nodePath} ${binPath} daemon
 Restart=on-failure
 RestartSec=10
 Environment=NODE_ENV=production
-${claudeEnvironment}WorkingDirectory=${homedir()}
+${environment}WorkingDirectory=${homedir()}
 
 [Install]
 WantedBy=default.target
 `;
 }
 
-export function generateLaunchdPlist(nodePath, binPath, claudeConfigDir = process.env.CLAUDE_CONFIG_DIR?.trim()) {
+export function generateLaunchdPlist(
+  nodePath,
+  binPath,
+  claudeConfigDir = process.env.CLAUDE_CONFIG_DIR?.trim(),
+  env = process.env,
+) {
   const logDir = join(homedir(), '.vibe-usage');
-  const claudeEnvironment = claudeConfigDir
-    ? `        <key>CLAUDE_CONFIG_DIR</key>\n        <string>${escapeXml(claudeConfigDir)}</string>\n`
-    : '';
+  const environment = serviceEnvironment(claudeConfigDir, env)
+    .map(([key, value]) => `        <key>${key}</key>\n        <string>${escapeXml(value)}</string>\n`)
+    .join('');
   return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
@@ -108,7 +128,7 @@ export function generateLaunchdPlist(nodePath, binPath, claudeConfigDir = proces
     <dict>
         <key>NODE_ENV</key>
         <string>production</string>
-${claudeEnvironment}    </dict>
+${environment}    </dict>
 </dict>
 </plist>
 `;

package/src/daemon.js

@@ -13,7 +13,7 @@ function sleep(ms) {
   return new Promise(resolve => setTimeout(resolve, ms));
 }
 
-export async function runDaemon() {
+export async function runDaemon({ codexExtraHome } = {}) {
   const config = loadConfig();
   if (!config?.apiKey) {
     console.error(failure('尚未配置，请先运行 `npx @vibe-cafe/vibe-usage init`。'));
@@ -34,7 +34,7 @@ export async function runDaemon() {
   // eslint-disable-next-line no-constant-condition
   while (true) {
     try {
-      await runSync({ throws: true, quiet: true, surface: 'daemon' });
+      await runSync({ throws: true, quiet: true, surface: 'daemon', codexExtraHome });
       consecutiveAuthFailures = 0;
     } catch (err) {
       if (err.message === 'UNAUTHORIZED') {

package/src/index.js

@@ -1,7 +1,8 @@
 import { loadConfig, saveConfig, getConfigPath } from './config.js';
 import { detectInstalledTools, TOOLS } from './tools.js';
 import { existsSync } from 'node:fs';
-import { smallHeader } from './output.js';
+import { validateExtraCodexHome } from './codex-roots.js';
+import { failure, smallHeader } from './output.js';
 
 function printSmallHeader() {
   console.log();
@@ -20,10 +21,14 @@ async function showStatus() {
     console.log(`  Config: ${getConfigPath()}`);
     console.log(`  API key: ${config.apiKey.slice(0, 8)}...`);
     console.log(`  API URL: ${config.apiUrl || 'https://vibecafe.ai'}`);
+    if (config.codexExtraHome) {
+      console.log(`  Extra Codex Home: ${config.codexExtraHome}`);
+    }
   }
 
   console.log('\n  Detected tools:');
-  const detected = detectInstalledTools();
+  const toolOptions = { codexExtraHome: config?.codexExtraHome };
+  const detected = detectInstalledTools(toolOptions);
   if (detected.length === 0) {
     console.log('    (none)\n');
   } else {
@@ -35,13 +40,15 @@ async function showStatus() {
 
   console.log('  All supported tools:');
   for (const tool of TOOLS) {
-    const installed = existsSync(tool.dataDir) ? 'installed' : 'not found';
+    const installed = (tool.detectDataDirs
+      ? tool.detectDataDirs(toolOptions).length > 0
+      : existsSync(tool.dataDir)) ? 'installed' : 'not found';
     console.log(`    ${tool.name}: ${installed}`);
   }
   console.log();
 }
 
-const VALID_CONFIG_KEYS = ['apiKey', 'apiUrl', 'hostname'];
+const VALID_CONFIG_KEYS = ['apiKey', 'apiUrl', 'hostname', 'codexExtraHome'];
 
 function handleConfig(args) {
   const sub = args[0];
@@ -64,7 +71,7 @@ function handleConfig(args) {
     }
     case 'set': {
       const key = args[1];
-      const value = args[2];
+      let value = args[2];
       if (!key || value === undefined) {
         console.error('Usage: vibe-usage config set <key> <value>');
         process.exit(1);
@@ -74,6 +81,14 @@ function handleConfig(args) {
         console.error(`Valid keys: ${VALID_CONFIG_KEYS.join(', ')}`);
         process.exit(1);
       }
+      if (key === 'codexExtraHome' && value !== '') {
+        const validation = validateExtraCodexHome(value);
+        if (!validation.ok) {
+          console.error(failure(`额外 Codex Home 无效，需要包含 sessions/ 或 archived_sessions/: ${validation.path}`));
+          process.exit(1);
+        }
+        value = validation.path;
+      }
       const config = loadConfig() || {};
       config[key] = value;
       saveConfig(config);
@@ -117,19 +132,30 @@ export async function run(rawArgs) {
   if (apiKey === undefined) {
     ({ args: stripped, value: apiKey } = extractOption(stripped, 'key'));
   }
+  let codexExtraHome;
+  ({ args: stripped, value: codexExtraHome } = extractOption(stripped, 'extra-codex-home'));
+  if (codexExtraHome !== undefined) {
+    const validation = validateExtraCodexHome(codexExtraHome);
+    if (!validation.ok) {
+      console.error(failure(`额外 Codex Home 无效，需要包含 sessions/ 或 archived_sessions/: ${validation.path}`));
+      process.exit(1);
+    }
+    codexExtraHome = validation.path;
+  }
+
   const args = stripped;
   const command = args[0];
 
   switch (command) {
     case 'init': {
       const { runInit } = await import('./init.js');
-      await runInit({ apiKey });
+      await runInit({ apiKey, codexExtraHome });
       break;
     }
     case 'sync': {
       printSmallHeader();
       const { runSync } = await import('./sync.js');
-      await runSync();
+      await runSync({ codexExtraHome });
       break;
     }
     case 'summary': {
@@ -149,8 +175,12 @@ export async function run(rawArgs) {
       if (sub === undefined) {
         // Foreground daemon loop — no header, just start syncing
         const { runDaemon } = await import('./daemon.js');
-        await runDaemon();
+        await runDaemon({ codexExtraHome });
       } else {
+        if (codexExtraHome !== undefined) {
+          console.error(failure('后台 daemon 不接受临时 Codex Home，请先运行 `config set codexExtraHome <path>`。'));
+          process.exit(1);
+        }
         // manageDaemon validates the subcommand and exits 1 on unknown ones —
         // a typo (e.g. `daemon stauts`) must never fall through to the
         // infinite foreground loop.
@@ -185,6 +215,7 @@ export async function run(rawArgs) {
     npx @vibe-cafe/vibe-usage init         Set up via browser login (default)
     npx @vibe-cafe/vibe-usage init --manual-key <vbu_...>   Skip browser, use a pre-issued key (CI/headless)
     npx @vibe-cafe/vibe-usage sync         Manually sync usage data
+    npx @vibe-cafe/vibe-usage sync --extra-codex-home <path>  Use another Codex Home for this run
     npx @vibe-cafe/vibe-usage summary       Print last 7 days as markdown (cost/tokens/model/project)
     npx @vibe-cafe/vibe-usage summary --days N   Same, but over the last N days (1-90)
     npx @vibe-cafe/vibe-usage daemon       Continuous sync (every 30m, foreground)
@@ -201,6 +232,7 @@ export async function run(rawArgs) {
     npx @vibe-cafe/vibe-usage config show  Show full config as JSON
     npx @vibe-cafe/vibe-usage config get <key>   Get a config value
     npx @vibe-cafe/vibe-usage config set <key> <value>  Set a config value
+    npx @vibe-cafe/vibe-usage config set codexExtraHome <path>  Persist another Codex Home
     npx @vibe-cafe/vibe-usage help         Show this help
 `);
       break;
@@ -212,12 +244,12 @@ export async function run(rawArgs) {
       if (!config?.apiKey || apiKey) {
         // First run OR user passed --key for a one-shot setup — init.js prints the big header
         const { runInit } = await import('./init.js');
-        await runInit({ apiKey });
+        await runInit({ apiKey, codexExtraHome });
       } else {
         // Already configured: small header + sync
         printSmallHeader();
         const { runSync } = await import('./sync.js');
-        await runSync();
+        await runSync({ codexExtraHome });
       }
       break;
     }

package/src/init.js

@@ -31,7 +31,7 @@ function isDaemonPlatform() {
 }
 
 export async function runInit(options = {}) {
-  const { apiKey: providedKey } = options;
+  const { apiKey: providedKey, codexExtraHome } = options;
 
   console.log(bigHeader());
 
@@ -40,7 +40,7 @@ export async function runInit(options = {}) {
     if (providedKey && existing.apiKey === providedKey) {
       console.log(dim('已配置同一个 Key，直接同步数据。'));
       console.log();
-      await runSync();
+      await runSync({ codexExtraHome });
       return;
     }
     const answer = await prompt('检测到已有配置，是否覆盖? (y/N) ');
@@ -80,10 +80,11 @@ export async function runInit(options = {}) {
     apiKey,
     apiUrl,
     hostname: host,
+    ...(existing?.codexExtraHome ? { codexExtraHome: existing.codexExtraHome } : {}),
   };
   saveConfig(config);
 
-  const tools = detectInstalledTools();
+  const tools = detectInstalledTools({ codexExtraHome: config.codexExtraHome });
   if (tools.length > 0) {
     console.log(success(`检测到 ${tools.length} 款工具: ${dim(tools.map(t => t.name).join(' · '))}`));
   } else {
@@ -94,7 +95,7 @@ export async function runInit(options = {}) {
   console.log(divider());
   console.log();
 
-  await runSync();
+  await runSync({ codexExtraHome });
 
   if (isDaemonPlatform()) {
     if (process.stdin.isTTY) {

package/src/parsers/claude-code.js

@@ -272,7 +272,9 @@ export async function parse() {
     warnings: [],
     incomplete: false,
   };
-  const roots = getClaudeRoots();
+  const roots = getClaudeRoots({
+    onWarning: (message) => addWarning(ctx, message),
+  });
   const projectGroups = collectCandidates(roots, 'projects', ctx);
   const projectSessionIds = new Set();
 

package/src/parsers/codex.js

@@ -8,10 +8,14 @@ import {
   statSync,
 } from 'node:fs';
 import { join } from 'node:path';
-import { homedir } from 'node:os';
 import { createInterface } from 'node:readline';
 import { createHash } from 'node:crypto';
 import { aggregateToBuckets } from './index.js';
+import {
+  codexSessionDirs,
+  resolveCodexHomes,
+  validateExtraCodexHome,
+} from '../codex-roots.js';
 import {
   codexCacheEnabled,
   fileSignature,
@@ -28,17 +32,6 @@ import {
 // both, index them together so fork replay-skip works across directories, and
 // select the most complete physical file when the same session briefly exists
 // in both locations during an archive move.
-function getCodexHome() {
-  return process.env.CODEX_HOME?.trim() || join(homedir(), '.codex');
-}
-
-function sessionsDirs(codexHome) {
-  return [
-    join(codexHome, 'sessions'),
-    join(codexHome, 'archived_sessions'),
-  ];
-}
-
 /**
  * Recursively find all .jsonl files under a directory.
  * Codex CLI stores sessions as: ~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl
@@ -456,10 +449,10 @@ function boundaryKey(boundary) {
   return `${boundary.rawTokenCount}:${boundary.recordIndex ?? ''}`;
 }
 
-function updateFileCache(codexHome, file, changes) {
+function updateFileCache(file, changes) {
   const data = cacheData(file.cache, changes);
   try {
-    saveCodexFileCache(codexHome, file.filePath, file.signature, data);
+    saveCodexFileCache(file.codexHome, file.filePath, file.signature, data);
   } catch {
     // A read-only home, full disk, or antivirus race must only disable the
     // optimization for this run. Raw-log parsing remains the source of truth.
@@ -803,10 +796,24 @@ function mergeFileResults(results) {
   return { buckets: aggregateToBuckets(entries), sessions };
 }
 
-export async function parse() {
-  const codexHome = getCodexHome();
-  const dirs = sessionsDirs(codexHome);
-  if (!dirs.some(existsSync)) return { buckets: [], sessions: [] };
+export async function parse({ codexExtraHome } = {}) {
+  if (codexExtraHome?.trim()) {
+    const validation = validateExtraCodexHome(codexExtraHome);
+    if (!validation.ok) {
+      return {
+        buckets: [],
+        sessions: [],
+        skipped: true,
+        warnings: [`codex: 额外 Codex Home 不可用，已跳过本次 Codex 同步: ${validation.path}`],
+      };
+    }
+  }
+
+  const codexHomes = resolveCodexHomes(codexExtraHome);
+  const dirs = codexHomes.flatMap(codexHome => (
+    codexSessionDirs(codexHome).map(dir => ({ codexHome, dir }))
+  ));
+  if (!dirs.some(({ dir }) => existsSync(dir))) return { buckets: [], sessions: [] };
 
   const startedAt = Date.now();
   const budget = workBudgetMs();
@@ -820,29 +827,32 @@ export async function parse() {
     audited: 0,
   };
   const files = [];
-  for (const filePath of dirs.flatMap(findJsonlFiles)) {
-    try {
-      const stat = statSync(filePath);
-      if (stat.size <= 0) continue;
-      const signature = fileSignature(stat);
-      const cache = loadCodexFileCache(codexHome, filePath, signature);
-      const priorCache = cache || loadCodexFileCache(codexHome, filePath);
-      const priorTail = cache ? null : loadCodexFileTail(codexHome, filePath);
-      const file = {
-        filePath,
-        snapshotSize: stat.size,
-        signature,
-        cache,
-        priorCache,
-        priorTail,
-        header: null,
-        appendTail: null,
-      };
-      if (!cache && priorCache) file.appendTail = tailStateFor(file);
-      files.push(file);
-    } catch {
-      // The file may move to archived_sessions between discovery and stat.
-      // Its archived copy will be picked up on the next sync.
+  for (const { codexHome, dir } of dirs) {
+    for (const filePath of findJsonlFiles(dir)) {
+      try {
+        const stat = statSync(filePath);
+        if (stat.size <= 0) continue;
+        const signature = fileSignature(stat);
+        const cache = loadCodexFileCache(codexHome, filePath, signature);
+        const priorCache = cache || loadCodexFileCache(codexHome, filePath);
+        const priorTail = cache ? null : loadCodexFileTail(codexHome, filePath);
+        const file = {
+          codexHome,
+          filePath,
+          snapshotSize: stat.size,
+          signature,
+          cache,
+          priorCache,
+          priorTail,
+          header: null,
+          appendTail: null,
+        };
+        if (!cache && priorCache) file.appendTail = tailStateFor(file);
+        files.push(file);
+      } catch {
+        // The file may move to archived_sessions between discovery and stat.
+        // Its archived copy will be picked up on the next sync.
+      }
     }
   }
   if (files.length === 0) return { buckets: [], sessions: [] };
@@ -875,7 +885,7 @@ export async function parse() {
       try {
         file.header = await readSessionHeader(file.filePath, file.snapshotSize);
         cacheStats.filesRead++;
-        updateFileCache(codexHome, file, { header: file.header });
+        updateFileCache(file, { header: file.header });
       } catch {
         continue;
       }
@@ -928,7 +938,7 @@ export async function parse() {
       try {
         meta = await indexSessionFile(file.filePath, file.snapshotSize);
         cacheStats.filesRead++;
-        updateFileCache(codexHome, file, { index: meta });
+        updateFileCache(file, { index: meta });
       } catch {
         continue;
       }
@@ -984,14 +994,14 @@ export async function parse() {
       const { tail, ...summary } = parsed;
       if (tail) {
         try {
-          saveCodexFileTail(codexHome, file.filePath, file.signature, tail);
+          saveCodexFileTail(file.codexHome, file.filePath, file.signature, tail);
         } catch {
           // Same fail-open rule as the summary cache: tail acceleration is
           // optional and a write failure must not fail the parser.
         }
       }
       result = { boundaryKey: key, ...summary };
-      updateFileCache(codexHome, file, { result, lastAuditedAt: Date.now() });
+      updateFileCache(file, { result, lastAuditedAt: Date.now() });
       file.appendTail = null;
       file.priorTail = null;
       if (auditPaths.has(file.filePath)) cacheStats.audited++;

package/src/parsers/dimagent.js

@@ -0,0 +1,133 @@
+import { existsSync } from 'node:fs';
+import { aggregateToBuckets, extractSessions } from './index.js';
+import { queryDbJson } from './sqlite.js';
+import { getDimAgentDbPath } from '../tools.js';
+
+const SOURCE = 'dimagent';
+const FORKED_LEDGER_ID = /^ledger_[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+function projectName(cwd) {
+  if (!cwd) return 'unknown';
+  const parts = String(cwd).replace(/[/\\]+$/, '').split(/[/\\]/);
+  return parts.at(-1) || 'unknown';
+}
+
+function tokenCount(value) {
+  const count = Number(value);
+  return Number.isFinite(count) && count > 0 ? count : 0;
+}
+
+function usageSignature(row) {
+  return [
+    row.runId || '',
+    row.providerId || '',
+    row.modelId || '',
+    row.usage || '',
+    row.cost ?? '',
+    row.createdAt || '',
+  ].join('\0');
+}
+
+function parseUsageRows(rows) {
+  const entries = [];
+  const originalSignatures = new Set(
+    rows
+      .filter(row => !FORKED_LEDGER_ID.test(row.ledgerId || ''))
+      .map(usageSignature),
+  );
+  const keptOrphanClones = new Set();
+
+  for (const row of rows) {
+    const signature = usageSignature(row);
+    if (FORKED_LEDGER_ID.test(row.ledgerId || '')) {
+      if (originalSignatures.has(signature) || keptOrphanClones.has(signature)) continue;
+      keptOrphanClones.add(signature);
+    }
+
+    let usage;
+    try {
+      usage = typeof row.usage === 'string' ? JSON.parse(row.usage) : row.usage;
+    } catch {
+      continue;
+    }
+    if (!usage || typeof usage !== 'object') continue;
+
+    const timestamp = new Date(row.createdAt);
+    if (Number.isNaN(timestamp.getTime())) continue;
+
+    const promptTokens = tokenCount(usage.promptTokens);
+    const cachedInputTokens = tokenCount(usage.cacheReadTokens);
+    const inputTokens = Math.max(0, promptTokens - cachedInputTokens);
+    const outputTokens = tokenCount(usage.completionTokens);
+    if (inputTokens + outputTokens + cachedInputTokens === 0) continue;
+
+    entries.push({
+      source: SOURCE,
+      model: row.modelId || 'unknown',
+      project: projectName(row.cwd),
+      timestamp,
+      inputTokens,
+      outputTokens,
+      cachedInputTokens,
+      reasoningOutputTokens: 0,
+    });
+  }
+
+  return entries;
+}
+
+function queryDb(dbPath, sql) {
+  try {
+    return queryDbJson(dbPath, sql);
+  } catch (err) {
+    if (err.code === 'ENOENT' || err.status === 127 || err.message?.includes('ENOENT')) {
+      throw new Error('sqlite3 CLI not found. Install sqlite3 (or use Node >= 22.5) to sync DimAgent data.');
+    }
+    throw err;
+  }
+}
+
+export async function parse() {
+  const dbPath = getDimAgentDbPath();
+  if (!existsSync(dbPath)) return { buckets: [], sessions: [] };
+
+  const usageRows = queryDb(dbPath, `SELECT
+    u.ledgerId,
+    u.runId,
+    u.providerId,
+    u.modelId,
+    u.usage,
+    u.cost,
+    u.createdAt,
+    s.cwd
+    FROM usage_ledger u
+    LEFT JOIN sessions s ON s.sessionId = u.sessionId`);
+
+  const messageRows = queryDb(dbPath, `SELECT
+    m.sessionId,
+    m.role,
+    m.createdAt,
+    s.cwd
+    FROM messages m
+    LEFT JOIN sessions s ON s.sessionId = m.sessionId
+    WHERE m.role IN ('user', 'assistant')
+      AND m.messageId NOT LIKE 'msg_fork_%'`);
+
+  const sessionEvents = [];
+  for (const row of messageRows) {
+    const timestamp = new Date(row.createdAt);
+    if (Number.isNaN(timestamp.getTime())) continue;
+    sessionEvents.push({
+      sessionId: row.sessionId,
+      source: SOURCE,
+      project: projectName(row.cwd),
+      timestamp,
+      role: row.role,
+    });
+  }
+
+  return {
+    buckets: aggregateToBuckets(parseUsageRows(usageRows)),
+    sessions: extractSessions(sessionEvents),
+  };
+}

package/src/parsers/index.js

@@ -4,6 +4,7 @@ import { parse as parseCline } from './cline.js';
 import { parse as parseCodex } from './codex.js';
 import { parse as parseCopilotCli } from './copilot-cli.js';
 import { parse as parseCursor } from './cursor.js';
+import { parse as parseDimAgent } from './dimagent.js';
 import { parse as parseRooCode } from './roo-code.js';
 import { parse as parseGeminiCli } from './gemini-cli.js';
 import { parse as parseGrok } from './grok.js';
@@ -16,6 +17,7 @@ import { parse as parseDroid } from './droid.js';
 import { parse as parseAntigravity } from './antigravity.js';
 import { parse as parseHermes } from './hermes.js';
 import { parse as parseKiro } from './kiro.js';
+import { parse as parseMimocode } from './mimocode.js';
 import { parse as parsePiCodingAgent } from './pi-coding-agent.js';
 import { parse as parseZcode } from './zcode.js';
 import { parse as parseTraeCli } from './trae-cli.js';
@@ -26,6 +28,7 @@ export const parsers = {
   'grok': parseGrok,
   'copilot-cli': parseCopilotCli,
   'cursor': parseCursor,
+  'dimagent': parseDimAgent,
   'gemini-cli': parseGeminiCli,
   'opencode': parseOpencode,
   'openclaw': parseOpenclaw,
@@ -38,6 +41,7 @@ export const parsers = {
   'trae-cli': parseTraeCli,
   'hermes': parseHermes,
   'kiro': parseKiro,
+  'mimocode': parseMimocode,
   'cline': parseCline,
   'roo-code': parseRooCode,
   'zcode': parseZcode,

package/src/parsers/mimocode.js

@@ -0,0 +1,90 @@
+import { existsSync } from 'node:fs';
+import { basename } from 'node:path';
+import { getMimocodeDbPath } from '../tools.js';
+import { aggregateToBuckets, extractSessions } from './index.js';
+import { queryDbJson } from './sqlite.js';
+
+export { getMimocodeDbPath as resolveMimocodeDbPath };
+
+export async function parse() {
+  const dbPath = getMimocodeDbPath();
+  if (!existsSync(dbPath)) return { buckets: [], sessions: [] };
+
+  let rows;
+  try {
+    const hasExternalImports = queryDbJson(dbPath, `
+      SELECT 1
+      FROM sqlite_master
+      WHERE type = 'table' AND name = 'external_import'
+      LIMIT 1
+    `).length > 0;
+    const externalImportJoin = hasExternalImports
+      ? 'LEFT JOIN external_import ON external_import.session_id = message.session_id'
+      : '';
+    const externalImportFilter = hasExternalImports
+      ? 'WHERE external_import.session_id IS NULL'
+      : '';
+    rows = queryDbJson(dbPath, `
+      SELECT
+        message.session_id AS sessionID,
+        message.time_created AS created,
+        message.data AS data,
+        session.directory AS directory
+      FROM message
+      JOIN session ON session.id = message.session_id
+      ${externalImportJoin}
+      ${externalImportFilter}
+    `);
+  } catch (err) {
+    if (err.status === 127 || err.message?.includes('ENOENT')) {
+      throw new Error('sqlite3 CLI not found. Install sqlite3 (or use Node >= 22.5) to sync MiMoCode data.');
+    }
+    throw err;
+  }
+
+  const entries = [];
+  const events = [];
+  for (const row of rows) {
+    let data;
+    try {
+      data = typeof row.data === 'string' ? JSON.parse(row.data) : row.data;
+    } catch {
+      continue;
+    }
+    if (data?.role !== 'user' && data?.role !== 'assistant') continue;
+
+    const timestamp = new Date(data.time?.created ?? row.created);
+    if (Number.isNaN(timestamp.getTime())) continue;
+    const project = row.directory ? basename(row.directory) : 'unknown';
+    events.push({
+      sessionId: row.sessionID || 'unknown',
+      source: 'mimocode',
+      project,
+      timestamp,
+      role: data.role,
+    });
+
+    const tokens = data.tokens;
+    if (data.role !== 'assistant' || !data.modelID || !tokens) continue;
+    const inputTokens = (Number(tokens.input) || 0) + (Number(tokens.cache?.write) || 0);
+    const outputTokens = Number(tokens.output) || 0;
+    const reasoningOutputTokens = Number(tokens.reasoning) || 0;
+    const cachedInputTokens = Number(tokens.cache?.read) || 0;
+    if (inputTokens + outputTokens + reasoningOutputTokens + cachedInputTokens <= 0) continue;
+    entries.push({
+      source: 'mimocode',
+      model: data.modelID,
+      project,
+      timestamp,
+      inputTokens,
+      outputTokens,
+      cachedInputTokens,
+      reasoningOutputTokens,
+    });
+  }
+
+  return {
+    buckets: aggregateToBuckets(entries),
+    sessions: extractSessions(events),
+  };
+}

package/src/sync.js

@@ -27,7 +27,16 @@ export function resolveUploadProjectSetting(settings) {
   return settings.uploadProject;
 }
 
-export async function runSync({ throws = false, quiet = false, surface = 'cli' } = {}) {
+export function resolveCodexExtraHome(configured, temporary) {
+  return temporary ?? configured;
+}
+
+export async function runSync({
+  throws = false,
+  quiet = false,
+  surface = 'cli',
+  codexExtraHome,
+} = {}) {
   const config = loadConfig();
   if (!config?.apiKey) {
     console.error(failure('尚未配置，请先运行 `npx @vibe-cafe/vibe-usage init`。'));
@@ -72,7 +81,9 @@ export async function runSync({ throws = false, quiet = false, surface = 'cli' }
 
   for (const [source, parse] of Object.entries(parsers)) {
     try {
-      const result = await parse();
+      const result = source === 'codex'
+        ? await parse({ codexExtraHome: resolveCodexExtraHome(config.codexExtraHome, codexExtraHome) })
+        : await parse();
       const buckets = Array.isArray(result) ? result : result.buckets;
       const sessions = Array.isArray(result) ? [] : (result.sessions || []);
       if (!Array.isArray(buckets) || !Array.isArray(sessions)) {

package/src/tools.js

@@ -1,7 +1,8 @@
 import { existsSync, readdirSync, statSync } from 'node:fs';
-import { join } from 'node:path';
+import { isAbsolute, join, resolve } from 'node:path';
 import { homedir } from 'node:os';
 import { findClaudeCodeDataDirs } from './claude-roots.js';
+import { codexSessionDirs, resolveCodexHomes } from './codex-roots.js';
 
 function getCursorStateDbPath() {
   const rel = join('User', 'globalStorage', 'state.vscdb');
@@ -84,11 +85,10 @@ function findOpenclawDataDirs() {
 // Codex keeps live sessions in ~/.codex/sessions and moves completed ones to
 // ~/.codex/archived_sessions. Detect Codex if either dir exists, so a user
 // whose sessions have all been archived is still recognized.
-function findCodexDataDirs() {
-  return [
-    join(homedir(), '.codex', 'sessions'),
-    join(homedir(), '.codex', 'archived_sessions'),
-  ].filter(existsSync);
+export function findCodexDataDirs(codexExtraHome) {
+  return resolveCodexHomes(codexExtraHome)
+    .flatMap(codexSessionDirs)
+    .filter(existsSync);
 }
 
 // Kimi Code moved its store from ~/.kimi to ~/.kimi-code; recognize either so
@@ -100,6 +100,17 @@ function findKimiCodeDataDirs() {
   ].filter(existsSync);
 }
 
+export function getMimocodeDbPath(env = process.env) {
+  if (env.MIMOCODE_HOME && !isAbsolute(env.MIMOCODE_HOME)) {
+    throw new Error(`MIMOCODE_HOME must be an absolute path, got: ${JSON.stringify(env.MIMOCODE_HOME)}`);
+  }
+  const dataDir = env.MIMOCODE_HOME
+    ? join(env.MIMOCODE_HOME, 'data')
+    : join(env.XDG_DATA_HOME || join(homedir(), '.local', 'share'), 'mimocode');
+  if (!env.MIMOCODE_DB) return join(dataDir, 'mimocode.db');
+  return isAbsolute(env.MIMOCODE_DB) ? env.MIMOCODE_DB : join(dataDir, env.MIMOCODE_DB);
+}
+
 function findAntigravityDataDirs() {
   return [
     join(homedir(), '.gemini', 'antigravity'),
@@ -145,6 +156,24 @@ export function findGrokDataDirs() {
   return [join(getGrokHome(), 'sessions')].filter(existsSync);
 }
 
+export function getDimAgentDbPath() {
+  const override = process.env.VIBE_USAGE_DIMAGENT_DB?.trim();
+  if (override) return resolve(override);
+
+  const explicitHome = process.env.DIMCODE_HOME?.trim();
+  if (explicitHome) return join(resolve(explicitHome), 'dimcode.sqlite');
+
+  const xdgConfigHome = process.env.XDG_CONFIG_HOME?.trim();
+  const home = xdgConfigHome
+    ? resolve(xdgConfigHome, '.dimcode', 'v2')
+    : join(homedir(), '.dimcode', 'v2');
+  return join(home, 'dimcode.sqlite');
+}
+
+export function findDimAgentDataDirs() {
+  return [getDimAgentDbPath()].filter(existsSync);
+}
+
 export const TOOLS = [
   {
     name: 'Claude Code',
@@ -156,7 +185,7 @@ export const TOOLS = [
     name: 'Codex CLI',
     id: 'codex',
     dataDir: join(homedir(), '.codex', 'sessions'),
-    detectDataDirs: findCodexDataDirs,
+    detectDataDirs: ({ codexExtraHome } = {}) => findCodexDataDirs(codexExtraHome),
   },
   {
     name: 'Grok',
@@ -174,6 +203,12 @@ export const TOOLS = [
     id: 'cursor',
     dataDir: getCursorStateDbPath(),
   },
+  {
+    name: 'DimAgent',
+    id: 'dimagent',
+    dataDir: getDimAgentDbPath(),
+    detectDataDirs: findDimAgentDataDirs,
+  },
   {
     name: 'Gemini CLI',
     id: 'gemini-cli',
@@ -208,6 +243,12 @@ export const TOOLS = [
     dataDir: join(homedir(), '.kimi-code', 'sessions'),
     detectDataDirs: findKimiCodeDataDirs,
   },
+  {
+    name: 'MiMoCode',
+    id: 'mimocode',
+    dataDir: join(homedir(), '.local', 'share', 'mimocode', 'mimocode.db'),
+    detectDataDirs: () => [getMimocodeDbPath()].filter(existsSync),
+  },
   {
     name: 'Amp',
     id: 'amp',
@@ -259,9 +300,9 @@ export const TOOLS = [
   },
 ];
 
-export function detectInstalledTools() {
+export function detectInstalledTools(options = {}) {
   return TOOLS.filter(t => {
-    if (t.detectDataDirs) return t.detectDataDirs().length > 0;
+    if (t.detectDataDirs) return t.detectDataDirs(options).length > 0;
     return existsSync(t.dataDir);
   });
 }