@tokentop/ttop 0.2.2 → 0.3.0

package/src/plugins/providers/minimax.ts

@@ -1,14 +1,14 @@
 import type {
-  ProviderPlugin,
-  ProviderFetchContext,
-  ProviderUsageData,
-  ProviderAuth,
-  PluginContext,
   CredentialResult,
   Credentials,
-} from '../types/provider.ts';
+  PluginContext,
+  ProviderAuth,
+  ProviderFetchContext,
+  ProviderPlugin,
+  ProviderUsageData,
+} from "../types/provider.ts";
 
-const MINIMAX_USAGE_URL = 'https://platform.minimax.io/v1/api/openplatform/coding_plan/remains';
+const MINIMAX_USAGE_URL = "https://platform.minimax.io/v1/api/openplatform/coding_plan/remains";
 
 interface MinimaxModelRemain {
   model_name?: string;
@@ -29,28 +29,28 @@ function createMinimaxPlugin(id: string, name: string): ProviderPlugin {
   return {
     apiVersion: 2,
     id,
-    type: 'provider',
+    type: "provider",
     name,
-    version: '1.0.0',
+    version: "1.0.0",
 
     meta: {
       description: `${name} usage and quota tracking`,
-      homepage: 'https://platform.minimax.io',
-      brandColor: '#6366f1',
+      homepage: "https://platform.minimax.io",
+      brandColor: "#6366f1",
     },
 
     permissions: {
       network: {
         enabled: true,
-        allowedDomains: ['platform.minimax.io'],
+        allowedDomains: ["platform.minimax.io"],
       },
       filesystem: {
         read: true,
-        paths: ['~/.local/share/opencode'],
+        paths: ["~/.local/share/opencode"],
       },
       env: {
         read: true,
-        vars: ['MINIMAX_API_KEY', 'MINIMAX_GROUP_ID'],
+        vars: ["MINIMAX_API_KEY", "MINIMAX_GROUP_ID"],
       },
     },
 
@@ -66,43 +66,47 @@ function createMinimaxPlugin(id: string, name: string): ProviderPlugin {
         // 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) {
+          if (entry.type === "api" && entry.key) {
             return {
               ok: true,
               credentials: {
                 apiKey: entry.key,
                 ...(entry.groupId && { groupId: entry.groupId }),
-                source: 'opencode',
+                source: "opencode",
               },
             };
           }
-          if (entry.type === 'wellknown' && (entry.token || entry.key)) {
+          if (entry.type === "wellknown" && (entry.token || entry.key)) {
             return {
               ok: true,
               credentials: {
                 apiKey: (entry.token || entry.key)!,
                 ...(entry.groupId && { groupId: entry.groupId }),
-                source: 'opencode',
+                source: "opencode",
               },
             };
           }
         }
 
         // 2. Try env vars
-        const apiKey = ctx.authSources.env.get('MINIMAX_API_KEY');
+        const apiKey = ctx.authSources.env.get("MINIMAX_API_KEY");
         if (apiKey) {
-          const groupId = ctx.authSources.env.get('MINIMAX_GROUP_ID');
+          const groupId = ctx.authSources.env.get("MINIMAX_GROUP_ID");
           return {
             ok: true,
             credentials: {
               apiKey,
               ...(groupId && { groupId }),
-              source: 'env',
+              source: "env",
             },
           };
         }
 
-        return { ok: false, reason: 'missing', message: 'No MiniMax API key found. Configure MiniMax in OpenCode.' };
+        return {
+          ok: false,
+          reason: "missing",
+          message: "No MiniMax API key found. Configure MiniMax in OpenCode.",
+        };
       },
 
       isConfigured(credentials: Credentials): boolean {
@@ -117,42 +121,43 @@ function createMinimaxPlugin(id: string, name: string): ProviderPlugin {
       if (!apiKey) {
         return {
           fetchedAt: Date.now(),
-          error: 'API key required. Configure MiniMax in OpenCode.',
+          error: "API key required. Configure MiniMax in OpenCode.",
         };
       }
 
-      const groupId = credentials.groupId || 
+      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.',
+          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',
+          method: "GET",
           headers: {
-            'Authorization': `Bearer ${apiKey}`,
-            'Referer': 'https://platform.minimax.io/user-center/payment/coding-plan',
-            'Accept': 'application/json',
+            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 });
-          
+          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.',
+              error: "Authorization failed. Check your MiniMax API key.",
             };
           }
-          
+
           return {
             fetchedAt: Date.now(),
             error: `API error: ${response.status} ${response.statusText}`,
@@ -162,7 +167,7 @@ function createMinimaxPlugin(id: string, name: string): ProviderPlugin {
         const data = (await response.json()) as MinimaxUsageResponse;
 
         if (!data || data.base_resp?.status_code !== 0) {
-          const errorMsg = data?.base_resp?.status_msg || 'Unknown error';
+          const errorMsg = data?.base_resp?.status_msg || "Unknown error";
           return {
             fetchedAt: Date.now(),
             error: `MiniMax API error: ${errorMsg}`,
@@ -173,7 +178,7 @@ function createMinimaxPlugin(id: string, name: string): ProviderPlugin {
         if (modelRemains.length === 0) {
           return {
             fetchedAt: Date.now(),
-            planType: 'MiniMax Coding Plan',
+            planType: "MiniMax Coding Plan",
             allowed: true,
           };
         }
@@ -184,20 +189,18 @@ function createMinimaxPlugin(id: string, name: string): ProviderPlugin {
         const remainsTime = model.remains_time ?? 0;
 
         const usedCount = totalCount > 0 ? totalCount - remainingCount : 0;
-        const usedPercent = totalCount > 0 
-          ? Math.round((usedCount / totalCount) * 100) 
-          : 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',
+          planType: model.model_name || "MiniMax Coding Plan",
           allowed: !limitReached,
           limitReached,
           limits: {
             primary: {
               usedPercent,
-              label: 'Requests',
+              label: "Requests",
             },
           },
           fetchedAt: Date.now(),
@@ -209,15 +212,18 @@ function createMinimaxPlugin(id: string, name: string): ProviderPlugin {
 
         return result;
       } catch (err) {
-        log.error('Failed to fetch MiniMax usage', { error: err });
+        log.error("Failed to fetch MiniMax usage", { error: err });
         return {
           fetchedAt: Date.now(),
-          error: err instanceof Error ? err.message : 'Unknown error',
+          error: err instanceof Error ? err.message : "Unknown error",
         };
       }
     },
   };
 }
 
-export const minimaxPlugin = createMinimaxPlugin('minimax', 'MiniMax');
-export const minimaxCodingPlanPlugin = createMinimaxPlugin('minimax-coding-plan', 'MiniMax Coding Plan');
+export const minimaxPlugin = createMinimaxPlugin("minimax", "MiniMax");
+export const minimaxCodingPlanPlugin = createMinimaxPlugin(
+  "minimax-coding-plan",
+  "MiniMax Coding Plan",
+);

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

@@ -1,12 +1,12 @@
 import type {
-  ProviderPlugin,
-  ProviderFetchContext,
-  ProviderUsageData,
-  ProviderAuth,
-  PluginContext,
   CredentialResult,
   Credentials,
-} from '../types/provider.ts';
+  PluginContext,
+  ProviderAuth,
+  ProviderFetchContext,
+  ProviderPlugin,
+  ProviderUsageData,
+} from "../types/provider.ts";
 
 interface UsageBucket {
   object: string;
@@ -51,26 +51,26 @@ interface CostsResponse {
 
 export const openaiApiPlugin: ProviderPlugin = {
   apiVersion: 2,
-  id: 'openai-api',
-  type: 'provider',
-  name: 'OpenAI API',
-  version: '1.0.0',
+  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'],
+    description: "OpenAI Codex subscription usage tracking (OAuth)",
+    homepage: "https://openai.com/codex",
+    brandColor: "#10a37f",
+    providerAliases: ["openai"],
   },
 
   permissions: {
     network: {
       enabled: true,
-      allowedDomains: ['api.openai.com'],
+      allowedDomains: ["api.openai.com"],
     },
     env: {
       read: true,
-      vars: ['OPENAI_API_KEY', 'OPENAI_ADMIN_KEY'],
+      vars: ["OPENAI_API_KEY", "OPENAI_ADMIN_KEY"],
     },
   },
 
@@ -82,33 +82,40 @@ export const openaiApiPlugin: ProviderPlugin = {
   },
 
   pricing: {
-    modelsDevProviderId: 'openai',
+    modelsDevProviderId: "openai",
   },
 
   auth: {
     async discover(ctx: PluginContext): Promise<CredentialResult> {
-      const entry = await ctx.authSources.opencode.getProviderEntry('openai');
+      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 === "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 (OPENAI_API_KEY, then OPENAI_ADMIN_KEY)
-      const apiKey = ctx.authSources.env.get('OPENAI_API_KEY');
+      const apiKey = ctx.authSources.env.get("OPENAI_API_KEY");
       if (apiKey) {
-        return { ok: true, credentials: { apiKey, source: 'env' } };
+        return { ok: true, credentials: { apiKey, source: "env" } };
       }
 
-      const adminKey = ctx.authSources.env.get('OPENAI_ADMIN_KEY');
+      const adminKey = ctx.authSources.env.get("OPENAI_ADMIN_KEY");
       if (adminKey) {
-        return { ok: true, credentials: { apiKey: adminKey, source: 'env' } };
+        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.' };
+      return {
+        ok: false,
+        reason: "missing",
+        message: "No OpenAI API key found. Set OPENAI_API_KEY or configure in OpenCode.",
+      };
     },
 
     isConfigured(credentials: Credentials): boolean {
@@ -122,7 +129,7 @@ export const openaiApiPlugin: ProviderPlugin = {
     if (!credentials.apiKey) {
       return {
         fetchedAt: Date.now(),
-        error: 'API key required. Set OPENAI_API_KEY environment variable.',
+        error: "API key required. Set OPENAI_API_KEY environment variable.",
       };
     }
 
@@ -130,7 +137,7 @@ export const openaiApiPlugin: ProviderPlugin = {
     const now = Math.floor(Date.now() / 1000);
     const oneDayAgo = now - 86400;
 
-    log.info('Fetching OpenAI usage', { keyPrefix: credentials.apiKey.slice(0, 10) });
+    log.info("Fetching OpenAI usage", { keyPrefix: credentials.apiKey.slice(0, 10) });
 
     try {
       const [usageResult, costsResult] = await Promise.allSettled([
@@ -139,19 +146,26 @@ export const openaiApiPlugin: ProviderPlugin = {
       ]);
 
       const result: ProviderUsageData = {
-        planType: 'API',
+        planType: "API",
         allowed: true,
         fetchedAt: Date.now(),
       };
 
-      if (usageResult.status === 'fulfilled' && usageResult.value) {
+      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);
+        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,
@@ -159,17 +173,23 @@ export const openaiApiPlugin: ProviderPlugin = {
           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 });
+        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) {
+      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';
+        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 = {
@@ -177,22 +197,22 @@ export const openaiApiPlugin: ProviderPlugin = {
               total: totalCost,
               currency,
             },
-            source: 'api',
+            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 });
+        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 });
-      
+      log.error("OpenAI fetch error", { error: msg });
+
       return {
-        planType: 'API',
+        planType: "API",
         allowed: true,
         fetchedAt: Date.now(),
         error: `Failed to fetch usage: ${msg}`,
@@ -202,16 +222,16 @@ export const openaiApiPlugin: ProviderPlugin = {
 };
 
 async function fetchCompletionsUsage(
-  http: ProviderFetchContext['http'],
+  http: ProviderFetchContext["http"],
   apiKey: string,
-  startTime: number
+  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',
+      Authorization: `Bearer ${apiKey}`,
+      "Content-Type": "application/json",
     },
   });
 
@@ -226,16 +246,16 @@ async function fetchCompletionsUsage(
 }
 
 async function fetchCosts(
-  http: ProviderFetchContext['http'],
+  http: ProviderFetchContext["http"],
   apiKey: string,
-  startTime: number
+  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',
+      Authorization: `Bearer ${apiKey}`,
+      "Content-Type": "application/json",
     },
   });
 

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

@@ -1,73 +1,80 @@
 import type {
-  ProviderPlugin,
-  ProviderFetchContext,
-  ProviderUsageData,
-  ProviderAuth,
-  PluginContext,
   CredentialResult,
   Credentials,
-} from '../types/provider.ts';
+  PluginContext,
+  ProviderAuth,
+  ProviderFetchContext,
+  ProviderPlugin,
+  ProviderUsageData,
+} from "../types/provider.ts";
 
 export const opencodeZenPlugin: ProviderPlugin = {
   apiVersion: 2,
-  id: 'opencode-zen',
-  type: 'provider',
-  name: 'OpenCode Zen',
-  version: '1.0.0',
+  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'],
+    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'],
+      allowedDomains: ["opencode.ai"],
     },
     filesystem: {
       read: true,
-      paths: ['~/.local/share/opencode'],
+      paths: ["~/.local/share/opencode"],
     },
     env: {
       read: true,
-      vars: ['OPENCODE_API_KEY'],
+      vars: ["OPENCODE_API_KEY"],
     },
   },
 
   capabilities: {
     usageLimits: false,
     apiRateLimits: false,
-    tokenUsage: true,
-    actualCosts: true,
+    tokenUsage: false,
+    actualCosts: false,
   },
 
   pricing: {
-    modelsDevProviderId: 'anthropic',
+    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');
+      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 === "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('OPENCODE_API_KEY');
+      const apiKey = ctx.authSources.env.get("OPENCODE_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 OpenCode API key found. Run /connect in OpenCode to set up Zen.' };
+      return {
+        ok: false,
+        reason: "missing",
+        message: "No OpenCode API key found. Run /connect in OpenCode to set up Zen.",
+      };
     },
 
     isConfigured(credentials: Credentials): boolean {
@@ -81,23 +88,23 @@ export const opencodeZenPlugin: ProviderPlugin = {
     if (!credentials.apiKey) {
       return {
         fetchedAt: Date.now(),
-        error: 'API key required. Run /connect in OpenCode to set up Zen.',
+        error: "API key required. Run /connect in OpenCode to set up Zen.",
       };
     }
 
-    log.info('OpenCode Zen configured', { keyPrefix: credentials.apiKey.slice(0, 10) });
+    log.info("OpenCode Zen configured", { keyPrefix: credentials.apiKey.slice(0, 10) });
 
     try {
-      const response = await http.fetch('https://opencode.ai/zen/v1/models', {
+      const response = await http.fetch("https://opencode.ai/zen/v1/models", {
         headers: {
-          'Authorization': `Bearer ${credentials.apiKey}`,
+          Authorization: `Bearer ${credentials.apiKey}`,
         },
       });
-      
+
       if (response.ok) {
-        log.info('OpenCode Zen API accessible');
+        log.info("OpenCode Zen API accessible");
         return {
-          planType: 'Pay-as-you-go',
+          planType: "Pay-as-you-go",
           allowed: true,
           fetchedAt: Date.now(),
           credits: {
@@ -108,15 +115,15 @@ export const opencodeZenPlugin: ProviderPlugin = {
       }
 
       return {
-        planType: 'Pay-as-you-go',
+        planType: "Pay-as-you-go",
         allowed: true,
         fetchedAt: Date.now(),
       };
     } catch (err) {
-      log.warn('Could not verify OpenCode Zen API access', { error: String(err) });
-      
+      log.warn("Could not verify OpenCode Zen API access", { error: String(err) });
+
       return {
-        planType: 'Pay-as-you-go',
+        planType: "Pay-as-you-go",
         allowed: true,
         fetchedAt: Date.now(),
       };