@johpaz/hive-core 1.0.8 → 1.0.10

package/src/plugins/api.ts

@@ -0,0 +1,129 @@
+import type { Logger, ChildLogger } from "../utils/logger.ts";
+import type { eventBus, EventMap, EventKey } from "../events/event-bus.ts";
+import type { StateStore } from "../state/store.ts";
+import type { Tool } from "../tools/registry.ts";
+
+export interface PluginManifest {
+  name: string;
+  version: string;
+  description?: string;
+  author?: string;
+  dependencies?: string[];
+  hiveVersion?: string;
+  main?: string;
+  enabled?: boolean;
+}
+
+export interface ToolDefinition {
+  name: string;
+  description: string;
+  parameters: Record<string, ParameterDefinition>;
+  execute: (args: Record<string, unknown>) => Promise<unknown>;
+}
+
+export interface ParameterDefinition {
+  type: "string" | "number" | "boolean" | "object" | "array";
+  description?: string;
+  required?: boolean;
+  default?: unknown;
+  enum?: string[];
+  items?: ParameterDefinition;
+  properties?: Record<string, ParameterDefinition>;
+}
+
+export interface ChannelDefinition {
+  name: string;
+  type: string;
+  config: Record<string, unknown>;
+  start: () => Promise<void>;
+  stop: () => Promise<void>;
+  send: (sessionId: string, message: unknown) => Promise<void>;
+}
+
+export interface CLICommand {
+  name: string;
+  description: string;
+  handler: (args: string[], options: Record<string, unknown>) => Promise<void>;
+  options?: Record<string, CommandOption>;
+}
+
+export interface CommandOption {
+  alias?: string;
+  description?: string;
+  type?: "string" | "boolean" | "number";
+  default?: unknown;
+}
+
+export interface PluginContext {
+  pluginName: string;
+  logger: ChildLogger;
+  config: Record<string, unknown>;
+  registerTool: (tool: ToolDefinition) => void;
+  unregisterTool: (name: string) => void;
+  registerChannel: (channel: ChannelDefinition) => void;
+  unregisterChannel: (name: string) => void;
+  registerCommand: (command: CLICommand) => void;
+  unregisterCommand: (name: string) => void;
+  events: {
+    emit: <K extends EventKey>(event: K, data: EventMap[K]) => void;
+    on: <K extends EventKey>(event: K, handler: (data: EventMap[K]) => void | Promise<void>) => () => void;
+    once: <K extends EventKey>(event: K, handler: (data: EventMap[K]) => void | Promise<void>) => void;
+  };
+  state: {
+    get: () => ReturnType<StateStore["getState"]>;
+    subscribe: (listener: (state: ReturnType<StateStore["getState"]>) => void) => () => void;
+  };
+  getTool: (name: string) => ToolDefinition | undefined;
+  getTools: () => ToolDefinition[];
+}
+
+export interface InboundMessage {
+  sessionId: string;
+  channel: string;
+  userId: string;
+  content: string;
+  timestamp: number;
+}
+
+export interface AgentResponse {
+  sessionId: string;
+  content: string;
+  toolsUsed: string[];
+  duration: number;
+}
+
+export interface PluginToolCall {
+  name: string;
+  args: Record<string, unknown>;
+  sessionId: string;
+}
+
+export type MiddlewareNext = () => Promise<void>;
+export type MiddlewareResult = Promise<void>;
+
+export interface HivePlugin {
+  name: string;
+  version: string;
+  dependencies?: string[];
+  manifest?: PluginManifest;
+
+  activate(context: PluginContext): Promise<void>;
+  deactivate(): Promise<void>;
+
+  onMessage?: (message: InboundMessage, next: MiddlewareNext) => MiddlewareResult;
+  onAgentResponse?: (response: AgentResponse, next: MiddlewareNext) => MiddlewareResult;
+  onToolCall?: (call: PluginToolCall, next: () => Promise<unknown>) => Promise<unknown>;
+  onError?: (error: Error, context: Record<string, unknown>) => Promise<void>;
+}
+
+export interface PluginState {
+  name: string;
+  status: "inactive" | "activating" | "active" | "deactivating" | "error";
+  version: string;
+  enabled: boolean;
+  error?: string;
+  loadedAt?: number;
+  activatedAt?: number;
+}
+
+export type PluginConstructor = new () => HivePlugin;

package/src/plugins/index.ts

@@ -0,0 +1,2 @@
+export * from "./api.ts";
+export * from "./loader.ts";

package/src/plugins/loader.test.ts

@@ -0,0 +1,285 @@
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { PluginLoader } from "../plugins/loader.ts";
+
+const TEST_PLUGIN_DIR = "/tmp/hive-plugins-test";
+
+describe("PluginLoader", () => {
+  let loader: PluginLoader;
+
+  beforeEach(() => {
+    if (fs.existsSync(TEST_PLUGIN_DIR)) {
+      fs.rmSync(TEST_PLUGIN_DIR, { recursive: true });
+    }
+    fs.mkdirSync(TEST_PLUGIN_DIR, { recursive: true });
+    loader = new PluginLoader({ pluginDir: TEST_PLUGIN_DIR, enableSandbox: false });
+  });
+
+  afterEach(() => {
+    if (fs.existsSync(TEST_PLUGIN_DIR)) {
+      fs.rmSync(TEST_PLUGIN_DIR, { recursive: true });
+    }
+  });
+
+  it("should discover plugins", async () => {
+    const pluginName = "test-plugin";
+    const pluginPath = path.join(TEST_PLUGIN_DIR, pluginName);
+    fs.mkdirSync(pluginPath, { recursive: true });
+
+    fs.writeFileSync(
+      path.join(pluginPath, "manifest.json"),
+      JSON.stringify({
+        name: pluginName,
+        version: "1.0.0",
+        main: "index.js",
+      })
+    );
+
+    const discovered = await loader.discover();
+    expect(discovered).toContain(pluginName);
+  });
+
+  it("should load a valid plugin", async () => {
+    const pluginName = "echo-plugin";
+    const pluginPath = path.join(TEST_PLUGIN_DIR, pluginName);
+    fs.mkdirSync(pluginPath, { recursive: true });
+
+    fs.writeFileSync(
+      path.join(pluginPath, "manifest.json"),
+      JSON.stringify({
+        name: pluginName,
+        version: "1.0.0",
+        main: "index.js",
+      })
+    );
+
+    fs.writeFileSync(
+      path.join(pluginPath, "index.js"),
+      `
+class EchoPlugin {
+  name = 'echo-plugin';
+  version = '1.0.0';
+
+  async activate(context) {
+    context.registerTool({
+      name: 'echo',
+      description: 'Echoes input',
+      parameters: {
+        message: { type: 'string', description: 'Message to echo' }
+      },
+      execute: async ({ message }) => message
+    });
+  }
+
+  async deactivate() {}
+}
+
+export default EchoPlugin;
+`
+    );
+
+    await loader.load(pluginName);
+
+    const tool = loader.getTool("echo-plugin:echo");
+    expect(tool).toBeDefined();
+    expect(tool?.description).toBe("Echoes input");
+
+    const result = await tool?.execute({ message: "hello" });
+    expect(result).toBe("hello");
+  });
+
+  it("should track plugin state", async () => {
+    const pluginName = "state-plugin";
+    const pluginPath = path.join(TEST_PLUGIN_DIR, pluginName);
+    fs.mkdirSync(pluginPath, { recursive: true });
+
+    fs.writeFileSync(
+      path.join(pluginPath, "manifest.json"),
+      JSON.stringify({
+        name: pluginName,
+        version: "2.0.0",
+        main: "index.js",
+      })
+    );
+
+    fs.writeFileSync(
+      path.join(pluginPath, "index.js"),
+      `
+class StatePlugin {
+  name = 'state-plugin';
+  version = '2.0.0';
+  async activate() {}
+  async deactivate() {}
+}
+export default StatePlugin;
+`
+    );
+
+    await loader.load(pluginName);
+
+    const state = loader.getPluginState(pluginName);
+    expect(state?.status).toBe("active");
+    expect(state?.version).toBe("2.0.0");
+  });
+
+  it("should unload plugin and cleanup tools", async () => {
+    const pluginName = "cleanup-plugin";
+    const pluginPath = path.join(TEST_PLUGIN_DIR, pluginName);
+    fs.mkdirSync(pluginPath, { recursive: true });
+
+    fs.writeFileSync(
+      path.join(pluginPath, "manifest.json"),
+      JSON.stringify({
+        name: pluginName,
+        version: "1.0.0",
+        main: "index.js",
+      })
+    );
+
+    fs.writeFileSync(
+      path.join(pluginPath, "index.js"),
+      `
+class CleanupPlugin {
+  name = 'cleanup-plugin';
+  version = '1.0.0';
+  async activate(ctx) {
+    ctx.registerTool({
+      name: 'test_tool',
+      description: 'Test',
+      parameters: {},
+      execute: async () => 'ok'
+    });
+  }
+  async deactivate() {}
+}
+export default CleanupPlugin;
+`
+    );
+
+    await loader.load(pluginName);
+    expect(loader.getTool("cleanup-plugin:test_tool")).toBeDefined();
+
+    await loader.unload(pluginName);
+
+    expect(loader.getTool("cleanup-plugin:test_tool")).toBeUndefined();
+    const state = loader.getPluginState(pluginName);
+    expect(state?.status).toBe("inactive");
+  });
+
+  it("should reload plugin", async () => {
+    const pluginName = "reload-plugin";
+    const pluginPath = path.join(TEST_PLUGIN_DIR, pluginName);
+    fs.mkdirSync(pluginPath, { recursive: true });
+
+    fs.writeFileSync(
+      path.join(pluginPath, "manifest.json"),
+      JSON.stringify({
+        name: pluginName,
+        version: "1.0.0",
+        main: "index.js",
+      })
+    );
+
+    fs.writeFileSync(
+      path.join(pluginPath, "index.js"),
+      `
+class ReloadPlugin {
+  name = 'reload-plugin';
+  version = '1.0.0';
+  async activate() {}
+  async deactivate() {}
+}
+export default ReloadPlugin;
+`
+    );
+
+    await loader.load(pluginName);
+    expect(loader.getPlugin(pluginName)).toBeDefined();
+
+    await loader.reload(pluginName);
+
+    expect(loader.getPlugin(pluginName)).toBeDefined();
+    const state = loader.getPluginState(pluginName);
+    expect(state?.status).toBe("active");
+  });
+
+  it("should handle disabled plugins", async () => {
+    const pluginName = "disabled-plugin";
+    const pluginPath = path.join(TEST_PLUGIN_DIR, pluginName);
+    fs.mkdirSync(pluginPath, { recursive: true });
+
+    fs.writeFileSync(
+      path.join(pluginPath, "manifest.json"),
+      JSON.stringify({
+        name: pluginName,
+        version: "1.0.0",
+        main: "index.js",
+        enabled: false,
+      })
+    );
+
+    fs.writeFileSync(
+      path.join(pluginPath, "index.js"),
+      `class Disabled { name = 'disabled'; version = '1.0.0'; async activate() {} async deactivate() {} }
+export default Disabled;`
+    );
+
+    await loader.load(pluginName);
+
+    const state = loader.getPluginState(pluginName);
+    expect(state?.status).toBe("inactive");
+    expect(loader.getPlugin(pluginName)).toBeUndefined();
+  });
+
+  it("should handle missing main file", async () => {
+    const pluginName = "missing-main";
+    const pluginPath = path.join(TEST_PLUGIN_DIR, pluginName);
+    fs.mkdirSync(pluginPath, { recursive: true });
+
+    fs.writeFileSync(
+      path.join(pluginPath, "manifest.json"),
+      JSON.stringify({
+        name: pluginName,
+        version: "1.0.0",
+        main: "nonexistent.js",
+      })
+    );
+
+    await expect(loader.load(pluginName)).rejects.toThrow();
+  });
+
+  it("should list all plugin states", async () => {
+    const states = loader.getAllPluginStates();
+    expect(Array.isArray(states)).toBe(true);
+  });
+
+  it("should load all discovered plugins", async () => {
+    const plugin1Path = path.join(TEST_PLUGIN_DIR, "plugin-one");
+    fs.mkdirSync(plugin1Path, { recursive: true });
+    fs.writeFileSync(
+      path.join(plugin1Path, "manifest.json"),
+      JSON.stringify({ name: "plugin-one", version: "1.0.0", main: "index.js" })
+    );
+    fs.writeFileSync(
+      path.join(plugin1Path, "index.js"),
+      `class P1 { name='plugin-one'; version='1.0.0'; async activate(){} async deactivate(){} } export default P1;`
+    );
+
+    const plugin2Path = path.join(TEST_PLUGIN_DIR, "plugin-two");
+    fs.mkdirSync(plugin2Path, { recursive: true });
+    fs.writeFileSync(
+      path.join(plugin2Path, "manifest.json"),
+      JSON.stringify({ name: "plugin-two", version: "1.0.0", main: "index.js" })
+    );
+    fs.writeFileSync(
+      path.join(plugin2Path, "index.js"),
+      `class P2 { name='plugin-two'; version='1.0.0'; async activate(){} async deactivate(){} } export default P2;`
+    );
+
+    await loader.loadAll();
+
+    const states = loader.getAllPluginStates();
+    expect(states.length).toBe(2);
+  });
+});