@tokentop/ttop 0.2.2 → 0.3.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,33 @@ 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("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 +106,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 +140,7 @@ export const zaiCodingPlanPlugin: ProviderPlugin = {
       if (!data || data.success !== true) {
         return {
           fetchedAt: Date.now(),
-          planType: 'Z.ai',
+          planType: "Z.ai",
           allowed: true,
         };
       }
@@ -142,18 +149,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 +173,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 +192,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 +222,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();
   }
 }

package/src/plugins/registry.ts

@@ -1,17 +1,22 @@
+import type { PluginsConfig } from "@/config/schema.ts";
+import {
+  discoverLocalPlugins,
+  loadLocalPlugin,
+  loadNpmPlugin,
+  resolvePluginPath,
+} from "./loader.ts";
+import { installAllNpmPlugins, resolveNpmPluginPath } from "./npm-installer.ts";
 import type {
+  AgentPlugin,
   AnyPlugin,
-  PluginType,
+  NotificationPlugin,
   PluginByType,
+  PluginType,
   ProviderPlugin,
-  AgentPlugin,
   ThemePlugin,
-  NotificationPlugin,
-} from './types/index.ts';
-import { loadLocalPlugin, loadNpmPlugin, discoverLocalPlugins, resolvePluginPath } from './loader.ts';
-import { installAllNpmPlugins, resolveNpmPluginPath } from './npm-installer.ts';
-import type { PluginsConfig } from '@/config/schema.ts';
+} from "./types/index.ts";
 
-export type PluginSource = 'builtin' | 'local' | 'npm';
+export type PluginSource = "builtin" | "local" | "npm";
 
 type PluginStore = {
   provider: Map<string, ProviderPlugin>;
@@ -35,35 +40,35 @@ class PluginRegistryImpl {
     return `${type}-${id}`;
   }
 
-  register(plugin: AnyPlugin, source: PluginSource = 'builtin'): void {
+  register(plugin: AnyPlugin, source: PluginSource = "builtin"): void {
     const key = this.sourceKey(plugin.type, plugin.id);
     const existingSource = this.sources.get(key);
 
-    if (existingSource === 'builtin' && source !== 'builtin') {
+    if (existingSource === "builtin" && source !== "builtin") {
       return;
     }
 
     this.sources.set(key, source);
     switch (plugin.type) {
-      case 'provider':
+      case "provider":
         if (this.plugins.provider.has(plugin.id)) {
           console.warn(`Plugin "${plugin.id}" already registered, overwriting`);
         }
         this.plugins.provider.set(plugin.id, plugin);
         break;
-      case 'agent':
+      case "agent":
         if (this.plugins.agent.has(plugin.id)) {
           console.warn(`Plugin "${plugin.id}" already registered, overwriting`);
         }
         this.plugins.agent.set(plugin.id, plugin);
         break;
-      case 'theme':
+      case "theme":
         if (this.plugins.theme.has(plugin.id)) {
           console.warn(`Plugin "${plugin.id}" already registered, overwriting`);
         }
         this.plugins.theme.set(plugin.id, plugin);
         break;
-      case 'notification':
+      case "notification":
         if (this.plugins.notification.has(plugin.id)) {
           console.warn(`Plugin "${plugin.id}" already registered, overwriting`);
         }
@@ -115,38 +120,38 @@ class PluginRegistryImpl {
 
   async loadBuiltinPlugins(): Promise<void> {
     const [providers, agents, themes, notifications] = await Promise.all([
-      import('./providers/index.ts'),
-      import('./agents/index.ts'),
-      import('./themes/index.ts'),
-      import('./notifications/index.ts'),
+      import("./providers/index.ts"),
+      import("./agents/index.ts"),
+      import("./themes/index.ts"),
+      import("./notifications/index.ts"),
     ]);
 
     for (const plugin of Object.values(providers)) {
-      if (isProviderPlugin(plugin)) this.register(plugin, 'builtin');
+      if (isProviderPlugin(plugin)) this.register(plugin, "builtin");
     }
 
     for (const plugin of Object.values(agents)) {
-      if (isAgentPlugin(plugin)) this.register(plugin, 'builtin');
+      if (isAgentPlugin(plugin)) this.register(plugin, "builtin");
     }
 
     for (const plugin of Object.values(themes)) {
-      if (isThemePlugin(plugin)) this.register(plugin, 'builtin');
+      if (isThemePlugin(plugin)) this.register(plugin, "builtin");
     }
 
     for (const plugin of Object.values(notifications)) {
-      if (isNotificationPlugin(plugin)) this.register(plugin, 'builtin');
+      if (isNotificationPlugin(plugin)) this.register(plugin, "builtin");
     }
   }
 
   async loadLocalPlugins(extraPaths: string[] = []): Promise<void> {
     const discoveredPaths = await discoverLocalPlugins();
-    const resolvedExtraPaths = extraPaths.map(p => resolvePluginPath(p));
+    const resolvedExtraPaths = extraPaths.map((p) => resolvePluginPath(p));
     const allPaths = [...discoveredPaths, ...resolvedExtraPaths];
 
     for (const pluginPath of allPaths) {
       const result = await loadLocalPlugin(pluginPath);
       if (result.success && result.plugin) {
-        this.register(result.plugin, 'local');
+        this.register(result.plugin, "local");
         console.info(`Loaded local plugin: ${result.plugin.name} (${result.plugin.id})`);
       } else {
         console.warn(`Failed to load plugin from ${pluginPath}: ${result.error}`);
@@ -170,7 +175,7 @@ class PluginRegistryImpl {
       const resolvedPath = resolveNpmPluginPath(packageName);
       const result = await loadNpmPlugin(packageName, resolvedPath);
       if (result.success && result.plugin) {
-        this.register(result.plugin, 'npm');
+        this.register(result.plugin, "npm");
         console.info(`Loaded npm plugin: ${result.plugin.name} (${packageName})`);
       } else {
         console.warn(`Failed to load npm plugin ${packageName}: ${result.error}`);
@@ -190,10 +195,7 @@ class PluginRegistryImpl {
 
     await this.loadBuiltinPlugins();
 
-    const localPaths = [
-      ...(config?.plugins?.local ?? []),
-      ...(config?.cliPlugins ?? []),
-    ];
+    const localPaths = [...(config?.plugins?.local ?? []), ...(config?.cliPlugins ?? [])];
     await this.loadLocalPlugins(localPaths);
 
     const npmPackages = config?.plugins?.npm ?? [];
@@ -203,7 +205,7 @@ class PluginRegistryImpl {
 
     const disabled = config?.plugins?.disabled ?? [];
     for (const pluginId of disabled) {
-      for (const type of ['provider', 'agent', 'theme', 'notification'] as PluginType[]) {
+      for (const type of ["provider", "agent", "theme", "notification"] as PluginType[]) {
         if (this.has(type, pluginId)) {
           this.disablePlugin(type, pluginId);
           console.info(`Disabled plugin: ${pluginId}`);
@@ -213,38 +215,40 @@ class PluginRegistryImpl {
 
     this.initialized = true;
     console.info(
-      `Plugin registry initialized: ${this.count('provider')} providers, ` +
-        `${this.count('agent')} agents, ${this.count('theme')} themes, ` +
-        `${this.count('notification')} notifications`
+      `Plugin registry initialized: ${this.count("provider")} providers, ` +
+        `${this.count("agent")} agents, ${this.count("theme")} themes, ` +
+        `${this.count("notification")} notifications`,
     );
   }
 }
 
-function hasPluginShape(obj: unknown): obj is { id: string; type: string; name: string; version: string } {
+function hasPluginShape(
+  obj: unknown,
+): obj is { id: string; type: string; name: string; version: string } {
   return (
     obj !== null &&
-    typeof obj === 'object' &&
-    'id' in obj &&
-    'type' in obj &&
-    'name' in obj &&
-    'version' in obj
+    typeof obj === "object" &&
+    "id" in obj &&
+    "type" in obj &&
+    "name" in obj &&
+    "version" in obj
   );
 }
 
 function isProviderPlugin(obj: unknown): obj is ProviderPlugin {
-  return hasPluginShape(obj) && obj.type === 'provider';
+  return hasPluginShape(obj) && obj.type === "provider";
 }
 
 function isAgentPlugin(obj: unknown): obj is AgentPlugin {
-  return hasPluginShape(obj) && obj.type === 'agent';
+  return hasPluginShape(obj) && obj.type === "agent";
 }
 
 function isThemePlugin(obj: unknown): obj is ThemePlugin {
-  return hasPluginShape(obj) && obj.type === 'theme';
+  return hasPluginShape(obj) && obj.type === "theme";
 }
 
 function isNotificationPlugin(obj: unknown): obj is NotificationPlugin {
-  return hasPluginShape(obj) && obj.type === 'notification';
+  return hasPluginShape(obj) && obj.type === "notification";
 }
 
 export const pluginRegistry = new PluginRegistryImpl();