@vibe-cafe/vibe-usage 0.10.34 → 0.11.1

package/README.md

@@ -51,11 +51,24 @@ npx @vibe-cafe/vibe-usage reset --local  # Delete this host's data only and re-u
 npx @vibe-cafe/vibe-usage skill         # Install skill for AI coding assistants
 npx @vibe-cafe/vibe-usage skill --remove  # Remove installed skills
 npx @vibe-cafe/vibe-usage status       # Config, detected tools, and what each tool has uploaded so far
+npx @vibe-cafe/vibe-usage quota discover --json  # Detect subscription-quota products locally
+npx @vibe-cafe/vibe-usage quota fetch --product kimi-code --product zcode --product grok --json  # Fetch only selected quotas
 npx @vibe-cafe/vibe-usage help --all   # Full help (plain `help` shows the short version)
 ```
 
 </details>
 
+## Subscription Quotas
+
+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.
+
+- **Kimi Code** reads the official Kimi CLI OAuth file (`$KIMI_SHARE_DIR/credentials/kimi-code.json`, otherwise `~/.kimi/credentials/kimi-code.json`) and calls `https://api.kimi.com/coding/v1/usages`. 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.
+- **Cursor** is detected independently but remains non-fetchable until an official or stable quota protocol is available. Quota monitoring does not read Cursor's login token/database, browser cookies, another app's Keychain, network traffic, or UI.
+
+Quota results are never uploaded or added to incremental sync state. Credential-backed providers may use the disposable cache at `~/.vibe-usage/quota-cache.json`; it contains normalized meters only, is scoped to a one-way hash of the active credential, rejects expired windows, and has a seven-day hard expiry. Grok's local-log result is not cached. No credential is stored in that cache, logs, or command output; the only credential write is Kimi's standard token rotation back to Kimi's own credential file.
+
 ## Supported Tools
 
 | Tool | Data Location |
@@ -236,6 +249,10 @@ For OpenCode, each root uses its SQLite database when present; only roots withou
 
 The first `npx @vibe-cafe/vibe-usage` run installs a user-level service (systemd on Linux, launchd on macOS, Task Scheduler on Windows — no admin rights needed) that syncs every 30 minutes and starts automatically on login. Nothing else to do.
 
+Switching the CLI to a different account (running `init` again, or `config set apiKey`) rebinds the upload state, so the next sync re-uploads your full local history to the new account instead of treating it as already sent.
+
+换绑账号后（重新 `init` 或 `config set apiKey`），下一次同步会自动全量重传本地历史，不会因为旧账号的同步记录而漏传。
+
 <details>
 <summary>Managing the service, and how it is launched</summary>
 

package/package.json

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

package/src/daemon-service.js

@@ -1,6 +1,6 @@
 import { execFileSync } from 'node:child_process';
 import { writeFileSync, readFileSync, unlinkSync, mkdirSync, existsSync } from 'node:fs';
-import { join, dirname, win32 as winPath } from 'node:path';
+import { join, win32 as winPath, posix as posixPath } from 'node:path';
 import { homedir, platform } from 'node:os';
 import { fileURLToPath } from 'node:url';
 import { success, failure, warn, dim } from './output.js';
@@ -41,8 +41,9 @@ export function isNpxCachePath(binPath) {
  * falls back to pinning the path and warning, as before).
  */
 export function npxLauncher(nodePath, exists = existsSync, os = platform()) {
-  const nodeDir = dirname(nodePath);
-  const npxPath = join(nodeDir, os === 'win32' ? 'npx.cmd' : 'npx');
+  const paths = os === 'win32' ? winPath : posixPath;
+  const nodeDir = paths.dirname(nodePath);
+  const npxPath = paths.join(nodeDir, os === 'win32' ? 'npx.cmd' : 'npx');
   return exists(npxPath) ? { mode: 'npx', npxPath, nodeDir } : null;
 }
 

package/src/index.js

@@ -11,6 +11,7 @@ import {
 import { dim as dimText, failure, hint, smallHeader, warn } from './output.js';
 import { loadState } from './state.js';
 import { fetchAccount } from './api.js';
+import { COLLECTOR_VERSION } from './client-meta.js';
 
 function printSmallHeader() {
   console.log();
@@ -298,6 +299,8 @@ const FULL_HELP = `
     ${BARE} skill         Install skill for AI coding tools
     ${BARE} skill --remove  Remove installed skills
     ${BARE} status       Show config and detected tools
+    ${BARE} quota discover --json  Detect subscription-quota products locally
+    ${BARE} quota fetch --product <id> --json  Fetch only selected subscription quotas
     ${BARE} config show  Show full config as JSON
     ${BARE} config get <key>   Get a config value
     ${BARE} config set <key> <value>  Set a config value
@@ -307,6 +310,7 @@ const FULL_HELP = `
     ${BARE} config roots  Show added data roots as JSON
     ${BARE} help         Show the short help
     ${BARE} help --all   Show this full list
+    ${BARE} --version    Print the installed CLI version
 `;
 
 export async function run(rawArgs) {
@@ -358,6 +362,16 @@ export async function run(rawArgs) {
       await runSummary(args.slice(1));
       break;
     }
+    case 'quota': {
+      const { runQuota } = await import('./quotas/index.js');
+      try {
+        await runQuota(args.slice(1));
+      } catch (error) {
+        console.error(error?.message || String(error));
+        process.exitCode = 1;
+      }
+      break;
+    }
     case 'reset': {
       printSmallHeader();
       if (args.includes('--host')) hint('reset --host 已改名 reset --local，旧写法仍可用');
@@ -399,6 +413,11 @@ export async function run(rawArgs) {
       handleConfig(args.slice(1));
       break;
     }
+    case '--version':
+    case '-v': {
+      console.log(COLLECTOR_VERSION);
+      break;
+    }
     case 'status': {
       await showStatus();
       break;

package/src/parsers/claude-code.js

@@ -384,6 +384,19 @@ export async function parse({ extraRoots = [] } = {}) {
   const roots = getClaudeRoots({
     onWarning: (message) => addWarning(ctx, message),
     extraRoots,
+  }).filter((root) => {
+    // On Windows readdir("file/projects") can return ENOENT rather than
+    // ENOTDIR. Validate the root first so that an invalid store cannot look
+    // like a successful empty scan and allow incremental state to be pruned.
+    try {
+      if (statSync(root).isDirectory()) return true;
+      addWarning(ctx, `Claude Code: cannot read directory ${root}: not a directory`);
+    } catch (err) {
+      if (err?.code !== 'ENOENT') {
+        addWarning(ctx, `Claude Code: cannot read directory ${root}: ${err.message}`);
+      }
+    }
+    return false;
   });
   const projectGroups = collectCandidates(roots, 'projects', ctx);
   const projectSessionIds = new Set();

package/src/quotas/cache.js

@@ -0,0 +1,91 @@
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { createHash } from 'node:crypto';
+import { normalizeMeter, quotaResult } from './schema.js';
+
+const CACHE_VERSION = 1;
+const MAX_CACHE_AGE_MS = 7 * 24 * 60 * 60 * 1000;
+
+function cachePath(environment = process.env) {
+  const root = environment.VIBE_USAGE_QUOTA_CACHE_DIR?.trim()
+    || join(homedir(), '.vibe-usage');
+  return join(root, 'quota-cache.json');
+}
+
+function loadDocument(environment) {
+  try {
+    const parsed = JSON.parse(readFileSync(cachePath(environment), 'utf8'));
+    if (!isRecord(parsed) || parsed.version !== CACHE_VERSION || !isRecord(parsed.products)) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+function isRecord(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+export function attachCacheScope(result, secret) {
+  const scope = createHash('sha256').update(`${result.id}\0${secret}`).digest('hex');
+  Object.defineProperty(result, 'cacheScope', { value: scope, enumerable: false });
+  return result;
+}
+
+export function loadCachedQuota(id, scope, environment = process.env, now = new Date()) {
+  if (!scope) return null;
+  const raw = loadDocument(environment)?.products?.[id];
+  if (!raw || raw.scope !== scope || raw.status !== 'ok' || !Array.isArray(raw.meters)) return null;
+  try {
+    const dataAsOf = new Date(raw.dataAsOf || raw.fetchedAt);
+    if (Number.isNaN(dataAsOf.getTime()) || now.getTime() - dataAsOf.getTime() > MAX_CACHE_AGE_MS) {
+      return null;
+    }
+    const meters = raw.meters.map(normalizeMeter).filter(meter => {
+      if (meter.resetsAt) return new Date(meter.resetsAt) > now;
+      if (meter.windowSeconds) {
+        return dataAsOf.getTime() + meter.windowSeconds * 1000 > now.getTime();
+      }
+      return true;
+    });
+    if (!meters.length) return null;
+    return quotaResult({
+      ...raw,
+      id,
+      status: 'ok',
+      meters,
+      source: 'cache',
+      fetchedAt: raw.fetchedAt,
+      dataAsOf: raw.dataAsOf || raw.fetchedAt,
+    });
+  } catch {
+    return null;
+  }
+}
+
+export function saveCachedQuota(result, scope, environment = process.env) {
+  if (result?.status !== 'ok' || !scope) return;
+  try {
+    // All disposable-cache work belongs inside the failure boundary, including
+    // path resolution and updating a document recovered from disk.
+    const path = cachePath(environment);
+    const document = loadDocument(environment) || { version: CACHE_VERSION, products: {} };
+    document.products[result.id] = {
+      id: result.id,
+      status: 'ok',
+      meters: result.meters,
+      planLabel: result.planLabel,
+      fetchedAt: result.fetchedAt,
+      dataAsOf: result.dataAsOf,
+      scope,
+    };
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    const temporary = `${path}.${process.pid}.tmp`;
+    writeFileSync(temporary, `${JSON.stringify(document)}\n`, { encoding: 'utf8', mode: 0o600 });
+    renameSync(temporary, path);
+  } catch {
+    // The cache is disposable. A read-only home must not turn a successful
+    // provider response into a CLI failure.
+  }
+}

package/src/quotas/index.js

@@ -0,0 +1,35 @@
+import { discoverQuotaProducts, fetchQuotaProducts } from './registry.js';
+
+function fail(message) {
+  throw new Error(message);
+}
+
+function parseFetchArguments(args) {
+  const products = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const argument = args[index];
+    if (argument === '--json') continue;
+    if (argument !== '--product') fail(`Unknown quota fetch option: ${argument}`);
+    const value = args[index + 1];
+    if (!value || value.startsWith('--')) fail('Option --product requires a value.');
+    products.push(value);
+    index += 1;
+  }
+  if (!products.length) fail('quota fetch requires at least one --product.');
+  return products;
+}
+
+export async function runQuota(args) {
+  const subcommand = args[0];
+  if (subcommand === 'discover') {
+    const unknown = args.slice(1).filter(argument => argument !== '--json');
+    if (unknown.length) fail(`Unknown quota discover option: ${unknown[0]}`);
+    console.log(JSON.stringify(discoverQuotaProducts()));
+    return;
+  }
+  if (subcommand === 'fetch') {
+    console.log(JSON.stringify(await fetchQuotaProducts(parseFetchArguments(args.slice(1)))));
+    return;
+  }
+  fail(`Unknown quota subcommand: ${subcommand || '(none)'}`);
+}

package/src/quotas/providers/grok.js

@@ -0,0 +1,151 @@
+import { closeSync, fstatSync, openSync, readSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { quotaResult } from '../schema.js';
+
+const PRODUCT_ID = 'grok';
+const DEFAULT_MAX_LOG_BYTES = 2 * 1024 * 1024;
+
+export function grokBillingLogPath(environment = process.env, home = homedir()) {
+  const configured = environment.GROK_HOME?.trim();
+  let root = configured || join(home, '.grok');
+  if (root === '~') root = home;
+  else if (root.startsWith('~/') || root.startsWith('~\\')) root = join(home, root.slice(2));
+  return join(root, 'logs', 'unified.jsonl');
+}
+
+function readLogTail(path, maxBytes = DEFAULT_MAX_LOG_BYTES) {
+  const descriptor = openSync(path, 'r');
+  try {
+    const size = fstatSync(descriptor).size;
+    const length = Math.min(size, maxBytes);
+    if (length <= 0) return '';
+    const buffer = Buffer.allocUnsafe(length);
+    const offset = size - length;
+    let total = 0;
+    while (total < length) {
+      const count = readSync(descriptor, buffer, total, length - total, offset + total);
+      if (count <= 0) break;
+      total += count;
+    }
+    let text = buffer.subarray(0, total).toString('utf8');
+    // A bounded tail may begin in the middle of a UTF-8 JSON line. Drop only
+    // that incomplete line; the CLI emits this billing snapshot repeatedly.
+    if (offset > 0) {
+      const newline = text.indexOf('\n');
+      text = newline < 0 ? '' : text.slice(newline + 1);
+    }
+    return text;
+  } finally {
+    closeSync(descriptor);
+  }
+}
+
+function finiteNumber(value) {
+  const number = typeof value === 'number' ? value : Number(value);
+  return Number.isFinite(number) ? number : null;
+}
+
+function date(value) {
+  if (typeof value !== 'string' || !value.trim()) return null;
+  const parsed = new Date(value);
+  return Number.isNaN(parsed.getTime()) ? null : parsed;
+}
+
+function periodLabel(type, seconds) {
+  if (type === 'USAGE_PERIOD_TYPE_DAILY') return '1d';
+  if (type === 'USAGE_PERIOD_TYPE_WEEKLY') return '7d';
+  if (type === 'USAGE_PERIOD_TYPE_MONTHLY') return 'Month';
+  const days = seconds / 86_400;
+  return Number.isInteger(days) && days > 0 ? `${days}d` : 'Credits';
+}
+
+/**
+ * Reads only Grok CLI's structured, non-secret billing status event. Other log
+ * messages are parsed only far enough to reject them and are never returned,
+ * cached, logged, or uploaded by Vibe Usage.
+ */
+export function parseGrokBillingLog(text, now = new Date()) {
+  if (typeof text !== 'string' || !text) return null;
+  const lines = text.split(/\r?\n/);
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    const line = lines[index].trim();
+    if (!line) continue;
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (event?.msg !== 'billing: fetched credits config') continue;
+    const config = event?.ctx?.config;
+    if (!config || typeof config !== 'object' || Array.isArray(config)) continue;
+    const utilization = finiteNumber(config.creditUsagePercent);
+    const dataAsOf = date(event.ts);
+    const startsAt = date(config.currentPeriod?.start || config.billingPeriodStart);
+    const resetsAt = date(config.currentPeriod?.end || config.billingPeriodEnd);
+    if (utilization === null || !dataAsOf || !startsAt || !resetsAt) continue;
+    const windowSeconds = (resetsAt.getTime() - startsAt.getTime()) / 1000;
+    if (windowSeconds <= 0) continue;
+    const planLabel = [event.ctx?.subscriptionTier, config.subscriptionTier]
+      .find(value => typeof value === 'string' && value.trim())?.trim();
+    return {
+      active: resetsAt > now,
+      dataAsOf,
+      meters: [{
+        id: 'subscription-credits',
+        label: periodLabel(config.currentPeriod?.type, windowSeconds),
+        utilization,
+        resetsAt: resetsAt.toISOString(),
+        windowSeconds,
+      }],
+      planLabel,
+    };
+  }
+  return null;
+}
+
+export function fetchGrokQuota({
+  environment = process.env,
+  home = homedir(),
+  now = new Date(),
+  maxLogBytes = DEFAULT_MAX_LOG_BYTES,
+} = {}) {
+  let parsed;
+  try {
+    parsed = parseGrokBillingLog(
+      readLogTail(grokBillingLogPath(environment, home), maxLogBytes),
+      now
+    );
+  } catch (error) {
+    const status = error?.code === 'ENOENT' ? 'no_data' : 'retryable_error';
+    return quotaResult({
+      id: PRODUCT_ID,
+      status,
+      message: status === 'no_data'
+        ? 'Grok billing status is not available yet'
+        : 'Grok billing status could not be read',
+      fetchedAt: now,
+      source: 'local',
+    });
+  }
+  if (!parsed || !parsed.active) {
+    return quotaResult({
+      id: PRODUCT_ID,
+      status: 'no_data',
+      message: 'Grok billing status is not available yet',
+      fetchedAt: now,
+      dataAsOf: parsed?.dataAsOf,
+      source: 'local',
+    });
+  }
+  return quotaResult({
+    id: PRODUCT_ID,
+    status: 'ok',
+    meters: parsed.meters,
+    planLabel: parsed.planLabel,
+    fetchedAt: now,
+    dataAsOf: parsed.dataAsOf,
+    source: 'local',
+  });
+}