@johpaz/hive-tools 1.0.10

package/src/filesystem/index.ts

@@ -0,0 +1,379 @@
+import type { Tool } from "@johpaz/hive-core";
+import { z } from "zod";
+import * as fs from "fs/promises";
+import * as path from "path";
+
+export interface FileSystemConfig {
+  allowedPaths: string[];
+  sandboxed: boolean;
+  maxFileSize: number;
+}
+
+function validatePath(targetPath: string, allowedPaths: string[]): void {
+  const resolved = path.resolve(targetPath);
+  const isAllowed = allowedPaths.some((allowed) => resolved.startsWith(path.resolve(allowed)));
+
+  if (!isAllowed) {
+    throw new Error(`Path not allowed: ${targetPath}. Allowed paths: ${allowedPaths.join(", ")}`);
+  }
+}
+
+function getFSConfig(config: Partial<FileSystemConfig>): FileSystemConfig {
+  return {
+    allowedPaths: config.allowedPaths ?? [process.cwd()],
+    sandboxed: config.sandboxed ?? true,
+    maxFileSize: config.maxFileSize ?? 10 * 1024 * 1024,
+  };
+}
+
+export function createFSReadTool(config: Partial<FileSystemConfig> = {}): Tool {
+  const fsConfig = getFSConfig(config);
+
+  return {
+    name: "fs_read",
+    description: "Read a file from the filesystem",
+    parameters: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Path to the file to read",
+        },
+        encoding: {
+          type: "string",
+          description: "File encoding (default: utf-8)",
+        },
+        startLine: {
+          type: "number",
+          description: "Start reading from this line (1-indexed)",
+        },
+        endLine: {
+          type: "number",
+          description: "Stop reading at this line",
+        },
+      },
+      required: ["path"],
+    },
+    execute: async (params: Record<string, unknown>) => {
+      const filePath = params.path as string;
+      const encoding = (params.encoding as BufferEncoding) ?? "utf-8";
+      const startLine = params.startLine as number | undefined;
+      const endLine = params.endLine as number | undefined;
+
+      if (fsConfig.sandboxed) {
+        validatePath(filePath, fsConfig.allowedPaths);
+      }
+
+      const stats = await fs.stat(filePath);
+      if (stats.size > fsConfig.maxFileSize) {
+        throw new Error(`File too large: ${stats.size} bytes (max: ${fsConfig.maxFileSize})`);
+      }
+
+      let content = await fs.readFile(filePath, encoding);
+
+      if (startLine !== undefined || endLine !== undefined) {
+        const lines = content.split("\n");
+        const start = Math.max(0, (startLine ?? 1) - 1);
+        const end = endLine !== undefined ? endLine : lines.length;
+        content = lines.slice(start, end).join("\n");
+      }
+
+      return {
+        success: true,
+        path: filePath,
+        content,
+        size: stats.size,
+        modified: stats.mtime.toISOString(),
+      };
+    },
+  };
+}
+
+export function createFSWriteTool(config: Partial<FileSystemConfig> = {}): Tool {
+  const fsConfig = getFSConfig(config);
+
+  return {
+    name: "fs_write",
+    description: "Write content to a file",
+    parameters: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Path to the file to write",
+        },
+        content: {
+          type: "string",
+          description: "Content to write",
+        },
+        mode: {
+          type: "string",
+          enum: ["overwrite", "append"],
+          description: "Write mode (default: overwrite)",
+        },
+      },
+      required: ["path", "content"],
+    },
+    execute: async (params: Record<string, unknown>) => {
+      const filePath = params.path as string;
+      const content = params.content as string;
+      const mode = (params.mode as string) ?? "overwrite";
+
+      if (fsConfig.sandboxed) {
+        validatePath(filePath, fsConfig.allowedPaths);
+      }
+
+      if (content.length > fsConfig.maxFileSize) {
+        throw new Error(`Content too large: ${content.length} bytes (max: ${fsConfig.maxFileSize})`);
+      }
+
+      const dir = path.dirname(filePath);
+      await fs.mkdir(dir, { recursive: true });
+
+      if (mode === "append") {
+        await fs.appendFile(filePath, content, "utf-8");
+      } else {
+        await fs.writeFile(filePath, content, "utf-8");
+      }
+
+      return {
+        success: true,
+        path: filePath,
+        bytesWritten: content.length,
+      };
+    },
+  };
+}
+
+export function createFSListTool(config: Partial<FileSystemConfig> = {}): Tool {
+  const fsConfig = getFSConfig(config);
+
+  return {
+    name: "fs_list",
+    description: "List contents of a directory",
+    parameters: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Path to the directory",
+        },
+        recursive: {
+          type: "boolean",
+          description: "List recursively (default: false)",
+        },
+      },
+      required: ["path"],
+    },
+    execute: async (params: Record<string, unknown>) => {
+      const dirPath = params.path as string;
+      const recursive = (params.recursive as boolean) ?? false;
+
+      if (fsConfig.sandboxed) {
+        validatePath(dirPath, fsConfig.allowedPaths);
+      }
+
+      const entries = await fs.readdir(dirPath, { withFileTypes: true });
+
+      const results: Array<{
+        name: string;
+        path: string;
+        type: string;
+        size: number;
+        modified: string;
+      }> = [];
+
+      for (const entry of entries) {
+        const fullPath = path.join(dirPath, entry.name);
+        const stats = await fs.stat(fullPath);
+
+        results.push({
+          name: entry.name,
+          path: fullPath,
+          type: entry.isDirectory() ? "directory" : "file",
+          size: stats.size,
+          modified: stats.mtime.toISOString(),
+        });
+      }
+
+      if (recursive) {
+        const subdirs = results.filter((r) => r.type === "directory");
+        for (const subdir of subdirs) {
+          try {
+            const subResult = await createFSListTool(config).execute({ path: subdir.path, recursive: true });
+            const subFiles = (subResult as { entries: typeof results }).entries;
+            results.push(...subFiles);
+          } catch {
+            // Skip directories we can't read
+          }
+        }
+      }
+
+      return {
+        success: true,
+        path: dirPath,
+        entries: results,
+        count: results.length,
+      };
+    },
+  };
+}
+
+export function createFSMkdirTool(config: Partial<FileSystemConfig> = {}): Tool {
+  const fsConfig = getFSConfig(config);
+
+  return {
+    name: "fs_mkdir",
+    description: "Create a directory",
+    parameters: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Path to create",
+        },
+      },
+      required: ["path"],
+    },
+    execute: async (params: Record<string, unknown>) => {
+      const dirPath = params.path as string;
+
+      if (fsConfig.sandboxed) {
+        validatePath(dirPath, fsConfig.allowedPaths);
+      }
+
+      await fs.mkdir(dirPath, { recursive: true });
+
+      return { success: true, path: dirPath };
+    },
+  };
+}
+
+export function createFSDeleteTool(config: Partial<FileSystemConfig> = {}): Tool {
+  const fsConfig = getFSConfig(config);
+
+  return {
+    name: "fs_delete",
+    description: "Delete a file or directory",
+    parameters: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Path to delete",
+        },
+        recursive: {
+          type: "boolean",
+          description: "Delete recursively for directories",
+        },
+      },
+      required: ["path"],
+    },
+    execute: async (params: Record<string, unknown>) => {
+      const targetPath = params.path as string;
+      const recursive = (params.recursive as boolean) ?? false;
+
+      if (fsConfig.sandboxed) {
+        validatePath(targetPath, fsConfig.allowedPaths);
+      }
+
+      const stats = await fs.stat(targetPath);
+
+      if (stats.isDirectory()) {
+        if (recursive) {
+          await fs.rm(targetPath, { recursive: true });
+        } else {
+          await fs.rmdir(targetPath);
+        }
+      } else {
+        await fs.unlink(targetPath);
+      }
+
+      return { success: true, path: targetPath };
+    },
+  };
+}
+
+export function createFSCopyTool(config: Partial<FileSystemConfig> = {}): Tool {
+  const fsConfig = getFSConfig(config);
+
+  return {
+    name: "fs_copy",
+    description: "Copy a file",
+    parameters: {
+      type: "object",
+      properties: {
+        source: {
+          type: "string",
+          description: "Source file path",
+        },
+        destination: {
+          type: "string",
+          description: "Destination file path",
+        },
+      },
+      required: ["source", "destination"],
+    },
+    execute: async (params: Record<string, unknown>) => {
+      const source = params.source as string;
+      const destination = params.destination as string;
+
+      if (fsConfig.sandboxed) {
+        validatePath(source, fsConfig.allowedPaths);
+        validatePath(destination, fsConfig.allowedPaths);
+      }
+
+      await fs.copyFile(source, destination);
+
+      return { success: true, source, destination };
+    },
+  };
+}
+
+export function createFSMoveTool(config: Partial<FileSystemConfig> = {}): Tool {
+  const fsConfig = getFSConfig(config);
+
+  return {
+    name: "fs_move",
+    description: "Move or rename a file",
+    parameters: {
+      type: "object",
+      properties: {
+        source: {
+          type: "string",
+          description: "Source file path",
+        },
+        destination: {
+          type: "string",
+          description: "Destination file path",
+        },
+      },
+      required: ["source", "destination"],
+    },
+    execute: async (params: Record<string, unknown>) => {
+      const source = params.source as string;
+      const destination = params.destination as string;
+
+      if (fsConfig.sandboxed) {
+        validatePath(source, fsConfig.allowedPaths);
+        validatePath(destination, fsConfig.allowedPaths);
+      }
+
+      await fs.rename(source, destination);
+
+      return { success: true, source, destination };
+    },
+  };
+}
+
+export function createFSTools(config: Partial<FileSystemConfig> = {}): Tool[] {
+  return [
+    createFSReadTool(config),
+    createFSWriteTool(config),
+    createFSListTool(config),
+    createFSMkdirTool(config),
+    createFSDeleteTool(config),
+    createFSCopyTool(config),
+    createFSMoveTool(config),
+  ];
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from "./browser/index.ts";
+export * from "./cron/index.ts";
+export * from "./filesystem/index.ts";
+export * from "./canvas/index.ts";