@algochad/archcoder 2.0.2

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

@@ -0,0 +1,152 @@
+/**
+ * Quota Providers Registry
+ *
+ * Implements quota fetching for various AI providers using a registry pattern.
+ * @module quota/providers
+ */
+
+import { buildResult } from '../utils/index.js';
+
+import * as claude from './claude.js';
+import * as codex from './codex.js';
+import * as copilot from './copilot.js';
+import * as google from './google/index.js';
+import * as kimi from './kimi.js';
+import * as nanogpt from './nanogpt.js';
+import * as openai from './openai.js';
+import * as openrouter from './openrouter.js';
+import * as zai from './zai.js';
+import * as minimaxCodingPlan from './minimax-coding-plan.js';
+import * as minimaxCnCodingPlan from './minimax-cn-coding-plan.js';
+import * as ollamaCloud from './ollama-cloud.js';
+
+const registry = {
+  claude: {
+    providerId: claude.providerId,
+    providerName: claude.providerName,
+    isConfigured: claude.isConfigured,
+    fetchQuota: claude.fetchQuota
+  },
+  codex: {
+    providerId: codex.providerId,
+    providerName: codex.providerName,
+    isConfigured: codex.isConfigured,
+    fetchQuota: codex.fetchQuota
+  },
+  google: {
+    providerId: 'google',
+    providerName: 'Google',
+    isConfigured: () => google.resolveGoogleAuthSources().length > 0,
+    fetchQuota: google.fetchGoogleQuota
+  },
+  'zai-coding-plan': {
+    providerId: zai.providerId,
+    providerName: zai.providerName,
+    isConfigured: zai.isConfigured,
+    fetchQuota: zai.fetchQuota
+  },
+  'kimi-for-coding': {
+    providerId: kimi.providerId,
+    providerName: kimi.providerName,
+    isConfigured: kimi.isConfigured,
+    fetchQuota: kimi.fetchQuota
+  },
+  openrouter: {
+    providerId: openrouter.providerId,
+    providerName: openrouter.providerName,
+    isConfigured: openrouter.isConfigured,
+    fetchQuota: openrouter.fetchQuota
+  },
+  'nano-gpt': {
+    providerId: nanogpt.providerId,
+    providerName: nanogpt.providerName,
+    isConfigured: nanogpt.isConfigured,
+    fetchQuota: nanogpt.fetchQuota
+  },
+  'github-copilot': {
+    providerId: copilot.providerId,
+    providerName: copilot.providerName,
+    isConfigured: copilot.isConfigured,
+    fetchQuota: copilot.fetchQuota
+  },
+  'github-copilot-addon': {
+    providerId: copilot.providerIdAddon,
+    providerName: copilot.providerNameAddon,
+    isConfigured: copilot.isConfigured,
+    fetchQuota: copilot.fetchQuotaAddon
+  },
+  'minimax-coding-plan': {
+    providerId: minimaxCodingPlan.providerId,
+    providerName: minimaxCodingPlan.providerName,
+    isConfigured: minimaxCodingPlan.isConfigured,
+    fetchQuota: minimaxCodingPlan.fetchQuota
+  },
+  'minimax-cn-coding-plan': {
+    providerId: minimaxCnCodingPlan.providerId,
+    providerName: minimaxCnCodingPlan.providerName,
+    isConfigured: minimaxCnCodingPlan.isConfigured,
+    fetchQuota: minimaxCnCodingPlan.fetchQuota
+  },
+  'ollama-cloud': {
+    providerId: ollamaCloud.providerId,
+    providerName: ollamaCloud.providerName,
+    isConfigured: ollamaCloud.isConfigured,
+    fetchQuota: ollamaCloud.fetchQuota
+  }
+};
+
+export const listConfiguredQuotaProviders = () => {
+  const configured = [];
+
+  for (const [id, provider] of Object.entries(registry)) {
+    try {
+      if (provider.isConfigured()) {
+        configured.push(id);
+      }
+    } catch {
+      // Ignore provider-specific config errors in list API.
+    }
+  }
+
+  return configured;
+};
+
+export const fetchQuotaForProvider = async (providerId) => {
+  const provider = registry[providerId];
+
+  if (!provider) {
+    return buildResult({
+      providerId,
+      providerName: providerId,
+      ok: false,
+      configured: false,
+      error: 'Unsupported provider'
+    });
+  }
+
+  try {
+    return await provider.fetchQuota();
+  } catch (error) {
+    return buildResult({
+      providerId: provider.providerId,
+      providerName: provider.providerName,
+      ok: false,
+      configured: true,
+      error: error instanceof Error ? error.message : 'Request failed'
+    });
+  }
+};
+
+export const fetchClaudeQuota = claude.fetchQuota;
+export const fetchOpenaiQuota = openai.fetchQuota;
+export const fetchGoogleQuota = google.fetchGoogleQuota;
+export const fetchCodexQuota = codex.fetchQuota;
+export const fetchCopilotQuota = copilot.fetchQuota;
+export const fetchCopilotAddonQuota = copilot.fetchQuotaAddon;
+export const fetchKimiQuota = kimi.fetchQuota;
+export const fetchOpenRouterQuota = openrouter.fetchQuota;
+export const fetchZaiQuota = zai.fetchQuota;
+export const fetchNanoGptQuota = nanogpt.fetchQuota;
+export const fetchMinimaxCodingPlanQuota = minimaxCodingPlan.fetchQuota;
+export const fetchMinimaxCnCodingPlanQuota = minimaxCnCodingPlan.fetchQuota;
+export const fetchOllamaCloudQuota = ollamaCloud.fetchQuota;

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

@@ -0,0 +1,55 @@
+/**
+ * Quota Provider Interface
+ *
+ * Defines the contract for implementing quota providers.
+ * @module quota/providers
+ */
+
+/**
+ * @typedef {Object} UsageWindow
+ * @property {number|null} usedPercent - Percentage of usage (0-100)
+ * @property {number|null} remainingPercent - Percentage remaining (0-100)
+ * @property {number|null} windowSeconds - Window duration in seconds
+ * @property {number|null} resetAfterSeconds - Seconds until reset
+ * @property {number|null} resetAt - Unix timestamp when quota resets
+ * @property {string|null} resetAtFormatted - Human-readable reset time
+ * @property {string|null} resetAfterFormatted - Human-readable time until reset
+ * @property {string|null} valueLabel - Optional label for display (e.g., "$10.00 remaining")
+ */
+
+/**
+ * @typedef {Object} ProviderUsage
+ * @property {Object.<string, UsageWindow>} windows - Usage windows by key (e.g., '5h', '7d', 'daily')
+ * @property {Object.<string, Object>} [models] - Model-specific usage (provider-specific)
+ */
+
+/**
+ * @typedef {Object} QuotaProviderResult
+ * @property {string} providerId - Unique identifier for the provider
+ * @property {string} providerName - Display name for the provider
+ * @property {boolean} ok - Whether the fetch was successful
+ * @property {boolean} configured - Whether the provider is configured
+ * @property {ProviderUsage|null} usage - Usage data if successful
+ * @property {string|null} [error] - Error message if not successful
+ * @property {number} fetchedAt - Unix timestamp when the result was fetched
+ */
+
+/**
+ * @typedef {Function} ProviderQuotaFetcher
+ * @returns {Promise<QuotaProviderResult>}
+ */
+
+/**
+ * @typedef {Function} ProviderConfigurationChecker
+ * @param {Object.<string, unknown>} [auth]
+ * @returns {boolean}
+ */
+
+/**
+ * @typedef {Object} QuotaProvider
+ * @property {string} providerId
+ * @property {string} providerName
+ * @property {string[]} aliases
+ * @property {ProviderConfigurationChecker} isConfigured
+ * @property {ProviderQuotaFetcher} fetchQuota
+ */

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

@@ -0,0 +1,108 @@
+import { readAuthFile } from '../../opencode/auth.js';
+import {
+  getAuthEntry,
+  normalizeAuthEntry,
+  buildResult,
+  toUsageWindow,
+  toNumber,
+  toTimestamp,
+  durationToLabel,
+  durationToSeconds
+} from '../utils/index.js';
+
+export const providerId = 'kimi-for-coding';
+export const providerName = 'Kimi for Coding';
+export const aliases = ['kimi-for-coding', 'kimi'];
+
+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.kimi.com/coding/v1/usages', {
+      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 windows = {};
+    const usage = payload?.usage ?? null;
+    if (usage) {
+      const limit = toNumber(usage.limit);
+      const remaining = toNumber(usage.remaining);
+      const usedPercent = limit && remaining !== null
+        ? Math.max(0, Math.min(100, 100 - (remaining / limit) * 100))
+        : null;
+      windows.weekly = toUsageWindow({
+        usedPercent,
+        windowSeconds: null,
+        resetAt: toTimestamp(usage.resetTime)
+      });
+    }
+
+    const limits = Array.isArray(payload?.limits) ? payload.limits : [];
+    for (const limit of limits) {
+      const window = limit?.window;
+      const detail = limit?.detail;
+      const rawLabel = durationToLabel(window?.duration, window?.timeUnit);
+      const windowSeconds = durationToSeconds(window?.duration, window?.timeUnit);
+      const label = windowSeconds === 5 * 60 * 60 ? `Rate Limit (${rawLabel})` : rawLabel;
+      const total = toNumber(detail?.limit);
+      const remaining = toNumber(detail?.remaining);
+      const usedPercent = total && remaining !== null
+        ? Math.max(0, Math.min(100, 100 - (remaining / total) * 100))
+        : null;
+      windows[label] = toUsageWindow({
+        usedPercent,
+        windowSeconds,
+        resetAt: toTimestamp(detail?.resetTime)
+      });
+    }
+
+    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/minimax-cn-coding-plan.js

@@ -0,0 +1,15 @@
+// MiniMax Coding Plan Provider
+import { createMiniMaxCodingPlanProvider } from './minimax-shared.js';
+
+const provider = createMiniMaxCodingPlanProvider({
+  providerId: 'minimax-cn-coding-plan',
+  providerName: 'MiniMax Coding Plan (minimaxi.com)',
+  aliases: ['minimax-cn-coding-plan'],
+  endpoint: 'https://www.minimaxi.com/v1/api/openplatform/coding_plan/remains',
+});
+
+export const providerId = provider.providerId;
+export const providerName = provider.providerName;
+export const aliases = provider.aliases;
+export const isConfigured = provider.isConfigured;
+export const fetchQuota = provider.fetchQuota;

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

@@ -0,0 +1,15 @@
+// MiniMax Coding Plan Provider
+import { createMiniMaxCodingPlanProvider } from './minimax-shared.js';
+
+const provider = createMiniMaxCodingPlanProvider({
+  providerId: 'minimax-coding-plan',
+  providerName: 'MiniMax Coding Plan (minimax.io)',
+  aliases: ['minimax-coding-plan'],
+  endpoint: 'https://www.minimax.io/v1/api/openplatform/coding_plan/remains',
+});
+
+export const providerId = provider.providerId;
+export const providerName = provider.providerName;
+export const aliases = provider.aliases;
+export const isConfigured = provider.isConfigured;
+export const fetchQuota = provider.fetchQuota;

package/server/lib/quota/providers/minimax-shared.js

@@ -0,0 +1,136 @@
+import { readAuthFile } from '../../opencode/auth.js';
+import {
+  getAuthEntry,
+  normalizeAuthEntry,
+  buildResult,
+  toUsageWindow,
+  toNumber,
+  toTimestamp,
+} from '../utils/index.js';
+
+export const createMiniMaxCodingPlanProvider = ({ providerId, providerName, aliases, endpoint }) => {
+  const isConfigured = () => {
+    const auth = readAuthFile();
+    const entry = normalizeAuthEntry(getAuthEntry(auth, aliases));
+    return Boolean(entry?.key || entry?.token);
+  };
+
+  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(endpoint, {
+        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 baseResp = payload?.base_resp;
+      if (baseResp && baseResp.status_code !== 0) {
+        return buildResult({
+          providerId,
+          providerName,
+          ok: false,
+          configured: true,
+          error: baseResp.status_msg || `API error: ${baseResp.status_code}`,
+        });
+      }
+
+      const firstModel = payload?.model_remains?.[0];
+      if (!firstModel) {
+        return buildResult({
+          providerId,
+          providerName,
+          ok: false,
+          configured: true,
+          error: 'No model quota data available',
+        });
+      }
+
+      const intervalTotal = toNumber(firstModel.current_interval_total_count);
+      const intervalUsage = toNumber(firstModel.current_interval_usage_count);
+      const intervalStartAt = toTimestamp(firstModel.start_time);
+      const intervalResetAt = toTimestamp(firstModel.end_time);
+      const weeklyTotal = toNumber(firstModel.current_weekly_total_count);
+      const weeklyUsage = toNumber(firstModel.current_weekly_usage_count);
+      const weeklyStartAt = toTimestamp(firstModel.weekly_start_time);
+      const weeklyResetAt = toTimestamp(firstModel.weekly_end_time);
+      const intervalUsed = intervalTotal - intervalUsage;
+      const weeklyUsed = weeklyTotal - weeklyUsage;
+      const intervalUsedPercent =
+        intervalTotal > 0 ? Math.max(0, Math.min(100, (intervalUsed / intervalTotal) * 100)) : null;
+      const intervalWindowSeconds =
+        intervalStartAt && intervalResetAt && intervalResetAt > intervalStartAt
+          ? Math.floor((intervalResetAt - intervalStartAt) / 1000)
+          : null;
+      const weeklyUsedPercent =
+        weeklyTotal > 0 ? Math.max(0, Math.min(100, (weeklyUsed / weeklyTotal) * 100)) : null;
+      const weeklyWindowSeconds =
+        weeklyStartAt && weeklyResetAt && weeklyResetAt > weeklyStartAt
+          ? Math.floor((weeklyResetAt - weeklyStartAt) / 1000)
+          : null;
+
+      const windows = {
+        '5h': toUsageWindow({
+          usedPercent: intervalUsedPercent,
+          windowSeconds: intervalWindowSeconds,
+          resetAt: intervalResetAt,
+        }),
+        weekly: toUsageWindow({
+          usedPercent: weeklyUsedPercent,
+          windowSeconds: weeklyWindowSeconds,
+          resetAt: weeklyResetAt,
+        }),
+      };
+
+      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',
+      });
+    }
+  };
+
+  return {
+    providerId,
+    providerName,
+    aliases,
+    isConfigured,
+    fetchQuota,
+  };
+};

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

@@ -0,0 +1,124 @@
+import { readAuthFile } from '../../opencode/auth.js';
+import {
+  getAuthEntry,
+  normalizeAuthEntry,
+  buildResult,
+  toUsageWindow,
+  toNumber,
+  toTimestamp
+} from '../utils/index.js';
+
+const NANO_GPT_DAILY_WINDOW_SECONDS = 86400;
+
+export const providerId = 'nano-gpt';
+export const providerName = 'NanoGPT';
+export const aliases = ['nano-gpt', 'nanogpt', 'nano_gpt'];
+
+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://nano-gpt.com/api/subscription/v1/usage', {
+      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 windows = {};
+    const period = payload?.period ?? null;
+    const daily = payload?.daily ?? null;
+    const monthly = payload?.monthly ?? null;
+    const state = payload?.state ?? 'active';
+
+    if (daily) {
+      let usedPercent = null;
+      const percentUsed = daily?.percentUsed;
+      if (typeof percentUsed === 'number') {
+        usedPercent = Math.max(0, Math.min(100, percentUsed * 100));
+      } else {
+        const used = toNumber(daily?.used);
+        const limit = toNumber(daily?.limit ?? daily?.limits?.daily);
+        if (used !== null && limit !== null && limit > 0) {
+          usedPercent = Math.max(0, Math.min(100, (used / limit) * 100));
+        }
+      }
+      const resetAt = toTimestamp(daily?.resetAt);
+      const valueLabel = state !== 'active' ? `(${state})` : null;
+      windows['daily'] = toUsageWindow({
+        usedPercent,
+        windowSeconds: NANO_GPT_DAILY_WINDOW_SECONDS,
+        resetAt,
+        valueLabel
+      });
+    }
+
+    if (monthly) {
+      let usedPercent = null;
+      const percentUsed = monthly?.percentUsed;
+      if (typeof percentUsed === 'number') {
+        usedPercent = Math.max(0, Math.min(100, percentUsed * 100));
+      } else {
+        const used = toNumber(monthly?.used);
+        const limit = toNumber(monthly?.limit ?? monthly?.limits?.monthly);
+        if (used !== null && limit !== null && limit > 0) {
+          usedPercent = Math.max(0, Math.min(100, (used / limit) * 100));
+        }
+      }
+      const resetAt = toTimestamp(monthly?.resetAt ?? period?.currentPeriodEnd);
+      const valueLabel = state !== 'active' ? `(${state})` : null;
+      windows['monthly'] = toUsageWindow({
+        usedPercent,
+        windowSeconds: null,
+        resetAt,
+        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'
+    });
+  }
+};