@johpaz/hive-core 1.0.8 → 1.0.10

package/src/canvas/canvas-manager.ts

@@ -0,0 +1,219 @@
+import { EventEmitter } from "events";
+import { logger } from "../utils/logger.ts";
+import { eventBus } from "../events/event-bus.ts";
+
+export interface WebSocketLike {
+  readyState: number;
+  send(data: string): void;
+  on(event: "message", callback: (data: unknown) => void): void;
+  on(event: "close", callback: () => void): void;
+}
+
+export const WebSocketState = {
+  CONNECTING: 0,
+  OPEN: 1,
+  CLOSING: 2,
+  CLOSED: 3,
+};
+
+export interface CanvasComponent {
+  id: string;
+  type: "button" | "form" | "chart" | "table" | "markdown" | "text" | "image";
+  props: Record<string, unknown>;
+}
+
+export interface CanvasMessage {
+  type: "canvas:render" | "canvas:update" | "canvas:clear" | "canvas:interact";
+  payload: {
+    sessionId: string;
+    componentId?: string;
+    component?: CanvasComponent;
+    action?: string;
+    data?: unknown;
+  };
+}
+
+export interface InteractionEvent {
+  sessionId: string;
+  componentId: string;
+  action: string;
+  data: unknown;
+}
+
+interface PendingInteraction {
+  resolve: (data: unknown) => void;
+  reject: (error: Error) => void;
+  timeoutId: ReturnType<typeof setTimeout>;
+}
+
+export class CanvasManager extends EventEmitter {
+  private sessions: Map<string, WebSocketLike> = new Map();
+  private pendingInteractions: Map<string, PendingInteraction> = new Map();
+  private log = logger.child("canvas");
+
+  registerSession(sessionId: string, ws: WebSocketLike): void {
+    this.sessions.set(sessionId, ws);
+    this.log.info(`Canvas session registered: ${sessionId}`);
+
+    ws.on("message", (data: unknown) => {
+      try {
+        const msg = JSON.parse(data as string) as CanvasMessage;
+        this.handleMessage(sessionId, msg);
+      } catch (error) {
+        this.log.error(`Invalid canvas message: ${(error as Error).message}`);
+      }
+    });
+
+    ws.on("close", () => {
+      this.sessions.delete(sessionId);
+      this.cleanupPendingInteractions(sessionId);
+      this.log.info(`Canvas session disconnected: ${sessionId}`);
+    });
+
+    eventBus.emit("tool:completed" as any, {
+      toolName: "canvas:session:register",
+      result: { sessionId },
+      duration: 0,
+      success: true,
+    });
+  }
+
+  private handleMessage(sessionId: string, msg: CanvasMessage): void {
+    if (msg.type === "canvas:interact") {
+      const { componentId, action, data } = msg.payload;
+
+      if (componentId) {
+        this.resolveInteraction(sessionId, componentId, data);
+      }
+
+      this.emit("interaction", {
+        sessionId,
+        componentId,
+        action,
+        data,
+      } as InteractionEvent);
+    }
+  }
+
+  private resolveInteraction(sessionId: string, componentId: string, data: unknown): void {
+    const key = `${sessionId}:${componentId}`;
+    const pending = this.pendingInteractions.get(key);
+
+    if (pending) {
+      clearTimeout(pending.timeoutId);
+      this.pendingInteractions.delete(key);
+      pending.resolve(data);
+    }
+  }
+
+  async render(sessionId: string, component: CanvasComponent): Promise<void> {
+    const ws = this.sessions.get(sessionId);
+
+    if (!ws || ws.readyState !== WebSocketState.OPEN) {
+      throw new Error(`Session not connected: ${sessionId}`);
+    }
+
+    const message: CanvasMessage = {
+      type: "canvas:render",
+      payload: { sessionId, component },
+    };
+
+    ws.send(JSON.stringify(message));
+    this.log.debug(`Rendered component ${component.id} to session ${sessionId}`);
+  }
+
+  async update(sessionId: string, component: CanvasComponent): Promise<void> {
+    const ws = this.sessions.get(sessionId);
+
+    if (!ws || ws.readyState !== WebSocketState.OPEN) {
+      throw new Error(`Session not connected: ${sessionId}`);
+    }
+
+    const message: CanvasMessage = {
+      type: "canvas:update",
+      payload: { sessionId, component },
+    };
+
+    ws.send(JSON.stringify(message));
+    this.log.debug(`Updated component ${component.id} in session ${sessionId}`);
+  }
+
+  async clear(sessionId: string): Promise<void> {
+    const ws = this.sessions.get(sessionId);
+
+    if (!ws || ws.readyState !== WebSocketState.OPEN) {
+      throw new Error(`Session not connected: ${sessionId}`);
+    }
+
+    const message: CanvasMessage = {
+      type: "canvas:clear",
+      payload: { sessionId },
+    };
+
+    ws.send(JSON.stringify(message));
+    this.log.debug(`Cleared canvas for session ${sessionId}`);
+  }
+
+  async waitForInteraction(
+    sessionId: string,
+    componentId: string,
+    timeout = 300000
+  ): Promise<unknown> {
+    const key = `${sessionId}:${componentId}`;
+
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        this.pendingInteractions.delete(key);
+        reject(new Error(`Interaction timeout for ${componentId}`));
+      }, timeout);
+
+      this.pendingInteractions.set(key, { resolve, reject, timeoutId });
+    });
+  }
+
+  handleInteraction(sessionId: string, componentId: string, data: unknown): void {
+    this.resolveInteraction(sessionId, componentId, data);
+  }
+
+  isSessionConnected(sessionId: string): boolean {
+    const ws = this.sessions.get(sessionId);
+    return ws !== undefined && ws.readyState === WebSocketState.OPEN;
+  }
+
+  getConnectedSessions(): string[] {
+    return Array.from(this.sessions.entries())
+      .filter(([_, ws]) => ws.readyState === WebSocketState.OPEN)
+      .map(([id]) => id);
+  }
+
+  getStats(): { totalSessions: number; activeSessions: number; pendingInteractions: number } {
+    return {
+      totalSessions: this.sessions.size,
+      activeSessions: this.getConnectedSessions().length,
+      pendingInteractions: this.pendingInteractions.size,
+    };
+  }
+
+  private cleanupPendingInteractions(sessionId: string): void {
+    for (const [key, pending] of this.pendingInteractions) {
+      if (key.startsWith(`${sessionId}:`)) {
+        clearTimeout(pending.timeoutId);
+        pending.reject(new Error(`Session disconnected: ${sessionId}`));
+        this.pendingInteractions.delete(key);
+      }
+    }
+  }
+
+  clearAll(): void {
+    for (const pending of this.pendingInteractions.values()) {
+      clearTimeout(pending.timeoutId);
+      pending.reject(new Error("Canvas manager cleared"));
+    }
+    
+    this.pendingInteractions.clear();
+    this.sessions.clear();
+    this.log.info("Canvas manager cleared");
+  }
+}
+
+export const canvasManager = new CanvasManager();

package/src/canvas/canvas-tools.ts

@@ -0,0 +1,189 @@
+import type { Tool } from "../tools/registry.ts";
+import type { Config } from "../config/loader.ts";
+import { canvasManager } from "./canvas-manager.ts";
+import { logger } from "../utils/logger.ts";
+
+export function createCanvasRenderTool(_config: Config): Tool {
+  const log = logger.child("canvas-render");
+
+  return {
+    name: "canvas_render",
+    description: "Render a component on the user's canvas",
+    parameters: {
+      type: "object",
+      properties: {
+        sessionId: {
+          type: "string",
+          description: "Session ID to render to",
+        },
+        component: {
+          type: "object",
+          properties: {
+            id: {
+              type: "string",
+              description: "Unique component ID",
+            },
+            type: {
+              type: "string",
+              enum: ["button", "form", "chart", "table", "markdown", "text", "image"],
+              description: "Component type",
+            },
+            props: {
+              type: "object",
+              description: "Component properties",
+            },
+          },
+          required: ["id", "type", "props"],
+        },
+      },
+      required: ["sessionId", "component"],
+    },
+    execute: async (params: Record<string, unknown>) => {
+      const sessionId = params.sessionId as string;
+      const component = params.component as {
+        id: string;
+        type: "button" | "form" | "chart" | "table" | "markdown" | "text" | "image";
+        props: Record<string, unknown>;
+      };
+
+      log.debug(`Rendering component ${component.id} to session ${sessionId}`);
+
+      await canvasManager.render(sessionId, {
+        id: component.id,
+        type: component.type,
+        props: component.props,
+      });
+
+      return {
+        success: true,
+        componentId: component.id,
+        sessionId,
+      };
+    },
+  };
+}
+
+export function createCanvasAskTool(_config: Config): Tool {
+  const log = logger.child("canvas-ask");
+
+  return {
+    name: "canvas_ask",
+    description: "Display a form and wait for user response",
+    parameters: {
+      type: "object",
+      properties: {
+        sessionId: {
+          type: "string",
+          description: "Session ID",
+        },
+        title: {
+          type: "string",
+          description: "Form title",
+        },
+        fields: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              name: { type: "string" },
+              label: { type: "string" },
+              type: { type: "string", enum: ["text", "email", "textarea", "select"] },
+              required: { type: "boolean" },
+              options: {
+                type: "array",
+                items: {
+                  type: "object",
+                  properties: {
+                    label: { type: "string" },
+                    value: { type: "string" },
+                  },
+                },
+              },
+            },
+            required: ["name", "label", "type"],
+          },
+          description: "Form fields",
+        },
+        timeout: {
+          type: "number",
+          description: "Timeout in milliseconds (default: 300000)",
+        },
+      },
+      required: ["sessionId", "fields"],
+    },
+    execute: async (params: Record<string, unknown>) => {
+      const sessionId = params.sessionId as string;
+      const title = (params.title as string) ?? "Form";
+      const fields = params.fields as Array<{
+        name: string;
+        label: string;
+        type: string;
+        required?: boolean;
+        options?: Array<{ label: string; value: string }>;
+      }>;
+      const timeout = (params.timeout as number) ?? 300000;
+
+      const formId = `form-${Date.now()}`;
+
+      log.debug(`Asking user via form ${formId}`);
+
+      await canvasManager.render(sessionId, {
+        id: formId,
+        type: "form",
+        props: { title, fields },
+      });
+
+      try {
+        const response = await canvasManager.waitForInteraction(sessionId, formId, timeout);
+
+        return {
+          success: true,
+          formId,
+          data: response,
+        };
+      } catch (error) {
+        return {
+          success: false,
+          formId,
+          error: (error as Error).message,
+        };
+      }
+    },
+  };
+}
+
+export function createCanvasClearTool(_config: Config): Tool {
+  const log = logger.child("canvas-clear");
+
+  return {
+    name: "canvas_clear",
+    description: "Clear the canvas for a session",
+    parameters: {
+      type: "object",
+      properties: {
+        sessionId: {
+          type: "string",
+          description: "Session ID to clear",
+        },
+      },
+      required: ["sessionId"],
+    },
+    execute: async (params: Record<string, unknown>) => {
+      const sessionId = params.sessionId as string;
+
+      log.debug(`Clearing canvas for session ${sessionId}`);
+
+      await canvasManager.clear(sessionId);
+
+      return { success: true, sessionId };
+    },
+  };
+}
+
+export function createCanvasTools(config: Config): Tool[] {
+  return [
+    createCanvasRenderTool(config),
+    createCanvasAskTool(config),
+    createCanvasClearTool(config),
+  ];
+}

package/src/canvas/index.ts

@@ -0,0 +1,2 @@
+export * from "./canvas-manager.ts";
+export * from "./canvas-tools.ts";

package/src/channels/whatsapp.ts

@@ -6,7 +6,7 @@ import makeWASocket, {
 } from "@whiskeysockets/baileys";
 import type { ChannelConfig, IncomingMessage, OutboundMessage } from "./base.ts";
 import { BaseChannel } from "./base.ts";
-import * as fs from "node:fs";
+import { existsSync, mkdirSync, rmSync } from "node:fs";
 import * as path from "node:path";
 import { logger } from "../utils/logger.ts";
 
@@ -29,7 +29,7 @@ export class WhatsAppChannel extends BaseChannel {
   name = "whatsapp";
   accountId: string;
   config: WhatsAppConfig;
-  
+
   private socket: WASocket | null = null;
   private connectionState: WhatsAppConnectionState = {
     status: "disconnected",
@@ -50,11 +50,11 @@ export class WhatsAppChannel extends BaseChannel {
   private getAuthPath(agentId: string, accountId: string): string {
     const baseDir = process.env.HOME ?? "";
     const authDir = path.join(baseDir, ".hive", "agents", agentId, "whatsapp", accountId);
-    
-    if (!fs.existsSync(authDir)) {
-      fs.mkdirSync(authDir, { recursive: true });
+
+    if (!existsSync(authDir)) {
+      mkdirSync(authDir, { recursive: true });
     }
-    
+
     return authDir;
   }
 
@@ -65,7 +65,7 @@ export class WhatsAppChannel extends BaseChannel {
 
   async stop(): Promise<void> {
     this.running = false;
-    
+
     if (this.reconnectTimeout) {
       clearTimeout(this.reconnectTimeout);
       this.reconnectTimeout = null;
@@ -144,8 +144,8 @@ export class WhatsAppChannel extends BaseChannel {
 
       if (statusCode === DisconnectReason.loggedOut) {
         this.log.error("WhatsApp logged out - session invalidated. Need to re-scan QR.");
-        fs.rmSync(this.authPath, { recursive: true, force: true });
-        fs.mkdirSync(this.authPath, { recursive: true });
+        rmSync(this.authPath, { recursive: true, force: true });
+        mkdirSync(this.authPath, { recursive: true });
       }
 
       if (shouldReconnect && this.running) {
@@ -167,7 +167,7 @@ export class WhatsAppChannel extends BaseChannel {
     console.log("\n" + "=".repeat(50));
     console.log("  WHATSAPP QR CODE - Scan with your phone");
     console.log("=".repeat(50) + "\n");
-    
+
     const qrcode = require("qrcode-terminal");
     qrcode.generate(qr, { small: false }, (qrString: string) => {
       console.log(qrString);
@@ -188,7 +188,7 @@ export class WhatsAppChannel extends BaseChannel {
         messageTimestamp?: number;
         pushName?: string;
       };
-      
+
       if (typedMsg.key.fromMe) continue;
 
       const from = typedMsg.key.remoteJid;
@@ -315,7 +315,7 @@ export class WhatsAppChannel extends BaseChannel {
     const jid = this.getJid(sessionId);
     try {
       await this.socket.readMessages([
-        { key: { remoteJid: jid, id: messageId, fromMe: false } }
+        { remoteJid: jid, id: messageId, fromMe: false }
       ]);
     } catch {
       // Ignore read receipt errors

package/src/config/loader.ts

@@ -1,5 +1,5 @@
 import * as z from "zod";
-import * as fs from "node:fs";
+import { mkdirSync } from "node:fs";
 import * as path from "node:path";
 import * as yaml from "js-yaml";
 
@@ -474,7 +474,7 @@ function deepMerge<T extends Record<string, unknown>>(target: T, source: Partial
   return result;
 }
 
-export function loadConfig(configPath?: string): Config {
+export async function loadConfig(configPath?: string): Promise<Config> {
   const paths = configPath
     ? [configPath]
     : [
@@ -487,9 +487,10 @@ export function loadConfig(configPath?: string): Config {
   let loadedConfig: Partial<Config> = {};
 
   for (const p of paths) {
-    if (fs.existsSync(p)) {
+    const file = Bun.file(p);
+    if (await file.exists()) {
       try {
-        const content = fs.readFileSync(p, "utf-8");
+        const content = await file.text();
         const parsed = yaml.load(content);
         loadedConfig = expandEnvInObject(parsed as Partial<Config>);
         break;
@@ -509,7 +510,7 @@ export function loadConfig(configPath?: string): Config {
   return result.data;
 }
 
-export function saveConfig(config: Config, configPath?: string): void {
+export async function saveConfig(config: Config, configPath?: string): Promise<void> {
   const paths = configPath
     ? [configPath]
     : [
@@ -519,7 +520,8 @@ export function saveConfig(config: Config, configPath?: string): void {
 
   let targetPath = paths[0];
   for (const p of paths) {
-    if (fs.existsSync(p)) {
+    const file = Bun.file(p);
+    if (await file.exists()) {
       targetPath = p;
       break;
     }
@@ -527,15 +529,16 @@ export function saveConfig(config: Config, configPath?: string): void {
 
   if (targetPath) {
     const dir = path.dirname(targetPath);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
+    const dirFile = Bun.file(dir);
+    if (!(await dirFile.exists())) {
+      mkdirSync(dir, { recursive: true });
     }
     const yamlStr = yaml.dump(config, {
       indent: 2,
       lineWidth: -1,
       noRefs: true,
     });
-    fs.writeFileSync(targetPath, yamlStr, "utf-8");
+    await Bun.write(targetPath, yamlStr);
   }
 }
 

package/src/events/event-bus.test.ts

@@ -0,0 +1,98 @@
+import { describe, it, expect, beforeEach } from "bun:test";
+import { eventBus } from "../events/event-bus";
+
+describe("TypedEventBus", () => {
+  beforeEach(() => {
+    eventBus.removeAllListeners();
+  });
+
+  it("should emit and receive typed events", async () => {
+    let receivedData: any = null;
+
+    eventBus.on("message:received", (data) => {
+      receivedData = data;
+    });
+
+    eventBus.emit("message:received", {
+      channel: "telegram",
+      userId: "123",
+      content: "hello",
+      timestamp: Date.now(),
+      sessionId: "session-1",
+    });
+
+    expect(receivedData).not.toBeNull();
+    expect(receivedData.channel).toBe("telegram");
+    expect(receivedData.content).toBe("hello");
+  });
+
+  it("should handle multiple listeners", () => {
+    const calls: string[] = [];
+
+    eventBus.on("agent:thinking", () => { calls.push("first"); });
+    eventBus.on("agent:thinking", () => { calls.push("second"); });
+
+    eventBus.emit("agent:thinking", {
+      agentId: "agent-1",
+      sessionId: "session-1",
+      stage: "planning",
+    });
+
+    expect(calls).toEqual(["first", "second"]);
+  });
+
+  it("should return unsubscribe function", () => {
+    const calls: string[] = [];
+
+    const unsubscribe = eventBus.on("tool:executing", () => { calls.push("called"); });
+
+    eventBus.emit("tool:executing", {
+      toolName: "read",
+      args: { path: "/test" },
+      sessionId: "session-1",
+    });
+
+    expect(calls.length).toBe(1);
+
+    unsubscribe();
+
+    eventBus.emit("tool:executing", {
+      toolName: "write",
+      args: { path: "/test2" },
+      sessionId: "session-1",
+    });
+
+    expect(calls.length).toBe(1);
+  });
+
+  it("should handle once listener", () => {
+    const calls: number[] = [];
+
+    eventBus.once("session:started", () => { calls.push(1); });
+
+    eventBus.emit("session:started", {
+      sessionId: "s1",
+      agentId: "agent-1",
+      channel: "telegram",
+      userId: "user-1",
+    });
+
+    eventBus.emit("session:started", {
+      sessionId: "s2",
+      agentId: "agent-1",
+      channel: "telegram",
+      userId: "user-1",
+    });
+
+    expect(calls.length).toBe(1);
+  });
+
+  it("should track listener count", () => {
+    eventBus.removeAllListeners("mcp:connected");
+
+    eventBus.on("mcp:connected", () => {});
+    eventBus.on("mcp:connected", () => {});
+
+    expect(eventBus.listenerCount("mcp:connected")).toBe(2);
+  });
+});