@thevinci/web 1.0.0

package/server/lib/quota/providers/openrouter.js

@@ -0,0 +1,92 @@
+import { readAuthFile } from '../../opencode/auth.js';
+import {
+  getAuthEntry,
+  normalizeAuthEntry,
+  buildResult,
+  toUsageWindow,
+  toNumber,
+  formatMoney
+} from '../utils/index.js';
+
+export const providerId = 'openrouter';
+export const providerName = 'OpenRouter';
+export const aliases = ['openrouter'];
+
+export const isConfigured = () => {
+  const auth = readAuthFile();
+  const entry = normalizeAuthEntry(getAuthEntry(auth, aliases));
+  return Boolean(entry?.key || entry?.token);
+};
+
+export const fetchQuota = async () => {
+  const auth = readAuthFile();
+  const entry = normalizeAuthEntry(getAuthEntry(auth, aliases));
+  const apiKey = entry?.key ?? entry?.token;
+
+  if (!apiKey) {
+    return buildResult({
+      providerId,
+      providerName,
+      ok: false,
+      configured: false,
+      error: 'Not configured'
+    });
+  }
+
+  try {
+    const response = await fetch('https://openrouter.ai/api/v1/credits', {
+      method: 'GET',
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        'Content-Type': 'application/json'
+      }
+    });
+
+    if (!response.ok) {
+      return buildResult({
+        providerId,
+        providerName,
+        ok: false,
+        configured: true,
+        error: `API error: ${response.status}`
+      });
+    }
+
+    const payload = await response.json();
+    const credits = payload?.data ?? {};
+    const totalCredits = toNumber(credits.total_credits);
+    const totalUsage = toNumber(credits.total_usage);
+    const remaining = totalCredits !== null && totalUsage !== null
+      ? Math.max(0, totalCredits - totalUsage)
+      : null;
+    let valueLabel = null;
+    if (remaining !== null && totalUsage !== null) {
+      valueLabel = `$${formatMoney(remaining)} left · $${formatMoney(totalUsage)} spent`;
+    }
+
+    const windows = {
+      credits: toUsageWindow({
+        usedPercent: null,
+        windowSeconds: null,
+        resetAt: null,
+        valueLabel
+      })
+    };
+
+    return buildResult({
+      providerId,
+      providerName,
+      ok: true,
+      configured: true,
+      usage: { windows }
+    });
+  } catch (error) {
+    return buildResult({
+      providerId,
+      providerName,
+      ok: false,
+      configured: true,
+      error: error instanceof Error ? error.message : 'Request failed'
+    });
+  }
+};

package/server/lib/quota/providers/zai.js

@@ -0,0 +1,91 @@
+import { readAuthFile } from '../../opencode/auth.js';
+import {
+  getAuthEntry,
+  normalizeAuthEntry,
+  buildResult,
+  toUsageWindow,
+  toNumber,
+  toTimestamp,
+  resolveWindowSeconds,
+  resolveWindowLabel,
+  normalizeTimestamp
+} from '../utils/index.js';
+
+export const providerId = 'zai-coding-plan';
+export const providerName = 'z.ai';
+export const aliases = ['zai-coding-plan', 'zai', 'z.ai'];
+
+export const isConfigured = () => {
+  const auth = readAuthFile();
+  const entry = normalizeAuthEntry(getAuthEntry(auth, aliases));
+  return Boolean(entry?.key || entry?.token);
+};
+
+export const fetchQuota = async () => {
+  const auth = readAuthFile();
+  const entry = normalizeAuthEntry(getAuthEntry(auth, aliases));
+  const apiKey = entry?.key ?? entry?.token;
+
+  if (!apiKey) {
+    return buildResult({
+      providerId,
+      providerName,
+      ok: false,
+      configured: false,
+      error: 'Not configured'
+    });
+  }
+
+  try {
+    const response = await fetch('https://api.z.ai/api/monitor/usage/quota/limit', {
+      method: 'GET',
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        'Content-Type': 'application/json'
+      }
+    });
+
+    if (!response.ok) {
+      return buildResult({
+        providerId,
+        providerName,
+        ok: false,
+        configured: true,
+        error: `API error: ${response.status}`
+      });
+    }
+
+    const payload = await response.json();
+    const limits = Array.isArray(payload?.data?.limits) ? payload.data.limits : [];
+    const tokensLimit = limits.find((limit) => limit?.type === 'TOKENS_LIMIT');
+    const windowSeconds = resolveWindowSeconds(tokensLimit);
+    const windowLabel = resolveWindowLabel(windowSeconds);
+    const resetAt = tokensLimit?.nextResetTime ? normalizeTimestamp(tokensLimit.nextResetTime) : null;
+    const usedPercent = typeof tokensLimit?.percentage === 'number' ? tokensLimit.percentage : null;
+
+    const windows = {};
+    if (tokensLimit) {
+      windows[windowLabel] = toUsageWindow({
+        usedPercent,
+        windowSeconds,
+        resetAt
+      });
+    }
+
+    return buildResult({
+      providerId,
+      providerName,
+      ok: true,
+      configured: true,
+      usage: { windows }
+    });
+  } catch (error) {
+    return buildResult({
+      providerId,
+      providerName,
+      ok: false,
+      configured: true,
+      error: error instanceof Error ? error.message : 'Request failed'
+    });
+  }
+};

package/server/lib/quota/providers/zhipuai-coding-plan.js

@@ -0,0 +1,133 @@
+/**
+ * Zhipu AI Coding Plan quota fetch
+ *
+ * API: https://open.bigmodel.cn/api/monitor/usage/quota/limit
+ *
+ * Response limits:
+ * - TOKENS_LIMIT: Token usage (5-hour rolling window)
+ * - TIME_LIMIT: MCP tools usage (monthly window)
+ *
+ * @typedef {Object} TokensLimit
+ * @property {string} type - 'TOKENS_LIMIT'
+ * @property {number} [unit]
+ * @property {number} [number]
+ * @property {number} [nextResetTime]
+ * @property {number} [percentage]
+ *
+ * @typedef {Object} McpToolsTimeLimit
+ * @property {string} type - 'TIME_LIMIT'
+ * @property {number} [unit]
+ * @property {number} [number]
+ * @property {number} [usage]
+ * @property {number} [currentValue]
+ * @property {number} [remaining]
+ * @property {number} [percentage]
+ * @property {number} [nextResetTime]
+ * @property {Array<{modelCode: string, usage: number}>} [usageDetails]
+ */
+import { readAuthFile } from '../../opencode/auth.js';
+import {
+  getAuthEntry,
+  normalizeAuthEntry,
+  buildResult,
+  toUsageWindow,
+  resolveWindowSeconds,
+  normalizeTimestamp
+} from '../utils/index.js';
+
+export const providerId = 'zhipuai-coding-plan';
+export const providerName = 'Zhipu AI Coding Plan';
+export const aliases = ['zhipuai-coding-plan'];
+
+export const isConfigured = () => {
+  const auth = readAuthFile();
+  const entry = normalizeAuthEntry(getAuthEntry(auth, aliases));
+  return Boolean(entry?.key || entry?.token);
+};
+
+export const fetchQuota = async () => {
+  const auth = readAuthFile();
+  const entry = normalizeAuthEntry(getAuthEntry(auth, aliases));
+  const apiKey = entry?.key ?? entry?.token;
+
+  if (!apiKey) {
+    return buildResult({
+      providerId,
+      providerName,
+      ok: false,
+      configured: false,
+      error: 'Not configured'
+    });
+  }
+
+  try {
+    const response = await fetch('https://open.bigmodel.cn/api/monitor/usage/quota/limit', {
+      method: 'GET',
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        'Content-Type': 'application/json'
+      }
+    });
+
+    if (!response.ok) {
+      return buildResult({
+        providerId,
+        providerName,
+        ok: false,
+        configured: true,
+        error: `API error: ${response.status}`
+      });
+    }
+
+    const payload = await response.json();
+    const limits = Array.isArray(payload?.data?.limits) ? payload.data.limits : [];
+
+    const tokensLimit = limits.find((limit) => limit?.type === 'TOKENS_LIMIT');
+    const mcpToolsTimeLimit = limits.find((limit) => limit?.type === 'TIME_LIMIT');
+
+    const windows = {};
+
+    // Handle TOKENS_LIMIT (5-hour window for token usage)
+    if (tokensLimit) {
+      const windowSeconds = resolveWindowSeconds(tokensLimit);
+      const resetAt = tokensLimit?.nextResetTime ? normalizeTimestamp(tokensLimit.nextResetTime) : null;
+      const usedPercent = typeof tokensLimit?.percentage === 'number' ? tokensLimit.percentage : null;
+
+      windows['Tokens'] = toUsageWindow({
+        usedPercent,
+        windowSeconds,
+        resetAt
+      });
+    }
+
+    // Handle TIME_LIMIT (MCP tools monthly window)
+    if (mcpToolsTimeLimit) {
+      // TIME_LIMIT unit=5 means 1 month (30 days)
+      const monthSeconds = 30 * 24 * 60 * 60;
+      const resetAt = mcpToolsTimeLimit?.nextResetTime ? normalizeTimestamp(mcpToolsTimeLimit.nextResetTime) : null;
+      const usedPercent = typeof mcpToolsTimeLimit?.percentage === 'number' ? mcpToolsTimeLimit.percentage : null;
+
+      windows['MCP Tools'] = toUsageWindow({
+        usedPercent,
+        windowSeconds: monthSeconds,
+        resetAt
+      });
+    }
+
+    return buildResult({
+      providerId,
+      providerName,
+      ok: true,
+      configured: true,
+      usage: { windows }
+    });
+  } catch (error) {
+    return buildResult({
+      providerId,
+      providerName,
+      ok: false,
+      configured: true,
+      error: error instanceof Error ? error.message : 'Request failed'
+    });
+  }
+};

package/server/lib/quota/providers/zhipuai.js

@@ -0,0 +1,114 @@
+import { readAuthFile } from '../../opencode/auth.js';
+import { readConfigLayers } from '../../opencode/shared.js';
+import {
+  getAuthEntry,
+  normalizeAuthEntry,
+  buildResult,
+  toUsageWindow,
+  toNumber,
+  toTimestamp,
+  resolveWindowSeconds,
+  resolveWindowLabel,
+  normalizeTimestamp
+} from '../utils/index.js';
+
+export const providerId = 'zhipuai-coding-plan';
+export const providerName = 'ZhipuAI';
+export const aliases = ['zhipuai-coding-plan', 'zhipuai', 'zhipu'];
+
+function getApiKey() {
+  const auth = readAuthFile();
+  const oldEntry = normalizeAuthEntry(getAuthEntry(auth, aliases));
+  const apiKeyFromOld = oldEntry?.key ?? oldEntry?.token;
+
+  if (apiKeyFromOld) {
+    return apiKeyFromOld;
+  }
+
+  try {
+    const layers = readConfigLayers();
+    const { mergedConfig } = layers;
+
+    for (const alias of aliases) {
+      const providerConfig = mergedConfig?.provider?.[alias];
+      if (providerConfig?.options?.apiKey) {
+        return providerConfig.options.apiKey;
+      }
+    }
+  } catch (error) {
+    // Ignore read errors
+  }
+
+  return null;
+}
+
+export const isConfigured = () => {
+  return Boolean(getApiKey());
+};
+
+export const fetchQuota = async () => {
+  const apiKey = getApiKey();
+
+  if (!apiKey) {
+    return buildResult({
+      providerId,
+      providerName,
+      ok: false,
+      configured: false,
+      error: 'Not configured'
+    });
+  }
+
+  try {
+    const response = await fetch('https://open.bigmodel.cn/api/monitor/usage/quota/limit', {
+      method: 'GET',
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        'Content-Type': 'application/json'
+      }
+    });
+
+    if (!response.ok) {
+      return buildResult({
+        providerId,
+        providerName,
+        ok: false,
+        configured: true,
+        error: `API error: ${response.status}`
+      });
+    }
+
+    const payload = await response.json();
+    const limits = Array.isArray(payload?.data?.limits) ? payload.data.limits : [];
+    const tokensLimit = limits.find((limit) => limit?.type === 'TOKENS_LIMIT');
+    const windowSeconds = resolveWindowSeconds(tokensLimit);
+    const windowLabel = resolveWindowLabel(windowSeconds);
+    const resetAt = tokensLimit?.nextResetTime ? normalizeTimestamp(tokensLimit.nextResetTime) : null;
+    const usedPercent = typeof tokensLimit?.percentage === 'number' ? tokensLimit.percentage : null;
+
+    const windows = {};
+    if (tokensLimit) {
+      windows[windowLabel] = toUsageWindow({
+        usedPercent,
+        windowSeconds,
+        resetAt
+      });
+    }
+
+    return buildResult({
+      providerId,
+      providerName,
+      ok: true,
+      configured: true,
+      usage: { windows }
+    });
+  } catch (error) {
+    return buildResult({
+      providerId,
+      providerName,
+      ok: false,
+      configured: true,
+      error: error instanceof Error ? error.message : 'Request failed'
+    });
+  }
+};

package/server/lib/quota/routes.js

@@ -0,0 +1,27 @@
+export function registerQuotaRoutes(app, { getQuotaProviders }) {
+  app.get('/api/quota/providers', async (_req, res) => {
+    try {
+      const { listConfiguredQuotaProviders } = await getQuotaProviders();
+      const providers = listConfiguredQuotaProviders();
+      res.json({ providers });
+    } catch (error) {
+      console.error('Failed to list quota providers:', error);
+      res.status(500).json({ error: error.message || 'Failed to list quota providers' });
+    }
+  });
+
+  app.get('/api/quota/:providerId', async (req, res) => {
+    try {
+      const { providerId } = req.params;
+      if (!providerId) {
+        return res.status(400).json({ error: 'Provider ID is required' });
+      }
+      const { fetchQuotaForProvider } = await getQuotaProviders();
+      const result = await fetchQuotaForProvider(providerId);
+      res.json(result);
+    } catch (error) {
+      console.error('Failed to fetch quota:', error);
+      res.status(500).json({ error: error.message || 'Failed to fetch quota' });
+    }
+  });
+}

package/server/lib/quota/utils/auth.js

@@ -0,0 +1,50 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const OPENCODE_CONFIG_DIR = process.env.OPENCODE_CONFIG_DIR
+  ? path.resolve(process.env.OPENCODE_CONFIG_DIR)
+  : path.join(os.homedir(), '.vinci', '.opencode');
+const OPENCODE_DATA_DIR = process.env.OPENCODE_DATA_DIR
+  ? path.resolve(process.env.OPENCODE_DATA_DIR)
+  : path.join(os.homedir(), '.vinci', '.opencode', 'data');
+
+export const ANTIGRAVITY_ACCOUNTS_PATHS = [
+  path.join(OPENCODE_CONFIG_DIR, 'antigravity-accounts.json'),
+  path.join(OPENCODE_DATA_DIR, 'antigravity-accounts.json')
+];
+
+export const readJsonFile = (filePath) => {
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+  try {
+    const raw = fs.readFileSync(filePath, 'utf8');
+    const trimmed = raw.trim();
+    if (!trimmed) return null;
+    return JSON.parse(trimmed);
+  } catch (error) {
+    console.warn(`Failed to read JSON file: ${filePath}`, error);
+    return null;
+  }
+};
+
+export const getAuthEntry = (auth, aliases) => {
+  for (const alias of aliases) {
+    if (auth[alias]) {
+      return auth[alias];
+    }
+  }
+  return null;
+};
+
+export const normalizeAuthEntry = (entry) => {
+  if (!entry) return null;
+  if (typeof entry === 'string') {
+    return { token: entry };
+  }
+  if (typeof entry === 'object') {
+    return entry;
+  }
+  return null;
+};

package/server/lib/quota/utils/formatters.js

@@ -0,0 +1,85 @@
+export const formatResetTime = (timestamp) => {
+  try {
+    const resetDate = new Date(timestamp);
+    if (!Number.isFinite(resetDate.getTime())) {
+      return null;
+    }
+
+    const now = new Date();
+    const isToday = resetDate.toDateString() === now.toDateString();
+    
+    if (isToday) {
+      return resetDate.toLocaleTimeString(undefined, {
+        hour: 'numeric',
+        minute: '2-digit'
+      });
+    }
+    
+    return resetDate.toLocaleString(undefined, {
+      month: 'short',
+      day: 'numeric',
+      weekday: 'short',
+      hour: 'numeric',
+      minute: '2-digit'
+    });
+  } catch {
+    return null;
+  }
+};
+
+const hasResetTimestamp = (resetAt) => resetAt !== null && resetAt !== undefined && resetAt !== '';
+
+export const calculateResetAfterSeconds = (resetAt) => {
+  if (!hasResetTimestamp(resetAt)) return null;
+  const resetAtTime = new Date(resetAt).getTime();
+  if (!Number.isFinite(resetAtTime)) return null;
+  const delta = Math.floor((resetAtTime - Date.now()) / 1000);
+  return delta < 0 ? 0 : delta;
+};
+
+export const toUsageWindow = ({ usedPercent, windowSeconds, resetAt, valueLabel }) => {
+  const resetAfterSeconds = calculateResetAfterSeconds(resetAt);
+  const resetFormatted = hasResetTimestamp(resetAt) ? formatResetTime(resetAt) : null;
+  const hasFiniteUsedPercent = typeof usedPercent === 'number' && Number.isFinite(usedPercent);
+  return {
+    usedPercent,
+    remainingPercent: hasFiniteUsedPercent ? Math.max(0, 100 - usedPercent) : null,
+    windowSeconds: windowSeconds ?? null,
+    resetAfterSeconds,
+    resetAt,
+    resetAtFormatted: resetFormatted,
+    resetAfterFormatted: resetFormatted,
+    ...(valueLabel ? { valueLabel } : {})
+  };
+};
+
+export const buildResult = ({ providerId, providerName, ok, configured, usage, error }) => ({
+  providerId,
+  providerName,
+  ok,
+  configured,
+  usage: usage ?? null,
+  ...(error ? { error } : {}),
+  fetchedAt: Date.now()
+});
+
+export const durationToLabel = (duration, unit) => {
+  if (!duration || !unit) return 'limit';
+  if (unit === 'TIME_UNIT_MINUTE') return `${duration}m`;
+  if (unit === 'TIME_UNIT_HOUR') return `${duration}h`;
+  if (unit === 'TIME_UNIT_DAY') return `${duration}d`;
+  return 'limit';
+};
+
+export const durationToSeconds = (duration, unit) => {
+  if (!duration || !unit) return null;
+  if (unit === 'TIME_UNIT_MINUTE') return duration * 60;
+  if (unit === 'TIME_UNIT_HOUR') return duration * 3600;
+  if (unit === 'TIME_UNIT_DAY') return duration * 86400;
+  return null;
+};
+
+export const formatMoney = (value) => {
+  if (typeof value !== 'number' || !Number.isFinite(value)) return null;
+  return value.toFixed(2);
+};

package/server/lib/quota/utils/formatters.test.js

@@ -0,0 +1,54 @@
+import { describe, expect, it } from 'vitest';
+
+import { calculateResetAfterSeconds, formatResetTime, toUsageWindow } from './formatters.js';
+
+describe('formatResetTime', () => {
+  it('returns null for invalid timestamps', () => {
+    expect(formatResetTime('not-a-date')).toBeNull();
+    expect(formatResetTime(NaN)).toBeNull();
+    expect(formatResetTime(Infinity)).toBeNull();
+    expect(formatResetTime(-Infinity)).toBeNull();
+  });
+});
+
+describe('calculateResetAfterSeconds', () => {
+  it('accepts an epoch reset timestamp', () => {
+    expect(calculateResetAfterSeconds(0)).toBe(0);
+  });
+
+  it('returns null for invalid timestamps', () => {
+    expect(calculateResetAfterSeconds('not-a-date')).toBeNull();
+    expect(calculateResetAfterSeconds(NaN)).toBeNull();
+    expect(calculateResetAfterSeconds(Infinity)).toBeNull();
+    expect(calculateResetAfterSeconds(-Infinity)).toBeNull();
+  });
+});
+
+describe('toUsageWindow', () => {
+  it('formats epoch reset timestamps', () => {
+    const usageWindow = toUsageWindow({ resetAt: 0 });
+
+    expect(usageWindow.resetAfterSeconds).toBe(0);
+    expect(usageWindow.resetAtFormatted).toBe(formatResetTime(0));
+    expect(usageWindow.resetAfterFormatted).toBe(formatResetTime(0));
+  });
+
+  it('does not derive remaining percent from missing usage', () => {
+    expect(toUsageWindow({ usedPercent: undefined }).remainingPercent).toBeNull();
+  });
+
+  it('does not derive remaining percent from non-finite usage', () => {
+    expect(toUsageWindow({ usedPercent: NaN }).remainingPercent).toBeNull();
+    expect(toUsageWindow({ usedPercent: Infinity }).remainingPercent).toBeNull();
+    expect(toUsageWindow({ usedPercent: -Infinity }).remainingPercent).toBeNull();
+    expect(toUsageWindow({ usedPercent: null }).remainingPercent).toBeNull();
+  });
+
+  it('derives remaining percent from a valid usage value', () => {
+    expect(toUsageWindow({ usedPercent: 60 }).remainingPercent).toBe(40);
+  });
+
+  it('clamps remaining percent to zero when usage exceeds 100', () => {
+    expect(toUsageWindow({ usedPercent: 110 }).remainingPercent).toBe(0);
+  });
+});

package/server/lib/quota/utils/index.js

@@ -0,0 +1,10 @@
+/**
+ * Quota Utilities
+ *
+ * Shared utility functions for quota calculations and formatting.
+ * @module quota/utils
+ */
+
+export * from './auth.js';
+export * from './transformers.js';
+export * from './formatters.js';