@tokentop/ttop 0.2.2 → 0.4.0

package/src/plugins/agents/index.ts

@@ -1,2 +1,2 @@
-export { default as opencodeAgentPlugin } from '@tokentop/agent-opencode';
-export { default as claudeCodeAgentPlugin } from '@tokentop/agent-claude-code';
+export { default as claudeCodeAgentPlugin } from "@tokentop/agent-claude-code";
+export { default as opencodeAgentPlugin } from "@tokentop/agent-opencode";

package/src/plugins/auth-sources.ts

@@ -1,15 +1,15 @@
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import * as os from 'os';
-import type { PluginPermissions } from './types/base.ts';
-import type { AuthSources, OpenCodeAuthEntry } from './types/provider.ts';
-import { PluginPermissionError } from './types/base.ts';
+import * as fs from "fs/promises";
+import * as os from "os";
+import * as path from "path";
+import type { PluginPermissions } from "./types/base.ts";
+import { PluginPermissionError } from "./types/base.ts";
+import type { AuthSources, OpenCodeAuthEntry } from "./types/provider.ts";
 
-const OPENCODE_AUTH_PATH = path.join(os.homedir(), '.local/share/opencode/auth.json');
-const OPENCODE_CONFIG_PATH = path.join(os.homedir(), '.config/opencode/opencode.json');
+const OPENCODE_AUTH_PATH = path.join(os.homedir(), ".local/share/opencode/auth.json");
+const OPENCODE_CONFIG_PATH = path.join(os.homedir(), ".config/opencode/opencode.json");
 
 function expandHome(filePath: string): string {
-  if (filePath.startsWith('~')) {
+  if (filePath.startsWith("~")) {
     return path.join(os.homedir(), filePath.slice(1));
   }
   return filePath;
@@ -35,7 +35,7 @@ function isEnvVarAllowed(name: string, permissions: PluginPermissions): boolean
 
 async function readJsonFile<T>(filePath: string): Promise<T | null> {
   try {
-    const content = await fs.readFile(filePath, 'utf-8');
+    const content = await fs.readFile(filePath, "utf-8");
     return JSON.parse(content) as T;
   } catch {
     return null;
@@ -43,14 +43,17 @@ async function readJsonFile<T>(filePath: string): Promise<T | null> {
 }
 
 interface OpenCodeConfig {
-  provider?: Record<string, {
-    name?: string;
-    key?: string;
-    options?: {
-      apiKey?: string;
-      [key: string]: unknown;
-    };
-  }>;
+  provider?: Record<
+    string,
+    {
+      name?: string;
+      key?: string;
+      options?: {
+        apiKey?: string;
+        [key: string]: unknown;
+      };
+    }
+  >;
 }
 
 function resolveEnvValue(value: string | undefined): string | undefined {
@@ -69,8 +72,8 @@ export function createAuthSources(pluginId: string, permissions: PluginPermissio
         if (!isEnvVarAllowed(name, permissions)) {
           throw new PluginPermissionError(
             pluginId,
-            'env',
-            `Environment variable "${name}" not in allowlist`
+            "env",
+            `Environment variable "${name}" not in allowlist`,
           );
         }
         return process.env[name];
@@ -83,19 +86,19 @@ export function createAuthSources(pluginId: string, permissions: PluginPermissio
         if (!permissions.filesystem?.read) {
           throw new PluginPermissionError(
             pluginId,
-            'filesystem',
-            'Filesystem read access not permitted'
+            "filesystem",
+            "Filesystem read access not permitted",
           );
         }
         if (!isPathAllowed(filePath, permissions)) {
           throw new PluginPermissionError(
             pluginId,
-            'filesystem',
-            `Path "${filePath}" not in allowlist`
+            "filesystem",
+            `Path "${filePath}" not in allowlist`,
           );
         }
         try {
-          return await fs.readFile(resolved, 'utf-8');
+          return await fs.readFile(resolved, "utf-8");
         } catch {
           return null;
         }
@@ -106,19 +109,19 @@ export function createAuthSources(pluginId: string, permissions: PluginPermissio
         if (!permissions.filesystem?.read) {
           throw new PluginPermissionError(
             pluginId,
-            'filesystem',
-            'Filesystem read access not permitted'
+            "filesystem",
+            "Filesystem read access not permitted",
           );
         }
         if (!isPathAllowed(filePath, permissions)) {
           throw new PluginPermissionError(
             pluginId,
-            'filesystem',
-            `Path "${filePath}" not in allowlist`
+            "filesystem",
+            `Path "${filePath}" not in allowlist`,
           );
         }
         try {
-          const content = await fs.readFile(resolved, 'utf-8');
+          const content = await fs.readFile(resolved, "utf-8");
           return JSON.parse(content) as T;
         } catch {
           return null;
@@ -130,15 +133,15 @@ export function createAuthSources(pluginId: string, permissions: PluginPermissio
         if (!permissions.filesystem?.read) {
           throw new PluginPermissionError(
             pluginId,
-            'filesystem',
-            'Filesystem read access not permitted'
+            "filesystem",
+            "Filesystem read access not permitted",
           );
         }
         if (!isPathAllowed(filePath, permissions)) {
           throw new PluginPermissionError(
             pluginId,
-            'filesystem',
-            `Path "${filePath}" not in allowlist`
+            "filesystem",
+            `Path "${filePath}" not in allowlist`,
           );
         }
         try {
@@ -162,11 +165,12 @@ export function createAuthSources(pluginId: string, permissions: PluginPermissio
         if (config?.provider) {
           const providerConfig = config.provider[key];
           if (providerConfig) {
-            const apiKey = resolveEnvValue(providerConfig.key) ??
-                           resolveEnvValue(providerConfig.options?.apiKey as string);
+            const apiKey =
+              resolveEnvValue(providerConfig.key) ??
+              resolveEnvValue(providerConfig.options?.apiKey as string);
             if (apiKey) {
               return {
-                type: 'api',
+                type: "api",
                 key: apiKey,
               };
             }
@@ -178,7 +182,7 @@ export function createAuthSources(pluginId: string, permissions: PluginPermissio
     },
 
     platform: {
-      os: process.platform as 'darwin' | 'linux' | 'win32',
+      os: process.platform as "darwin" | "linux" | "win32",
       homedir: os.homedir(),
       arch: process.arch,
     },

package/src/plugins/lifecycle.ts

@@ -5,23 +5,23 @@
  * with safeInvoke for error isolation and circuit breaker protection.
  */
 
-import type { BasePlugin, PluginLifecycleContext, PluginLogger } from './types/base.ts';
-import { pluginRegistry } from './registry.ts';
-import { safeInvoke } from './plugin-host.ts';
-import { createPluginLogger } from './sandbox.ts';
-import { runInPluginGuard } from './sandbox-guard.ts';
+import { safeInvoke } from "./plugin-host.ts";
+import { pluginRegistry } from "./registry.ts";
+import { createPluginLogger } from "./sandbox.ts";
+import { runInPluginGuard } from "./sandbox-guard.ts";
+import type { BasePlugin, PluginLifecycleContext, PluginLogger } from "./types/base.ts";
 
 // ---------------------------------------------------------------------------
 // State machine
 // ---------------------------------------------------------------------------
 
 export type PluginLifecycleState =
-  | 'loaded'
-  | 'initialized'
-  | 'started'
-  | 'stopped'
-  | 'destroyed'
-  | 'failed';
+  | "loaded"
+  | "initialized"
+  | "started"
+  | "stopped"
+  | "destroyed"
+  | "failed";
 
 interface PluginLifecycleEntry {
   pluginId: string;
@@ -44,7 +44,7 @@ class PluginLifecycleManager {
     if (!entry) {
       entry = {
         pluginId: plugin.id,
-        state: 'loaded',
+        state: "loaded",
         config: { ...(plugin.defaultConfig ?? {}) },
         logger: createPluginLogger(plugin.id),
       };
@@ -59,7 +59,7 @@ class PluginLifecycleManager {
 
   private async invokeHook(
     plugin: BasePlugin,
-    hook: 'initialize' | 'start' | 'stop' | 'destroy',
+    hook: "initialize" | "start" | "stop" | "destroy",
   ): Promise<boolean> {
     const fn = plugin[hook];
     if (!fn) return true;
@@ -72,7 +72,10 @@ class PluginLifecycleManager {
         Promise.race([
           fn.call(plugin, ctx),
           new Promise<never>((_, reject) =>
-            setTimeout(() => reject(new Error(`${hook} timed out after ${HOOK_TIMEOUT_MS}ms`)), HOOK_TIMEOUT_MS),
+            setTimeout(
+              () => reject(new Error(`${hook} timed out after ${HOOK_TIMEOUT_MS}ms`)),
+              HOOK_TIMEOUT_MS,
+            ),
           ),
         ]),
       ),
@@ -88,25 +91,29 @@ class PluginLifecycleManager {
   async initializeAll(): Promise<void> {
     const plugins = pluginRegistry.getAllPlugins();
 
-    for (const plugin of plugins) {
-      const entry = this.getOrCreate(plugin);
-      if (entry.state !== 'loaded') continue;
+    await Promise.all(
+      plugins.map(async (plugin) => {
+        const entry = this.getOrCreate(plugin);
+        if (entry.state !== "loaded") return;
 
-      const ok = await this.invokeHook(plugin, 'initialize');
-      entry.state = ok ? 'initialized' : 'failed';
-    }
+        const ok = await this.invokeHook(plugin, "initialize");
+        entry.state = ok ? "initialized" : "failed";
+      }),
+    );
   }
 
   async startAll(): Promise<void> {
     const plugins = pluginRegistry.getAllPlugins();
 
-    for (const plugin of plugins) {
-      const entry = this.getOrCreate(plugin);
-      if (entry.state !== 'initialized') continue;
+    await Promise.all(
+      plugins.map(async (plugin) => {
+        const entry = this.getOrCreate(plugin);
+        if (entry.state !== "initialized") return;
 
-      const ok = await this.invokeHook(plugin, 'start');
-      entry.state = ok ? 'started' : 'failed';
-    }
+        const ok = await this.invokeHook(plugin, "start");
+        entry.state = ok ? "started" : "failed";
+      }),
+    );
   }
 
   async stopAll(): Promise<void> {
@@ -114,10 +121,10 @@ class PluginLifecycleManager {
 
     for (const plugin of plugins) {
       const entry = this.entries.get(plugin.id);
-      if (!entry || entry.state !== 'started') continue;
+      if (!entry || entry.state !== "started") continue;
 
-      const ok = await this.invokeHook(plugin, 'stop');
-      entry.state = ok ? 'stopped' : 'failed';
+      const ok = await this.invokeHook(plugin, "stop");
+      entry.state = ok ? "stopped" : "failed";
     }
   }
 
@@ -127,27 +134,24 @@ class PluginLifecycleManager {
     for (const plugin of plugins) {
       const entry = this.entries.get(plugin.id);
       if (!entry) continue;
-      if (entry.state === 'destroyed') continue;
+      if (entry.state === "destroyed") continue;
 
-      await this.invokeHook(plugin, 'destroy');
-      entry.state = 'destroyed';
+      await this.invokeHook(plugin, "destroy");
+      entry.state = "destroyed";
     }
   }
 
-  async notifyConfigChange(
-    pluginId: string,
-    newConfig: Record<string, unknown>,
-  ): Promise<void> {
+  async notifyConfigChange(pluginId: string, newConfig: Record<string, unknown>): Promise<void> {
     const plugin = pluginRegistry.getAllPlugins().find((p) => p.id === pluginId);
     if (!plugin?.onConfigChange) return;
 
     const entry = this.entries.get(pluginId);
-    if (!entry || entry.state === 'destroyed' || entry.state === 'failed') return;
+    if (!entry || entry.state === "destroyed" || entry.state === "failed") return;
 
     entry.config = { ...newConfig };
 
     const ctx = this.makeCtx(entry);
-    await safeInvoke(pluginId, 'onConfigChange', () =>
+    await safeInvoke(pluginId, "onConfigChange", () =>
       runInPluginGuard(pluginId, plugin.permissions, () =>
         Promise.resolve(plugin.onConfigChange!(newConfig, ctx)),
       ),

package/src/plugins/loader.test.ts

@@ -1,12 +1,12 @@
-import { describe, expect, test } from 'bun:test';
-import { validatePlugin } from './loader.ts';
-import { CURRENT_API_VERSION } from './types/base.ts';
+import { describe, expect, test } from "bun:test";
+import { validatePlugin } from "./loader.ts";
+import { CURRENT_API_VERSION } from "./types/base.ts";
 
 const validPlugin = {
-  id: 'test-plugin',
-  type: 'notification',
-  name: 'Test Plugin',
-  version: '1.0.0',
+  id: "test-plugin",
+  type: "notification",
+  name: "Test Plugin",
+  version: "1.0.0",
   apiVersion: CURRENT_API_VERSION,
   permissions: {},
   initialize: async () => {},
@@ -17,18 +17,18 @@ function hasError(errors: string[], fragment: string): boolean {
   return errors.some((error) => error.includes(fragment));
 }
 
-describe('validatePlugin', () => {
-  test('accepts a valid minimal plugin object', async () => {
+describe("validatePlugin", () => {
+  test("accepts a valid minimal plugin object", async () => {
     const result = await validatePlugin(validPlugin);
 
     expect(result.valid).toBe(true);
     expect(result.errors).toHaveLength(0);
   });
 
-  test('rejects plugin missing id', async () => {
+  test("rejects plugin missing id", async () => {
     const plugin = {
       ...validPlugin,
-      id: '',
+      id: "",
     };
 
     const result = await validatePlugin(plugin);
@@ -36,46 +36,46 @@ describe('validatePlugin', () => {
     expect(hasError(result.errors, 'non-empty string "id"')).toBe(true);
   });
 
-  test('rejects plugin with invalid id format', async () => {
+  test("rejects plugin with invalid id format", async () => {
     const plugin = {
       ...validPlugin,
-      id: 'Bad Plugin',
+      id: "Bad Plugin",
     };
 
     const result = await validatePlugin(plugin);
     expect(result.valid).toBe(false);
-    expect(hasError(result.errors, 'kebab-case')).toBe(true);
+    expect(hasError(result.errors, "kebab-case")).toBe(true);
   });
 
-  test('rejects plugin missing type', async () => {
+  test("rejects plugin missing type", async () => {
     const plugin = {
-      id: 'test-plugin',
-      name: 'Test Plugin',
-      version: '1.0.0',
+      id: "test-plugin",
+      name: "Test Plugin",
+      version: "1.0.0",
       apiVersion: CURRENT_API_VERSION,
       permissions: {},
     };
 
     const result = await validatePlugin(plugin);
     expect(result.valid).toBe(false);
-    expect(hasError(result.errors, 'must be one of')).toBe(true);
+    expect(hasError(result.errors, "must be one of")).toBe(true);
   });
 
-  test('rejects plugin with invalid type', async () => {
+  test("rejects plugin with invalid type", async () => {
     const plugin = {
       ...validPlugin,
-      type: 'invalid',
+      type: "invalid",
     };
 
     const result = await validatePlugin(plugin);
     expect(result.valid).toBe(false);
-    expect(hasError(result.errors, 'provider, agent, theme, notification')).toBe(true);
+    expect(hasError(result.errors, "provider, agent, theme, notification")).toBe(true);
   });
 
-  test('rejects plugin missing name', async () => {
+  test("rejects plugin missing name", async () => {
     const plugin = {
       ...validPlugin,
-      name: '',
+      name: "",
     };
 
     const result = await validatePlugin(plugin);
@@ -83,10 +83,10 @@ describe('validatePlugin', () => {
     expect(hasError(result.errors, 'non-empty string "name"')).toBe(true);
   });
 
-  test('rejects plugin missing version', async () => {
+  test("rejects plugin missing version", async () => {
     const plugin = {
       ...validPlugin,
-      version: '',
+      version: "",
     };
 
     const result = await validatePlugin(plugin);
@@ -94,10 +94,10 @@ describe('validatePlugin', () => {
     expect(hasError(result.errors, 'valid semver "version"')).toBe(true);
   });
 
-  test('rejects plugin with invalid version format', async () => {
+  test("rejects plugin with invalid version format", async () => {
     const plugin = {
       ...validPlugin,
-      version: 'v1',
+      version: "v1",
     };
 
     const result = await validatePlugin(plugin);
@@ -105,12 +105,12 @@ describe('validatePlugin', () => {
     expect(hasError(result.errors, 'valid semver "version"')).toBe(true);
   });
 
-  test('rejects plugin missing permissions', async () => {
+  test("rejects plugin missing permissions", async () => {
     const plugin = {
-      id: 'test-plugin',
-      type: 'notification',
-      name: 'Test Plugin',
-      version: '1.0.0',
+      id: "test-plugin",
+      type: "notification",
+      name: "Test Plugin",
+      version: "1.0.0",
       apiVersion: CURRENT_API_VERSION,
     };
 
@@ -119,7 +119,7 @@ describe('validatePlugin', () => {
     expect(hasError(result.errors, 'declare "permissions" object')).toBe(true);
   });
 
-  test('rejects plugin with wrong apiVersion', async () => {
+  test("rejects plugin with wrong apiVersion", async () => {
     const plugin = {
       ...validPlugin,
       apiVersion: CURRENT_API_VERSION + 1,
@@ -130,10 +130,10 @@ describe('validatePlugin', () => {
     expect(hasError(result.errors, `expected ${CURRENT_API_VERSION}`)).toBe(true);
   });
 
-  test('rejects provider plugin missing auth', async () => {
+  test("rejects provider plugin missing auth", async () => {
     const providerPlugin = {
       ...validPlugin,
-      type: 'provider',
+      type: "provider",
       fetchUsage: async () => [],
     };
 
@@ -142,10 +142,10 @@ describe('validatePlugin', () => {
     expect(hasError(result.errors, 'declare "auth" object')).toBe(true);
   });
 
-  test('accepts valid provider plugin with auth and fetchUsage', async () => {
+  test("accepts valid provider plugin with auth and fetchUsage", async () => {
     const providerPlugin = {
       ...validPlugin,
-      type: 'provider',
+      type: "provider",
       auth: {
         discover: async () => undefined,
         isConfigured: () => true,
@@ -157,11 +157,11 @@ describe('validatePlugin', () => {
     expect(result.valid).toBe(true);
   });
 
-  test('rejects theme plugin missing colors object', async () => {
+  test("rejects theme plugin missing colors object", async () => {
     const themePlugin = {
       ...validPlugin,
-      type: 'theme',
-      colorScheme: 'dark',
+      type: "theme",
+      colorScheme: "dark",
     };
 
     const result = await validatePlugin(themePlugin);
@@ -169,24 +169,24 @@ describe('validatePlugin', () => {
     expect(hasError(result.errors, '"colors" object')).toBe(true);
   });
 
-  test('rejects theme plugin missing colorScheme', async () => {
+  test("rejects theme plugin missing colorScheme", async () => {
     const themePlugin = {
       ...validPlugin,
-      type: 'theme',
-      colors: { primary: '#fff' },
+      type: "theme",
+      colors: { primary: "#fff" },
     };
 
     const result = await validatePlugin(themePlugin);
     expect(result.valid).toBe(false);
-    expect(hasError(result.errors, 'colorScheme')).toBe(true);
+    expect(hasError(result.errors, "colorScheme")).toBe(true);
   });
 
-  test('accepts valid theme plugin', async () => {
+  test("accepts valid theme plugin", async () => {
     const themePlugin = {
       ...validPlugin,
-      type: 'theme',
-      colorScheme: 'dark',
-      colors: { primary: '#fff' },
+      type: "theme",
+      colorScheme: "dark",
+      colors: { primary: "#fff" },
     };
 
     const result = await validatePlugin(themePlugin);