iris-chatbot 0.2.4

package/template/src/lib/tooling/tools/files.ts

@@ -0,0 +1,395 @@
+import fs from "node:fs/promises";
+import nodeFs from "node:fs";
+import path from "node:path";
+import { assertAllowedPath, ensureMacOS } from "../safety";
+import { runCommandSafe } from "../runtime";
+import type { ToolDefinition, ToolExecutionContext } from "../types";
+
+type FileListInput = {
+  path: string;
+  recursive?: boolean;
+  pattern?: string;
+  limit?: number;
+};
+
+type FileWriteInput = {
+  source?: string;
+  destination?: string;
+  path?: string;
+  overwrite?: boolean;
+  recursive?: boolean;
+};
+
+const APPLESCRIPT_TIMEOUT_MS = 20_000;
+
+function asObject(input: unknown): Record<string, unknown> {
+  if (!input || typeof input !== "object") {
+    throw new Error("Tool input must be an object.");
+  }
+  return input as Record<string, unknown>;
+}
+
+function asString(input: unknown, field: string): string {
+  if (typeof input !== "string" || !input.trim()) {
+    throw new Error(`Missing required string field: ${field}`);
+  }
+  return input.trim();
+}
+
+function asOptionalBoolean(input: unknown, defaultValue: boolean): boolean {
+  if (typeof input === "boolean") {
+    return input;
+  }
+  return defaultValue;
+}
+
+function wildcardToRegex(pattern: string): RegExp {
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`^${escaped.replace(/\*/g, ".*")}$`, "i");
+}
+
+async function listDirectory(params: {
+  rootPath: string;
+  recursive: boolean;
+  pattern?: string;
+  limit: number;
+  signal?: AbortSignal;
+}) {
+  const matcher = params.pattern ? wildcardToRegex(params.pattern) : null;
+  const output: Array<Record<string, unknown>> = [];
+  const queue: string[] = [params.rootPath];
+  let totalCount = 0;
+
+  while (queue.length > 0) {
+    if (params.signal?.aborted) {
+      throw new Error("Aborted.");
+    }
+
+    const current = queue.shift() as string;
+    const entries = await fs.readdir(current, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(current, entry.name);
+      if (matcher && !matcher.test(entry.name)) {
+        if (!(params.recursive && entry.isDirectory())) {
+          continue;
+        }
+      }
+
+      if (entry.isDirectory()) {
+        totalCount += 1;
+        if (output.length < params.limit) {
+          output.push({
+            path: fullPath,
+            name: entry.name,
+            type: "directory",
+          });
+        }
+        if (params.recursive) {
+          queue.push(fullPath);
+        }
+        continue;
+      }
+
+      const stat = await fs.stat(fullPath);
+      totalCount += 1;
+      if (output.length < params.limit) {
+        output.push({
+          path: fullPath,
+          name: entry.name,
+          type: "file",
+          size: stat.size,
+          modifiedAt: stat.mtimeMs,
+        });
+      }
+    }
+  }
+
+  return {
+    entries: output,
+    totalCount,
+  };
+}
+
+async function runAppleScript(
+  script: string,
+  args: string[],
+  signal?: AbortSignal,
+): Promise<string> {
+  const { stdout } = await runCommandSafe({
+    command: "osascript",
+    args: ["-e", script, ...args.map((arg) => String(arg))],
+    signal,
+    timeoutMs: APPLESCRIPT_TIMEOUT_MS,
+  });
+  return stdout;
+}
+
+async function runFileList(input: unknown, context: ToolExecutionContext) {
+  const payload = asObject(input) as FileListInput;
+  const targetPath = asString(payload.path, "path");
+  const rootPath = await assertAllowedPath({
+    candidate: targetPath,
+    localTools: context.localTools,
+    mode: "read",
+  });
+
+  const recursive = asOptionalBoolean(payload.recursive, false);
+  const pattern = typeof payload.pattern === "string" && payload.pattern.trim()
+    ? payload.pattern.trim()
+    : undefined;
+  const limit =
+    typeof payload.limit === "number" && Number.isFinite(payload.limit)
+      ? Math.max(1, Math.min(1000, Math.floor(payload.limit)))
+      : 200;
+
+  const { entries, totalCount } = await listDirectory({
+    rootPath,
+    recursive,
+    pattern,
+    limit,
+    signal: context.signal,
+  });
+
+  return {
+    rootPath,
+    recursive,
+    pattern,
+    count: totalCount,
+    returnedCount: entries.length,
+    limit,
+    truncated: totalCount > entries.length,
+    entries,
+  };
+}
+
+async function runFileMove(input: unknown, context: ToolExecutionContext) {
+  const payload = asObject(input) as FileWriteInput;
+  const source = asString(payload.source, "source");
+  const destination = asString(payload.destination, "destination");
+  const overwrite = asOptionalBoolean(payload.overwrite, false);
+
+  const resolvedSource = await assertAllowedPath({
+    candidate: source,
+    localTools: context.localTools,
+    mode: "read",
+  });
+  const resolvedDestination = await assertAllowedPath({
+    candidate: destination,
+    localTools: context.localTools,
+    mode: "write",
+  });
+
+  if (!overwrite) {
+    try {
+      await fs.access(resolvedDestination);
+      throw new Error(`Destination already exists: ${resolvedDestination}`);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
+        throw error;
+      }
+    }
+  }
+
+  if (context.localTools.dryRun) {
+    return {
+      dryRun: true,
+      action: "file_move",
+      source: resolvedSource,
+      destination: resolvedDestination,
+      overwrite,
+    };
+  }
+
+  await fs.mkdir(path.dirname(resolvedDestination), { recursive: true });
+  await fs.rename(resolvedSource, resolvedDestination);
+
+  return {
+    moved: true,
+    source: resolvedSource,
+    destination: resolvedDestination,
+  };
+}
+
+async function runFileCopy(input: unknown, context: ToolExecutionContext) {
+  const payload = asObject(input) as FileWriteInput;
+  const source = asString(payload.source, "source");
+  const destination = asString(payload.destination, "destination");
+  const overwrite = asOptionalBoolean(payload.overwrite, false);
+
+  const resolvedSource = await assertAllowedPath({
+    candidate: source,
+    localTools: context.localTools,
+    mode: "read",
+  });
+  const resolvedDestination = await assertAllowedPath({
+    candidate: destination,
+    localTools: context.localTools,
+    mode: "write",
+  });
+
+  const copyFlag = overwrite ? 0 : nodeFs.constants.COPYFILE_EXCL;
+
+  if (context.localTools.dryRun) {
+    return {
+      dryRun: true,
+      action: "file_copy",
+      source: resolvedSource,
+      destination: resolvedDestination,
+      overwrite,
+    };
+  }
+
+  await fs.mkdir(path.dirname(resolvedDestination), { recursive: true });
+  await fs.copyFile(resolvedSource, resolvedDestination, copyFlag);
+
+  return {
+    copied: true,
+    source: resolvedSource,
+    destination: resolvedDestination,
+  };
+}
+
+async function runFileMkdir(input: unknown, context: ToolExecutionContext) {
+  const payload = asObject(input) as FileWriteInput;
+  const target = asString(payload.path, "path");
+  const recursive = asOptionalBoolean(payload.recursive, true);
+
+  const resolvedTarget = await assertAllowedPath({
+    candidate: target,
+    localTools: context.localTools,
+    mode: "write",
+  });
+
+  if (context.localTools.dryRun) {
+    return {
+      dryRun: true,
+      action: "file_mkdir",
+      path: resolvedTarget,
+      recursive,
+    };
+  }
+
+  await fs.mkdir(resolvedTarget, { recursive });
+  return {
+    created: true,
+    path: resolvedTarget,
+    recursive,
+  };
+}
+
+async function runFileDeleteToTrash(input: unknown, context: ToolExecutionContext) {
+  const payload = asObject(input) as FileWriteInput;
+  const target = asString(payload.path, "path");
+
+  const resolvedTarget = await assertAllowedPath({
+    candidate: target,
+    localTools: context.localTools,
+    mode: "read",
+  });
+
+  if (context.localTools.dryRun) {
+    return {
+      dryRun: true,
+      action: "file_delete_to_trash",
+      path: resolvedTarget,
+    };
+  }
+
+  ensureMacOS("Moving files to Trash");
+  const script =
+    'on run argv\n' +
+    'set targetPath to item 1 of argv\n' +
+    'tell application "Finder"\n' +
+    'delete POSIX file targetPath\n' +
+    'end tell\n' +
+    'return "ok"\n' +
+    'end run';
+
+  await runAppleScript(script, [resolvedTarget], context.signal);
+  return {
+    trashed: true,
+    path: resolvedTarget,
+  };
+}
+
+export const fileTools: ToolDefinition[] = [
+  {
+    name: "file_list",
+    description: "List files/folders under an allowed path. Supports optional recursion and wildcard name pattern.",
+    inputSchema: {
+      type: "object",
+      required: ["path"],
+      properties: {
+        path: { type: "string" },
+        recursive: { type: "boolean" },
+        pattern: { type: "string" },
+        limit: { type: "number" },
+      },
+      additionalProperties: false,
+    },
+    risk: "read",
+    execute: runFileList,
+  },
+  {
+    name: "file_move",
+    description: "Move a file/folder from source to destination.",
+    inputSchema: {
+      type: "object",
+      required: ["source", "destination"],
+      properties: {
+        source: { type: "string" },
+        destination: { type: "string" },
+        overwrite: { type: "boolean" },
+      },
+      additionalProperties: false,
+    },
+    risk: "write",
+    execute: runFileMove,
+  },
+  {
+    name: "file_copy",
+    description: "Copy a file from source to destination.",
+    inputSchema: {
+      type: "object",
+      required: ["source", "destination"],
+      properties: {
+        source: { type: "string" },
+        destination: { type: "string" },
+        overwrite: { type: "boolean" },
+      },
+      additionalProperties: false,
+    },
+    risk: "write",
+    execute: runFileCopy,
+  },
+  {
+    name: "file_mkdir",
+    description: "Create a folder path.",
+    inputSchema: {
+      type: "object",
+      required: ["path"],
+      properties: {
+        path: { type: "string" },
+        recursive: { type: "boolean" },
+      },
+      additionalProperties: false,
+    },
+    risk: "write",
+    execute: runFileMkdir,
+  },
+  {
+    name: "file_delete_to_trash",
+    description: "Move a file/folder to Trash (macOS).",
+    inputSchema: {
+      type: "object",
+      required: ["path"],
+      properties: {
+        path: { type: "string" },
+      },
+      additionalProperties: false,
+    },
+    risk: "destructive",
+    execute: runFileDeleteToTrash,
+  },
+];