@tokentop/ttop 0.2.2

package/src/plugins/providers/github-copilot.ts

@@ -0,0 +1,194 @@
+import type {
+  ProviderPlugin,
+  ProviderFetchContext,
+  ProviderUsageData,
+  UsageLimit,
+  ProviderAuth,
+  PluginContext,
+  CredentialResult,
+  Credentials,
+} from '../types/provider.ts';
+
+interface CopilotUserResponse {
+  access_type_sku?: string;
+  copilot_plan?: string;
+  chat_enabled?: boolean;
+  quota_reset_date?: string;
+  quota_reset_date_utc?: string;
+  quota_snapshots?: Record<string, CopilotQuotaSnapshot | undefined>;
+}
+
+interface CopilotQuotaSnapshot {
+  entitlement: number;
+  remaining: number;
+  percent_remaining?: number;
+  unlimited: boolean;
+  quota_id?: string;
+  timestamp_utc?: string;
+}
+
+export const githubCopilotPlugin: ProviderPlugin = {
+  apiVersion: 2,
+  id: 'github-copilot',
+  type: 'provider',
+  name: 'GitHub Copilot',
+  version: '1.0.0',
+
+  meta: {
+    description: 'GitHub Copilot usage tracking including premium requests',
+    homepage: 'https://github.com/features/copilot',
+    brandColor: '#6e40c9',
+  },
+
+  permissions: {
+    network: {
+      enabled: true,
+      allowedDomains: ['api.github.com'],
+    },
+    env: {
+      read: true,
+      vars: ['GITHUB_TOKEN', 'GH_TOKEN'],
+    },
+    filesystem: {
+      read: true,
+      paths: ['~/.config/github-copilot'],
+    },
+  },
+
+  capabilities: {
+    usageLimits: true,
+    apiRateLimits: false,
+    tokenUsage: false,
+    actualCosts: false,
+  },
+
+  pricing: {
+    modelsDevProviderId: 'openai',
+  },
+
+  auth: {
+    async discover(ctx: PluginContext): Promise<CredentialResult> {
+      const entry = await ctx.authSources.opencode.getProviderEntry('github-copilot');
+      if (entry) {
+        const token = entry.token || entry.key || entry.access;
+        if (token) {
+          return { ok: true, credentials: { apiKey: token, source: 'opencode' } };
+        }
+      }
+
+      // 2. Try env vars
+      const githubToken = ctx.authSources.env.get('GITHUB_TOKEN');
+      if (githubToken) {
+        return { ok: true, credentials: { apiKey: githubToken, source: 'env' } };
+      }
+
+      const ghToken = ctx.authSources.env.get('GH_TOKEN');
+      if (ghToken) {
+        return { ok: true, credentials: { apiKey: ghToken, source: 'env' } };
+      }
+
+      // 3. Try external file: ~/.config/github-copilot/hosts.json
+      const hostsData = await ctx.authSources.files.readJson<{
+        'github.com'?: { oauth_token?: string; user?: string };
+      }>('~/.config/github-copilot/hosts.json');
+      if (hostsData) {
+        const githubEntry = hostsData['github.com'];
+        if (githubEntry?.oauth_token) {
+          return { ok: true, credentials: { apiKey: githubEntry.oauth_token, source: 'external' } };
+        }
+      }
+
+      return { ok: false, reason: 'missing', message: 'No GitHub token found. Set GITHUB_TOKEN or install GitHub Copilot CLI.' };
+    },
+
+    isConfigured(credentials: Credentials): boolean {
+      return !!(credentials.apiKey || credentials.oauth?.accessToken);
+    },
+  } satisfies ProviderAuth,
+
+  async fetchUsage(ctx: ProviderFetchContext): Promise<ProviderUsageData> {
+    const { credentials, http, logger: log } = ctx;
+    const token = credentials.apiKey ?? credentials.oauth?.accessToken;
+
+    if (!token) {
+      return {
+        fetchedAt: Date.now(),
+        error: 'Not configured: missing GitHub token',
+      };
+    }
+
+    const headers: Record<string, string> = {
+      'Accept': 'application/vnd.github+json',
+      'Authorization': `token ${token}`,
+      'X-GitHub-Api-Version': '2022-11-28',
+    };
+
+    try {
+      const response = await http.fetch('https://api.github.com/copilot_internal/user', {
+        method: 'GET',
+        headers,
+      });
+
+      if (!response.ok) {
+        if (response.status === 404) {
+          return {
+            planType: 'None',
+            fetchedAt: Date.now(),
+            error: 'Copilot not enabled for this account',
+          };
+        }
+        log.warn('Failed to fetch Copilot usage', { status: response.status });
+        return {
+          fetchedAt: Date.now(),
+          error: `API error: ${response.status} ${response.statusText}`,
+        };
+      }
+
+      const data = (await response.json()) as CopilotUserResponse;
+
+      const planType = data.copilot_plan ?? data.access_type_sku ?? 'Copilot';
+      const result: ProviderUsageData = {
+        planType,
+        fetchedAt: Date.now(),
+      };
+
+      const premiumSnapshot = data.quota_snapshots?.premium_interactions;
+      if (premiumSnapshot) {
+        const used = premiumSnapshot.entitlement - premiumSnapshot.remaining;
+        const usedPercent = premiumSnapshot.unlimited
+          ? 0
+          : premiumSnapshot.percent_remaining !== undefined
+          ? Math.max(0, 100 - premiumSnapshot.percent_remaining)
+          : premiumSnapshot.entitlement > 0
+          ? (used / premiumSnapshot.entitlement) * 100
+          : 0;
+
+        const label = premiumSnapshot.unlimited
+          ? 'Premium requests (unlimited)'
+          : `Premium requests (${Math.max(0, used)}/${premiumSnapshot.entitlement})`;
+
+        const primary: UsageLimit = {
+          usedPercent,
+          label,
+        };
+
+        const resetAt = data.quota_reset_date_utc ?? data.quota_reset_date;
+        if (resetAt) {
+          primary.resetsAt = new Date(resetAt).getTime();
+        }
+
+        result.limits = { primary };
+
+        result.limitReached = !premiumSnapshot.unlimited && premiumSnapshot.remaining <= 0;
+      }
+
+      return result;
+    } catch (err) {
+      log.error('Failed to fetch Copilot usage', { error: err });
+      return {
+        fetchedAt: Date.now(),
+        error: err instanceof Error ? err.message : 'Unknown error',
+      };
+    }
+  },
+};

package/src/plugins/providers/index.ts

@@ -0,0 +1,12 @@
+export { anthropicPlugin } from './anthropic.ts';
+export { codexPlugin } from './codex.ts';
+export { antigravityPlugin } from './antigravity.ts';
+export { githubCopilotPlugin } from './github-copilot.ts';
+export { geminiPlugin } from './gemini.ts';
+
+export { openaiApiPlugin } from './openai-api.ts';
+export { perplexityPlugin } from './perplexity.ts';
+export { opencodeZenPlugin } from './opencode-zen.ts';
+
+export { zaiCodingPlanPlugin } from './zai.ts';
+export { minimaxPlugin, minimaxCodingPlanPlugin } from './minimax.ts';

package/src/plugins/providers/minimax.ts

@@ -0,0 +1,223 @@
+import type {
+  ProviderPlugin,
+  ProviderFetchContext,
+  ProviderUsageData,
+  ProviderAuth,
+  PluginContext,
+  CredentialResult,
+  Credentials,
+} from '../types/provider.ts';
+
+const MINIMAX_USAGE_URL = 'https://platform.minimax.io/v1/api/openplatform/coding_plan/remains';
+
+interface MinimaxModelRemain {
+  model_name?: string;
+  current_interval_total_count?: number;
+  current_interval_usage_count?: number;
+  remains_time?: number;
+}
+
+interface MinimaxUsageResponse {
+  base_resp?: {
+    status_code?: number;
+    status_msg?: string;
+  };
+  model_remains?: MinimaxModelRemain[];
+}
+
+function createMinimaxPlugin(id: string, name: string): ProviderPlugin {
+  return {
+    apiVersion: 2,
+    id,
+    type: 'provider',
+    name,
+    version: '1.0.0',
+
+    meta: {
+      description: `${name} usage and quota tracking`,
+      homepage: 'https://platform.minimax.io',
+      brandColor: '#6366f1',
+    },
+
+    permissions: {
+      network: {
+        enabled: true,
+        allowedDomains: ['platform.minimax.io'],
+      },
+      filesystem: {
+        read: true,
+        paths: ['~/.local/share/opencode'],
+      },
+      env: {
+        read: true,
+        vars: ['MINIMAX_API_KEY', 'MINIMAX_GROUP_ID'],
+      },
+    },
+
+    capabilities: {
+      usageLimits: true,
+      apiRateLimits: false,
+      tokenUsage: false,
+      actualCosts: false,
+    },
+
+    auth: {
+      async discover(ctx: PluginContext): Promise<CredentialResult> {
+        // 1. Try OpenCode auth (api type with key + groupId)
+        const entry = await ctx.authSources.opencode.getProviderEntry(id);
+        if (entry) {
+          if (entry.type === 'api' && entry.key) {
+            return {
+              ok: true,
+              credentials: {
+                apiKey: entry.key,
+                ...(entry.groupId && { groupId: entry.groupId }),
+                source: 'opencode',
+              },
+            };
+          }
+          if (entry.type === 'wellknown' && (entry.token || entry.key)) {
+            return {
+              ok: true,
+              credentials: {
+                apiKey: (entry.token || entry.key)!,
+                ...(entry.groupId && { groupId: entry.groupId }),
+                source: 'opencode',
+              },
+            };
+          }
+        }
+
+        // 2. Try env vars
+        const apiKey = ctx.authSources.env.get('MINIMAX_API_KEY');
+        if (apiKey) {
+          const groupId = ctx.authSources.env.get('MINIMAX_GROUP_ID');
+          return {
+            ok: true,
+            credentials: {
+              apiKey,
+              ...(groupId && { groupId }),
+              source: 'env',
+            },
+          };
+        }
+
+        return { ok: false, reason: 'missing', message: 'No MiniMax API key found. Configure MiniMax in OpenCode.' };
+      },
+
+      isConfigured(credentials: Credentials): boolean {
+        return !!credentials.apiKey;
+      },
+    } satisfies ProviderAuth,
+
+    async fetchUsage(ctx: ProviderFetchContext): Promise<ProviderUsageData> {
+      const { credentials, http, logger: log, config } = ctx;
+
+      const apiKey = credentials.apiKey;
+      if (!apiKey) {
+        return {
+          fetchedAt: Date.now(),
+          error: 'API key required. Configure MiniMax in OpenCode.',
+        };
+      }
+
+      const groupId = credentials.groupId || 
+        (config.groupId as string | undefined) ||
+        process.env.MINIMAX_GROUP_ID;
+
+      if (!groupId) {
+        return {
+          fetchedAt: Date.now(),
+          error: 'MiniMax groupId required. Set MINIMAX_GROUP_ID or configure in OpenCode.',
+        };
+      }
+
+      try {
+        const url = `${MINIMAX_USAGE_URL}?GroupId=${encodeURIComponent(groupId)}`;
+        const response = await http.fetch(url, {
+          method: 'GET',
+          headers: {
+            'Authorization': `Bearer ${apiKey}`,
+            'Referer': 'https://platform.minimax.io/user-center/payment/coding-plan',
+            'Accept': 'application/json',
+          },
+        });
+
+        if (!response.ok) {
+          log.warn('Failed to fetch MiniMax usage', { status: response.status });
+          
+          if (response.status === 401 || response.status === 403) {
+            return {
+              fetchedAt: Date.now(),
+              error: 'Authorization failed. Check your MiniMax API key.',
+            };
+          }
+          
+          return {
+            fetchedAt: Date.now(),
+            error: `API error: ${response.status} ${response.statusText}`,
+          };
+        }
+
+        const data = (await response.json()) as MinimaxUsageResponse;
+
+        if (!data || data.base_resp?.status_code !== 0) {
+          const errorMsg = data?.base_resp?.status_msg || 'Unknown error';
+          return {
+            fetchedAt: Date.now(),
+            error: `MiniMax API error: ${errorMsg}`,
+          };
+        }
+
+        const modelRemains = data.model_remains ?? [];
+        if (modelRemains.length === 0) {
+          return {
+            fetchedAt: Date.now(),
+            planType: 'MiniMax Coding Plan',
+            allowed: true,
+          };
+        }
+
+        const model = modelRemains[0]!;
+        const totalCount = model.current_interval_total_count ?? 0;
+        const remainingCount = model.current_interval_usage_count ?? 0;
+        const remainsTime = model.remains_time ?? 0;
+
+        const usedCount = totalCount > 0 ? totalCount - remainingCount : 0;
+        const usedPercent = totalCount > 0 
+          ? Math.round((usedCount / totalCount) * 100) 
+          : 0;
+
+        const limitReached = usedCount >= totalCount && totalCount > 0;
+
+        const result: ProviderUsageData = {
+          planType: model.model_name || 'MiniMax Coding Plan',
+          allowed: !limitReached,
+          limitReached,
+          limits: {
+            primary: {
+              usedPercent,
+              label: 'Requests',
+            },
+          },
+          fetchedAt: Date.now(),
+        };
+
+        if (remainsTime > 0 && result.limits?.primary) {
+          result.limits.primary.resetsAt = Date.now() + remainsTime;
+        }
+
+        return result;
+      } catch (err) {
+        log.error('Failed to fetch MiniMax usage', { error: err });
+        return {
+          fetchedAt: Date.now(),
+          error: err instanceof Error ? err.message : 'Unknown error',
+        };
+      }
+    },
+  };
+}
+
+export const minimaxPlugin = createMinimaxPlugin('minimax', 'MiniMax');
+export const minimaxCodingPlanPlugin = createMinimaxPlugin('minimax-coding-plan', 'MiniMax Coding Plan');

package/src/plugins/providers/openai-api.ts

@@ -0,0 +1,250 @@
+import type {
+  ProviderPlugin,
+  ProviderFetchContext,
+  ProviderUsageData,
+  ProviderAuth,
+  PluginContext,
+  CredentialResult,
+  Credentials,
+} from '../types/provider.ts';
+
+interface UsageBucket {
+  object: string;
+  start_time: number;
+  end_time: number;
+  results: Array<{
+    object: string;
+    input_tokens: number;
+    output_tokens: number;
+    input_cached_tokens?: number;
+    num_model_requests: number;
+    model?: string | null;
+  }>;
+}
+
+interface UsageResponse {
+  object: string;
+  data: UsageBucket[];
+  has_more: boolean;
+}
+
+interface CostsBucket {
+  object: string;
+  start_time: number;
+  end_time: number;
+  results: Array<{
+    object: string;
+    amount: {
+      value: number;
+      currency: string;
+    };
+    line_item?: string | null;
+    project_id?: string | null;
+  }>;
+}
+
+interface CostsResponse {
+  object: string;
+  data: CostsBucket[];
+  has_more: boolean;
+}
+
+export const openaiApiPlugin: ProviderPlugin = {
+  apiVersion: 2,
+  id: 'openai-api',
+  type: 'provider',
+  name: 'OpenAI API',
+  version: '1.0.0',
+
+  meta: {
+    description: 'OpenAI Codex subscription usage tracking (OAuth)',
+    homepage: 'https://openai.com/codex',
+    brandColor: '#10a37f',
+    providerAliases: ['openai'],
+  },
+
+  permissions: {
+    network: {
+      enabled: true,
+      allowedDomains: ['api.openai.com'],
+    },
+    env: {
+      read: true,
+      vars: ['OPENAI_API_KEY', 'OPENAI_ADMIN_KEY'],
+    },
+  },
+
+  capabilities: {
+    usageLimits: false,
+    apiRateLimits: true,
+    tokenUsage: true,
+    actualCosts: true,
+  },
+
+  pricing: {
+    modelsDevProviderId: 'openai',
+  },
+
+  auth: {
+    async discover(ctx: PluginContext): Promise<CredentialResult> {
+      const entry = await ctx.authSources.opencode.getProviderEntry('openai');
+      if (entry) {
+        if (entry.type === 'api' && entry.key) {
+          return { ok: true, credentials: { apiKey: entry.key, source: 'opencode' } };
+        }
+        if (entry.type === 'wellknown' && (entry.token || entry.key)) {
+          return { ok: true, credentials: { apiKey: (entry.token || entry.key)!, source: 'opencode' } };
+        }
+      }
+
+      // 2. Try env vars (OPENAI_API_KEY, then OPENAI_ADMIN_KEY)
+      const apiKey = ctx.authSources.env.get('OPENAI_API_KEY');
+      if (apiKey) {
+        return { ok: true, credentials: { apiKey, source: 'env' } };
+      }
+
+      const adminKey = ctx.authSources.env.get('OPENAI_ADMIN_KEY');
+      if (adminKey) {
+        return { ok: true, credentials: { apiKey: adminKey, source: 'env' } };
+      }
+
+      return { ok: false, reason: 'missing', message: 'No OpenAI API key found. Set OPENAI_API_KEY or configure in OpenCode.' };
+    },
+
+    isConfigured(credentials: Credentials): boolean {
+      return !!credentials.apiKey;
+    },
+  } satisfies ProviderAuth,
+
+  async fetchUsage(ctx: ProviderFetchContext): Promise<ProviderUsageData> {
+    const { credentials, http, logger: log } = ctx;
+
+    if (!credentials.apiKey) {
+      return {
+        fetchedAt: Date.now(),
+        error: 'API key required. Set OPENAI_API_KEY environment variable.',
+      };
+    }
+
+    const adminKey = process.env.OPENAI_ADMIN_KEY || credentials.apiKey;
+    const now = Math.floor(Date.now() / 1000);
+    const oneDayAgo = now - 86400;
+
+    log.info('Fetching OpenAI usage', { keyPrefix: credentials.apiKey.slice(0, 10) });
+
+    try {
+      const [usageResult, costsResult] = await Promise.allSettled([
+        fetchCompletionsUsage(http, adminKey, oneDayAgo),
+        fetchCosts(http, adminKey, oneDayAgo),
+      ]);
+
+      const result: ProviderUsageData = {
+        planType: 'API',
+        allowed: true,
+        fetchedAt: Date.now(),
+      };
+
+      if (usageResult.status === 'fulfilled' && usageResult.value) {
+        const usage = usageResult.value;
+        const totalInput = usage.data.reduce((sum, bucket) => 
+          sum + bucket.results.reduce((s, r) => s + (r.input_tokens || 0), 0), 0);
+        const totalOutput = usage.data.reduce((sum, bucket) => 
+          sum + bucket.results.reduce((s, r) => s + (r.output_tokens || 0), 0), 0);
+        const totalCached = usage.data.reduce((sum, bucket) => 
+          sum + bucket.results.reduce((s, r) => s + (r.input_cached_tokens || 0), 0), 0);
+
+        result.tokens = {
+          input: totalInput,
+          output: totalOutput,
+          cacheRead: totalCached,
+        };
+
+        log.debug('OpenAI tokens (24h)', { input: totalInput, output: totalOutput, cached: totalCached });
+      } else if (usageResult.status === 'rejected') {
+        log.warn('Failed to fetch OpenAI usage', { error: usageResult.reason?.message });
+      }
+
+      if (costsResult.status === 'fulfilled' && costsResult.value) {
+        const costs = costsResult.value;
+        const totalCost = costs.data.reduce((sum, bucket) => 
+          sum + bucket.results.reduce((s, r) => s + (r.amount?.value || 0), 0), 0);
+        
+        const currency = costs.data[0]?.results[0]?.amount?.currency || 'USD';
+
+        if (totalCost > 0) {
+          result.cost = {
+            actual: {
+              total: totalCost,
+              currency,
+            },
+            source: 'api',
+          };
+        }
+
+        log.debug('OpenAI costs (24h)', { total: totalCost, currency });
+      } else if (costsResult.status === 'rejected') {
+        log.warn('Failed to fetch OpenAI costs', { error: costsResult.reason?.message });
+      }
+
+      return result;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      log.error('OpenAI fetch error', { error: msg });
+      
+      return {
+        planType: 'API',
+        allowed: true,
+        fetchedAt: Date.now(),
+        error: `Failed to fetch usage: ${msg}`,
+      };
+    }
+  },
+};
+
+async function fetchCompletionsUsage(
+  http: ProviderFetchContext['http'],
+  apiKey: string,
+  startTime: number
+): Promise<UsageResponse | null> {
+  const url = `https://api.openai.com/v1/organization/usage/completions?start_time=${startTime}&bucket_width=1d&limit=1`;
+  
+  const response = await http.fetch(url, {
+    headers: {
+      'Authorization': `Bearer ${apiKey}`,
+      'Content-Type': 'application/json',
+    },
+  });
+
+  if (!response.ok) {
+    if (response.status === 403) {
+      return null;
+    }
+    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+  }
+
+  return response.json() as Promise<UsageResponse>;
+}
+
+async function fetchCosts(
+  http: ProviderFetchContext['http'],
+  apiKey: string,
+  startTime: number
+): Promise<CostsResponse | null> {
+  const url = `https://api.openai.com/v1/organization/usage/costs?start_time=${startTime}&bucket_width=1d&limit=1`;
+  
+  const response = await http.fetch(url, {
+    headers: {
+      'Authorization': `Bearer ${apiKey}`,
+      'Content-Type': 'application/json',
+    },
+  });
+
+  if (!response.ok) {
+    if (response.status === 403) {
+      return null;
+    }
+    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+  }
+
+  return response.json() as Promise<CostsResponse>;
+}