@vibe-cafe/vibe-usage 0.10.33 → 0.11.0

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/tools.js

@@ -1,5 +1,5 @@
 import { existsSync, readdirSync, statSync } from 'node:fs';
-import { dirname, isAbsolute, join, posix, resolve, win32 } from 'node:path';
+import { delimiter, dirname, isAbsolute, join, posix, resolve, win32 } from 'node:path';
 import { homedir } from 'node:os';
 import { getOpenCodeStores } from './opencode-roots.js';
 import { findClaudeCodeDataDirs } from './claude-roots.js';
@@ -182,6 +182,12 @@ export function getMimocodeDbPath(env = process.env) {
   return isAbsolute(env.MIMOCODE_DB) ? env.MIMOCODE_DB : join(dataDir, env.MIMOCODE_DB);
 }
 
+export function getCodebuddyRoots(env = process.env, home = homedir()) {
+  const override = env.VIBE_USAGE_CODEBUDDY_DIRS?.trim();
+  if (override) return override.split(delimiter).map(value => value.trim()).filter(Boolean);
+  return [env.CODEBUDDY_CONFIG_DIR?.trim() || join(home, '.codebuddy')];
+}
+
 export function getZcodeDbPath(env = process.env, home = homedir()) {
   const override = env.VIBE_USAGE_ZCODE_DB?.trim();
   if (override) return isAbsolute(override) ? override : resolve(override);
@@ -451,6 +457,12 @@ export const TOOLS = [
     id: 'zcode',
     dataDir: getZcodeDbPath(),
   },
+  {
+    name: 'CodeBuddy',
+    id: 'codebuddy',
+    dataDir: join(getCodebuddyRoots()[0], 'projects'),
+    detectDataDirs: () => getCodebuddyRoots().map(root => join(root, 'projects')).filter(existsSync),
+  },
   {
     name: 'Devin',
     id: 'devin',