@johpaz/hive-tools 1.0.10

package/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",
+      ]);
+    });
+  });
+});

package/src/cron/index.ts

@@ -0,0 +1,304 @@
+import type { Tool } from "@johpaz/hive-core";
+import { z } from "zod";
+
+export interface CronConfig {
+  maxJobs?: number;
+  defaultTimeout?: number;
+}
+
+interface CronJob {
+  id: string;
+  expression: string;
+  task: string;
+  enabled: boolean;
+  createdAt: Date;
+  lastRun?: Date;
+  nextRun?: Date;
+  data?: unknown;
+}
+
+const cronJobs: Map<string, CronJob> = new Map();
+let jobCounter = 0;
+let schedulerInterval: ReturnType<typeof setInterval> | null = null;
+
+function parseCronExpression(expr: string): { valid: boolean; error?: string } {
+  const parts = expr.trim().split(/\s+/);
+  if (parts.length !== 5) {
+    return { valid: false, error: "Cron expression must have 5 fields (minute hour day month weekday)" };
+  }
+  return { valid: true };
+}
+
+function matchCron(expr: string, date: Date): boolean {
+  const parts = expr.split(/\s+/);
+  if (parts.length !== 5) return false;
+
+  const [min, hour, dom, month, dow] = parts;
+
+  const match = (val: number, p: string): boolean => {
+    if (p === "*") return true;
+    if (p.startsWith("*/")) {
+      const step = parseInt(p.slice(2), 10);
+      return step > 0 && val % step === 0;
+    }
+    if (p.includes(",")) {
+      return p.split(",").some(v => match(val, v));
+    }
+    if (p.includes("-")) {
+      const [start, end] = p.split("-").map(Number);
+      return val >= start! && val <= end!;
+    }
+    return parseInt(p, 10) === val;
+  };
+
+  return (
+    match(date.getMinutes(), min!) &&
+    match(date.getHours(), hour!) &&
+    match(date.getDate(), dom!) &&
+    match(date.getMonth() + 1, month!) &&
+    match(date.getDay(), dow!)
+  );
+}
+
+function getNextRun(expression: string): Date | undefined {
+  const now = new Date();
+  for (let i = 1; i <= 525600; i++) {
+    const next = new Date(now.getTime() + i * 60000);
+    if (matchCron(expression, next)) {
+      return next;
+    }
+  }
+  return undefined;
+}
+
+function startScheduler(onTrigger: (job: CronJob) => void): void {
+  if (schedulerInterval) return;
+
+  schedulerInterval = setInterval(() => {
+    const now = new Date();
+    const currentMinute = Math.floor(now.getTime() / 60000);
+
+    for (const job of cronJobs.values()) {
+      if (!job.enabled) continue;
+
+      const lastRunMinute = job.lastRun ? Math.floor(job.lastRun.getTime() / 60000) : 0;
+
+      if (lastRunMinute === currentMinute) continue;
+
+      if (matchCron(job.expression, now)) {
+        job.lastRun = now;
+        job.nextRun = getNextRun(job.expression);
+        onTrigger(job);
+      }
+    }
+  }, 60000);
+}
+
+export function createCronAddTool(config: CronConfig = {}): Tool {
+  return {
+    name: "cron_add",
+    description: "Add a scheduled task with cron expression",
+    parameters: {
+      type: "object",
+      properties: {
+        expression: {
+          type: "string",
+          description: "Cron expression (e.g., '0 9 * * *' for daily at 9am)",
+        },
+        task: {
+          type: "string",
+          description: "Task description or command to execute",
+        },
+        data: {
+          type: "object",
+          description: "Additional data for the task",
+        },
+      },
+      required: ["expression", "task"],
+    },
+    execute: async (params: Record<string, unknown>) => {
+      const expression = params.expression as string;
+      const task = params.task as string;
+      const data = params.data;
+
+      if (cronJobs.size >= (config.maxJobs || 100)) {
+        throw new Error("Maximum number of cron jobs reached");
+      }
+
+      const validation = parseCronExpression(expression);
+      if (!validation.valid) {
+        throw new Error(validation.error);
+      }
+
+      const id = `cron-${++jobCounter}`;
+      const job: CronJob = {
+        id,
+        expression,
+        task,
+        enabled: true,
+        createdAt: new Date(),
+        nextRun: getNextRun(expression),
+        data,
+      };
+
+      cronJobs.set(id, job);
+
+      return {
+        success: true,
+        jobId: id,
+        job: {
+          id: job.id,
+          expression: job.expression,
+          task: job.task.slice(0, 100),
+          enabled: job.enabled,
+          nextRun: job.nextRun?.toISOString(),
+        },
+      };
+    },
+  };
+}
+
+export function createCronListTool(): Tool {
+  return {
+    name: "cron_list",
+    description: "List all scheduled cron jobs",
+    parameters: {
+      type: "object",
+      properties: {},
+    },
+    execute: async () => {
+      const jobs = Array.from(cronJobs.values()).map(job => ({
+        id: job.id,
+        expression: job.expression,
+        task: job.task.slice(0, 100),
+        enabled: job.enabled,
+        lastRun: job.lastRun?.toISOString(),
+        nextRun: job.nextRun?.toISOString(),
+      }));
+
+      return {
+        success: true,
+        jobs,
+        count: jobs.length,
+      };
+    },
+  };
+}
+
+export function createCronRemoveTool(): Tool {
+  return {
+    name: "cron_remove",
+    description: "Remove a scheduled cron job",
+    parameters: {
+      type: "object",
+      properties: {
+        jobId: {
+          type: "string",
+          description: "The ID of the job to remove",
+        },
+      },
+      required: ["jobId"],
+    },
+    execute: async (params: Record<string, unknown>) => {
+      const jobId = params.jobId as string;
+
+      if (!cronJobs.has(jobId)) {
+        throw new Error(`Job not found: ${jobId}`);
+      }
+
+      cronJobs.delete(jobId);
+
+      return { success: true, removedJob: jobId };
+    },
+  };
+}
+
+export function createCronEditTool(): Tool {
+  return {
+    name: "cron_edit",
+    description: "Edit a scheduled cron job",
+    parameters: {
+      type: "object",
+      properties: {
+        jobId: {
+          type: "string",
+          description: "The ID of the job to edit",
+        },
+        expression: {
+          type: "string",
+          description: "New cron expression",
+        },
+        task: {
+          type: "string",
+          description: "New task description",
+        },
+        enabled: {
+          type: "boolean",
+          description: "Enable or disable the job",
+        },
+      },
+      required: ["jobId"],
+    },
+    execute: async (params: Record<string, unknown>) => {
+      const jobId = params.jobId as string;
+      const job = cronJobs.get(jobId);
+
+      if (!job) {
+        throw new Error(`Job not found: ${jobId}`);
+      }
+
+      if (params.expression) {
+        const validation = parseCronExpression(params.expression as string);
+        if (!validation.valid) {
+          throw new Error(validation.error);
+        }
+        job.expression = params.expression as string;
+        job.nextRun = getNextRun(job.expression);
+      }
+
+      if (params.task) {
+        job.task = params.task as string;
+      }
+
+      if (params.enabled !== undefined) {
+        job.enabled = params.enabled as boolean;
+      }
+
+      return {
+        success: true,
+        job: {
+          id: job.id,
+          expression: job.expression,
+          task: job.task.slice(0, 100),
+          enabled: job.enabled,
+          nextRun: job.nextRun?.toISOString(),
+        },
+      };
+    },
+  };
+}
+
+export function createCronTools(config: CronConfig = {}, onTrigger?: (job: CronJob) => void): Tool[] {
+  if (onTrigger) {
+    startScheduler(onTrigger);
+  }
+
+  return [
+    createCronAddTool(config),
+    createCronListTool(),
+    createCronRemoveTool(),
+    createCronEditTool(),
+  ];
+}
+
+export function getAllCronJobs(): CronJob[] {
+  return Array.from(cronJobs.values());
+}
+
+export function clearAllCronJobs(): void {
+  cronJobs.clear();
+  if (schedulerInterval) {
+    clearInterval(schedulerInterval);
+    schedulerInterval = null;
+  }
+}

package/src/filesystem/filesystem.test.ts

@@ -0,0 +1,240 @@
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import * as fs from "fs/promises";
+import * as path from "path";
+import * as os from "os";
+import {
+  createFSReadTool,
+  createFSWriteTool,
+  createFSListTool,
+  createFSMkdirTool,
+  createFSDeleteTool,
+  createFSCopyTool,
+  createFSMoveTool,
+  createFSTools,
+} from "./index";
+
+describe("FileSystem Tools", () => {
+  let tempDir: string;
+
+  beforeEach(async () => {
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "fs-tools-test-"));
+  });
+
+  afterEach(async () => {
+    await fs.rm(tempDir, { recursive: true, force: true });
+  });
+
+  describe("createFSReadTool", () => {
+    it("creates tool with correct name", () => {
+      const tool = createFSReadTool({ allowedPaths: [tempDir], sandboxed: false });
+      expect(tool.name).toBe("fs_read");
+    });
+
+    it("reads a file", async () => {
+      const testFile = path.join(tempDir, "test.txt");
+      await fs.writeFile(testFile, "Hello, World!");
+
+      const tool = createFSReadTool({ allowedPaths: [tempDir], sandboxed: false });
+      const result = await tool.execute({ path: testFile }) as { success: boolean; content: string };
+
+      expect(result.success).toBe(true);
+      expect(result.content).toBe("Hello, World!");
+    });
+
+    it("reads file with line range", async () => {
+      const testFile = path.join(tempDir, "lines.txt");
+      await fs.writeFile(testFile, "line1\nline2\nline3\nline4\nline5");
+
+      const tool = createFSReadTool({ allowedPaths: [tempDir], sandboxed: false });
+      const result = await tool.execute({
+        path: testFile,
+        startLine: 2,
+        endLine: 4,
+      }) as { success: boolean; content: string };
+
+      expect(result.success).toBe(true);
+      expect(result.content).toBe("line2\nline3\nline4");
+    });
+
+    it("rejects path outside allowed paths when sandboxed", async () => {
+      const tool = createFSReadTool({ allowedPaths: [tempDir], sandboxed: true });
+      await expect(
+        tool.execute({ path: "/etc/passwd" })
+      ).rejects.toThrow("Path not allowed");
+    });
+  });
+
+  describe("createFSWriteTool", () => {
+    it("creates tool with correct name", () => {
+      const tool = createFSWriteTool({ allowedPaths: [tempDir], sandboxed: false });
+      expect(tool.name).toBe("fs_write");
+    });
+
+    it("writes a file", async () => {
+      const testFile = path.join(tempDir, "write-test.txt");
+
+      const tool = createFSWriteTool({ allowedPaths: [tempDir], sandboxed: false });
+      const result = await tool.execute({
+        path: testFile,
+        content: "Test content",
+      }) as { success: boolean; bytesWritten: number };
+
+      expect(result.success).toBe(true);
+      expect(result.bytesWritten).toBe(12);
+
+      const content = await fs.readFile(testFile, "utf-8");
+      expect(content).toBe("Test content");
+    });
+
+    it("appends to a file", async () => {
+      const testFile = path.join(tempDir, "append-test.txt");
+      await fs.writeFile(testFile, "Initial ");
+
+      const tool = createFSWriteTool({ allowedPaths: [tempDir], sandboxed: false });
+      await tool.execute({
+        path: testFile,
+        content: "Appended",
+        mode: "append",
+      });
+
+      const content = await fs.readFile(testFile, "utf-8");
+      expect(content).toBe("Initial Appended");
+    });
+  });
+
+  describe("createFSListTool", () => {
+    it("creates tool with correct name", () => {
+      const tool = createFSListTool({ allowedPaths: [tempDir], sandboxed: false });
+      expect(tool.name).toBe("fs_list");
+    });
+
+    it("lists directory contents", async () => {
+      await fs.writeFile(path.join(tempDir, "file1.txt"), "content1");
+      await fs.writeFile(path.join(tempDir, "file2.txt"), "content2");
+      await fs.mkdir(path.join(tempDir, "subdir"));
+
+      const tool = createFSListTool({ allowedPaths: [tempDir], sandboxed: false });
+      const result = await tool.execute({ path: tempDir }) as { success: boolean; entries: Array<{ name: string; type: string }>; count: number };
+
+      expect(result.success).toBe(true);
+      expect(result.count).toBe(3);
+      expect(result.entries.find((e) => e.name === "file1.txt")?.type).toBe("file");
+      expect(result.entries.find((e) => e.name === "subdir")?.type).toBe("directory");
+    });
+  });
+
+  describe("createFSMkdirTool", () => {
+    it("creates tool with correct name", () => {
+      const tool = createFSMkdirTool({ allowedPaths: [tempDir], sandboxed: false });
+      expect(tool.name).toBe("fs_mkdir");
+    });
+
+    it("creates a directory", async () => {
+      const newDir = path.join(tempDir, "new-dir");
+
+      const tool = createFSMkdirTool({ allowedPaths: [tempDir], sandboxed: false });
+      const result = await tool.execute({ path: newDir }) as { success: boolean };
+
+      expect(result.success).toBe(true);
+      const stat = await fs.stat(newDir);
+      expect(stat.isDirectory()).toBe(true);
+    });
+
+    it("creates nested directories", async () => {
+      const nestedDir = path.join(tempDir, "a", "b", "c");
+
+      const tool = createFSMkdirTool({ allowedPaths: [tempDir], sandboxed: false });
+      await tool.execute({ path: nestedDir });
+
+      const stat = await fs.stat(nestedDir);
+      expect(stat.isDirectory()).toBe(true);
+    });
+  });
+
+  describe("createFSDeleteTool", () => {
+    it("creates tool with correct name", () => {
+      const tool = createFSDeleteTool({ allowedPaths: [tempDir], sandboxed: false });
+      expect(tool.name).toBe("fs_delete");
+    });
+
+    it("deletes a file", async () => {
+      const testFile = path.join(tempDir, "to-delete.txt");
+      await fs.writeFile(testFile, "content");
+
+      const tool = createFSDeleteTool({ allowedPaths: [tempDir], sandboxed: false });
+      const result = await tool.execute({ path: testFile }) as { success: boolean };
+
+      expect(result.success).toBe(true);
+      await expect(fs.stat(testFile)).rejects.toThrow();
+    });
+
+    it("deletes a directory recursively", async () => {
+      const testDir = path.join(tempDir, "to-delete-dir");
+      await fs.mkdir(testDir);
+      await fs.writeFile(path.join(testDir, "file.txt"), "content");
+
+      const tool = createFSDeleteTool({ allowedPaths: [tempDir], sandboxed: false });
+      const result = await tool.execute({ path: testDir, recursive: true }) as { success: boolean };
+
+      expect(result.success).toBe(true);
+      await expect(fs.stat(testDir)).rejects.toThrow();
+    });
+  });
+
+  describe("createFSCopyTool", () => {
+    it("creates tool with correct name", () => {
+      const tool = createFSCopyTool({ allowedPaths: [tempDir], sandboxed: false });
+      expect(tool.name).toBe("fs_copy");
+    });
+
+    it("copies a file", async () => {
+      const source = path.join(tempDir, "source.txt");
+      const dest = path.join(tempDir, "dest.txt");
+      await fs.writeFile(source, "content");
+
+      const tool = createFSCopyTool({ allowedPaths: [tempDir], sandboxed: false });
+      const result = await tool.execute({ source, destination: dest }) as { success: boolean };
+
+      expect(result.success).toBe(true);
+      const content = await fs.readFile(dest, "utf-8");
+      expect(content).toBe("content");
+    });
+  });
+
+  describe("createFSMoveTool", () => {
+    it("creates tool with correct name", () => {
+      const tool = createFSMoveTool({ allowedPaths: [tempDir], sandboxed: false });
+      expect(tool.name).toBe("fs_move");
+    });
+
+    it("moves a file", async () => {
+      const source = path.join(tempDir, "source.txt");
+      const dest = path.join(tempDir, "dest.txt");
+      await fs.writeFile(source, "content");
+
+      const tool = createFSMoveTool({ allowedPaths: [tempDir], sandboxed: false });
+      const result = await tool.execute({ source, destination: dest }) as { success: boolean };
+
+      expect(result.success).toBe(true);
+      await expect(fs.stat(source)).rejects.toThrow();
+      const content = await fs.readFile(dest, "utf-8");
+      expect(content).toBe("content");
+    });
+  });
+
+  describe("createFSTools", () => {
+    it("returns all filesystem tools", () => {
+      const tools = createFSTools({ allowedPaths: [tempDir], sandboxed: false });
+      expect(tools.length).toBe(7);
+      expect(tools.map((t) => t.name)).toEqual([
+        "fs_read",
+        "fs_write",
+        "fs_list",
+        "fs_mkdir",
+        "fs_delete",
+        "fs_copy",
+        "fs_move",
+      ]);
+    });
+  });
+});