@johpaz/hive 1.1.0

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

@@ -0,0 +1,272 @@
+import type { Tool } from "@johpaz/hive-core";
+import { z } from "zod";
+
+export interface BrowserConfig {
+  headless?: boolean;
+  timeout?: number;
+  userAgent?: string;
+}
+
+type ZodObjectSchema = z.ZodObject<z.ZodRawShape>;
+
+const createBrowserTool = <T extends ZodObjectSchema>(
+  name: string,
+  description: string,
+  paramsSchema: T,
+  execute: (params: z.infer<T>, config: BrowserConfig) => Promise<unknown>
+): Tool => {
+  const shape = paramsSchema.shape;
+  return {
+    name,
+    description,
+    parameters: {
+      type: "object",
+      properties: Object.fromEntries(
+        Object.entries(shape).map(([key, schema]) => [
+          key,
+          {
+            type: schema instanceof z.ZodString
+              ? "string"
+              : schema instanceof z.ZodNumber
+                ? "number"
+                : schema instanceof z.ZodBoolean
+                  ? "boolean"
+                  : schema instanceof z.ZodArray
+                    ? "array"
+                    : "object",
+            description: ((schema as unknown as { _def?: { description?: string } })._def?.description) || key,
+          },
+        ])
+      ),
+      required: Object.entries(shape)
+        .filter(([_, schema]) => !(schema instanceof z.ZodOptional))
+        .map(([key]) => key),
+    },
+    execute: async (params: Record<string, unknown>) => {
+      const parsed = paramsSchema.safeParse(params);
+      if (!parsed.success) {
+        throw new Error(`Invalid parameters: ${parsed.error.message}`);
+      }
+      return execute(parsed.data, {});
+    },
+  };
+};
+
+export function createBrowserNavigateTool(config: BrowserConfig = {}): Tool {
+  return createBrowserTool(
+    "browser_navigate",
+    "Navigate to a URL and retrieve the page content",
+    z.object({
+      url: z.string().url().describe("The URL to navigate to"),
+      waitFor: z.string().optional().describe("CSS selector to wait for before returning"),
+      timeout: z.number().optional().describe("Timeout in milliseconds"),
+    }),
+    async (params, cfg) => {
+      const timeout = params.timeout || cfg.timeout || 30000;
+      
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+      
+      try {
+        const response = await fetch(params.url, {
+          signal: controller.signal,
+          headers: {
+            "User-Agent": cfg.userAgent || "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: params.url,
+          finalUrl: response.url,
+          title: extractTitle(content),
+          content: content.slice(0, 50000),
+          contentType,
+        };
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    }
+  );
+}
+
+export function createBrowserFetchTool(config: BrowserConfig = {}): Tool {
+  return createBrowserTool(
+    "browser_fetch",
+    "Fetch content from a URL with custom options",
+    z.object({
+      url: z.string().url().describe("The URL to fetch"),
+      method: z.enum(["GET", "POST", "PUT", "DELETE"]).optional().default("GET"),
+      headers: z.record(z.string(), z.string()).optional().describe("Custom headers"),
+      body: z.string().optional().describe("Request body for POST/PUT"),
+      timeout: z.number().optional().describe("Timeout in milliseconds"),
+    }),
+    async (params, cfg) => {
+      const timeout = params.timeout || cfg.timeout || 30000;
+      
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+      
+      try {
+        const response = await fetch(params.url, {
+          method: params.method,
+          headers: {
+            "User-Agent": cfg.userAgent || "HiveBot/1.0",
+            ...params.headers,
+          },
+          body: params.body,
+          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,
+        };
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    }
+  );
+}
+
+export function createBrowserScreenshotTool(_config: BrowserConfig = {}): Tool {
+  return {
+    name: "browser_screenshot",
+    description: "Take a screenshot of a webpage (returns placeholder - requires puppeteer 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)",
+        },
+        fullPage: {
+          type: "boolean",
+          description: "Capture full page (default: false)",
+        },
+      },
+      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 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 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,
+      };
+    },
+  };
+}
+
+function extractTitle(content: string): string {
+  const match = content.match(/<title[^>]*>([^<]+)<\/title>/i);
+  return match ? match[1]!.trim() : "";
+}
+
+export function createBrowserTools(config: BrowserConfig = {}): Tool[] {
+  return [
+    createBrowserNavigateTool(config),
+    createBrowserFetchTool(config),
+    createBrowserScreenshotTool(config),
+    createBrowserClickTool(config),
+    createBrowserTypeTool(config),
+  ];
+}

package/packages/tools/src/canvas/index.ts

@@ -0,0 +1,220 @@
+import type { Tool } from "@johpaz/hive-core";
+import { canvasManager, type CanvasComponent } from "@johpaz/hive-core/canvas";
+
+export interface CanvasToolConfig {
+  defaultTimeout?: number;
+}
+
+export function createCanvasRenderTool(_config: CanvasToolConfig = {}): Tool {
+  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 CanvasComponent;
+
+      await canvasManager.render(sessionId, component);
+
+      return {
+        success: true,
+        componentId: component.id,
+        sessionId,
+      };
+    },
+  };
+}
+
+export function createCanvasAskTool(config: CanvasToolConfig = {}): Tool {
+  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: ${config.defaultTimeout || 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) ?? config.defaultTimeout ?? 300000;
+
+      const formId = `form-${Date.now()}`;
+
+      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: CanvasToolConfig = {}): Tool {
+  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;
+
+      await canvasManager.clear(sessionId);
+
+      return { success: true, sessionId };
+    },
+  };
+}
+
+export function createCanvasUpdateTool(_config: CanvasToolConfig = {}): Tool {
+  return {
+    name: "canvas_update",
+    description: "Update an existing component on the canvas",
+    parameters: {
+      type: "object",
+      properties: {
+        sessionId: {
+          type: "string",
+          description: "Session ID",
+        },
+        component: {
+          type: "object",
+          properties: {
+            id: {
+              type: "string",
+              description: "Component ID to update",
+            },
+            type: {
+              type: "string",
+              enum: ["button", "form", "chart", "table", "markdown", "text", "image"],
+              description: "Component type",
+            },
+            props: {
+              type: "object",
+              description: "Updated properties",
+            },
+          },
+          required: ["id"],
+        },
+      },
+      required: ["sessionId", "component"],
+    },
+    execute: async (params: Record<string, unknown>) => {
+      const sessionId = params.sessionId as string;
+      const component = params.component as Partial<CanvasComponent> & { id: string };
+
+      await canvasManager.update(sessionId, component as CanvasComponent);
+
+      return {
+        success: true,
+        componentId: component.id,
+        sessionId,
+      };
+    },
+  };
+}
+
+export function createCanvasTools(config: CanvasToolConfig = {}): Tool[] {
+  return [
+    createCanvasRenderTool(config),
+    createCanvasAskTool(config),
+    createCanvasClearTool(config),
+    createCanvasUpdateTool(config),
+  ];
+}

package/packages/tools/src/cron/cron.test.ts

@@ -0,0 +1,164 @@
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import {
+  createCronAddTool,
+  createCronListTool,
+  createCronRemoveTool,
+  createCronEditTool,
+  createCronTools,
+  getAllCronJobs,
+  clearAllCronJobs,
+} from "./index";
+
+describe("Cron Tools", () => {
+  beforeEach(() => {
+    clearAllCronJobs();
+  });
+
+  afterEach(() => {
+    clearAllCronJobs();
+  });
+
+  describe("createCronAddTool", () => {
+    it("creates tool with correct name", () => {
+      const tool = createCronAddTool();
+      expect(tool.name).toBe("cron_add");
+    });
+
+    it("adds a cron job", async () => {
+      const tool = createCronAddTool();
+      const result = await tool.execute({
+        expression: "0 9 * * *",
+        task: "Daily reminder",
+      }) as { success: boolean; jobId: string };
+
+      expect(result.success).toBe(true);
+      expect(result.jobId).toMatch(/^cron-\d+$/);
+    });
+
+    it("rejects invalid cron expression", async () => {
+      const tool = createCronAddTool();
+      await expect(
+        tool.execute({
+          expression: "invalid",
+          task: "Test task",
+        })
+      ).rejects.toThrow("Cron expression must have 5 fields");
+    });
+
+    it("rejects when max jobs reached", async () => {
+      const tool = createCronAddTool({ maxJobs: 1 });
+      await tool.execute({
+        expression: "* * * * *",
+        task: "Task 1",
+      });
+
+      await expect(
+        tool.execute({
+          expression: "* * * * *",
+          task: "Task 2",
+        })
+      ).rejects.toThrow("Maximum number of cron jobs reached");
+    });
+  });
+
+  describe("createCronListTool", () => {
+    it("creates tool with correct name", () => {
+      const tool = createCronListTool();
+      expect(tool.name).toBe("cron_list");
+    });
+
+    it("lists all cron jobs", async () => {
+      const addTool = createCronAddTool();
+      await addTool.execute({
+        expression: "* * * * *",
+        task: "Task 1",
+      });
+      await addTool.execute({
+        expression: "0 0 * * *",
+        task: "Task 2",
+      });
+
+      const listTool = createCronListTool();
+      const result = await listTool.execute({}) as { success: boolean; jobs: unknown[]; count: number };
+
+      expect(result.success).toBe(true);
+      expect(result.count).toBe(2);
+    });
+  });
+
+  describe("createCronRemoveTool", () => {
+    it("creates tool with correct name", () => {
+      const tool = createCronRemoveTool();
+      expect(tool.name).toBe("cron_remove");
+    });
+
+    it("removes a cron job", async () => {
+      const addTool = createCronAddTool();
+      const addResult = await addTool.execute({
+        expression: "* * * * *",
+        task: "To remove",
+      }) as { jobId: string };
+
+      const removeTool = createCronRemoveTool();
+      const result = await removeTool.execute({
+        jobId: addResult.jobId,
+      }) as { success: boolean; removedJob: string };
+
+      expect(result.success).toBe(true);
+      expect(result.removedJob).toBe(addResult.jobId);
+    });
+
+    it("throws for non-existent job", async () => {
+      const tool = createCronRemoveTool();
+      await expect(
+        tool.execute({ jobId: "non-existent" })
+      ).rejects.toThrow("Job not found");
+    });
+  });
+
+  describe("createCronEditTool", () => {
+    it("creates tool with correct name", () => {
+      const tool = createCronEditTool();
+      expect(tool.name).toBe("cron_edit");
+    });
+
+    it("edits a cron job", async () => {
+      const addTool = createCronAddTool();
+      const addResult = await addTool.execute({
+        expression: "* * * * *",
+        task: "Original",
+      }) as { jobId: string };
+
+      const editTool = createCronEditTool();
+      const result = await editTool.execute({
+        jobId: addResult.jobId,
+        task: "Updated",
+        enabled: false,
+      }) as { success: boolean; job: { task: string; enabled: boolean } };
+
+      expect(result.success).toBe(true);
+      expect(result.job.task).toBe("Updated");
+      expect(result.job.enabled).toBe(false);
+    });
+
+    it("throws for non-existent job", async () => {
+      const tool = createCronEditTool();
+      await expect(
+        tool.execute({ jobId: "non-existent" })
+      ).rejects.toThrow("Job not found");
+    });
+  });
+
+  describe("createCronTools", () => {
+    it("returns all cron tools", () => {
+      const tools = createCronTools();
+      expect(tools.length).toBe(4);
+      expect(tools.map((t) => t.name)).toEqual([
+        "cron_add",
+        "cron_list",
+        "cron_remove",
+        "cron_edit",
+      ]);
+    });
+  });
+});