@johpaz/hive-core 1.0.8 → 1.0.10

package/src/events/event-bus.ts

@@ -0,0 +1,171 @@
+import { EventEmitter } from "events";
+
+export interface EventMap {
+  "message:received": {
+    channel: string;
+    userId: string;
+    content: string;
+    timestamp: number;
+    sessionId: string;
+  };
+  "message:sent": {
+    channel: string;
+    userId: string;
+    content: string;
+    messageId: string;
+    sessionId: string;
+  };
+  "agent:thinking": {
+    agentId: string;
+    sessionId: string;
+    stage: "planning" | "executing" | "responding";
+  };
+  "agent:response": {
+    agentId: string;
+    sessionId: string;
+    content: string;
+    toolsUsed: string[];
+    duration: number;
+  };
+  "tool:executing": {
+    toolName: string;
+    args: Record<string, unknown>;
+    sessionId: string;
+  };
+  "tool:completed": {
+    toolName: string;
+    result: unknown;
+    duration: number;
+    success: boolean;
+  };
+  "tool:error": {
+    toolName: string;
+    error: Error;
+    args: Record<string, unknown>;
+  };
+  "error": {
+    source: string;
+    error: Error;
+    context: Record<string, unknown>;
+    recoverable: boolean;
+  };
+  "session:started": {
+    sessionId: string;
+    agentId: string;
+    channel: string;
+    userId: string;
+  };
+  "session:ended": {
+    sessionId: string;
+    duration: number;
+    messageCount: number;
+    reason: "completed" | "cancelled" | "error" | "timeout";
+  };
+  "mcp:connected": {
+    serverName: string;
+    toolsCount: number;
+    resourcesCount: number;
+  };
+  "mcp:disconnected": {
+    serverName: string;
+    reason: string;
+  };
+  "mcp:error": {
+    serverName: string;
+    error: Error;
+  };
+  "channel:started": {
+    channel: string;
+    accountId: string;
+  };
+  "channel:stopped": {
+    channel: string;
+    accountId: string;
+    reason: string;
+  };
+  "gateway:started": {
+    host: string;
+    port: number;
+  };
+  "gateway:stopped": {
+    reason: string;
+  };
+  "pairing:requested": {
+    channel: string;
+    userId: string;
+    code: string;
+    expiresAt: number;
+  };
+  "pairing:approved": {
+    channel: string;
+    userId: string;
+  };
+  "pairing:rejected": {
+    channel: string;
+    userId: string;
+    reason: string;
+  };
+  "pairing:expired": {
+    code: string;
+    channel: string;
+    userId: string;
+  };
+}
+
+export type EventKey = keyof EventMap;
+
+export interface EventHandler<K extends EventKey> {
+  (data: EventMap[K]): void | Promise<void>;
+}
+
+class TypedEventBusImpl {
+  private emitter = new EventEmitter();
+  private logPrefix = "[events]";
+
+  emit<K extends EventKey>(event: K, data: EventMap[K]): void {
+    const enrichedData = {
+      ...data,
+      _eventId: crypto.randomUUID(),
+      _timestamp: Date.now(),
+      _event: event,
+    } as EventMap[K] & { _eventId: string; _timestamp: number; _event: string };
+
+    this.emitter.emit(event, enrichedData);
+    
+    if (process.env.DEBUG_EVENTS === "true") {
+      console.log(
+        `${this.logPrefix} emitted: ${event}`,
+        JSON.stringify(data, null, 2)
+      );
+    }
+  }
+
+  on<K extends EventKey>(event: K, handler: EventHandler<K>): () => void {
+    this.emitter.on(event, handler);
+    return () => this.off(event, handler);
+  }
+
+  once<K extends EventKey>(event: K, handler: EventHandler<K>): void {
+    this.emitter.once(event, handler);
+  }
+
+  off<K extends EventKey>(event: K, handler: EventHandler<K>): void {
+    this.emitter.off(event, handler);
+  }
+
+  removeAllListeners<K extends EventKey>(event?: K): void {
+    if (event) {
+      this.emitter.removeAllListeners(event);
+    } else {
+      this.emitter.removeAllListeners();
+    }
+  }
+
+  listenerCount<K extends EventKey>(event: K): number {
+    return this.emitter.listenerCount(event);
+  }
+}
+
+export const eventBus = new TypedEventBusImpl();
+
+export type TypedEventBus = typeof eventBus;

package/src/gateway/server.ts

@@ -12,8 +12,9 @@ import {
 import { ChannelManager } from "../channels/manager";
 import { Agent, watchEthics, watchSoul, watchUser } from "../agent/index";
 import { AgentRunner } from "../agent/providers/index";
+import { tool as aiTool, jsonSchema } from "ai";
 import type { IncomingMessage } from "../channels/base";
-import * as fs from "node:fs";
+import { mkdirSync, rmSync, unlinkSync } from "node:fs";
 import * as path from "node:path";
 import { dbService, type ChatMessageRow } from "../storage/sqlite";
 
@@ -99,8 +100,8 @@ export async function startGateway(config: Config): Promise<void> {
 
   const pidFile = expandPath(config.gateway?.pidFile ?? "~/.hive/gateway.pid");
   try {
-    fs.mkdirSync(path.dirname(pidFile), { recursive: true });
-    fs.writeFileSync(pidFile, process.pid.toString());
+    mkdirSync(path.dirname(pidFile), { recursive: true });
+    await Bun.write(pidFile, process.pid.toString());
   } catch (error) {
     log.warn(`Could not write PID file: ${(error as Error).message}`);
   }
@@ -119,21 +120,109 @@ export async function startGateway(config: Config): Promise<void> {
   await agent.initialize();
   log.info(`Agent initialized: ${agent.agentId}`);
 
+  function prepareTools(agentInstance: Agent, sessionId: string) {
+    const tools: Record<string, any> = {};
+
+    const registry = agentInstance.getToolRegistry();
+    if (registry) {
+      for (const t of registry.list()) {
+        tools[t.name] = aiTool({
+          description: t.description,
+          parameters: jsonSchema(t.parameters as any),
+          execute: async (args: any): Promise<any> => {
+            log.info(`🛠️ LLM calling native tool: ${t.name}`);
+            const res = await registry.execute(t.name, { ...args, sessionId });
+            // AI SDK expects { content: string } or string, convert from ToolResult
+            return { content: res.success ? JSON.stringify(res.result) : `Error: ${res.error}` };
+          },
+        } as any);
+      }
+    }
+
+    const mcp = agentInstance.getMCPManager();
+    if (mcp) {
+      for (const server of mcp.listServers()) {
+        if (server.status !== "connected") continue;
+        const serverTools = mcp.getServerTools(server.name);
+        for (const t of serverTools) {
+          const mcpToolName = `${server.name}__${t.name}`.replace(/[^a-zA-Z0-9_-]/g, "_");
+          tools[mcpToolName] = aiTool({
+            description: t.description,
+            parameters: jsonSchema(t.inputSchema as any),
+            execute: async (args: any): Promise<any> => {
+              log.info(`🛠️ LLM calling MCP tool: ${t.name} (on ${server.name})`);
+              const res = await mcp.callTool(server.name, t.name, args as any);
+              // AI SDK expects { content: string } or string
+              return { content: typeof res === 'string' ? res : JSON.stringify(res) };
+            },
+          } as any);
+        }
+      }
+    }
+
+    return Object.keys(tools).length > 0 ? tools : undefined;
+  }
+
+  agent.on("cron", (sessionId: string, task: string) => {
+    log.info(`[CRON] Triggered task '${task}' for session ${sessionId}`);
+    dbService.addMessage(sessionId, "system", `Scheduled task triggered: ${task}. Please execute it now.`);
+
+    laneQueue.enqueue(sessionId, async (_t, signal) => {
+      if (signal.aborted) return;
+      try {
+        const history = dbService.getMessages(sessionId);
+        const messages = history.map((row: ChatMessageRow) => ({
+          role: row.role as "user" | "assistant" | "system",
+          content: row.content,
+        }));
+        const systemPrompt = agent.buildPrompt();
+
+        const provider = config.models?.defaultProvider ?? "gemini";
+
+        log.info(`[CRON] Generating response for session ${sessionId}...`);
+        const response = await runner.generate({
+          provider: provider as any,
+          system: systemPrompt,
+          messages,
+          maxTokens: 4096,
+          tools: prepareTools(agent, sessionId),
+          maxSteps: 5,
+        });
+
+        const responseContent = response.content?.trim() || "Task completed.";
+        dbService.addMessage(sessionId, "assistant", responseContent);
+
+        const parts = sessionId.split(":");
+        const isWebchat = parts[2] === "webchat";
+        if (isWebchat) {
+          const session = sessionManager.get(sessionId);
+          if (session?.ws) {
+            session.ws.send(JSON.stringify({ type: "message", sessionId: sessionId, content: responseContent } as OutboundMessage));
+          }
+        } else {
+          await channelManager.send(parts[2], sessionId, responseContent);
+        }
+      } catch (error) {
+        log.error(`[CRON] Error for session ${sessionId}: ${(error as Error).message}`);
+      }
+    });
+  });
+
   // Set up hot reload watchers
   const watchers: Array<() => void> = [];
   const soulPath = path.join(workspacePath, "SOUL.md");
   const userPath = path.join(workspacePath, "USER.md");
   const ethicsPath = path.join(workspacePath, "ETHICS.md");
 
-  if (fs.existsSync(soulPath)) {
+  if (await Bun.file(soulPath).exists()) {
     watchers.push(watchSoul(soulPath, () => agent.reloadSoul()));
     log.debug("Watching SOUL.md for changes");
   }
-  if (fs.existsSync(userPath)) {
+  if (await Bun.file(userPath).exists()) {
     watchers.push(watchUser(userPath, () => agent.reloadUser()));
     log.debug("Watching USER.md for changes");
   }
-  if (fs.existsSync(ethicsPath)) {
+  if (await Bun.file(ethicsPath).exists()) {
     watchers.push(watchEthics(ethicsPath, async () => agent.reloadEthics()));
     log.debug("Watching ETHICS.md for changes");
   }
@@ -150,7 +239,7 @@ export async function startGateway(config: Config): Promise<void> {
   function getUnifiedUserId(channel: string, peerId: string): string {
     const userConfig = config.user;
     if (!userConfig) return peerId;
-    
+
     const channelId = userConfig.channels?.[channel];
     if (channelId && channelId === peerId) {
       return userConfig.id;
@@ -188,6 +277,8 @@ export async function startGateway(config: Config): Promise<void> {
         system: systemPrompt,
         messages,
         maxTokens: 4096,
+        tools: prepareTools(agent, message.sessionId),
+        maxSteps: 5,
       });
 
       const responseContent = response.content || "...";
@@ -250,23 +341,25 @@ export async function startGateway(config: Config): Promise<void> {
         if (!subPath) subPath = "index.html";
 
         const filePath = path.join(dashboardDir, subPath);
-        if (fs.existsSync(filePath) && fs.statSync(filePath).isFile()) {
+        const dashFile = Bun.file(filePath);
+        const dashFileStat = await dashFile.exists();
+        if (dashFileStat) {
           if (subPath === "index.html" && token) {
             const urlToken = url.searchParams.get("token");
             if (!urlToken || urlToken !== token) {
               return Response.redirect(`/dashboard?token=${token}`, 302);
             }
-            const html = fs.readFileSync(filePath, "utf-8");
+            const html = await dashFile.text();
             const injected = html.replace(
               "</head>",
               `  <script>window.HIVE_AUTH_TOKEN = "${token}";</script>\n</head>`
             );
             return new Response(injected, { headers: { "Content-Type": "text/html" } });
           }
-          return new Response(Bun.file(filePath));
+          return new Response(dashFile);
         }
         const indexHtml = path.join(dashboardDir, "index.html");
-        if (fs.existsSync(indexHtml)) return new Response(Bun.file(indexHtml));
+        if (await Bun.file(indexHtml).exists()) return new Response(Bun.file(indexHtml));
         return new Response("Dashboard build not found. Run 'bun run build' in packages/dashboard.", { status: 404 });
       }
 
@@ -347,7 +440,7 @@ export async function startGateway(config: Config): Promise<void> {
           const channelEntry = config.channels[name] as any;
           channelEntry.accounts = channelEntry.accounts || {};
           channelEntry.accounts[accountId] = channelConfigData;
-          saveConfig(config);
+          await saveConfig(config);
           await channelManager.removeChannel(name, accountId);
           await channelManager.startChannel(name, accountId);
           return Response.json({ success: true });
@@ -372,7 +465,7 @@ export async function startGateway(config: Config): Promise<void> {
           const channelEntry = config.channels[name] as any;
           channelEntry.accounts = channelEntry.accounts || {};
           channelEntry.accounts[accountId] = body.config;
-          saveConfig(config);
+          await saveConfig(config);
           await channelManager.removeChannel(name, accountId);
           await channelManager.startChannel(name, accountId);
           return Response.json({ success: true });
@@ -386,7 +479,7 @@ export async function startGateway(config: Config): Promise<void> {
                 delete config.channels[name];
               }
             }
-            saveConfig(config);
+            await saveConfig(config);
             await channelManager.removeChannel(name, accountId);
           }
           return Response.json({ success: true });
@@ -424,9 +517,9 @@ export async function startGateway(config: Config): Promise<void> {
           const managedDir = expandPath(config.skills?.managedDir ?? "~/.hive/skills");
           const skillDir = path.join(managedDir, name);
           const skillFile = path.join(skillDir, "SKILL.md");
-          fs.mkdirSync(skillDir, { recursive: true });
+          mkdirSync(skillDir, { recursive: true });
           const skillMd = raw || `---\nname: ${name}\ndescription: ${description || ""}\n---\n${content}`;
-          fs.writeFileSync(skillFile, skillMd);
+          await Bun.write(skillFile, skillMd);
           agent.reloadSkills();
           return Response.json({ success: true });
         }
@@ -448,7 +541,7 @@ export async function startGateway(config: Config): Promise<void> {
           } else {
             config.skills.allowBundled = config.skills.allowBundled.filter((n) => n !== bundledName);
           }
-          saveConfig(config);
+          await saveConfig(config);
           await agent.updateConfig(config);
           agent.reloadSkills();
           return Response.json({ success: true });
@@ -464,7 +557,7 @@ export async function startGateway(config: Config): Promise<void> {
           }
           const skillFile = path.join(skill.path, "SKILL.md");
           const skillMd = raw || `---\nname: ${name || skillName}\ndescription: ${description || ""}\n---\n${content}`;
-          fs.writeFileSync(skillFile, skillMd);
+          await Bun.write(skillFile, skillMd);
           agent.reloadSkills();
           return Response.json({ success: true });
         }
@@ -472,12 +565,12 @@ export async function startGateway(config: Config): Promise<void> {
         if (req.method === "DELETE") {
           const skill = agent.getSkills().find((s) => s.name === skillName);
           if (skill?.source === "managed") {
-            fs.rmSync(skill.path, { recursive: true, force: true });
+            rmSync(skill.path, { recursive: true, force: true });
             agent.reloadSkills();
           } else if (skill?.source === "bundled") {
             config.skills = config.skills || {};
             config.skills.allowBundled = (config.skills.allowBundled || []).filter((n) => n !== skillName);
-            saveConfig(config);
+            await saveConfig(config);
             await agent.updateConfig(config);
             agent.reloadSkills();
           }
@@ -500,7 +593,7 @@ export async function startGateway(config: Config): Promise<void> {
           if (defaultProvider) config.models.defaultProvider = defaultProvider;
           if (defaults) config.models.defaults = { ...(config.models.defaults || {}), ...defaults };
           if (providers) config.models.providers = { ...(config.models.providers || {}), ...providers };
-          saveConfig(config);
+          await saveConfig(config);
           await agent.updateConfig(config);
           return Response.json({ success: true });
         }
@@ -523,7 +616,7 @@ export async function startGateway(config: Config): Promise<void> {
             config.mcp = config.mcp || {};
             config.mcp.servers = config.mcp.servers || {};
             config.mcp.servers[body.name] = body.config;
-            saveConfig(config);
+            await saveConfig(config);
             await agent.updateConfig(config);
             return Response.json({ success: true });
           }
@@ -552,14 +645,14 @@ export async function startGateway(config: Config): Promise<void> {
             config.mcp = config.mcp || {};
             config.mcp.servers = config.mcp.servers || {};
             config.mcp.servers[serverName] = body.config;
-            saveConfig(config);
+            await saveConfig(config);
             await agent.updateConfig(config);
             return Response.json({ success: true });
           }
           if (req.method === "DELETE") {
             if (config.mcp?.servers?.[serverName]) {
               delete config.mcp.servers[serverName];
-              saveConfig(config);
+              await saveConfig(config);
               await agent.updateConfig(config);
             }
             return Response.json({ success: true });
@@ -590,16 +683,17 @@ export async function startGateway(config: Config): Promise<void> {
               user: "# User Profile\n\nAdd user preferences here.",
               ethics: "# Ethics\n\nDefine ethical guidelines here.",
             };
-            const content = fs.existsSync(filePath)
-              ? fs.readFileSync(filePath, "utf-8")
+            const wsFile = Bun.file(filePath);
+            const content = (await wsFile.exists())
+              ? await wsFile.text()
               : defaults[wsType];
             return new Response(content, { headers: { "Content-Type": "text/plain" } });
           }
 
           if (req.method === "POST") {
             const content = await req.text();
-            fs.mkdirSync(workspacePath, { recursive: true });
-            fs.writeFileSync(filePath, content);
+            mkdirSync(workspacePath, { recursive: true });
+            await Bun.write(filePath, content);
             if (wsType === "soul") agent.reloadSoul();
             if (wsType === "user") agent.reloadUser();
             if (wsType === "ethics") await agent.reloadEthics();
@@ -611,7 +705,7 @@ export async function startGateway(config: Config): Promise<void> {
       // ── Reload API ───────────────────────────────────────────────────────
       if (url.pathname === "/api/reload" && req.method === "POST") {
         try {
-          const newConfig = loadConfig();
+          const newConfig = await loadConfig();
           await agent.updateConfig(newConfig);
           await agent.reload();
           log.info("Configuration reloaded via API");
@@ -628,7 +722,7 @@ export async function startGateway(config: Config): Promise<void> {
       if (url.pathname === "/api/user/channels" && req.method === "POST") {
         const body = await req.json().catch(() => ({}));
         const { channel, channelUserId } = body;
-        
+
         if (!channel || !channelUserId) {
           return Response.json({ success: false, error: "Missing channel or channelUserId" }, { status: 400 });
         }
@@ -636,10 +730,10 @@ export async function startGateway(config: Config): Promise<void> {
         config.user = config.user || { id: "", name: "User" };
         config.user.channels = config.user.channels || {};
         config.user.channels[channel] = channelUserId;
-        
-        saveConfig(config);
+
+        await saveConfig(config);
         log.info(`Linked channel ${channel} to user ID ${channelUserId}`);
-        
+
         return Response.json({ success: true, channels: config.user.channels });
       }
 
@@ -748,6 +842,8 @@ export async function startGateway(config: Config): Promise<void> {
                 system: systemPrompt,
                 messages,
                 maxTokens: 4096,
+                tools: prepareTools(agent, msg.sessionId),
+                maxSteps: 5,
               });
 
               const content = response.content?.trim() || "...";
@@ -813,14 +909,14 @@ export async function startGateway(config: Config): Promise<void> {
     }
     await channelManager.stopAll();
     server.stop();
-    try { fs.unlinkSync(pidFile); } catch { }
+    try { unlinkSync(pidFile); } catch { }
     process.exit(0);
   });
 
   process.on("SIGHUP", async () => {
     log.info("Received SIGHUP, reloading configuration...");
     try {
-      const newConfig = loadConfig();
+      const newConfig = await loadConfig();
       await agent.updateConfig(newConfig);
       await agent.reload();
       log.info("Configuration reloaded successfully");

package/src/index.ts

@@ -4,7 +4,8 @@ export * from "./agent/index.ts";
 export * from "./agent/ethics.ts";
 export * from "./agent/context.ts";
 export * from "./agent/soul.ts";
-export * from "./agent/user.ts";
+export { loadUser, watchUser, type UserConfig as AgentUserConfig } from "./agent/user.ts";
+export * from "./agent/workspace.ts";
 export * from "./channels/index.ts";
 export * from "./channels/manager.ts";
 export * from "./config/loader.ts";
@@ -14,8 +15,15 @@ export * from "./utils/retry.ts";
 export * from "./security/index.ts";
 export * from "./heartbeat/index.ts";
 export * from "./tools/registry.ts";
+export * from "./tools/dynamic-registry.ts";
 export * from "./multi-agent/manager.ts";
 export * from "./multi-agent/bindings.ts";
 export * from "./multi-agent/sandbox.ts";
 export * from "./multi-agent/subagents.ts";
 export * from "./memory/notes.ts";
+export * from "./events/event-bus.ts";
+export * from "./state/store.ts";
+export * from "./resilience/circuit-breaker.ts";
+export * from "./plugins/index.ts";
+export * from "./agents/index.ts";
+export * from "./canvas/index.ts";

package/src/multi-agent/manager.ts

@@ -1,4 +1,4 @@
-import * as fs from "node:fs";
+import { existsSync, mkdirSync } from "node:fs";
 import * as path from "node:path";
 import type { Config, AgentEntry } from "../config/loader.ts";
 import { Agent } from "../agent/index.ts";
@@ -30,7 +30,7 @@ export class AgentManager {
 
   async initialize(): Promise<void> {
     const agentList = this.config.agents?.list ?? [];
-    
+
     if (agentList.length === 0) {
       await this.createDefaultAgent();
       return;
@@ -45,7 +45,7 @@ export class AgentManager {
 
   private async createDefaultAgent(): Promise<void> {
     const defaultWorkspace = this.expandPath(
-      this.config.agent?.baseDir 
+      this.config.agent?.baseDir
         ? `${this.config.agent.baseDir}/main/workspace`
         : "~/.hive/agents/main/workspace"
     );
@@ -59,7 +59,7 @@ export class AgentManager {
 
   private async createAgent(entry: AgentEntry): Promise<void> {
     const workspacePath = this.expandPath(entry.workspace);
-    
+
     this.ensureWorkspace(workspacePath);
 
     const agent = new Agent({
@@ -121,19 +121,19 @@ export class AgentManager {
     ];
 
     for (const dir of dirs) {
-      if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
+      if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
       }
     }
 
     const soulPath = path.join(workspacePath, "SOUL.md");
-    if (!fs.existsSync(soulPath)) {
-      fs.writeFileSync(soulPath, `# Agent Identity\n\nThis is agent ${path.basename(workspacePath)}.\n`);
+    if (!existsSync(soulPath)) {
+      Bun.write(soulPath, `# Agent Identity\n\nThis is agent ${path.basename(workspacePath)}.\n`);
     }
 
     const userPath = path.join(workspacePath, "USER.md");
-    if (!fs.existsSync(userPath)) {
-      fs.writeFileSync(userPath, `# User Profile\n\nName: User\nLanguage: English\n`);
+    if (!existsSync(userPath)) {
+      Bun.write(userPath, `# User Profile\n\nName: User\nLanguage: English\n`);
     }
   }
 
@@ -172,7 +172,7 @@ export class AgentManager {
 
     const baseDir = this.config.agent?.baseDir?.replace(/^~/, process.env.HOME ?? "")
       ?? `${process.env.HOME}/.hive/agents`;
-    
+
     const workspace = options.workspace ?? `${baseDir}/${agentId}/workspace`;
 
     const entry: AgentEntry = {
@@ -182,7 +182,7 @@ export class AgentManager {
     };
 
     await this.createAgent(entry);
-    
+
     return this.agents.get(agentId)!;
   }