@johpaz/hive 1.1.0

package/packages/core/src/plugins/loader.ts

@@ -0,0 +1,365 @@
+import { mkdirSync, readdirSync, existsSync } from "node:fs";
+import * as path from "node:path";
+import { logger } from "../utils/logger.ts";
+import { eventBus } from "../events/event-bus.ts";
+import { stateStore } from "../state/store.ts";
+import type {
+  HivePlugin,
+  PluginManifest,
+  PluginState,
+  PluginContext,
+  ToolDefinition,
+  ChannelDefinition,
+  CLICommand,
+  PluginConstructor,
+} from "./api.ts";
+
+export interface PluginLoaderOptions {
+  pluginDir: string;
+  enableSandbox?: boolean;
+  autoActivate?: boolean;
+  pluginConfig?: Record<string, Record<string, unknown>>;
+}
+
+export class PluginLoader {
+  private plugins: Map<string, HivePlugin> = new Map();
+  private pluginStates: Map<string, PluginState> = new Map();
+  private manifests: Map<string, PluginManifest> = new Map();
+  private tools: Map<string, ToolDefinition> = new Map();
+  private channels: Map<string, ChannelDefinition> = new Map();
+  private commands: Map<string, CLICommand> = new Map();
+  private log = logger.child("plugins");
+
+  constructor(private options: PluginLoaderOptions) {
+    if (!existsSync(options.pluginDir)) {
+      mkdirSync(options.pluginDir, { recursive: true });
+    }
+  }
+
+  async discover(): Promise<string[]> {
+    const pluginDir = this.options.pluginDir;
+    const discovered: string[] = [];
+
+    try {
+      const entries = readdirSync(pluginDir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          const manifestPath = path.join(pluginDir, entry.name, "manifest.json");
+          if (existsSync(manifestPath)) {
+            discovered.push(entry.name);
+          }
+        }
+      }
+    } catch (error) {
+      this.log.error("Failed to discover plugins", { error: (error as Error).message });
+    }
+
+    return discovered;
+  }
+
+  async load(pluginName: string): Promise<void> {
+    if (this.plugins.has(pluginName)) {
+      this.log.warn(`Plugin ${pluginName} already loaded`);
+      return;
+    }
+
+    const pluginPath = path.join(this.options.pluginDir, pluginName);
+    const manifestPath = path.join(pluginPath, "manifest.json");
+
+    this.updateState(pluginName, "activating");
+
+    try {
+      this.log.debug(`Reading plugin manifest: ${manifestPath}`);
+      const manifestContent = await Bun.file(manifestPath).text();
+      const manifest: PluginManifest = JSON.parse(manifestContent);
+      this.manifests.set(pluginName, manifest);
+
+      if (manifest.enabled === false) {
+        this.updateState(pluginName, "inactive", "Disabled in manifest");
+        return;
+      }
+
+      const mainFile = manifest.main ?? "index.js";
+      const mainPath = path.join(pluginPath, mainFile);
+
+      if (!(await Bun.file(mainPath).exists())) {
+        throw new Error(`Main file not found: ${mainPath}`);
+      }
+
+      const PluginClass = await this.loadPluginClass(mainPath);
+      const plugin = new PluginClass();
+      const context = this.createContext(pluginName);
+
+      await plugin.activate(context);
+
+      this.plugins.set(pluginName, plugin);
+      this.updateState(pluginName, "active");
+
+      eventBus.emit("gateway:started", {
+        host: "plugin",
+        port: 0,
+      });
+
+      this.log.info(`Plugin ${pluginName} loaded`, {
+        name: plugin.name,
+        version: plugin.version,
+      });
+    } catch (error) {
+      const errorMsg = (error as Error).message;
+      this.updateState(pluginName, "error", errorMsg);
+      this.log.error(`Failed to load plugin ${pluginName}`, { error: errorMsg });
+      throw error;
+    }
+  }
+
+  private async loadPluginClass(mainPath: string): Promise<PluginConstructor> {
+    if (this.options.enableSandbox) {
+      return this.loadSandboxed(mainPath);
+    }
+    return this.loadDirect(mainPath);
+  }
+
+  private async loadDirect(mainPath: string): Promise<PluginConstructor> {
+    const module = await import(mainPath);
+    const PluginClass = module.default ?? module[Object.keys(module)[0]!];
+
+    if (typeof PluginClass !== "function") {
+      throw new Error("Plugin must export a class as default");
+    }
+
+    return PluginClass;
+  }
+
+  private async loadSandboxed(mainPath: string): Promise<PluginConstructor> {
+    this.log.debug(`Reading plugin source for sandboxed execution: ${mainPath}`);
+    const code = await Bun.file(mainPath).text();
+
+    const safeGlobals = this.createSafeGlobals();
+    const wrappedCode = `
+      (function(module, exports, __dirname, __filename) {
+        ${code}
+      })
+    `;
+
+    const module = { exports: {} };
+    const exports = {};
+
+    try {
+      const fn = eval(wrappedCode);
+      fn(module, exports, path.dirname(mainPath), mainPath);
+
+      const PluginClass = (module.exports as any).default ?? (exports as any).default;
+
+      if (typeof PluginClass !== "function") {
+        throw new Error("Plugin must export a class as default");
+      }
+
+      return PluginClass;
+    } catch (error) {
+      throw new Error(`Sandboxed plugin execution failed: ${(error as Error).message}`);
+    }
+  }
+
+  private createSafeGlobals(): Record<string, unknown> {
+    return {
+      console: {
+        log: (...args: unknown[]) => this.log.debug(String(args[0])),
+        error: (...args: unknown[]) => this.log.error(String(args[0])),
+        warn: (...args: unknown[]) => this.log.warn(String(args[0])),
+        info: (...args: unknown[]) => this.log.info(String(args[0])),
+      },
+      setTimeout: () => 0,
+      clearTimeout: () => { },
+      setInterval: () => 0,
+      clearInterval: () => { },
+      Buffer: {
+        from: () => Buffer.from,
+        isBuffer: () => false,
+      },
+      URL: URL,
+      URLSearchParams: URLSearchParams,
+      JSON: JSON,
+      Object: Object,
+      Array: Array,
+      String: String,
+      Number: Number,
+      Boolean: Boolean,
+      Date: Date,
+      Error: Error,
+      Promise: Promise,
+    };
+  }
+
+  async unload(pluginName: string): Promise<void> {
+    const plugin = this.plugins.get(pluginName);
+
+    if (!plugin) {
+      this.log.warn(`Plugin ${pluginName} not loaded`);
+      return;
+    }
+
+    this.updateState(pluginName, "deactivating");
+
+    try {
+      await plugin.deactivate();
+
+      for (const [toolName, tool] of this.tools) {
+        if (toolName.startsWith(`${pluginName}:`)) {
+          this.tools.delete(toolName);
+        }
+      }
+
+      for (const [channelName, channel] of this.channels) {
+        if (channelName.startsWith(`${pluginName}:`)) {
+          await channel.stop();
+          this.channels.delete(channelName);
+        }
+      }
+
+      for (const [cmdName] of this.commands) {
+        if (cmdName.startsWith(`${pluginName}:`)) {
+          this.commands.delete(cmdName);
+        }
+      }
+
+      this.plugins.delete(pluginName);
+      this.updateState(pluginName, "inactive");
+
+      this.log.info(`Plugin ${pluginName} unloaded`);
+    } catch (error) {
+      const errorMsg = (error as Error).message;
+      this.updateState(pluginName, "error", errorMsg);
+      this.log.error(`Failed to unload plugin ${pluginName}`, { error: errorMsg });
+      throw error;
+    }
+  }
+
+  async reload(pluginName: string): Promise<void> {
+    this.log.info(`Reloading plugin ${pluginName}`);
+    await this.unload(pluginName);
+    await this.load(pluginName);
+  }
+
+  private createContext(pluginName: string): PluginContext {
+    const pluginLogger = logger.child(pluginName);
+    const pluginConfig = this.options.pluginConfig?.[pluginName] ?? {};
+
+    return {
+      pluginName,
+      logger: pluginLogger,
+      config: pluginConfig,
+      registerTool: (tool: ToolDefinition) => {
+        const fullName = `${pluginName}:${tool.name}`;
+        this.tools.set(fullName, tool);
+        this.log.debug(`Tool registered: ${fullName}`);
+      },
+      unregisterTool: (name: string) => {
+        const fullName = `${pluginName}:${name}`;
+        this.tools.delete(fullName);
+      },
+      registerChannel: (channel: ChannelDefinition) => {
+        const fullName = `${pluginName}:${channel.name}`;
+        this.channels.set(fullName, channel);
+        this.log.debug(`Channel registered: ${fullName}`);
+      },
+      unregisterChannel: (name: string) => {
+        const fullName = `${pluginName}:${name}`;
+        this.channels.delete(fullName);
+      },
+      registerCommand: (command: CLICommand) => {
+        const fullName = `${pluginName}:${command.name}`;
+        this.commands.set(fullName, command);
+        this.log.debug(`Command registered: ${fullName}`);
+      },
+      unregisterCommand: (name: string) => {
+        const fullName = `${pluginName}:${name}`;
+        this.commands.delete(fullName);
+      },
+      events: {
+        emit: (event, data) => eventBus.emit(event as any, data as any),
+        on: (event, handler) => eventBus.on(event as any, handler as any),
+        once: (event, handler) => eventBus.once(event as any, handler as any),
+      },
+      state: {
+        get: () => stateStore.getState(),
+        subscribe: (listener) => stateStore.subscribe(listener),
+      },
+      getTool: (name: string) => this.tools.get(name) ?? this.tools.get(`${pluginName}:${name}`),
+      getTools: () => Array.from(this.tools.values()),
+    };
+  }
+
+  private updateState(name: string, status: PluginState["status"], error?: string): void {
+    const existing = this.pluginStates.get(name);
+    const manifest = this.manifests.get(name);
+
+    this.pluginStates.set(name, {
+      name,
+      status,
+      version: manifest?.version ?? existing?.version ?? "unknown",
+      enabled: manifest?.enabled ?? true,
+      error,
+      loadedAt: existing?.loadedAt ?? Date.now(),
+      activatedAt: status === "active" ? Date.now() : existing?.activatedAt,
+    });
+  }
+
+  getPlugin(name: string): HivePlugin | undefined {
+    return this.plugins.get(name);
+  }
+
+  getPluginState(name: string): PluginState | undefined {
+    return this.pluginStates.get(name);
+  }
+
+  getAllPluginStates(): PluginState[] {
+    return Array.from(this.pluginStates.values());
+  }
+
+  getTool(name: string): ToolDefinition | undefined {
+    return this.tools.get(name);
+  }
+
+  getTools(): ToolDefinition[] {
+    return Array.from(this.tools.values());
+  }
+
+  getChannel(name: string): ChannelDefinition | undefined {
+    return this.channels.get(name);
+  }
+
+  getChannels(): ChannelDefinition[] {
+    return Array.from(this.channels.values());
+  }
+
+  getCommand(name: string): CLICommand | undefined {
+    return this.commands.get(name);
+  }
+
+  getCommands(): CLICommand[] {
+    return Array.from(this.commands.values());
+  }
+
+  async loadAll(): Promise<void> {
+    const discovered = await this.discover();
+
+    for (const pluginName of discovered) {
+      try {
+        await this.load(pluginName);
+      } catch (error) {
+        this.log.error(`Failed to load ${pluginName}`, { error: (error as Error).message });
+      }
+    }
+  }
+
+  async unloadAll(): Promise<void> {
+    for (const pluginName of this.plugins.keys()) {
+      try {
+        await this.unload(pluginName);
+      } catch (error) {
+        this.log.error(`Failed to unload ${pluginName}`, { error: (error as Error).message });
+      }
+    }
+  }
+}

package/packages/core/src/resilience/circuit-breaker.ts

@@ -0,0 +1,225 @@
+import { logger } from "../utils/logger.ts";
+
+type CircuitState = "closed" | "open" | "half-open";
+
+export interface CircuitBreakerOptions {
+  failureThreshold: number;
+  successThreshold: number;
+  resetTimeout: number;
+  halfOpenMaxCalls: number;
+  onStateChange?: (from: CircuitState, to: CircuitState) => void;
+}
+
+const defaultOptions: CircuitBreakerOptions = {
+  failureThreshold: 5,
+  successThreshold: 3,
+  resetTimeout: 30000,
+  halfOpenMaxCalls: 1,
+};
+
+export interface CircuitBreakerStats {
+  state: CircuitState;
+  failures: number;
+  successes: number;
+  lastFailureTime?: number;
+  lastSuccessTime?: number;
+  totalCalls: number;
+  totalFailures: number;
+  totalSuccesses: number;
+}
+
+export class CircuitBreaker {
+  private state: CircuitState = "closed";
+  private failures = 0;
+  private successes = 0;
+  private lastFailureTime?: number;
+  private lastSuccessTime?: number;
+  private halfOpenCalls = 0;
+  private totalCalls = 0;
+  private totalFailures = 0;
+  private totalSuccesses = 0;
+
+  constructor(
+    private readonly name: string,
+    private readonly options: CircuitBreakerOptions = defaultOptions
+  ) { }
+
+  async execute<T>(fn: () => Promise<T>): Promise<T> {
+    if (this.state === "open") {
+      const timeSinceLastFailure = Date.now() - (this.lastFailureTime ?? 0);
+
+      if (timeSinceLastFailure > this.options.resetTimeout) {
+        this.transitionTo("half-open");
+      } else {
+        const waitTime = this.options.resetTimeout - timeSinceLastFailure;
+        throw new CircuitBreakerOpenError(
+          `Circuit breaker '${this.name}' is OPEN. Retry in ${Math.ceil(waitTime / 1000)}s`,
+          this.name,
+          waitTime
+        );
+      }
+    }
+
+    if (this.state === "half-open") {
+      if (this.halfOpenCalls >= this.options.halfOpenMaxCalls) {
+        throw new CircuitBreakerOpenError(
+          `Circuit breaker '${this.name}' is HALF-OPEN with pending calls`,
+          this.name,
+          0
+        );
+      }
+      this.halfOpenCalls++;
+    }
+
+    this.totalCalls++;
+
+    try {
+      const result = await fn();
+      this.onSuccess();
+      return result;
+    } catch (error) {
+      this.onFailure();
+      throw error;
+    }
+  }
+
+  private onSuccess(): void {
+    this.lastSuccessTime = Date.now();
+    this.totalSuccesses++;
+    this.failures = 0;
+
+    if (this.state === "half-open") {
+      this.successes++;
+      this.halfOpenCalls--;
+
+      if (this.successes >= this.options.successThreshold) {
+        this.transitionTo("closed");
+      }
+    }
+  }
+
+  private onFailure(): void {
+    this.lastFailureTime = Date.now();
+    this.totalFailures++;
+    this.failures++;
+
+    if (this.state === "half-open") {
+      this.halfOpenCalls--;
+      this.transitionTo("open");
+    } else if (this.state === "closed") {
+      if (this.failures >= this.options.failureThreshold) {
+        this.transitionTo("open");
+      }
+    }
+  }
+
+  private transitionTo(newState: CircuitState): void {
+    const oldState = this.state;
+    this.state = newState;
+
+    if (newState === "closed") {
+      this.failures = 0;
+      this.successes = 0;
+      this.halfOpenCalls = 0;
+    } else if (newState === "open") {
+      this.successes = 0;
+      this.halfOpenCalls = 0;
+    }
+
+    this.options.onStateChange?.(oldState, newState);
+    logger.info(`[CircuitBreaker] ${this.name}: ${oldState} → ${newState}`);
+  }
+
+  getState(): CircuitState {
+    return this.state;
+  }
+
+  isOpen(): boolean {
+    return this.state === "open";
+  }
+
+  isClosed(): boolean {
+    return this.state === "closed";
+  }
+
+  isHalfOpen(): boolean {
+    return this.state === "half-open";
+  }
+
+  getStats(): CircuitBreakerStats {
+    return {
+      state: this.state,
+      failures: this.failures,
+      successes: this.successes,
+      lastFailureTime: this.lastFailureTime,
+      lastSuccessTime: this.lastSuccessTime,
+      totalCalls: this.totalCalls,
+      totalFailures: this.totalFailures,
+      totalSuccesses: this.totalSuccesses,
+    };
+  }
+
+  reset(): void {
+    this.transitionTo("closed");
+    this.failures = 0;
+    this.successes = 0;
+    this.lastFailureTime = undefined;
+    this.lastSuccessTime = undefined;
+    this.halfOpenCalls = 0;
+  }
+
+  forceOpen(): void {
+    this.transitionTo("open");
+    this.lastFailureTime = Date.now();
+  }
+}
+
+export class CircuitBreakerOpenError extends Error {
+  constructor(
+    message: string,
+    public readonly circuitName: string,
+    public readonly retryAfterMs: number
+  ) {
+    super(message);
+    this.name = "CircuitBreakerOpenError";
+  }
+}
+
+export class CircuitBreakerRegistry {
+  private breakers: Map<string, CircuitBreaker> = new Map();
+
+  getOrCreate(name: string, options?: Partial<CircuitBreakerOptions>): CircuitBreaker {
+    let breaker = this.breakers.get(name);
+
+    if (!breaker) {
+      breaker = new CircuitBreaker(name, { ...defaultOptions, ...options });
+      this.breakers.set(name, breaker);
+    }
+
+    return breaker;
+  }
+
+  get(name: string): CircuitBreaker | undefined {
+    return this.breakers.get(name);
+  }
+
+  getAll(): Map<string, CircuitBreaker> {
+    return new Map(this.breakers);
+  }
+
+  getAllStats(): Record<string, CircuitBreakerStats> {
+    const stats: Record<string, CircuitBreakerStats> = {};
+    for (const [name, breaker] of this.breakers) {
+      stats[name] = breaker.getStats();
+    }
+    return stats;
+  }
+
+  resetAll(): void {
+    for (const breaker of this.breakers.values()) {
+      breaker.reset();
+    }
+  }
+}
+
+export const circuitBreakerRegistry = new CircuitBreakerRegistry();