@tokentop/ttop 0.2.2 → 0.4.0

package/src/tui/contexts/PluginContext.tsx

@@ -1,20 +1,29 @@
-import { createContext, useContext, useState, useEffect, useCallback, useRef, type ReactNode } from 'react';
-import type { ProviderPlugin, ProviderUsageData, Credentials } from '@/plugins/types/provider.ts';
-import type { ThemePlugin } from '@/plugins/types/theme.ts';
-import type { NotificationPlugin } from '@/plugins/types/notification.ts';
-import { pluginRegistry } from '@/plugins/registry.ts';
-import { createSandboxedHttpClient, createPluginLogger } from '@/plugins/sandbox.ts';
-import { createPluginContext } from '@/plugins/plugin-context-factory.ts';
-import { safeInvoke, safeInvokeSync } from '@/plugins/plugin-host.ts';
-import { notificationBus } from '@/plugins/notification-bus.ts';
-import { pluginLifecycle } from '@/plugins/lifecycle.ts';
-import { installGlobalFetchGuard, runInPluginGuard } from '@/plugins/sandbox-guard.ts';
-import { initPricingFromPlugins } from '@/pricing/index.ts';
-import { useLogs } from './LogContext.tsx';
-import { useStorage } from './StorageContext.tsx';
-import type { ProviderSnapshotInsert } from '@/storage/types.ts';
-import { useDemoMode } from './DemoModeContext.tsx';
-import { useConfig } from './ConfigContext.tsx';
+import {
+  createContext,
+  type ReactNode,
+  useCallback,
+  useContext,
+  useEffect,
+  useRef,
+  useState,
+} from "react";
+import { pluginLifecycle } from "@/plugins/lifecycle.ts";
+import { notificationBus } from "@/plugins/notification-bus.ts";
+import { createPluginContext } from "@/plugins/plugin-context-factory.ts";
+import { safeInvoke, safeInvokeSync } from "@/plugins/plugin-host.ts";
+import { pluginRegistry } from "@/plugins/registry.ts";
+import { createPluginLogger, createSandboxedHttpClient } from "@/plugins/sandbox.ts";
+import { installGlobalFetchGuard, runInPluginGuard } from "@/plugins/sandbox-guard.ts";
+import type { AgentPlugin } from "@/plugins/types/agent.ts";
+import type { NotificationPlugin } from "@/plugins/types/notification.ts";
+import type { Credentials, ProviderPlugin, ProviderUsageData } from "@/plugins/types/provider.ts";
+import type { ThemePlugin } from "@/plugins/types/theme.ts";
+import { initPricingFromPlugins } from "@/pricing/index.ts";
+import type { ProviderSnapshotInsert } from "@/storage/types.ts";
+import { useConfig } from "./ConfigContext.tsx";
+import { useDemoMode } from "./DemoModeContext.tsx";
+import { useLogs } from "./LogContext.tsx";
+import { useStorage } from "./StorageContext.tsx";
 
 export interface UsageSnapshot {
   timestamp: number;
@@ -35,6 +44,7 @@ export interface ProviderState {
 
 interface PluginContextValue {
   providers: Map<string, ProviderState>;
+  agents: AgentPlugin[];
   themes: ThemePlugin[];
   notifications: NotificationPlugin[];
   isInitialized: boolean;
@@ -46,16 +56,16 @@ const PluginContext = createContext<PluginContextValue | null>(null);
 
 function getMaxUsagePercent(usage: ProviderUsageData): number | null {
   if (!usage.limits) return null;
-  
+
   const items = usage.limits.items ?? [];
   if (items.length > 0) {
     const percents = items.map((item) => item.usedPercent).filter((p): p is number => p !== null);
     return percents.length > 0 ? Math.max(...percents) : null;
   }
-  
+
   const primary = usage.limits.primary?.usedPercent;
   const secondary = usage.limits.secondary?.usedPercent;
-  
+
   if (primary !== null && primary !== undefined && secondary !== null && secondary !== undefined) {
     return Math.max(primary, secondary);
   }
@@ -79,6 +89,7 @@ export function PluginProvider({ children, cliPlugins }: PluginProviderProps) {
   const [isInitialized, setIsInitialized] = useState(false);
   const [providers, setProviders] = useState<Map<string, ProviderState>>(new Map());
   const [themes, setThemes] = useState<ThemePlugin[]>([]);
+  const [agents, setAgents] = useState<AgentPlugin[]>([]);
   const [notifications, setNotifications] = useState<NotificationPlugin[]>([]);
   const { demoMode, simulator } = useDemoMode();
   const { debug, info, warn, error: logError } = useLogs();
@@ -88,7 +99,7 @@ export function PluginProvider({ children, cliPlugins }: PluginProviderProps) {
   useEffect(() => {
     async function initialize() {
       installGlobalFetchGuard();
-      debug('Initializing plugin registry...', undefined, 'plugins');
+      debug("Initializing plugin registry...", undefined, "plugins");
 
       try {
         if (!demoMode) {
@@ -102,44 +113,55 @@ export function PluginProvider({ children, cliPlugins }: PluginProviderProps) {
         } else {
           await pluginRegistry.loadBuiltinPlugins();
         }
-        info('Plugin registry initialized', undefined, 'plugins');
+        info("Plugin registry initialized", undefined, "plugins");
       } catch (err) {
-        logError('Failed to initialize plugin registry', { error: String(err) }, 'plugins');
+        logError("Failed to initialize plugin registry", { error: String(err) }, "plugins");
       }
 
-      const providerPlugins = pluginRegistry.getAll('provider');
-      const themePlugins = pluginRegistry.getAll('theme');
-      const notificationPlugins = pluginRegistry.getAll('notification');
+      const providerPlugins = pluginRegistry.getAll("provider");
+      const agentPlugins = pluginRegistry.getAll("agent");
+      const themePlugins = pluginRegistry.getAll("theme");
+      const notificationPlugins = pluginRegistry.getAll("notification");
 
       initPricingFromPlugins(providerPlugins, {
-        'google-gemini': 'google',
+        "google-gemini": "google",
       });
 
-      info(`Loaded plugins`, {
-        providers: providerPlugins.length,
-        themes: themePlugins.length,
-        notifications: notificationPlugins.length,
-      }, 'plugins');
+      info(
+        `Loaded plugins`,
+        {
+          providers: providerPlugins.length,
+          themes: themePlugins.length,
+          notifications: notificationPlugins.length,
+        },
+        "plugins",
+      );
 
       await pluginLifecycle.initializeAll();
       await pluginLifecycle.startAll();
-      debug('Plugin lifecycle: all plugins initialized and started', undefined, 'plugins');
+      debug("Plugin lifecycle: all plugins initialized and started", undefined, "plugins");
 
-      debug('Discovering credentials...', undefined, 'credentials');
+      debug("Discovering credentials...", undefined, "credentials");
 
       const credentials = new Map<string, Credentials>();
       if (!demoMode) {
-        await Promise.all(providerPlugins.map(async (p) => {
-          const ctx = createPluginContext(p.id, p.permissions);
-          const result = await safeInvoke(p.id, 'auth.discover', () =>
-            runInPluginGuard(p.id, p.permissions, () => p.auth.discover(ctx)),
-          );
-          if (result.ok && result.value.ok && result.value.credentials) {
-            credentials.set(p.id, result.value.credentials);
-          } else if (!result.ok) {
-            logError(`Credential discovery failed for ${p.id}`, { error: result.error.message }, 'credentials');
-          }
-        }));
+        await Promise.all(
+          providerPlugins.map(async (p) => {
+            const ctx = createPluginContext(p.id, p.permissions);
+            const result = await safeInvoke(p.id, "auth.discover", () =>
+              runInPluginGuard(p.id, p.permissions, () => p.auth.discover(ctx)),
+            );
+            if (result.ok && result.value.ok && result.value.credentials) {
+              credentials.set(p.id, result.value.credentials);
+            } else if (!result.ok) {
+              logError(
+                `Credential discovery failed for ${p.id}`,
+                { error: result.error.message },
+                "credentials",
+              );
+            }
+          }),
+        );
       }
 
       const providerStates = new Map<string, ProviderState>();
@@ -152,7 +174,9 @@ export function PluginProvider({ children, cliPlugins }: PluginProviderProps) {
         if (demoMode) {
           configured = true;
         } else if (creds) {
-          const check = safeInvokeSync(plugin.id, 'auth.isConfigured', () => plugin.auth.isConfigured(creds));
+          const check = safeInvokeSync(plugin.id, "auth.isConfigured", () =>
+            plugin.auth.isConfigured(creds),
+          );
           configured = check.ok ? check.value : false;
         }
         providerStates.set(plugin.id, {
@@ -171,10 +195,14 @@ export function PluginProvider({ children, cliPlugins }: PluginProviderProps) {
         }
       }
 
-      info('Credential discovery complete', {
-        configured: configuredIds,
-        unconfigured: unconfiguredIds,
-      }, 'credentials');
+      info(
+        "Credential discovery complete",
+        {
+          configured: configuredIds,
+          unconfigured: unconfiguredIds,
+        },
+        "credentials",
+      );
 
       if (demoMode && simulator) {
         const snapshot = simulator.tick();
@@ -197,6 +225,7 @@ export function PluginProvider({ children, cliPlugins }: PluginProviderProps) {
       notificationBus.registerPlugins(notificationPlugins);
 
       setProviders(providerStates);
+      setAgents(agentPlugins);
       setThemes(themePlugins);
       setNotifications(notificationPlugins);
       setIsInitialized(true);
@@ -216,181 +245,211 @@ export function PluginProvider({ children, cliPlugins }: PluginProviderProps) {
       const prevStr = JSON.stringify(prev[pluginId] ?? {});
       const nextStr = JSON.stringify(next[pluginId] ?? {});
       if (prevStr !== nextStr) {
-        debug(`Plugin config changed for ${pluginId}`, undefined, 'plugins');
+        debug(`Plugin config changed for ${pluginId}`, undefined, "plugins");
         pluginLifecycle.notifyConfigChange(pluginId, next[pluginId] ?? {});
       }
     }
     prevPluginConfigRef.current = { ...next };
   }, [config.pluginConfig, isInitialized]);
 
-  const refreshProvider = useCallback(async (providerId: string) => {
-    const state = providers.get(providerId);
-    if (!state || !state.configured) {
-      debug(`Skipping refresh for ${providerId}: not configured`, undefined, 'refresh');
-      return;
-    }
+  const refreshProvider = useCallback(
+    async (providerId: string) => {
+      const state = providers.get(providerId);
+      if (!state || !state.configured) {
+        debug(`Skipping refresh for ${providerId}: not configured`, undefined, "refresh");
+        return;
+      }
 
-    info(`Refreshing ${providerId}...`, undefined, 'refresh');
+      info(`Refreshing ${providerId}...`, undefined, "refresh");
 
-    setProviders((prev) => {
-      const next = new Map(prev);
-      const current = next.get(providerId);
-      if (current) {
-        next.set(providerId, { ...current, loading: true });
-      }
-      return next;
-    });
+      setProviders((prev) => {
+        const next = new Map(prev);
+        const current = next.get(providerId);
+        if (current) {
+          next.set(providerId, { ...current, loading: true });
+        }
+        return next;
+      });
 
-    try {
-      if (demoMode && simulator) {
-        const snapshot = simulator.tick();
-        const usage = snapshot.providerUsage.get(providerId) ?? {
-          fetchedAt: Date.now(),
-          error: 'Demo provider data missing',
-        };
+      try {
+        if (demoMode && simulator) {
+          const snapshot = simulator.tick();
+          const usage = snapshot.providerUsage.get(providerId) ?? {
+            fetchedAt: Date.now(),
+            error: "Demo provider data missing",
+          };
 
-        if (storageReady) {
-          recordProviderSnapshots([
-            {
+          if (storageReady) {
+            recordProviderSnapshots([
+              {
+                timestamp: Date.now(),
+                provider: providerId,
+                usedPercent: getMaxUsagePercent(usage),
+                limitReached: usage.limitReached ?? false,
+                resetsAt: usage.limits?.primary?.resetsAt ?? null,
+                rawJson: JSON.stringify(usage),
+              },
+            ]);
+          }
+
+          setProviders((prev) => {
+            const next = new Map(prev);
+            const current = next.get(providerId);
+            const currentHistory = current?.history ?? [];
+            const snapshotEntry: UsageSnapshot = {
               timestamp: Date.now(),
+              usedPercent: getMaxUsagePercent(usage),
+              limitReached: usage.limitReached,
+            };
+            next.set(providerId, {
+              ...state,
+              usage,
+              loading: false,
+              lastFetchAt: Date.now(),
+              history: addToHistory(currentHistory, snapshotEntry),
+            });
+            return next;
+          });
+
+          return;
+        }
+
+        const ctx = createPluginContext(providerId, state.plugin.permissions);
+        const discoverResult = await safeInvoke(providerId, "auth.discover", () =>
+          runInPluginGuard(providerId, state.plugin.permissions, () =>
+            state.plugin.auth.discover(ctx),
+          ),
+        );
+
+        if (!discoverResult.ok) {
+          throw discoverResult.error;
+        }
+        const creds = discoverResult.value.ok ? discoverResult.value.credentials : undefined;
+
+        if (!creds) {
+          throw new Error("Credentials not found");
+        }
+
+        const http = createSandboxedHttpClient(providerId, state.plugin.permissions);
+        const logger = createPluginLogger(providerId);
+
+        const fetchResult = await safeInvoke(providerId, "fetchUsage", () =>
+          runInPluginGuard(providerId, state.plugin.permissions, () =>
+            state.plugin.fetchUsage({
+              credentials: creds,
+              http,
+              logger,
+              config: {},
+              signal: AbortSignal.timeout(30_000),
+            }),
+          ),
+        );
+
+        if (!fetchResult.ok) {
+          throw fetchResult.error;
+        }
+
+        const usage = fetchResult.value;
+
+        if (usage.error) {
+          warn(`${providerId} returned error: ${usage.error}`, undefined, "refresh");
+        } else {
+          info(
+            `${providerId} refreshed successfully`,
+            {
+              limitReached: usage.limitReached,
+              primaryUsage: usage.limits?.primary?.usedPercent,
+            },
+            "refresh",
+          );
+
+          if (storageReady) {
+            const now = Date.now();
+            const snapshotInsert: ProviderSnapshotInsert = {
+              timestamp: now,
               provider: providerId,
               usedPercent: getMaxUsagePercent(usage),
               limitReached: usage.limitReached ?? false,
               resetsAt: usage.limits?.primary?.resetsAt ?? null,
               rawJson: JSON.stringify(usage),
-            },
-          ]);
+            };
+            recordProviderSnapshots([snapshotInsert]);
+          }
+
+          notificationBus.checkProviderUsage(providerId, state.plugin.name, usage);
         }
 
         setProviders((prev) => {
           const next = new Map(prev);
           const current = next.get(providerId);
           const currentHistory = current?.history ?? [];
-          const snapshotEntry: UsageSnapshot = {
+
+          const snapshot: UsageSnapshot = {
             timestamp: Date.now(),
             usedPercent: getMaxUsagePercent(usage),
             limitReached: usage.limitReached,
           };
+
           next.set(providerId, {
             ...state,
             usage,
             loading: false,
             lastFetchAt: Date.now(),
-            history: addToHistory(currentHistory, snapshotEntry),
+            history: addToHistory(currentHistory, snapshot),
           });
           return next;
         });
+      } catch (err) {
+        const errorMsg = err instanceof Error ? err.message : "Unknown error";
+        logError(`Failed to refresh ${providerId}: ${errorMsg}`, undefined, "refresh");
 
-        return;
-      }
-
-      const ctx = createPluginContext(providerId, state.plugin.permissions);
-      const discoverResult = await safeInvoke(providerId, 'auth.discover', () =>
-        runInPluginGuard(providerId, state.plugin.permissions, () => state.plugin.auth.discover(ctx)),
-      );
-
-      if (!discoverResult.ok) {
-        throw discoverResult.error;
-      }
-      const creds = discoverResult.value.ok ? discoverResult.value.credentials : undefined;
-
-      if (!creds) {
-        throw new Error('Credentials not found');
-      }
-
-      const http = createSandboxedHttpClient(providerId, state.plugin.permissions);
-      const logger = createPluginLogger(providerId);
-
-      const fetchResult = await safeInvoke(providerId, 'fetchUsage', () =>
-        runInPluginGuard(providerId, state.plugin.permissions, () =>
-          state.plugin.fetchUsage({ credentials: creds, http, logger, config: {}, signal: AbortSignal.timeout(30_000) }),
-        ),
-      );
-
-      if (!fetchResult.ok) {
-        throw fetchResult.error;
-      }
-
-      const usage = fetchResult.value;
-
-      if (usage.error) {
-        warn(`${providerId} returned error: ${usage.error}`, undefined, 'refresh');
-      } else {
-        info(`${providerId} refreshed successfully`, {
-          limitReached: usage.limitReached,
-          primaryUsage: usage.limits?.primary?.usedPercent,
-        }, 'refresh');
-        
-        if (storageReady) {
-          const now = Date.now();
-          const snapshotInsert: ProviderSnapshotInsert = {
-            timestamp: now,
-            provider: providerId,
-            usedPercent: getMaxUsagePercent(usage),
-            limitReached: usage.limitReached ?? false,
-            resetsAt: usage.limits?.primary?.resetsAt ?? null,
-            rawJson: JSON.stringify(usage),
-          };
-          recordProviderSnapshots([snapshotInsert]);
-        }
-
-        notificationBus.checkProviderUsage(providerId, state.plugin.name, usage);
-      }
-
-      setProviders((prev) => {
-        const next = new Map(prev);
-        const current = next.get(providerId);
-        const currentHistory = current?.history ?? [];
-        
-        const snapshot: UsageSnapshot = {
-          timestamp: Date.now(),
-          usedPercent: getMaxUsagePercent(usage),
-          limitReached: usage.limitReached,
-        };
-        
-        next.set(providerId, {
-          ...state,
-          usage,
-          loading: false,
-          lastFetchAt: Date.now(),
-          history: addToHistory(currentHistory, snapshot),
-        });
-        return next;
-      });
-    } catch (err) {
-      const errorMsg = err instanceof Error ? err.message : 'Unknown error';
-      logError(`Failed to refresh ${providerId}: ${errorMsg}`, undefined, 'refresh');
-
-      setProviders((prev) => {
-        const next = new Map(prev);
-        const current = next.get(providerId);
-        next.set(providerId, {
-          ...state,
-          usage: {
-            fetchedAt: Date.now(),
-            error: errorMsg,
-          },
-          loading: false,
-          lastFetchAt: Date.now(),
-          history: current?.history ?? [],
+        setProviders((prev) => {
+          const next = new Map(prev);
+          const current = next.get(providerId);
+          next.set(providerId, {
+            ...state,
+            usage: {
+              fetchedAt: Date.now(),
+              error: errorMsg,
+            },
+            loading: false,
+            lastFetchAt: Date.now(),
+            history: current?.history ?? [],
+          });
+          return next;
         });
-        return next;
-      });
-    }
-  }, [providers, debug, info, warn, logError, storageReady, recordProviderSnapshots, demoMode, simulator]);
+      }
+    },
+    [
+      providers,
+      debug,
+      info,
+      warn,
+      logError,
+      storageReady,
+      recordProviderSnapshots,
+      demoMode,
+      simulator,
+    ],
+  );
 
   const refreshAllProviders = useCallback(async () => {
     const configuredProviders = Array.from(providers.entries())
       .filter(([_, state]) => state.configured)
       .map(([id]) => id);
 
-    info(`Refreshing ${configuredProviders.length} providers`, { providers: configuredProviders }, 'refresh');
+    info(
+      `Refreshing ${configuredProviders.length} providers`,
+      { providers: configuredProviders },
+      "refresh",
+    );
 
     await Promise.all(configuredProviders.map(refreshProvider));
   }, [providers, refreshProvider, info]);
 
   const value: PluginContextValue = {
     providers,
+    agents,
     themes,
     notifications,
     isInitialized,
@@ -398,17 +457,13 @@ export function PluginProvider({ children, cliPlugins }: PluginProviderProps) {
     refreshAllProviders,
   };
 
-  return (
-    <PluginContext.Provider value={value}>
-      {children}
-    </PluginContext.Provider>
-  );
+  return <PluginContext.Provider value={value}>{children}</PluginContext.Provider>;
 }
 
 export function usePlugins(): PluginContextValue {
   const context = useContext(PluginContext);
   if (!context) {
-    throw new Error('usePlugins must be used within PluginProvider');
+    throw new Error("usePlugins must be used within PluginProvider");
   }
   return context;
 }