@tokentop/ttop 0.2.2 → 0.4.0

package/src/plugins/providers/perplexity.ts

@@ -1,48 +1,48 @@
 import type {
-  ProviderPlugin,
-  ProviderFetchContext,
-  ProviderUsageData,
-  ProviderAuth,
-  PluginContext,
   CredentialResult,
   Credentials,
-} from '../types/provider.ts';
+  PluginContext,
+  ProviderAuth,
+  ProviderFetchContext,
+  ProviderPlugin,
+  ProviderUsageData,
+} 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',
+  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',
+    description: "Perplexity AI API usage (credit-based)",
+    homepage: "https://www.perplexity.ai",
+    brandColor: "#20b2aa",
   },
 
   permissions: {
     network: {
       enabled: true,
-      allowedDomains: ['api.perplexity.ai'],
+      allowedDomains: ["api.perplexity.ai"],
     },
     env: {
       read: true,
-      vars: ['PERPLEXITY_API_KEY'],
+      vars: ["PERPLEXITY_API_KEY"],
     },
   },
 
@@ -56,23 +56,30 @@ export const perplexityPlugin: ProviderPlugin = {
   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');
+      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 === "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 === "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');
+      const apiKey = ctx.authSources.env.get("PERPLEXITY_API_KEY");
       if (apiKey) {
-        return { ok: true, credentials: { apiKey, source: 'env' } };
+        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.' };
+      return {
+        ok: false,
+        reason: "missing",
+        message: "No Perplexity API key found. Set PERPLEXITY_API_KEY or configure in OpenCode.",
+      };
     },
 
     isConfigured(credentials: Credentials): boolean {
@@ -86,22 +93,22 @@ export const perplexityPlugin: ProviderPlugin = {
     if (!credentials.apiKey) {
       return {
         fetchedAt: Date.now(),
-        error: 'API key required. Set PERPLEXITY_API_KEY environment variable.',
+        error: "API key required. Set PERPLEXITY_API_KEY environment variable.",
       };
     }
 
-    log.info('Checking Perplexity API', { keyPrefix: credentials.apiKey.slice(0, 8) });
+    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',
+      const response = await http.fetch("https://api.perplexity.ai/chat/completions", {
+        method: "POST",
         headers: {
-          'Authorization': `Bearer ${credentials.apiKey}`,
-          'Content-Type': 'application/json',
+          Authorization: `Bearer ${credentials.apiKey}`,
+          "Content-Type": "application/json",
         },
         body: JSON.stringify({
-          model: 'sonar',
-          messages: [{ role: 'user', content: 'ping' }],
+          model: "sonar",
+          messages: [{ role: "user", content: "ping" }],
           max_tokens: 1,
         }),
       });
@@ -109,39 +116,41 @@ export const perplexityPlugin: ProviderPlugin = {
       if (response.status === 401) {
         return {
           fetchedAt: Date.now(),
-          error: 'Invalid API key',
+          error: "Invalid API key",
         };
       }
 
       if (response.status === 402) {
         return {
-          planType: 'API',
+          planType: "API",
           allowed: false,
           fetchedAt: Date.now(),
           credits: {
             hasCredits: false,
             unlimited: false,
-            balance: '$0.00',
+            balance: "$0.00",
           },
-          error: 'Insufficient credits',
+          error: "Insufficient credits",
         };
       }
 
       if (response.status === 429) {
         return {
-          planType: 'API',
+          planType: "API",
           allowed: true,
           fetchedAt: Date.now(),
-          error: 'Rate limited',
+          error: "Rate limited",
         };
       }
 
       if (response.ok) {
-        const data = await response.json().catch(() => null) as { usage?: { prompt_tokens?: number; completion_tokens?: number } } | null;
+        const data = (await response.json().catch(() => null)) as {
+          usage?: { prompt_tokens?: number; completion_tokens?: number };
+        } | null;
         const usage = data?.usage;
-        
+
         return {
-          planType: 'API',
+          planType: "API",
           allowed: true,
           fetchedAt: Date.now(),
           credits: {
@@ -157,17 +166,17 @@ export const perplexityPlugin: ProviderPlugin = {
         };
       }
 
-      const errorText = await response.text().catch(() => '');
+      const errorText = await response.text().catch(() => "");
       return {
-        planType: 'API',
+        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 });
-      
+      log.error("Perplexity fetch error", { error: msg });
+
       return {
         fetchedAt: Date.now(),
         error: `Connection error: ${msg}`,

package/src/plugins/providers/zai.ts

@@ -1,15 +1,15 @@
 import type {
-  ProviderPlugin,
+  CredentialResult,
+  Credentials,
+  PluginContext,
+  ProviderAuth,
   ProviderFetchContext,
+  ProviderPlugin,
   ProviderUsageData,
   UsageLimit,
-  ProviderAuth,
-  PluginContext,
-  CredentialResult,
-  Credentials,
-} from '../types/provider.ts';
+} from "../types/provider.ts";
 
-const ZAI_USAGE_URL = 'https://api.z.ai/api/monitor/usage/quota/limit';
+const ZAI_USAGE_URL = "https://api.z.ai/api/monitor/usage/quota/limit";
 
 interface ZaiLimitEntry {
   type?: string;
@@ -28,29 +28,29 @@ interface ZaiUsageResponse {
 
 export const zaiCodingPlanPlugin: ProviderPlugin = {
   apiVersion: 2,
-  id: 'zai-coding-plan',
-  type: 'provider',
-  name: 'Z.ai Coding Plan',
-  version: '1.0.0',
+  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',
+    description: "Z.ai coding plan usage and quota tracking",
+    homepage: "https://z.ai",
+    brandColor: "#10b981",
   },
 
   permissions: {
     network: {
       enabled: true,
-      allowedDomains: ['api.z.ai'],
+      allowedDomains: ["api.z.ai"],
     },
     filesystem: {
       read: true,
-      paths: ['~/.local/share/opencode'],
+      paths: ["~/.local/share/opencode"],
     },
     env: {
       read: true,
-      vars: ['ZAI_API_KEY'],
+      vars: ["ZAI_API_KEY"],
     },
   },
 
@@ -64,26 +64,35 @@ export const zaiCodingPlanPlugin: ProviderPlugin = {
   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');
+      const entry =
+        (await ctx.authSources.opencode.getProviderEntry("zhipuai-coding-plan")) ||
+        (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 === "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 === "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' } };
+        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');
+      const apiKey = ctx.authSources.env.get("ZAI_API_KEY");
       if (apiKey) {
-        return { ok: true, credentials: { apiKey, source: 'env' } };
+        return { ok: true, credentials: { apiKey, source: "env" } };
       }
 
-      return { ok: false, reason: 'missing', message: 'No Z.ai API key found. Configure Z.ai in OpenCode.' };
+      return {
+        ok: false,
+        reason: "missing",
+        message: "No Z.ai API key found. Configure Z.ai in OpenCode.",
+      };
     },
 
     isConfigured(credentials: Credentials): boolean {
@@ -99,29 +108,29 @@ export const zaiCodingPlanPlugin: ProviderPlugin = {
     if (!token) {
       return {
         fetchedAt: Date.now(),
-        error: 'API key required. Configure Z.ai in OpenCode.',
+        error: "API key required. Configure Z.ai in OpenCode.",
       };
     }
 
     try {
       const response = await http.fetch(ZAI_USAGE_URL, {
-        method: 'GET',
+        method: "GET",
         headers: {
-          'Authorization': `Bearer ${token}`,
-          'Accept': 'application/json',
+          Authorization: `Bearer ${token}`,
+          Accept: "application/json",
         },
       });
 
       if (!response.ok) {
-        log.warn('Failed to fetch Z.ai usage', { status: response.status });
-        
+        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.',
+            error: "Authorization failed. Check your Z.ai API key.",
           };
         }
-        
+
         return {
           fetchedAt: Date.now(),
           error: `API error: ${response.status} ${response.statusText}`,
@@ -133,7 +142,7 @@ export const zaiCodingPlanPlugin: ProviderPlugin = {
       if (!data || data.success !== true) {
         return {
           fetchedAt: Date.now(),
-          planType: 'Z.ai',
+          planType: "Z.ai",
           allowed: true,
         };
       }
@@ -142,18 +151,18 @@ export const zaiCodingPlanPlugin: ProviderPlugin = {
       if (limits.length === 0) {
         return {
           fetchedAt: Date.now(),
-          planType: 'Z.ai',
+          planType: "Z.ai",
           allowed: true,
         };
       }
 
       const parsedLimits = limits
-        .map(limit => ({
+        .map((limit) => ({
           type: limit.type,
           usedPercent: resolveUsedPercent(limit),
           remaining: limit.remaining,
         }))
-        .filter(l => l.usedPercent !== null);
+        .filter((l) => l.usedPercent !== null);
 
       let primary: UsageLimit | undefined;
       for (const limit of parsedLimits) {
@@ -166,13 +175,14 @@ export const zaiCodingPlanPlugin: ProviderPlugin = {
         }
       }
 
-      const limitReached = parsedLimits.some(l => 
-        (l.usedPercent !== null && l.usedPercent >= 100) ||
-        (typeof l.remaining === 'number' && l.remaining <= 0)
+      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',
+        planType: "Z.ai Coding Plan",
         allowed: !limitReached,
         limitReached,
         fetchedAt: Date.now(),
@@ -184,26 +194,27 @@ export const zaiCodingPlanPlugin: ProviderPlugin = {
 
       return result;
     } catch (err) {
-      log.error('Failed to fetch Z.ai usage', { error: err });
+      log.error("Failed to fetch Z.ai usage", { error: err });
       return {
         fetchedAt: Date.now(),
-        error: err instanceof Error ? err.message : 'Unknown error',
+        error: err instanceof Error ? err.message : "Unknown error",
       };
     }
   },
 };
 
 function resolveUsedPercent(limit: ZaiLimitEntry): number | null {
-  if (typeof limit.percentage === 'number') {
+  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;
+  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);
@@ -213,13 +224,13 @@ function resolveUsedPercent(limit: ZaiLimitEntry): number | null {
 }
 
 function formatLimitType(type?: string): string {
-  if (!type) return 'Quota';
+  if (!type) return "Quota";
   switch (type) {
-    case 'TIME_LIMIT':
-      return 'Time';
-    case 'TOKENS_LIMIT':
-      return 'Tokens';
+    case "TIME_LIMIT":
+      return "Time";
+    case "TOKENS_LIMIT":
+      return "Tokens";
     default:
-      return type.replace(/_/g, ' ').toLowerCase();
+      return type.replace(/_/g, " ").toLowerCase();
   }
 }