@johpaz/hive 1.1.0

package/packages/core/src/tools/browser.ts

@@ -0,0 +1,275 @@
+import type { Tool } from "../agent/native-tools.ts";
+import { logger } from "../utils/logger.ts";
+
+export interface BrowserConfig {
+  headless?: boolean;
+  timeout?: number;
+  userAgent?: string;
+}
+
+export function createBrowserNavigateTool(config: BrowserConfig = {}): Tool {
+  const log = logger.child("browser");
+
+  return {
+    name: "browser_navigate",
+    description: "Navigate to a URL and retrieve the page content. Useful for scraping websites or getting current information.",
+    parameters: {
+      type: "object",
+      properties: {
+        url: {
+          type: "string",
+          description: "The URL to navigate to",
+        },
+        waitFor: {
+          type: "string",
+          description: "CSS selector to wait for before returning (optional)",
+        },
+        timeout: {
+          type: "number",
+          description: "Timeout in milliseconds (default: 30000)",
+        },
+      },
+      required: ["url"],
+    },
+    execute: async (params: Record<string, unknown>) => {
+      const url = params.url as string;
+      const timeout = (params.timeout as number) ?? config.timeout ?? 30000;
+
+      log.info(`Browser navigation started: ${url}`, { timeout });
+
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+      try {
+        const response = await fetch(url, {
+          signal: controller.signal,
+          headers: {
+            "User-Agent": config.userAgent || "Mozilla/5.0 (compatible; HiveBot/1.0)",
+          },
+        });
+
+        if (!response.ok) {
+          throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+
+        const contentType = response.headers.get("content-type") || "";
+        let content: string;
+
+        if (contentType.includes("application/json")) {
+          const json = await response.json();
+          content = JSON.stringify(json, null, 2);
+        } else {
+          content = await response.text();
+
+          content = content
+            .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "")
+            .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "")
+            .replace(/<[^>]+>/g, " ")
+            .replace(/\s+/g, " ")
+            .trim();
+        }
+
+        return {
+          success: true,
+          url: url,
+          finalUrl: response.url,
+          content: content.slice(0, 50000),
+          contentType,
+        };
+      } catch (error) {
+        const err = error as Error;
+        if (err.name === "AbortError") {
+          throw new Error(`Timeout after ${timeout}ms`);
+        }
+        throw error;
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    },
+  };
+}
+
+export function createBrowserFetchTool(config: BrowserConfig = {}): Tool {
+  const log = logger.child("browser");
+
+  return {
+    name: "browser_fetch",
+    description: "Fetch content from a URL with custom HTTP method, headers, and body.",
+    parameters: {
+      type: "object",
+      properties: {
+        url: {
+          type: "string",
+          description: "The URL to fetch",
+        },
+        method: {
+          type: "string",
+          enum: ["GET", "POST", "PUT", "DELETE", "PATCH"],
+          description: "HTTP method (default: GET)",
+        },
+        headers: {
+          type: "object",
+          description: "Custom headers as key-value pairs",
+        },
+        body: {
+          type: "string",
+          description: "Request body for POST/PUT/PATCH",
+        },
+        timeout: {
+          type: "number",
+          description: "Timeout in milliseconds (default: 30000)",
+        },
+      },
+      required: ["url"],
+    },
+    execute: async (params: Record<string, unknown>) => {
+      const url = params.url as string;
+      const method = (params.method as string) ?? "GET";
+      const headers = (params.headers as Record<string, string>) ?? {};
+      const body = params.body as string | undefined;
+      const timeout = (params.timeout as number) ?? config.timeout ?? 30000;
+
+      log.info(`Browser fetch started: ${url} [${method}]`, { timeout });
+
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+      try {
+        const response = await fetch(url, {
+          method,
+          headers: {
+            "User-Agent": config.userAgent || "Mozilla/5.0 (compatible; HiveBot/1.0)",
+            ...headers,
+          },
+          body: method !== "GET" && method !== "DELETE" ? body : undefined,
+          signal: controller.signal,
+        });
+
+        if (!response.ok) {
+          throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+
+        const contentType = response.headers.get("content-type") || "";
+        let data: unknown;
+
+        if (contentType.includes("application/json")) {
+          data = await response.json();
+        } else {
+          data = await response.text();
+        }
+
+        return {
+          success: true,
+          status: response.status,
+          statusText: response.statusText,
+          headers: Object.fromEntries(response.headers.entries()),
+          data,
+        };
+      } catch (error) {
+        const err = error as Error;
+        if (err.name === "AbortError") {
+          throw new Error(`Timeout after ${timeout}ms`);
+        }
+        throw error;
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    },
+  };
+}
+
+export function createBrowserScreenshotTool(_config: BrowserConfig = {}): Tool {
+  return {
+    name: "browser_screenshot",
+    description: "Take a screenshot of a webpage (requires puppeteer/playwright integration)",
+    parameters: {
+      type: "object",
+      properties: {
+        url: {
+          type: "string",
+          description: "The URL to screenshot",
+        },
+        width: {
+          type: "number",
+          description: "Viewport width (default: 1280)",
+        },
+        height: {
+          type: "number",
+          description: "Viewport height (default: 720)",
+        },
+      },
+      required: ["url"],
+    },
+    execute: async (params: Record<string, unknown>) => {
+      return {
+        success: false,
+        error: "Screenshot requires puppeteer/playwright integration. Use browser_navigate to get page content instead.",
+        url: params.url,
+        note: "Install puppeteer and implement headless browser capture for screenshots.",
+      };
+    },
+  };
+}
+
+export function createBrowserClickTool(_config: BrowserConfig = {}): Tool {
+  return {
+    name: "browser_click",
+    description: "Click an element on a page (requires puppeteer/playwright integration)",
+    parameters: {
+      type: "object",
+      properties: {
+        selector: {
+          type: "string",
+          description: "CSS selector for the element to click",
+        },
+      },
+      required: ["selector"],
+    },
+    execute: async (params: Record<string, unknown>) => {
+      return {
+        success: false,
+        error: "Click interaction requires puppeteer/playwright integration.",
+        selector: params.selector,
+      };
+    },
+  };
+}
+
+export function createBrowserTypeTool(_config: BrowserConfig = {}): Tool {
+  return {
+    name: "browser_type",
+    description: "Type text into an input field (requires puppeteer/playwright integration)",
+    parameters: {
+      type: "object",
+      properties: {
+        selector: {
+          type: "string",
+          description: "CSS selector for the input field",
+        },
+        text: {
+          type: "string",
+          description: "Text to type",
+        },
+      },
+      required: ["selector", "text"],
+    },
+    execute: async (params: Record<string, unknown>) => {
+      return {
+        success: false,
+        error: "Type interaction requires puppeteer/playwright integration.",
+        selector: params.selector,
+        text: params.text,
+      };
+    },
+  };
+}
+
+export function createBrowserTools(config: BrowserConfig = {}): Tool[] {
+  return [
+    createBrowserNavigateTool(config),
+    createBrowserFetchTool(config),
+    createBrowserScreenshotTool(config),
+    createBrowserClickTool(config),
+    createBrowserTypeTool(config),
+  ];
+}

package/packages/core/src/tools/codebridge.ts

@@ -0,0 +1,421 @@
+import type { Tool } from "../agent/native-tools.ts";
+import { logger } from "../utils/logger.ts";
+import { emitBridge } from "./bridge-events.ts";
+
+const CODE_BRIDGE_URL = "ws://localhost:18791";
+
+interface CodeBridgeMessage {
+  cmd: string;
+  taskId?: string;
+  config?: {
+    role: string;
+    cli: string;
+    args?: string[];
+    cwd?: string;
+    timeoutSeconds?: number;
+  };
+  prompt?: string;
+}
+
+interface CodeBridgeEvent {
+  type: string;
+  taskId?: string;
+  role?: string;
+  pid?: number;
+  stream?: string;
+  chunk?: string;
+  message?: string;
+  exitCode?: number;
+  percent?: number;
+  ok?: boolean;
+  agents?: Array<{
+    taskId: string;
+    role: string;
+    cli: string;
+    pid: number;
+    state: string;
+  }>;
+}
+
+async function checkCodeBridgeAvailable(): Promise<boolean> {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 1000);
+    const response = await fetch("http://localhost:18791/health", {
+      signal: controller.signal,
+    });
+    clearTimeout(timeout);
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+
+export function createCodeBridgeLaunchTool(): Tool {
+  const log = logger.child("codebridge-launch");
+
+  return {
+    name: "codebridge_launch",
+    description: "Launch a subagent process (qwen, claude-code, opencode, etc.) via Code Bridge. Use this to delegate tasks to AI coding assistants. Requires Code Bridge to be running on port 18791.",
+    parameters: {
+      type: "object",
+      properties: {
+        cli: {
+          type: "string",
+          description: "CLI command to run (e.g., 'qwen', 'claude', 'opencode', 'gemini')",
+        },
+        args: {
+          type: "array",
+          items: { type: "string" },
+          description: "Arguments to pass to the CLI (optional)",
+        },
+        prompt: {
+          type: "string",
+          description: "The prompt/task for the subagent",
+        },
+        role: {
+          type: "string",
+          enum: ["architecture", "development", "testing", "documentation"],
+          description: "Role of the subagent (optional, default: development)",
+        },
+        cwd: {
+          type: "string",
+          description: "Working directory (optional)",
+        },
+        timeoutSeconds: {
+          type: "number",
+          description: "Timeout in seconds (default: 600)",
+        },
+      },
+      required: ["cli", "prompt"],
+    },
+    execute: async (params: Record<string, unknown>) => {
+      // First check if Code Bridge is available
+      const available = await checkCodeBridgeAvailable();
+      
+      if (!available) {
+        log.warn("Code Bridge not available. Falling back to terminal execution.");
+        const cli = params.cli as string;
+        const prompt = params.prompt as string;
+        const cwd = params.cwd as string | undefined;
+        const fbProcessId = `codebridge-${Date.now()}-${Math.random().toString(36).substring(7)}`;
+
+        emitBridge("bridge:cmd_start", { processId: fbProcessId, command: `${cli} "${prompt}"`, cwd, name: cli });
+
+        try {
+          const shell = process.platform === "win32"
+            ? ["cmd", "/c", `${cli} "${prompt}"`]
+            : ["/bin/bash", "-c", `${cli} "${prompt.replace(/"/g, '\\"')}"`];
+
+          const proc = Bun.spawn(shell, {
+            cwd: cwd ?? process.cwd(),
+            timeout: 60000,
+            maxBuffer: 10 * 1024 * 1024,
+          });
+
+          const stdout = await new Response(proc.stdout).text();
+          const stderr = await new Response(proc.stderr).text();
+          const exitCode = await proc.exited;
+
+          if (stdout) emitBridge("bridge:cmd_output", { processId: fbProcessId, chunk: stdout.slice(-50000), stream: "stdout" });
+          if (stderr) emitBridge("bridge:cmd_output", { processId: fbProcessId, chunk: stderr.slice(-10000), stream: "stderr" });
+          emitBridge("bridge:cmd_done", { processId: fbProcessId, exitCode, success: exitCode === 0 });
+
+          return {
+            success: exitCode === 0,
+            stdout: stdout.slice(-50000),
+            stderr: stderr.slice(-10000),
+            exitCode,
+            message: "Code Bridge not available, executed via terminal instead",
+          };
+        } catch (error) {
+          emitBridge("bridge:cmd_error", { processId: fbProcessId, message: (error as Error).message });
+          return {
+            success: false,
+            error: `Code Bridge not available and terminal fallback failed: ${(error as Error).message}`,
+          };
+        }
+      }
+
+      const cli = params.cli as string;
+      const args = (params.args as string[]) ?? [];
+      const prompt = params.prompt as string;
+      const role = (params.role as string) ?? "development";
+      const cwd = params.cwd as string | undefined;
+      const timeoutSeconds = (params.timeoutSeconds as number) ?? 600;
+      const taskId = `task-${Date.now()}-${Math.random().toString(36).substring(7)}`;
+
+      log.info(`Launching ${cli} with task ${taskId}`);
+
+      return new Promise((resolve, reject) => {
+        let ws: WebSocket | null = null;
+        let output = "";
+        let connected = false;
+        let timeoutHandle: NodeJS.Timeout | null = null;
+
+        const cleanup = () => {
+          if (timeoutHandle) clearTimeout(timeoutHandle);
+          if (ws) {
+            ws.onopen = null;
+            ws.onmessage = null;
+            ws.onerror = null;
+            ws.onclose = null;
+          }
+        };
+
+        try {
+          ws = new WebSocket(CODE_BRIDGE_URL);
+
+          ws.onopen = () => {
+            connected = true;
+            const msg: CodeBridgeMessage = {
+              cmd: "launch",
+              taskId,
+              config: {
+                role,
+                cli,
+                args,
+                cwd,
+                timeoutSeconds,
+              },
+              prompt,
+            };
+            ws!.send(JSON.stringify(msg));
+          };
+
+          ws.onmessage = (event) => {
+            try {
+              const data = JSON.parse(event.data) as CodeBridgeEvent;
+
+              if (data.type === "ack" && data.taskId === taskId) {
+                log.debug(`Launch acknowledged: ${data.taskId}, PID: ${data.pid}`);
+              }
+
+              if (data.type === "agent:output" && data.taskId === taskId) {
+                output += data.chunk || "";
+              }
+
+              if (data.type === "agent:finished" && data.taskId === taskId) {
+                log.info(`Task ${taskId} finished with code ${data.exitCode}`);
+                cleanup();
+                resolve({
+                  success: true,
+                  taskId,
+                  exitCode: data.exitCode,
+                  output: output.slice(-50000),
+                });
+                ws?.close();
+              }
+
+              if (data.type === "agent:error" && data.taskId === taskId) {
+                log.error(`Task ${taskId} error: ${data.message}`);
+                cleanup();
+                reject(new Error(data.message ?? "Subagent error"));
+                ws?.close();
+              }
+            } catch (e) {
+              // Ignore parse errors for non-JSON messages
+            }
+          };
+
+          ws.onerror = (error) => {
+            log.error(`WebSocket error: ${error}`);
+          };
+
+          ws.onclose = () => {
+            if (!connected) {
+              cleanup();
+              reject(new Error("Failed to connect to Code Bridge"));
+            }
+          };
+
+          timeoutHandle = setTimeout(() => {
+            if (ws && ws.readyState === WebSocket.OPEN) {
+              cleanup();
+              ws.close();
+              resolve({
+                success: true,
+                taskId,
+                output: output.slice(-50000),
+                message: "Timeout reached, task may still be running",
+              });
+            }
+          }, timeoutSeconds * 1000);
+        } catch (error) {
+          cleanup();
+          reject(new Error(`Failed to connect to Code Bridge: ${(error as Error).message}`));
+        }
+      });
+    },
+  };
+}
+
+export function createCodeBridgeStatusTool(): Tool {
+  const log = logger.child("codebridge-status");
+
+  return {
+    name: "codebridge_status",
+    description: "Get the status of all running subagent processes from Code Bridge",
+    parameters: {
+      type: "object",
+      properties: {},
+    },
+    execute: async () => {
+      try {
+        const response = await fetch("http://localhost:18791/status");
+        const data = await response.json();
+        return data;
+      } catch (error) {
+        log.error(`Status failed: ${(error as Error).message}`);
+        return {
+          type: "code-bridge:status",
+          agents: [],
+          error: (error as Error).message,
+        };
+      }
+    },
+  };
+}
+
+export function createCodeBridgeCancelTool(): Tool {
+  const log = logger.child("codebridge-cancel");
+
+  return {
+    name: "codebridge_cancel",
+    description: "Cancel a running subagent process by task ID",
+    parameters: {
+      type: "object",
+      properties: {
+        taskId: {
+          type: "string",
+          description: "The task ID to cancel",
+        },
+      },
+      required: ["taskId"],
+    },
+    execute: async (params: Record<string, unknown>) => {
+      const taskId = params.taskId as string;
+      log.info(`Cancelling task ${taskId}`);
+
+      return new Promise((resolve, reject) => {
+        const ws = new WebSocket(CODE_BRIDGE_URL);
+
+        ws.onopen = () => {
+          const msg = { cmd: "cancel", taskId };
+          ws.send(JSON.stringify(msg));
+        };
+
+        ws.onmessage = (event) => {
+          try {
+            const data = JSON.parse(event.data) as CodeBridgeEvent & { cmd?: string };
+            if (data.type === "ack" && (data as any).cmd === "cancel") {
+              resolve({
+                success: data.ok ?? true,
+                taskId,
+                message: data.ok ? "Task cancelled" : "Task not found",
+              });
+              ws.close();
+            }
+          } catch {
+            // Ignore
+          }
+        };
+
+        ws.onerror = () => {
+          reject(new Error("Code Bridge WebSocket error"));
+        };
+
+        ws.onclose = () => {
+          setTimeout(() => {
+            reject(new Error("Cancellation timeout"));
+          }, 5000);
+        };
+      });
+    },
+  };
+}
+
+export function createTerminalTool(): Tool {
+  const log = logger.child("terminal");
+
+  return {
+    name: "terminal",
+    description: "Execute a terminal command directly. Use this for shell commands, git operations, npm scripts, etc.",
+    parameters: {
+      type: "object",
+      properties: {
+        command: {
+          type: "string",
+          description: "The terminal command to execute",
+        },
+        cwd: {
+          type: "string",
+          description: "Working directory (optional)",
+        },
+        timeoutSeconds: {
+          type: "number",
+          description: "Timeout in seconds (default: 60)",
+        },
+      },
+      required: ["command"],
+    },
+    execute: async (params: Record<string, unknown>) => {
+      const command = params.command as string;
+      const cwd = params.cwd as string | undefined;
+      const timeoutSeconds = (params.timeoutSeconds as number) ?? 60;
+      const processId = `terminal-${Date.now()}-${Math.random().toString(36).substring(7)}`;
+
+      const platform = process.platform;
+      let shell: string[];
+
+      if (platform === "win32") {
+        shell = ["cmd", "/c", command];
+      } else if (platform === "darwin") {
+        shell = ["/bin/zsh", "-c", command];
+      } else {
+        shell = ["/bin/bash", "-c", command];
+      }
+
+      log.debug(`Executing: ${command}`);
+
+      emitBridge("bridge:cmd_start", { processId, command, cwd, name: "terminal" });
+
+      try {
+        const proc = Bun.spawn(shell, {
+          cwd: cwd ?? process.cwd(),
+          timeout: timeoutSeconds * 1000,
+          maxBuffer: 10 * 1024 * 1024,
+        });
+
+        const stdout = await new Response(proc.stdout).text();
+        const stderr = await new Response(proc.stderr).text();
+        const exitCode = await proc.exited;
+
+        if (stdout) emitBridge("bridge:cmd_output", { processId, chunk: stdout.slice(-50000), stream: "stdout" });
+        if (stderr) emitBridge("bridge:cmd_output", { processId, chunk: stderr.slice(-10000), stream: "stderr" });
+        emitBridge("bridge:cmd_done", { processId, exitCode, success: exitCode === 0 });
+
+        return {
+          success: exitCode === 0,
+          stdout: stdout.slice(-50000),
+          stderr: stderr.slice(-10000),
+          exitCode,
+          platform,
+        };
+      } catch (error) {
+        log.error(`Terminal failed: ${(error as Error).message}`);
+        emitBridge("bridge:cmd_error", { processId, message: (error as Error).message });
+        throw new Error(`Terminal execution failed: ${(error as Error).message}`);
+      }
+    },
+  };
+}
+
+export function createCodeBridgeTools(): Tool[] {
+  return [
+    createCodeBridgeLaunchTool(),
+    createCodeBridgeStatusTool(),
+    createCodeBridgeCancelTool(),
+    createTerminalTool(),
+  ];
+}