@vibe-cafe/vibe-usage 0.10.34 → 0.11.1

package/src/quotas/registry.js

@@ -0,0 +1,114 @@
+import { accessSync, constants, existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { delimiter, join } from 'node:path';
+import { loadCachedQuota, saveCachedQuota } from './cache.js';
+import { fetchGrokQuota } from './providers/grok.js';
+import { fetchKimiCodeQuota } from './providers/kimi-code.js';
+import { fetchZaiQuota } from './providers/zai.js';
+import { FETCHABLE_QUOTA_PRODUCT_IDS, quotaEnvelope, quotaResult } from './schema.js';
+
+const providers = new Map([
+  ['kimi-code', fetchKimiCodeQuota],
+  ['zcode', fetchZaiQuota],
+  ['grok', fetchGrokQuota],
+]);
+
+function executableExists(name, environment, platform) {
+  const pathDelimiter = platform === 'win32' ? ';' : delimiter;
+  const candidateNames = [name];
+  if (platform === 'win32') {
+    const extensions = (environment.PATHEXT || '.COM;.EXE;.BAT;.CMD')
+      .split(';')
+      .map(value => value.trim())
+      .filter(Boolean)
+      .map(value => value.startsWith('.') ? value : `.${value}`);
+    for (const extension of extensions) {
+      candidateNames.push(`${name}${extension}`, `${name}${extension.toLowerCase()}`);
+    }
+  }
+
+  return (environment.PATH || '').split(pathDelimiter).filter(Boolean).some(directory => (
+    candidateNames.some(candidate => {
+      const path = join(directory, candidate);
+      try {
+        // Windows does not expose POSIX execute bits; file presence plus a
+        // PATHEXT executable suffix is its ordinary command-discovery rule.
+        accessSync(path, platform === 'win32' ? constants.F_OK : constants.X_OK);
+        return true;
+      } catch {
+        return false;
+      }
+    })
+  ));
+}
+
+export function discoverQuotaProducts({
+  environment = process.env,
+  home = homedir(),
+  platform = process.platform,
+} = {}) {
+  const applications = platform === 'darwin'
+    ? ['/Applications', join(home, 'Applications')] : [];
+  const existsAny = paths => paths.some(path => existsSync(path));
+  const configuredGrokHome = environment.GROK_HOME?.trim();
+  const grokHome = configuredGrokHome
+    ? configuredGrokHome.replace(/^~(?=$|[\\/])/, home)
+    : join(home, '.grok');
+  return quotaEnvelope([
+    {
+      id: 'kimi-code',
+      detected: existsAny([join(home, '.kimi'), join(home, '.kimi-code')])
+        || executableExists('kimi', environment, platform),
+      fetchable: true,
+    },
+    {
+      id: 'zcode',
+      detected: existsAny([join(home, '.zcode'), join(home, '.config', 'zcode'),
+        ...applications.map(path => join(path, 'ZCode.app'))])
+        || executableExists('zcode', environment, platform),
+      fetchable: true,
+    },
+    {
+      id: 'grok',
+      detected: existsAny([grokHome]) || executableExists('grok', environment, platform),
+      fetchable: true,
+    },
+    {
+      id: 'cursor',
+      detected: existsAny([join(home, '.cursor'),
+        ...applications.map(path => join(path, 'Cursor.app'))])
+        || executableExists('cursor', environment, platform),
+      fetchable: false,
+    },
+  ]);
+}
+
+export async function fetchQuotaProducts(ids, options = {}) {
+  const unique = [...new Set(ids)];
+  const invalid = unique.filter(id => !FETCHABLE_QUOTA_PRODUCT_IDS.includes(id));
+  if (invalid.length) throw new Error(`Unsupported quota product: ${invalid.join(', ')}`);
+
+  const fetched = await Promise.all(unique.map(async id => {
+    try {
+      return await providers.get(id)(options);
+    } catch {
+      return quotaResult({ id, status: 'retryable_error', message: 'Provider failed unexpectedly' });
+    }
+  }));
+  const results = fetched.map(result => {
+    if (result.status === 'ok') {
+      saveCachedQuota(result, result.cacheScope, options.environment);
+      return result;
+    }
+    if (result.status === 'retryable_error') {
+      return loadCachedQuota(
+        result.id,
+        result.cacheScope,
+        options.environment,
+        options.now || new Date()
+      ) || result;
+    }
+    return result;
+  });
+  return quotaEnvelope(results);
+}

package/src/quotas/schema.js

@@ -0,0 +1,94 @@
+export const QUOTA_SCHEMA_VERSION = 1;
+
+export const QUOTA_PRODUCT_IDS = Object.freeze([
+  'kimi-code',
+  'zcode',
+  'grok',
+  'cursor',
+]);
+
+export const FETCHABLE_QUOTA_PRODUCT_IDS = Object.freeze([
+  'kimi-code',
+  'zcode',
+  'grok',
+]);
+
+const FETCH_STATUSES = new Set([
+  'ok',
+  'no_data',
+  'missing_credentials',
+  'expired_credentials',
+  'unauthorized',
+  'retryable_error',
+  'unsupported',
+]);
+
+function finiteNumber(value, name) {
+  if (typeof value !== 'number' || !Number.isFinite(value)) {
+    throw new TypeError(`${name} must be a finite number`);
+  }
+  return value;
+}
+
+function optionalISODate(value, name) {
+  if (value === undefined || value === null) return undefined;
+  const date = value instanceof Date ? value : new Date(value);
+  if (Number.isNaN(date.getTime())) {
+    throw new TypeError(`${name} must be an ISO date string`);
+  }
+  return date.toISOString();
+}
+
+export function normalizeMeter(raw, index = 0) {
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+    throw new TypeError(`meters[${index}] must be an object`);
+  }
+  const id = String(raw.id || '').trim();
+  const label = String(raw.label || '').trim();
+  if (!id || !label) throw new TypeError(`meters[${index}] needs id and label`);
+
+  const utilization = Math.max(0, Math.min(100,
+    finiteNumber(raw.utilization, `meters[${index}].utilization`)));
+  const meter = { id, label, utilization };
+  const resetsAt = optionalISODate(raw.resetsAt, `meters[${index}].resetsAt`);
+  if (resetsAt) meter.resetsAt = resetsAt;
+  if (raw.windowSeconds !== undefined && raw.windowSeconds !== null) {
+    const seconds = finiteNumber(raw.windowSeconds, `meters[${index}].windowSeconds`);
+    if (seconds > 0) meter.windowSeconds = seconds;
+  }
+  return meter;
+}
+
+export function quotaResult({
+  id,
+  status,
+  meters = [],
+  planLabel,
+  fetchedAt = new Date(),
+  dataAsOf = fetchedAt,
+  message,
+  source = 'live',
+}) {
+  if (!FETCHABLE_QUOTA_PRODUCT_IDS.includes(id)) {
+    throw new TypeError(`unsupported quota product: ${id}`);
+  }
+  if (!FETCH_STATUSES.has(status)) {
+    throw new TypeError(`invalid quota status: ${status}`);
+  }
+  const result = {
+    id,
+    status,
+    meters: meters.map(normalizeMeter),
+    fetchedAt: new Date(fetchedAt).toISOString(),
+    source,
+  };
+  const normalizedDataAsOf = optionalISODate(dataAsOf, 'dataAsOf');
+  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();
+  return result;
+}
+
+export function quotaEnvelope(products) {
+  return { schemaVersion: QUOTA_SCHEMA_VERSION, products };
+}

package/src/state.js

@@ -8,6 +8,8 @@ import { createHash, randomBytes } from 'node:crypto';
 // already uploaded successfully. Lets each sync skip re-sending unchanged
 // history: parsers stay stateless (still parse everything from disk every run),
 // but only new/changed items hit the network.
+// The file also records the upload target it belongs to (`identity`), so state
+// left by a previous account can never suppress that account's history.
 // VIBE_USAGE_STATE_DIR overrides the dir (test hook).
 const STATE_DIR = process.env.VIBE_USAGE_STATE_DIR?.trim() || join(homedir(), '.vibe-usage');
 const isDev = process.env.VIBE_USAGE_DEV === '1';
@@ -17,14 +19,57 @@ export function getStatePath() {
   return STATE_FILE;
 }
 
-export function loadState() {
+// The upload target this state belongs to: which server, and which account on
+// it. state.json only records what was already uploaded *to that target*, so
+// after a re-bind (`init` again, `config set apiKey`, or a desktop app
+// rewriting config.json) the old hashes must not make sync skip history the new
+// account has never received.
+//
+// The key is stored only as a fingerprint. The raw apiKey must never appear in
+// state.json — it is an ordinary-permission file next to the parser state, not
+// a credential store; config.json (mode 0600) remains the only place it lives.
+export function stateIdentity({ apiUrl, apiKey } = {}) {
+  return {
+    apiUrl: apiUrl || '',
+    keyFingerprint: apiKey
+      ? createHash('sha256').update(String(apiKey)).digest('hex').slice(0, 16)
+      : '',
+  };
+}
+
+function isIdentity(value) {
+  return !!value
+    && typeof value === 'object'
+    && typeof value.apiUrl === 'string'
+    && typeof value.keyFingerprint === 'string';
+}
+
+function sameIdentity(a, b) {
+  return a.apiUrl === b.apiUrl && a.keyFingerprint === b.keyFingerprint;
+}
+
+// `identity` is optional: callers that only read the recorded counts (e.g.
+// `status`) pass nothing and keep the pre-0.11.1 behaviour of taking the file
+// at face value.
+export function loadState(identity) {
   if (!existsSync(STATE_FILE)) return { buckets: {}, sessions: {} };
   try {
     const parsed = JSON.parse(readFileSync(STATE_FILE, 'utf-8'));
-    return {
-      buckets: parsed.buckets ?? {},
-      sessions: parsed.sessions ?? {},
-    };
+    const buckets = parsed.buckets ?? {};
+    const sessions = parsed.sessions ?? {};
+    if (!isIdentity(identity) || !isIdentity(parsed.identity)) {
+      // No identity recorded — written by a CLI older than 0.11.1. Adopt the
+      // entries as-is rather than forcing a re-upload: on upgrade day that
+      // would make every installed client re-send its whole history at once.
+      // The next saveState() stamps the current identity, so any later re-bind
+      // is caught.
+      return { buckets, sessions };
+    }
+    if (sameIdentity(parsed.identity, identity)) return { buckets, sessions };
+    // Bound to a different account or server: nothing recorded here was ever
+    // uploaded to the current target, so start empty and re-send local history.
+    // `identityChanged` is a runtime signal for the caller, never persisted.
+    return { buckets: {}, sessions: {}, identityChanged: true };
   } catch {
     // Corrupt/unreadable state must not lose data — treat as empty, which
     // triggers a one-time full re-upload (same as a fresh install).
@@ -32,14 +77,28 @@ export function loadState() {
   }
 }
 
-export function saveState(state) {
+export function saveState(state, identity) {
   mkdirSync(STATE_DIR, { recursive: true });
+  // Only the durable fields are written: `identityChanged` is loadState()'s
+  // one-run signal, not state. A CLI older than 0.11.1 reads just
+  // buckets/sessions, so the extra top-level `identity` key is ignored there —
+  // a file written by this version stays readable by older clients.
+  const payload = {
+    buckets: state.buckets ?? {},
+    sessions: state.sessions ?? {},
+  };
+  if (isIdentity(identity)) {
+    payload.identity = {
+      apiUrl: identity.apiUrl,
+      keyFingerprint: identity.keyFingerprint,
+    };
+  }
   // Atomic replace: write to a unique temp file then rename over the target.
   // A crash mid-write can no longer truncate state.json into an unreadable
   // file that loadState() would treat as empty (triggering a full re-upload).
   const tempPath = `${STATE_FILE}.${process.pid}.${randomBytes(6).toString('hex')}.tmp`;
   try {
-    writeFileSync(tempPath, JSON.stringify(state) + '\n', 'utf-8');
+    writeFileSync(tempPath, JSON.stringify(payload) + '\n', 'utf-8');
     renameSync(tempPath, STATE_FILE);
   } finally {
     // No-op after a successful rename (the temp file is already gone); cleans

package/src/sync.js

@@ -1,7 +1,7 @@
 import { hostname as osHostname } from 'node:os';
 import { loadConfig, saveConfig } from './config.js';
 import {
-  loadState, saveState, pruneState,
+  loadState, saveState, pruneState, stateIdentity,
   bucketKey, bucketHash, sessionKey, sessionHash,
 } from './state.js';
 import { ingest, fetchSettings } from './api.js';
@@ -119,6 +119,13 @@ export async function runSync({
   // Resolve it before parsing or loading upload state so failure is a true
   // no-op: no data upload and no state mutation.
   const apiUrl = config.apiUrl || 'https://vibecafe.ai';
+  // state.json records what was already uploaded to *this* account on *this*
+  // server. Passing the identity into loadState() makes state left by a
+  // previous account fall away, so a re-bind re-uploads the local history
+  // instead of diffing it against uploads the new account never received.
+  // Built from the same `apiUrl` the ingest calls below use, so the recorded
+  // target and the actual target can never drift apart.
+  const identity = stateIdentity({ apiUrl, apiKey: config.apiKey });
   let uploadProject;
   try {
     const settings = await fetchSettings(apiUrl, config.apiKey);
@@ -223,11 +230,14 @@ export async function runSync({
     // Successful parsers emitted no live items. Prune their old keys even on
     // this fast path; otherwise deleting the final local log would leave dead
     // state entries forever. Failed-parser sources remain protected.
-    const state = loadState();
+    const state = loadState(identity);
+    if (state.identityChanged && !quiet) {
+      console.log(dim('检测到上传账号已更换，本次全量重传本地历史'));
+    }
     const before = Object.keys(state.buckets).length + Object.keys(state.sessions).length;
     pruneState(state, new Set(), new Set(), okSources);
     const pruned = before - (Object.keys(state.buckets).length + Object.keys(state.sessions).length);
-    if (pruned > 0) saveState(state);
+    if (pruned > 0) saveState(state, identity);
     if (!quiet && parserProgress.length > 0) {
       for (const p of parserProgress) {
         console.log(dim(`  ${p.source}: 正在建立本地索引 ${p.completed}/${p.total}（下次同步继续）`));
@@ -283,7 +293,10 @@ export async function runSync({
   // an active one sends just the current 30-min bucket.
   // Missing/corrupt state.json => empty maps => one-time full upload, then
   // incremental forever after.
-  const state = loadState();
+  const state = loadState(identity);
+  if (state.identityChanged && !quiet) {
+    console.log(dim('检测到上传账号已更换，本次全量重传本地历史'));
+  }
   const changedBuckets = [];
   const changedSessions = [];
   const liveBucketKeys = new Set();
@@ -321,7 +334,7 @@ export async function runSync({
   const before = Object.keys(state.buckets).length + Object.keys(state.sessions).length;
   pruneState(state, liveBucketKeys, liveSessionKeys, okSources);
   const pruned = before - (Object.keys(state.buckets).length + Object.keys(state.sessions).length);
-  if (pruned > 0) saveState(state);
+  if (pruned > 0) saveState(state, identity);
 
   if (changedBuckets.length === 0 && changedSessions.length === 0) {
     if (!quiet) console.log(dim('无新增数据。'));
@@ -422,7 +435,7 @@ export async function runSync({
           batchStateChanged = true;
         }
       }
-      if (batchStateChanged) saveState(state);
+      if (batchStateChanged) saveState(state, identity);
     }
 
     if (totalBatches > 1 || allBucketsToSend.length > 0) {