@tokentop/ttop 0.2.2

package/src/plugins/providers/opencode-zen.ts

@@ -0,0 +1,125 @@
+import type {
+  ProviderPlugin,
+  ProviderFetchContext,
+  ProviderUsageData,
+  ProviderAuth,
+  PluginContext,
+  CredentialResult,
+  Credentials,
+} from '../types/provider.ts';
+
+export const opencodeZenPlugin: ProviderPlugin = {
+  apiVersion: 2,
+  id: 'opencode-zen',
+  type: 'provider',
+  name: 'OpenCode Zen',
+  version: '1.0.0',
+
+  meta: {
+    description: 'OpenCode Zen - curated AI models for coding agents',
+    homepage: 'https://opencode.ai/zen',
+    brandColor: '#6366f1',
+    providerAliases: ['opencode'],
+  },
+
+  permissions: {
+    network: {
+      enabled: true,
+      allowedDomains: ['opencode.ai'],
+    },
+    filesystem: {
+      read: true,
+      paths: ['~/.local/share/opencode'],
+    },
+    env: {
+      read: true,
+      vars: ['OPENCODE_API_KEY'],
+    },
+  },
+
+  capabilities: {
+    usageLimits: false,
+    apiRateLimits: false,
+    tokenUsage: true,
+    actualCosts: true,
+  },
+
+  pricing: {
+    modelsDevProviderId: 'anthropic',
+  },
+
+  auth: {
+    async discover(ctx: PluginContext): Promise<CredentialResult> {
+      // 1. Try OpenCode auth (getProviderEntry reads auth.json and config)
+      const entry = await ctx.authSources.opencode.getProviderEntry('opencode');
+      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
+      const apiKey = ctx.authSources.env.get('OPENCODE_API_KEY');
+      if (apiKey) {
+        return { ok: true, credentials: { apiKey, source: 'env' } };
+      }
+
+      return { ok: false, reason: 'missing', message: 'No OpenCode API key found. Run /connect in OpenCode to set up Zen.' };
+    },
+
+    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. Run /connect in OpenCode to set up Zen.',
+      };
+    }
+
+    log.info('OpenCode Zen configured', { keyPrefix: credentials.apiKey.slice(0, 10) });
+
+    try {
+      const response = await http.fetch('https://opencode.ai/zen/v1/models', {
+        headers: {
+          'Authorization': `Bearer ${credentials.apiKey}`,
+        },
+      });
+      
+      if (response.ok) {
+        log.info('OpenCode Zen API accessible');
+        return {
+          planType: 'Pay-as-you-go',
+          allowed: true,
+          fetchedAt: Date.now(),
+          credits: {
+            hasCredits: true,
+            unlimited: false,
+          },
+        };
+      }
+
+      return {
+        planType: 'Pay-as-you-go',
+        allowed: true,
+        fetchedAt: Date.now(),
+      };
+    } catch (err) {
+      log.warn('Could not verify OpenCode Zen API access', { error: String(err) });
+      
+      return {
+        planType: 'Pay-as-you-go',
+        allowed: true,
+        fetchedAt: Date.now(),
+      };
+    }
+  },
+};

package/src/plugins/providers/perplexity.ts

@@ -0,0 +1,177 @@
+import type {
+  ProviderPlugin,
+  ProviderFetchContext,
+  ProviderUsageData,
+  ProviderAuth,
+  PluginContext,
+  CredentialResult,
+  Credentials,
+} from '../types/provider.ts';
+
+/**
+ * Perplexity Shadow API Discovery (January 2026):
+ * 
+ * Internal endpoints that power the billing dashboard (require session cookies, not API key):
+ * - GET /rest/pplx-api/v2/groups → { orgs: [{ api_org_id, display_name, usage_tier }] }
+ * - GET /rest/pplx-api/v2/groups/{orgId} → { customerInfo: { balance, auto_top_up_amount, ... } }
+ * - GET /rest/pplx-api/v2/groups/{orgId}/usage-analytics?time_bucket=day&time_range=past_month
+ *     → Array of meter data (api_requests, input_tokens, output_tokens, etc.) with costs
+ * - GET /rest/pplx-api/v2/groups/{orgId}/invoices → Invoice history
+ * 
+ * Unfortunately, these endpoints use web session auth, not API key auth.
+ * GitHub issue #266 requests a public usage API endpoint.
+ */
+
+export const perplexityPlugin: ProviderPlugin = {
+  apiVersion: 2,
+  id: 'perplexity',
+  type: 'provider',
+  name: 'Perplexity',
+  version: '1.0.0',
+
+  meta: {
+    description: 'Perplexity AI API usage (credit-based)',
+    homepage: 'https://www.perplexity.ai',
+    brandColor: '#20b2aa',
+  },
+
+  permissions: {
+    network: {
+      enabled: true,
+      allowedDomains: ['api.perplexity.ai'],
+    },
+    env: {
+      read: true,
+      vars: ['PERPLEXITY_API_KEY'],
+    },
+  },
+
+  capabilities: {
+    usageLimits: false,
+    apiRateLimits: true,
+    tokenUsage: true,
+    actualCosts: false,
+  },
+
+  auth: {
+    async discover(ctx: PluginContext): Promise<CredentialResult> {
+      // 1. Try OpenCode auth first (wellknown type, has token or key)
+      const entry = await ctx.authSources.opencode.getProviderEntry('perplexity');
+      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
+      const apiKey = ctx.authSources.env.get('PERPLEXITY_API_KEY');
+      if (apiKey) {
+        return { ok: true, credentials: { apiKey, source: 'env' } };
+      }
+
+      return { ok: false, reason: 'missing', message: 'No Perplexity API key found. Set PERPLEXITY_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 PERPLEXITY_API_KEY environment variable.',
+      };
+    }
+
+    log.info('Checking Perplexity API', { keyPrefix: credentials.apiKey.slice(0, 8) });
+
+    try {
+      const response = await http.fetch('https://api.perplexity.ai/chat/completions', {
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${credentials.apiKey}`,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          model: 'sonar',
+          messages: [{ role: 'user', content: 'ping' }],
+          max_tokens: 1,
+        }),
+      });
+
+      if (response.status === 401) {
+        return {
+          fetchedAt: Date.now(),
+          error: 'Invalid API key',
+        };
+      }
+
+      if (response.status === 402) {
+        return {
+          planType: 'API',
+          allowed: false,
+          fetchedAt: Date.now(),
+          credits: {
+            hasCredits: false,
+            unlimited: false,
+            balance: '$0.00',
+          },
+          error: 'Insufficient credits',
+        };
+      }
+
+      if (response.status === 429) {
+        return {
+          planType: 'API',
+          allowed: true,
+          fetchedAt: Date.now(),
+          error: 'Rate limited',
+        };
+      }
+
+      if (response.ok) {
+        const data = await response.json().catch(() => null) as { usage?: { prompt_tokens?: number; completion_tokens?: number } } | null;
+        const usage = data?.usage;
+        
+        return {
+          planType: 'API',
+          allowed: true,
+          fetchedAt: Date.now(),
+          credits: {
+            hasCredits: true,
+            unlimited: false,
+          },
+          ...(usage && {
+            tokens: {
+              input: usage.prompt_tokens ?? 0,
+              output: usage.completion_tokens ?? 0,
+            },
+          }),
+        };
+      }
+
+      const errorText = await response.text().catch(() => '');
+      return {
+        planType: 'API',
+        allowed: true,
+        fetchedAt: Date.now(),
+        error: `API error: ${response.status} ${errorText.slice(0, 100)}`,
+      };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      log.error('Perplexity fetch error', { error: msg });
+      
+      return {
+        fetchedAt: Date.now(),
+        error: `Connection error: ${msg}`,
+      };
+    }
+  },
+};

package/src/plugins/providers/zai.ts

@@ -0,0 +1,225 @@
+import type {
+  ProviderPlugin,
+  ProviderFetchContext,
+  ProviderUsageData,
+  UsageLimit,
+  ProviderAuth,
+  PluginContext,
+  CredentialResult,
+  Credentials,
+} from '../types/provider.ts';
+
+const ZAI_USAGE_URL = 'https://api.z.ai/api/monitor/usage/quota/limit';
+
+interface ZaiLimitEntry {
+  type?: string;
+  usage?: number;
+  currentValue?: number;
+  remaining?: number;
+  percentage?: number;
+}
+
+interface ZaiUsageResponse {
+  success?: boolean;
+  data?: {
+    limits?: ZaiLimitEntry[];
+  };
+}
+
+export const zaiCodingPlanPlugin: ProviderPlugin = {
+  apiVersion: 2,
+  id: 'zai-coding-plan',
+  type: 'provider',
+  name: 'Z.ai Coding Plan',
+  version: '1.0.0',
+
+  meta: {
+    description: 'Z.ai coding plan usage and quota tracking',
+    homepage: 'https://z.ai',
+    brandColor: '#10b981',
+  },
+
+  permissions: {
+    network: {
+      enabled: true,
+      allowedDomains: ['api.z.ai'],
+    },
+    filesystem: {
+      read: true,
+      paths: ['~/.local/share/opencode'],
+    },
+    env: {
+      read: true,
+      vars: ['ZAI_API_KEY'],
+    },
+  },
+
+  capabilities: {
+    usageLimits: true,
+    apiRateLimits: false,
+    tokenUsage: false,
+    actualCosts: false,
+  },
+
+  auth: {
+    async discover(ctx: PluginContext): Promise<CredentialResult> {
+      // 1. Try OpenCode auth (api, wellknown, or oauth)
+      const entry = await ctx.authSources.opencode.getProviderEntry('zai-coding-plan');
+      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' } };
+        }
+        if (entry.type === 'oauth' && entry.access) {
+          return { ok: true, credentials: { apiKey: entry.access, source: 'opencode' } };
+        }
+      }
+
+      // 2. Try env vars
+      const apiKey = ctx.authSources.env.get('ZAI_API_KEY');
+      if (apiKey) {
+        return { ok: true, credentials: { apiKey, source: 'env' } };
+      }
+
+      return { ok: false, reason: 'missing', message: 'No Z.ai API key found. Configure Z.ai in OpenCode.' };
+    },
+
+    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: 'API key required. Configure Z.ai in OpenCode.',
+      };
+    }
+
+    try {
+      const response = await http.fetch(ZAI_USAGE_URL, {
+        method: 'GET',
+        headers: {
+          'Authorization': `Bearer ${token}`,
+          'Accept': 'application/json',
+        },
+      });
+
+      if (!response.ok) {
+        log.warn('Failed to fetch Z.ai usage', { status: response.status });
+        
+        if (response.status === 401 || response.status === 403) {
+          return {
+            fetchedAt: Date.now(),
+            error: 'Authorization failed. Check your Z.ai API key.',
+          };
+        }
+        
+        return {
+          fetchedAt: Date.now(),
+          error: `API error: ${response.status} ${response.statusText}`,
+        };
+      }
+
+      const data = (await response.json()) as ZaiUsageResponse;
+
+      if (!data || data.success !== true) {
+        return {
+          fetchedAt: Date.now(),
+          planType: 'Z.ai',
+          allowed: true,
+        };
+      }
+
+      const limits = data.data?.limits ?? [];
+      if (limits.length === 0) {
+        return {
+          fetchedAt: Date.now(),
+          planType: 'Z.ai',
+          allowed: true,
+        };
+      }
+
+      const parsedLimits = limits
+        .map(limit => ({
+          type: limit.type,
+          usedPercent: resolveUsedPercent(limit),
+          remaining: limit.remaining,
+        }))
+        .filter(l => l.usedPercent !== null);
+
+      let primary: UsageLimit | undefined;
+      for (const limit of parsedLimits) {
+        if (limit.usedPercent === null) continue;
+        if (!primary || limit.usedPercent > (primary.usedPercent ?? 0)) {
+          primary = {
+            usedPercent: limit.usedPercent,
+            label: formatLimitType(limit.type),
+          };
+        }
+      }
+
+      const limitReached = parsedLimits.some(l => 
+        (l.usedPercent !== null && l.usedPercent >= 100) ||
+        (typeof l.remaining === 'number' && l.remaining <= 0)
+      );
+
+      const result: ProviderUsageData = {
+        planType: 'Z.ai Coding Plan',
+        allowed: !limitReached,
+        limitReached,
+        fetchedAt: Date.now(),
+      };
+
+      if (primary) {
+        result.limits = { primary };
+      }
+
+      return result;
+    } catch (err) {
+      log.error('Failed to fetch Z.ai usage', { error: err });
+      return {
+        fetchedAt: Date.now(),
+        error: err instanceof Error ? err.message : 'Unknown error',
+      };
+    }
+  },
+};
+
+function resolveUsedPercent(limit: ZaiLimitEntry): number | null {
+  if (typeof limit.percentage === 'number') {
+    return Math.round(Math.max(0, Math.min(100, limit.percentage)));
+  }
+
+  const total = limit.usage;
+  const used = typeof limit.currentValue === 'number'
+    ? limit.currentValue
+    : (total !== undefined && typeof limit.remaining === 'number')
+      ? Math.max(0, total - limit.remaining)
+      : undefined;
+
+  if (total && used !== undefined && total > 0) {
+    return Math.round((used / total) * 100);
+  }
+
+  return null;
+}
+
+function formatLimitType(type?: string): string {
+  if (!type) return 'Quota';
+  switch (type) {
+    case 'TIME_LIMIT':
+      return 'Time';
+    case 'TOKENS_LIMIT':
+      return 'Tokens';
+    default:
+      return type.replace(/_/g, ' ').toLowerCase();
+  }
+}