@4onstudios/iris-agent 0.1.0

package/dist/api/core/agent/tools/editFile.js

@@ -0,0 +1,173 @@
+import fs from "fs/promises";
+import path from "path";
+import { z } from "zod";
+import { generateDiff } from "../utils/diffUtils.js";
+const countOccurrences = (source, token) => {
+    if (!token)
+        return 0;
+    let count = 0;
+    let from = 0;
+    while (true) {
+        const index = source.indexOf(token, from);
+        if (index === -1)
+            return count;
+        count += 1;
+        from = index + token.length;
+    }
+};
+/**
+ * Tool for editing files by replacing content or specific lines
+ * @param {Object} params - The parameters for editing a file
+ * @param {string} params.filePath - The path to the file to edit
+ * @param {string} [params.oldContent] - The old content to replace (must match exactly)
+ * @param {string} [params.newContent] - The new content to replace with
+ * @param {number} [params.startLine] - Starting line number to replace (1-indexed)
+ * @param {number} [params.endLine] - Ending line number to replace (1-indexed)
+ * @param {string} [params.lineContent] - New content for the line range
+ * @param {string} [params.encoding='utf8'] - The encoding to use
+ * @returns {Promise<Object>} Object containing success status and edit info or error
+ */
+export async function editFile({ filePath, oldContent, newContent, startLine, endLine, lineContent, encoding = "utf8", }) {
+    try {
+        // Validate input
+        if (!filePath) {
+            return {
+                success: false,
+                error: "File path is required",
+            };
+        }
+        // Resolve to absolute path
+        const absolutePath = path.resolve(filePath);
+        // Check if file exists
+        try {
+            await fs.access(absolutePath, fs.constants.R_OK | fs.constants.W_OK);
+        }
+        catch (err) {
+            return {
+                success: false,
+                error: `File not found or not writable: ${filePath}`,
+            };
+        }
+        // Read current content
+        const currentContent = await fs.readFile(absolutePath, encoding);
+        let updatedContent;
+        // Mode 1: Replace by content matching
+        if (oldContent !== undefined && newContent !== undefined) {
+            const matches = countOccurrences(currentContent, oldContent);
+            if (matches === 0) {
+                return {
+                    success: false,
+                    error: "Old content not found in file. Content must match exactly.",
+                };
+            }
+            if (matches > 1) {
+                return {
+                    success: false,
+                    error: "Old content appears multiple times. Provide a unique anchor (for example line-based edit with matching oldContent).",
+                };
+            }
+            updatedContent = currentContent.replace(oldContent, newContent);
+        }
+        // Mode 2: Replace by line numbers
+        else if (startLine !== undefined && lineContent !== undefined) {
+            const lines = currentContent.split("\n");
+            if (startLine < 1 || startLine > lines.length) {
+                return {
+                    success: false,
+                    error: `Start line ${startLine} is out of range (file has ${lines.length} lines)`,
+                };
+            }
+            const start = startLine - 1; // Convert to 0-indexed
+            const end = endLine !== undefined ? endLine : startLine;
+            if (end < startLine || end > lines.length) {
+                return {
+                    success: false,
+                    error: `End line ${end} is invalid`,
+                };
+            }
+            const selectedLines = lines.slice(startLine - 1, end);
+            const selectedContent = selectedLines.join("\n");
+            if (oldContent === undefined) {
+                return {
+                    success: false,
+                    error: "Line-based edits require oldContent to match the current line range exactly.",
+                };
+            }
+            if (selectedContent !== oldContent) {
+                return {
+                    success: false,
+                    error: "Line range content does not match oldContent. Re-read the file and retry with current content.",
+                };
+            }
+            // Replace the line range
+            lines.splice(start, end - startLine + 1, lineContent);
+            updatedContent = lines.join("\n");
+        }
+        else {
+            return {
+                success: false,
+                error: "Must provide either (oldContent + newContent) or (startLine + lineContent)",
+            };
+        }
+        // Write updated content
+        await fs.writeFile(absolutePath, updatedContent, encoding);
+        // Get file stats
+        const stats = await fs.stat(absolutePath);
+        // Generate diff for UI display (includes accurate line counts)
+        const { diff, linesAdded, linesRemoved } = generateDiff(currentContent, updatedContent, absolutePath);
+        return {
+            success: true,
+            filePath: absolutePath,
+            fileExisted: true,
+            size: stats.size,
+            modified: stats.mtime,
+            linesAdded,
+            linesRemoved,
+            diff,
+            oldContent: currentContent,
+            newContent: updatedContent,
+        };
+    }
+    catch (error) {
+        const err = error;
+        return {
+            success: false,
+            error: err.message,
+        };
+    }
+}
+/**
+ * Tool metadata for agent system
+ */
+export const editFileTool = {
+    description: "Edit a file by replacing uniquely matched content or a line range anchored by exact oldContent",
+    parameters: z.object({
+        filePath: z.string().describe("The path to the file to edit"),
+        oldContent: z
+            .string()
+            .optional()
+            .describe("The current file content to replace or the exact current content of the target line range"),
+        newContent: z
+            .string()
+            .optional()
+            .describe("The new content to replace with"),
+        startLine: z
+            .number()
+            .optional()
+            .describe("Starting line number to replace (1-indexed)"),
+        endLine: z
+            .number()
+            .optional()
+            .describe("Ending line number to replace (1-indexed)"),
+        lineContent: z
+            .string()
+            .optional()
+            .describe("New content for the line range (requires oldContent to match the current range)"),
+        encoding: z
+            .enum(["utf8", "ascii", "base64", "binary", "hex"])
+            .default("utf8")
+            .describe("The encoding to use"),
+    }),
+    execute: editFile,
+};
+export default editFileTool;

package/dist/api/core/agent/tools/executeCommand.d.ts

@@ -0,0 +1,59 @@
+import { z } from "zod";
+import { type TerminalApprovalPolicy } from "./terminalAutoApprove.js";
+import type { TerminalAutoApproveRules } from "../../library/terminalAutoApproveSettings.js";
+type ExecuteCommandParams = {
+    command?: string;
+    cwd?: string;
+    workspaceRoot?: string;
+    timeout?: number;
+    env?: NodeJS.ProcessEnv;
+    runInBackground?: boolean;
+    description?: string;
+    skipConfirmation?: boolean;
+    approvalPolicy?: TerminalApprovalPolicy;
+    autoApproveRules?: TerminalAutoApproveRules;
+};
+type CommandResult = Record<string, unknown> & {
+    success?: boolean;
+    error?: string;
+};
+export declare function executeCommand({ command, cwd, workspaceRoot, timeout, env, runInBackground, description, skipConfirmation, approvalPolicy, autoApproveRules, }: ExecuteCommandParams): Promise<CommandResult>;
+export declare const executeCommandTool: {
+    description: string;
+    parameters: z.ZodObject<{
+        command: z.ZodOptional<z.ZodString>;
+        cwd: z.ZodDefault<z.ZodString>;
+        workspaceRoot: z.ZodOptional<z.ZodString>;
+        timeout: z.ZodDefault<z.ZodNumber>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        runInBackground: z.ZodDefault<z.ZodBoolean>;
+        description: z.ZodOptional<z.ZodString>;
+        skipConfirmation: z.ZodDefault<z.ZodBoolean>;
+        approvalPolicy: z.ZodDefault<z.ZodEnum<["always_prompt", "auto_approve_safe"]>>;
+        autoApproveRules: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, "strip", z.ZodTypeAny, {
+        command?: string;
+        cwd?: string;
+        env?: Record<string, string>;
+        description?: string;
+        timeout?: number;
+        workspaceRoot?: string;
+        runInBackground?: boolean;
+        skipConfirmation?: boolean;
+        approvalPolicy?: "always_prompt" | "auto_approve_safe";
+        autoApproveRules?: Record<string, any>;
+    }, {
+        command?: string;
+        cwd?: string;
+        env?: Record<string, string>;
+        description?: string;
+        timeout?: number;
+        workspaceRoot?: string;
+        runInBackground?: boolean;
+        skipConfirmation?: boolean;
+        approvalPolicy?: "always_prompt" | "auto_approve_safe";
+        autoApproveRules?: Record<string, any>;
+    }>;
+    execute: typeof executeCommand;
+};
+export default executeCommandTool;

package/dist/api/core/agent/tools/executeCommand.js

@@ -0,0 +1,250 @@
+import { exec, execFile } from "child_process";
+import { promisify } from "util";
+import path from "path";
+import { z } from "zod";
+import fs from "fs";
+import { startBackgroundTask } from "./backgroundTasks.js";
+import { shouldAutoApproveTerminalCommand, } from "./terminalAutoApprove.js";
+const execAsync = promisify(exec);
+const execFileAsync = promisify(execFile);
+function isPathWithinWorkspace(resolvedPath, workspacePath) {
+    const normalizedResolved = path.resolve(resolvedPath);
+    const normalizedWorkspace = path.resolve(workspacePath);
+    return (normalizedResolved.startsWith(normalizedWorkspace + path.sep) ||
+        normalizedResolved === normalizedWorkspace);
+}
+function detectWorkspaceRootFromCwd(cwd) {
+    let current = path.resolve(cwd);
+    while (true) {
+        const gitMarker = path.join(current, ".git");
+        if (fs.existsSync(gitMarker)) {
+            return current;
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            break;
+        }
+        current = parent;
+    }
+    return path.resolve(cwd);
+}
+function requestConfirmation(commandInfo) {
+    const confirmationId = `cmd_${Date.now()}_${Math.random()
+        .toString(36)
+        .substr(2, 9)}`;
+    return {
+        status: "pending_confirmation",
+        confirmationId,
+        command: commandInfo.command,
+    };
+}
+async function resolveLegacyPythonCommand(command, cwd, env) {
+    if (!/^python(?=\s|$)/.test(command)) {
+        return command;
+    }
+    const options = {
+        cwd,
+        timeout: 3000,
+        env: { ...process.env, ...env },
+    };
+    try {
+        const current = await execFileAsync("python", ["-c", "import sys; print(sys.version_info[0])"], options);
+        if (current.stdout.trim() !== "2") {
+            return command;
+        }
+        const replacement = await execFileAsync("python3", ["-c", "import sys; print(sys.version_info[0])"], options);
+        if (replacement.stdout.trim() === "3") {
+            return command.replace(/^python(?=\s|$)/, "python3");
+        }
+    }
+    catch {
+        // Preserve the original command so normal execution reports the useful error.
+    }
+    return command;
+}
+export async function executeCommand({ command, cwd = process.cwd(), workspaceRoot, timeout = 30000, env = {}, runInBackground = false, description, skipConfirmation = false, approvalPolicy = "always_prompt", autoApproveRules, }) {
+    try {
+        if (!command) {
+            return {
+                success: false,
+                error: "'command' is required",
+            };
+        }
+        const dangerousPatterns = [
+            /rm\s+-rf\s+\//,
+            /:\(\)\{.*;\};/,
+            /mkfs/,
+            /dd\s+if=/,
+            />\s*\/dev\/sda/,
+        ];
+        const injectionPatterns = [
+            /`[^`]*`/,
+            /\$\([^)]*\)/,
+            />\s*\/dev\//,
+        ];
+        for (const pattern of dangerousPatterns) {
+            if (pattern.test(command)) {
+                return {
+                    success: false,
+                    error: "Command blocked for safety reasons",
+                };
+            }
+        }
+        const baseCommandMatch = command.match(/^(\S+)/);
+        const baseCommand = baseCommandMatch ? baseCommandMatch[1] : "";
+        const isSafeBaseCommand = /^(echo|cat|ls|pwd|cd|mkdir|touch|cp|mv|which|npm|node|git)$/.test(baseCommand);
+        const hasShellOperators = /[`$();|&<>]/.test(command);
+        if (!isSafeBaseCommand || hasShellOperators) {
+            for (const pattern of injectionPatterns) {
+                if (pattern.test(command)) {
+                    return {
+                        success: false,
+                        error: "Command contains potentially unsafe characters. Use simple commands without shell operators.",
+                    };
+                }
+            }
+        }
+        const absoluteCwd = path.resolve(cwd);
+        if (!skipConfirmation) {
+            const canAutoApprove = approvalPolicy === "auto_approve_safe" &&
+                shouldAutoApproveTerminalCommand(command, autoApproveRules);
+            if (!canAutoApprove) {
+                return requestConfirmation({
+                    command,
+                });
+            }
+        }
+        const validationRoot = workspaceRoot
+            ? path.resolve(workspaceRoot)
+            : detectWorkspaceRootFromCwd(absoluteCwd);
+        if (!workspaceRoot) {
+            console.warn(`⚠️  Security warning: workspaceRoot not provided, inferred workspace root for validation: ${validationRoot}`);
+        }
+        if (!isPathWithinWorkspace(absoluteCwd, validationRoot)) {
+            return {
+                success: false,
+                error: "Working directory is outside workspace boundary. Access denied for security.",
+            };
+        }
+        const resolvedCommand = await resolveLegacyPythonCommand(command, absoluteCwd, env);
+        if (runInBackground) {
+            return startBackgroundTask({
+                command: resolvedCommand,
+                cwd: absoluteCwd,
+                env,
+                description,
+            });
+        }
+        const startTime = Date.now();
+        const parts = resolvedCommand.trim().split(/\s+/);
+        const execCommand = parts[0];
+        const args = parts.slice(1);
+        // Package managers commonly use >= / <= version specs; those are not shell operators.
+        const needsShell = /[`$();|&<>]/.test(resolvedCommand.replace(/[<>]=/g, ""));
+        try {
+            let stdout = "";
+            let stderr = "";
+            if (!needsShell) {
+                const result = await execFileAsync(execCommand, args, {
+                    cwd: absoluteCwd,
+                    timeout,
+                    maxBuffer: 1024 * 1024 * 10,
+                    env: { ...process.env, ...env },
+                });
+                stdout = result.stdout;
+                stderr = result.stderr;
+            }
+            else {
+                const result = await execAsync(resolvedCommand, {
+                    cwd: absoluteCwd,
+                    timeout,
+                    maxBuffer: 1024 * 1024 * 10,
+                    env: { ...process.env, ...env },
+                });
+                stdout = result.stdout;
+                stderr = result.stderr;
+            }
+            const executionTime = Date.now() - startTime;
+            return {
+                success: true,
+                command,
+                ...(resolvedCommand !== command ? { resolvedCommand } : {}),
+                cwd: absoluteCwd,
+                stdout: stdout.trim(),
+                stderr: stderr.trim(),
+                executionTime,
+                exitCode: 0,
+                executionMethod: needsShell ? "shell" : "direct",
+            };
+        }
+        catch (execError) {
+            const error = execError;
+            const executionTime = Date.now() - startTime;
+            return {
+                success: false,
+                command,
+                ...(resolvedCommand !== command ? { resolvedCommand } : {}),
+                cwd: absoluteCwd,
+                error: error.message,
+                stdout: error.stdout ? error.stdout.trim() : "",
+                stderr: error.stderr ? error.stderr.trim() : "",
+                exitCode: typeof error.code === "number" ? error.code : 1,
+                timedOut: error.killed && error.signal === "SIGTERM",
+                executionTime,
+            };
+        }
+    }
+    catch (error) {
+        const err = error;
+        return {
+            success: false,
+            command,
+            error: err.message,
+            stdout: err.stdout ? err.stdout.trim() : "",
+            stderr: err.stderr ? err.stderr.trim() : "",
+            exitCode: typeof err.code === "number" ? err.code : 1,
+            timedOut: err.killed && err.signal === "SIGTERM",
+        };
+    }
+}
+export const executeCommandTool = {
+    description: "Execute terminal commands and return output. Commands require approval unless skipConfirmation is set internally or safe auto-approval policy applies.",
+    parameters: z.object({
+        command: z.string().optional().describe("The shell command to execute"),
+        cwd: z
+            .string()
+            .default(process.cwd())
+            .describe("Current working directory for the command"),
+        workspaceRoot: z
+            .string()
+            .optional()
+            .describe("Workspace root path for security validation - ensures paths stay within this boundary"),
+        timeout: z.number().default(30000).describe("Timeout in milliseconds"),
+        env: z
+            .record(z.string())
+            .optional()
+            .describe("Environment variables to pass to the command"),
+        runInBackground: z
+            .boolean()
+            .default(false)
+            .describe("Run the command as a managed background task and return a taskId for TaskList/TaskOutput/TaskStop"),
+        description: z
+            .string()
+            .optional()
+            .describe("Optional short description for background task tracking"),
+        skipConfirmation: z
+            .boolean()
+            .default(false)
+            .describe("Skip user confirmation - only used internally after user approves the command"),
+        approvalPolicy: z
+            .enum(["always_prompt", "auto_approve_safe"])
+            .default("always_prompt")
+            .describe("Approval behavior for the command. Use auto_approve_safe only for wrapper-aware readonly auto-approval."),
+        autoApproveRules: z
+            .record(z.any())
+            .optional()
+            .describe("Optional auto-approve rule map used for terminal command approval."),
+    }),
+    execute: executeCommand,
+};
+export default executeCommandTool;

package/dist/api/core/agent/tools/fileContent.d.ts

@@ -0,0 +1,54 @@
+import { z } from "zod";
+type FindFileContentParams = {
+    rootFolder: string;
+    fileName: string;
+    concurrency?: number;
+    isWebMode?: boolean;
+};
+type FileContentSuccessResult = {
+    found: true;
+    path: string;
+    content: string | null;
+    error?: string;
+};
+type FileContentErrorResult = {
+    found: false;
+    error: string;
+};
+type FileContentResult = FileContentSuccessResult | FileContentErrorResult;
+/**
+ * Tool for finding and reading file content by searching through directory tree
+ * Supports both filesystem (Node.js) and web-based File System Access API
+ *
+ * @param {Object} params - The parameters for finding file content
+ * @param {string} params.rootFolder - Root directory to start searching from
+ * @param {string} params.fileName - Exact file name to search for (including extension)
+ * @param {number} [params.concurrency=32] - Maximum number of parallel filesystem operations
+ * @param {boolean} [params.isWebMode=false] - Whether running in web mode (uses File System Access API)
+ * @returns {Promise<Object>} Object containing found status, file path, and content or error
+ */
+export declare function findFileContent({ rootFolder, fileName, concurrency, isWebMode, }: FindFileContentParams): Promise<FileContentResult>;
+/**
+ * Tool metadata for agent system
+ */
+export declare const findFileContentTool: {
+    description: string;
+    parameters: z.ZodObject<{
+        rootFolder: z.ZodString;
+        fileName: z.ZodString;
+        concurrency: z.ZodDefault<z.ZodNumber>;
+        isWebMode: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        rootFolder?: string;
+        fileName?: string;
+        concurrency?: number;
+        isWebMode?: boolean;
+    }, {
+        rootFolder?: string;
+        fileName?: string;
+        concurrency?: number;
+        isWebMode?: boolean;
+    }>;
+    execute: typeof findFileContent;
+};
+export default findFileContentTool;