protoagent 0.0.1

package/dist/tools/directory-operations.js

@@ -0,0 +1,195 @@
+import fs from 'fs/promises';
+import path from 'path';
+// Current working directory for file operations
+const workingDirectory = process.cwd();
+// Security utilities
+function normalizePath(p) {
+    return path.normalize(p);
+}
+async function validatePath(requestedPath) {
+    const absolute = path.isAbsolute(requestedPath)
+        ? path.resolve(requestedPath)
+        : path.resolve(workingDirectory, requestedPath);
+    const normalizedRequested = normalizePath(absolute);
+    // Check if path is within working directory
+    if (!normalizedRequested.startsWith(workingDirectory)) {
+        throw new Error(`Access denied - path outside working directory: ${absolute}`);
+    }
+    // Handle symlinks by checking their real path
+    try {
+        const realPath = await fs.realpath(absolute);
+        const normalizedReal = normalizePath(realPath);
+        if (!normalizedReal.startsWith(workingDirectory)) {
+            throw new Error(`Access denied - symlink target outside working directory: ${realPath}`);
+        }
+        return realPath;
+    }
+    catch (error) {
+        // For new files that don't exist yet, verify parent directory
+        if (error.code === 'ENOENT') {
+            const parentDir = path.dirname(absolute);
+            try {
+                const realParentPath = await fs.realpath(parentDir);
+                const normalizedParent = normalizePath(realParentPath);
+                if (!normalizedParent.startsWith(workingDirectory)) {
+                    throw new Error(`Access denied - parent directory outside working directory: ${realParentPath}`);
+                }
+                return absolute;
+            }
+            catch {
+                throw new Error(`Parent directory does not exist: ${parentDir}`);
+            }
+        }
+        throw error;
+    }
+}
+// Directory tree utility function
+async function buildDirectoryTree(dirPath, prefix = '', isLast = true, maxDepth = 5, currentDepth = 0) {
+    if (currentDepth >= maxDepth) {
+        return '';
+    }
+    const validPath = await validatePath(dirPath);
+    const stats = await fs.stat(validPath);
+    if (!stats.isDirectory()) {
+        return '';
+    }
+    let result = '';
+    const entries = await fs.readdir(validPath, { withFileTypes: true });
+    // Sort entries: directories first, then files, alphabetically
+    entries.sort((a, b) => {
+        if (a.isDirectory() && !b.isDirectory())
+            return -1;
+        if (!a.isDirectory() && b.isDirectory())
+            return 1;
+        return a.name.localeCompare(b.name);
+    });
+    for (let i = 0; i < entries.length; i++) {
+        const entry = entries[i];
+        const isLastEntry = i === entries.length - 1;
+        const currentPrefix = isLastEntry ? '└── ' : '├── ';
+        const nextPrefix = prefix + (isLastEntry ? '    ' : '│   ');
+        result += `${prefix}${currentPrefix}${entry.name}${entry.isDirectory() ? '/' : ''}\n`;
+        if (entry.isDirectory()) {
+            const subPath = path.join(dirPath, entry.name);
+            try {
+                result += await buildDirectoryTree(subPath, nextPrefix, isLastEntry, maxDepth, currentDepth + 1);
+            }
+            catch (error) {
+                // Skip directories we can't read (permissions, etc.)
+                result += `${nextPrefix}└── [Permission Denied]\n`;
+            }
+        }
+    }
+    return result;
+}
+export async function listDirectory(dirPath) {
+    try {
+        const validPath = await validatePath(dirPath);
+        // Check if path exists and is a directory
+        const stats = await fs.stat(validPath);
+        if (!stats.isDirectory()) {
+            throw new Error('Path is not a directory');
+        }
+        const entries = await fs.readdir(validPath, { withFileTypes: true });
+        const formatted = entries
+            .map((entry) => `${entry.isDirectory() ? "[DIR]" : "[FILE]"} ${entry.name}`)
+            .join("\n");
+        return formatted || "Directory is empty";
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Failed to list directory: ${error.message}`);
+        }
+        throw new Error('Failed to list directory: Unknown error');
+    }
+}
+export async function createDirectory(dirPath) {
+    try {
+        const validPath = await validatePath(dirPath);
+        await fs.mkdir(validPath, { recursive: true });
+        return `Successfully created directory ${dirPath}`;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Failed to create directory: ${error.message}`);
+        }
+        throw new Error('Failed to create directory: Unknown error');
+    }
+}
+export async function viewDirectoryTree(dirPath, maxDepth = 5) {
+    try {
+        const validPath = await validatePath(dirPath);
+        // Check if path exists and is a directory
+        const stats = await fs.stat(validPath);
+        if (!stats.isDirectory()) {
+            throw new Error('Path is not a directory');
+        }
+        const relativePath = path.relative(workingDirectory, validPath) || '.';
+        const tree = await buildDirectoryTree(validPath, '', true, maxDepth);
+        return `Directory tree for ${relativePath}:\n${relativePath}/\n${tree}`;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Failed to view directory tree: ${error.message}`);
+        }
+        throw new Error('Failed to view directory tree: Unknown error');
+    }
+}
+// Tool definitions
+export const directoryOperationTools = [
+    {
+        type: 'function',
+        function: {
+            name: 'list_directory',
+            description: 'List all files and directories in a specified directory. Use this to explore the project structure or find files. Returns a formatted list showing [FILE] and [DIR] prefixes.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    directory_path: {
+                        type: 'string',
+                        description: 'The path to the directory to list, relative to the current working directory. Use "." for current directory. Examples: ".", "src", "src/components"'
+                    }
+                },
+                required: ['directory_path']
+            }
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'create_directory',
+            description: 'Create a new directory or ensure a directory exists. Can create multiple nested directories in one operation. Use this when you need to set up directory structures for projects.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    directory_path: {
+                        type: 'string',
+                        description: 'The path to the directory to create, relative to the current working directory. Examples: "src/components", "tests/unit", "docs"'
+                    }
+                },
+                required: ['directory_path']
+            }
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'view_directory_tree',
+            description: 'Display the directory tree of a specified directory up to a certain depth. This provides a visual overview of the directory structure, showing nested folders and files. Useful for understanding project layout or finding files.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    directory_path: {
+                        type: 'string',
+                        description: 'The path to the directory to display, relative to the current working directory. Examples: "src", "docs"'
+                    },
+                    max_depth: {
+                        type: 'integer',
+                        description: 'The maximum depth to display in the directory tree. Use a higher number to show more levels of the tree.'
+                    }
+                },
+                required: ['directory_path']
+            }
+        }
+    }
+];

package/dist/tools/edit-file.js

@@ -0,0 +1,144 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { randomBytes } from 'crypto';
+import { requestFileOperationApproval } from '../utils/file-operations-approval.js';
+import { logger } from '../utils/logger.js';
+// Current working directory for file operations
+const workingDirectory = process.cwd();
+// Security utilities
+function normalizePath(p) {
+    return path.normalize(p);
+}
+async function validatePath(requestedPath) {
+    const absolute = path.isAbsolute(requestedPath)
+        ? path.resolve(requestedPath)
+        : path.resolve(workingDirectory, requestedPath);
+    const normalizedRequested = normalizePath(absolute);
+    // Check if path is within working directory
+    if (!normalizedRequested.startsWith(workingDirectory)) {
+        throw new Error(`Access denied - path outside working directory: ${absolute}`);
+    }
+    // Handle symlinks by checking their real path
+    try {
+        const realPath = await fs.realpath(absolute);
+        const normalizedReal = normalizePath(realPath);
+        if (!normalizedReal.startsWith(workingDirectory)) {
+            throw new Error(`Access denied - symlink target outside working directory: ${realPath}`);
+        }
+        return realPath;
+    }
+    catch (error) {
+        // For new files that don't exist yet, verify parent directory
+        if (error.code === 'ENOENT') {
+            const parentDir = path.dirname(absolute);
+            try {
+                const realParentPath = await fs.realpath(parentDir);
+                const normalizedParent = normalizePath(realParentPath);
+                if (!normalizedParent.startsWith(workingDirectory)) {
+                    throw new Error(`Access denied - parent directory outside working directory: ${realParentPath}`);
+                }
+                return absolute;
+            }
+            catch {
+                throw new Error(`Parent directory does not exist: ${parentDir}`);
+            }
+        }
+        throw error;
+    }
+}
+export async function editFile(filePath, oldString, newString, expectedReplacements) {
+    try {
+        const validPath = await validatePath(filePath);
+        // Read current file content
+        const currentContent = await fs.readFile(validPath, 'utf-8');
+        // Check if the old string exists in the file
+        if (!currentContent.includes(oldString)) {
+            throw new Error(`Old string not found in file. Make sure the text matches exactly, including whitespace and line breaks.`);
+        }
+        // Count occurrences of the old string
+        const occurrences = (currentContent.match(new RegExp(escapeRegExp(oldString), 'g')) || []).length;
+        // If expected replacements is specified, validate it
+        if (expectedReplacements !== undefined) {
+            if (occurrences !== expectedReplacements) {
+                throw new Error(`Expected ${expectedReplacements} occurrences of the old string, but found ${occurrences}. This prevents accidental multiple replacements.`);
+            }
+        }
+        else if (occurrences > 1) {
+            throw new Error(`Found ${occurrences} occurrences of the old string. Use expected_replacements parameter to confirm you want to replace all ${occurrences} occurrences, or make your old_string more specific to match only the intended text.`);
+        }
+        // Perform the replacement to show preview
+        const updatedContent = currentContent.replace(new RegExp(escapeRegExp(oldString), 'g'), newString);
+        // Verify that the replacement actually changed something
+        if (updatedContent === currentContent) {
+            throw new Error(`No changes were made to the file. The old_string and new_string appear to be identical.`);
+        }
+        // Request user approval for edit operation
+        const replacementCount = expectedReplacements || 1;
+        const approvalContext = {
+            operation: 'edit',
+            filePath: filePath,
+            description: `Replace ${replacementCount} occurrence${replacementCount === 1 ? '' : 's'} of text in file`,
+            contentPreview: `OLD TEXT (${oldString.length} chars):\n${oldString.substring(0, 200)}${oldString.length > 200 ? '...' : ''}\n\nNEW TEXT (${newString.length} chars):\n${newString.substring(0, 200)}${newString.length > 200 ? '...' : ''}`
+        };
+        const approved = await requestFileOperationApproval(approvalContext);
+        if (!approved) {
+            return `Edit operation cancelled by user: ${filePath}`;
+        }
+        logger.debug(`✏️  Editing file: ${filePath} (${replacementCount} replacement${replacementCount === 1 ? '' : 's'})`, { component: 'EditFile', operation: 'editFile' });
+        // Write the updated content using atomic operation
+        const tempPath = `${validPath}.${randomBytes(16).toString('hex')}.tmp`;
+        try {
+            await fs.writeFile(tempPath, updatedContent, 'utf-8');
+            await fs.rename(tempPath, validPath);
+            logger.info(`✅ Successfully edited: ${filePath} (${replacementCount} replacement${replacementCount === 1 ? '' : 's'})`, { component: 'EditFile', operation: 'editFile' });
+        }
+        catch (renameError) {
+            try {
+                await fs.unlink(tempPath);
+            }
+            catch { }
+            throw renameError;
+        }
+        return `Successfully edited ${filePath} - replaced ${replacementCount} occurrence${replacementCount === 1 ? '' : 's'} of the specified text`;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Failed to edit file: ${error.message}`);
+        }
+        throw new Error('Failed to edit file: Unknown error');
+    }
+}
+// Helper function to escape special regex characters
+function escapeRegExp(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+// Tool definition
+export const editFileTool = {
+    type: 'function',
+    function: {
+        name: 'edit_file',
+        description: 'Edit an existing file by replacing specific text with new text. This operation is atomic and ensures file integrity. Use this to modify configuration files, scripts, or any text files where you need to update specific sections. The old_string must match exactly, including whitespace and line breaks.',
+        parameters: {
+            type: 'object',
+            properties: {
+                file_path: {
+                    type: 'string',
+                    description: 'The path to the file to edit, relative to the current working directory. Examples: "src/config.json", "README.md"'
+                },
+                old_string: {
+                    type: 'string',
+                    description: 'The exact text to find and replace. Must match exactly, including whitespace, indentation, and line breaks. For better precision, include some surrounding context.'
+                },
+                new_string: {
+                    type: 'string',
+                    description: 'The new text to replace the old_string with. Can be empty string to delete text.'
+                },
+                expected_replacements: {
+                    type: 'integer',
+                    description: 'Optional: The expected number of replacements. If not specified, only allows 1 replacement. Use this to confirm when you want to replace multiple occurrences of the same text.'
+                }
+            },
+            required: ['file_path', 'old_string', 'new_string']
+        }
+    }
+};

package/dist/tools/file-operations.js

@@ -0,0 +1,211 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { randomBytes } from 'crypto';
+// Current working directory for file operations
+const workingDirectory = process.cwd();
+// Security utilities
+function normalizePath(p) {
+    return path.normalize(p);
+}
+async function validatePath(requestedPath) {
+    const absolute = path.isAbsolute(requestedPath)
+        ? path.resolve(requestedPath)
+        : path.resolve(workingDirectory, requestedPath);
+    const normalizedRequested = normalizePath(absolute);
+    // Check if path is within working directory
+    if (!normalizedRequested.startsWith(workingDirectory)) {
+        throw new Error(`Access denied - path outside working directory: ${absolute}`);
+    }
+    // Handle symlinks by checking their real path
+    try {
+        const realPath = await fs.realpath(absolute);
+        const normalizedReal = normalizePath(realPath);
+        if (!normalizedReal.startsWith(workingDirectory)) {
+            throw new Error(`Access denied - symlink target outside working directory: ${realPath}`);
+        }
+        return realPath;
+    }
+    catch (error) {
+        // For new files that don't exist yet, verify parent directory
+        if (error.code === 'ENOENT') {
+            const parentDir = path.dirname(absolute);
+            try {
+                const realParentPath = await fs.realpath(parentDir);
+                const normalizedParent = normalizePath(realParentPath);
+                if (!normalizedParent.startsWith(workingDirectory)) {
+                    throw new Error(`Access denied - parent directory outside working directory: ${realParentPath}`);
+                }
+                return absolute;
+            }
+            catch {
+                throw new Error(`Parent directory does not exist: ${parentDir}`);
+            }
+        }
+        throw error;
+    }
+}
+export async function readFile(filePath) {
+    try {
+        const validPath = await validatePath(filePath);
+        // Check if file exists and is actually a file
+        const stats = await fs.stat(validPath);
+        if (!stats.isFile()) {
+            throw new Error('Path is not a file');
+        }
+        // Read and return file content
+        const content = await fs.readFile(validPath, 'utf-8');
+        return content;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Failed to read file: ${error.message}`);
+        }
+        throw new Error('Failed to read file: Unknown error');
+    }
+}
+export async function writeFile(filePath, content) {
+    try {
+        const validPath = await validatePath(filePath);
+        try {
+            // Security: 'wx' flag ensures exclusive creation - fails if file/symlink exists,
+            // preventing writes through pre-existing symlinks
+            await fs.writeFile(validPath, content, { encoding: "utf-8", flag: 'wx' });
+        }
+        catch (error) {
+            if (error.code === 'EEXIST') {
+                // Security: Use atomic rename to prevent race conditions where symlinks
+                // could be created between validation and write. Rename operations
+                // replace the target file atomically and don't follow symlinks.
+                const tempPath = `${validPath}.${randomBytes(16).toString('hex')}.tmp`;
+                try {
+                    await fs.writeFile(tempPath, content, 'utf-8');
+                    await fs.rename(tempPath, validPath);
+                }
+                catch (renameError) {
+                    try {
+                        await fs.unlink(tempPath);
+                    }
+                    catch { }
+                    throw renameError;
+                }
+            }
+            else {
+                throw error;
+            }
+        }
+        return `Successfully wrote to ${filePath}`;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Failed to write file: ${error.message}`);
+        }
+        throw new Error('Failed to write file: Unknown error');
+    }
+}
+export async function editFile(filePath, startLine, endLine, newContent) {
+    try {
+        const validPath = await validatePath(filePath);
+        // Read current file content
+        const currentContent = await fs.readFile(validPath, 'utf-8');
+        const lines = currentContent.split('\n');
+        // Validate line numbers (1-based indexing for user, 0-based for array)
+        if (startLine < 1 || endLine < 1 || startLine > lines.length || endLine > lines.length || startLine > endLine) {
+            throw new Error(`Invalid line range: ${startLine}-${endLine}. File has ${lines.length} lines.`);
+        }
+        // Replace the specified lines
+        const newLines = newContent.split('\n');
+        const beforeLines = lines.slice(0, startLine - 1);
+        const afterLines = lines.slice(endLine);
+        const updatedContent = [...beforeLines, ...newLines, ...afterLines].join('\n');
+        // Write the updated content using atomic operation
+        const tempPath = `${validPath}.${randomBytes(16).toString('hex')}.tmp`;
+        try {
+            await fs.writeFile(tempPath, updatedContent, 'utf-8');
+            await fs.rename(tempPath, validPath);
+        }
+        catch (renameError) {
+            try {
+                await fs.unlink(tempPath);
+            }
+            catch { }
+            throw renameError;
+        }
+        return `Successfully edited ${filePath} (lines ${startLine}-${endLine})`;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Failed to edit file: ${error.message}`);
+        }
+        throw new Error('Failed to edit file: Unknown error');
+    }
+}
+// Tool definitions
+export const fileOperationTools = [
+    {
+        type: 'function',
+        function: {
+            name: 'read_file',
+            description: 'Read the contents of a file in the current working directory or its subdirectories. Use this when you need to examine code, configuration files, or any text-based files to help the user.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    file_path: {
+                        type: 'string',
+                        description: 'The path to the file to read, relative to the current working directory. Examples: "src/index.ts", "package.json", "README.md"'
+                    }
+                },
+                required: ['file_path']
+            }
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'write_file',
+            description: 'Create a new file or completely overwrite an existing file with new content. Use this when you need to create new files or update existing ones. The file will be created in the current working directory or subdirectories.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    file_path: {
+                        type: 'string',
+                        description: 'The path to the file to write, relative to the current working directory. Examples: "src/newfile.ts", "config.json", "README.md"'
+                    },
+                    content: {
+                        type: 'string',
+                        description: 'The content to write to the file. This will completely replace any existing content.'
+                    }
+                },
+                required: ['file_path', 'content']
+            }
+        }
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'edit_file',
+            description: 'Edit an existing file by replacing specific lines with new content. This operation is atomic and ensures file integrity. Use this to modify configuration files, scripts, or any text files where you need to update specific sections.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    file_path: {
+                        type: 'string',
+                        description: 'The path to the file to edit, relative to the current working directory. Examples: "src/config.json", "README.md"'
+                    },
+                    start_line: {
+                        type: 'integer',
+                        description: 'The starting line number for the replacement (inclusive, 1-based).'
+                    },
+                    end_line: {
+                        type: 'integer',
+                        description: 'The ending line number for the replacement (inclusive, 1-based).'
+                    },
+                    new_content: {
+                        type: 'string',
+                        description: 'The new content to insert, replacing the specified line range.'
+                    }
+                },
+                required: ['file_path', 'start_line', 'end_line', 'new_content']
+            }
+        }
+    }
+];

package/dist/tools/index.js

@@ -0,0 +1,95 @@
+// Export all tools and their implementations
+export { readFile, readFileTool } from './read-file.js';
+export { writeFile, writeFileTool } from './write-file.js';
+export { editFile, editFileTool } from './edit-file.js';
+export { listDirectory, listDirectoryTool } from './list-directory.js';
+export { createDirectory, createDirectoryTool } from './create-directory.js';
+export { viewDirectoryTree, viewDirectoryTreeTool } from './view-directory-tree.js';
+export { searchFiles, searchFilesTool } from './search-files.js';
+export { runShellCommand, setShellConfig, setDangerouslyAcceptAll, runShellCommandTool } from './run-shell-command.js';
+export { handleTodoTool, todoReadTool, todoWriteTool } from './todo.js';
+export { setFileOperationConfig, setDangerouslyAcceptAllFileOps, getSessionApprovalStatus, clearSessionApprovals, showApprovalStatus } from '../utils/file-operations-approval.js';
+// Import all tool definitions
+import { readFileTool } from './read-file.js';
+import { writeFileTool } from './write-file.js';
+import { editFileTool } from './edit-file.js';
+import { listDirectoryTool } from './list-directory.js';
+import { createDirectoryTool } from './create-directory.js';
+import { viewDirectoryTreeTool } from './view-directory-tree.js';
+import { searchFilesTool } from './search-files.js';
+import { runShellCommandTool } from './run-shell-command.js';
+import { todoReadTool, todoWriteTool } from './todo.js';
+// Import all tool implementations
+import { readFile } from './read-file.js';
+import { writeFile } from './write-file.js';
+import { editFile } from './edit-file.js';
+import { listDirectory } from './list-directory.js';
+import { createDirectory } from './create-directory.js';
+import { viewDirectoryTree } from './view-directory-tree.js';
+import { searchFiles } from './search-files.js';
+import { runShellCommand } from './run-shell-command.js';
+import { handleTodoTool } from './todo.js';
+// Consolidated tool definitions
+export const tools = [
+    readFileTool,
+    writeFileTool,
+    editFileTool,
+    listDirectoryTool,
+    createDirectoryTool,
+    viewDirectoryTreeTool,
+    searchFilesTool,
+    runShellCommandTool,
+    todoReadTool,
+    todoWriteTool
+];
+// Tool handler function
+export async function handleToolCall(toolName, args) {
+    try {
+        switch (toolName) {
+            case 'read_file':
+                const content = await readFile(args.file_path, args.offset, args.limit);
+                return `File content of ${args.file_path}:\n\n${content}`;
+            case 'write_file':
+                const writeResult = await writeFile(args.file_path, args.content);
+                return writeResult;
+            case 'edit_file':
+                const editResult = await editFile(args.file_path, args.old_string, args.new_string, args.expected_replacements);
+                return editResult;
+            case 'list_directory':
+                const listResult = await listDirectory(args.directory_path);
+                return `Contents of ${args.directory_path}:\n\n${listResult}`;
+            case 'create_directory':
+                const createResult = await createDirectory(args.directory_path);
+                return createResult;
+            case 'view_directory_tree':
+                const treeResult = await viewDirectoryTree(args.directory_path, args.max_depth);
+                return treeResult;
+            case 'search_files':
+                const searchResult = await searchFiles(args.search_term, args.directory_path, args.case_sensitive, args.file_extensions);
+                return searchResult;
+            case 'run_shell_command':
+                const shellResult = await runShellCommand(args.command, args.args || [], args.timeout_ms || 30000);
+                return shellResult;
+            case 'todo_read':
+            case 'todo_write':
+                return await handleTodoTool(toolName, args);
+            default:
+                return `Error: Unknown tool ${toolName}`;
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        return `Error executing ${toolName}: ${errorMessage}`;
+    }
+}
+// Convenience functions for config setup
+import { setShellConfig, setDangerouslyAcceptAll } from './run-shell-command.js';
+import { setFileOperationConfig, setDangerouslyAcceptAllFileOps } from '../utils/file-operations-approval.js';
+export function setToolsConfig(config) {
+    setShellConfig(config);
+    setFileOperationConfig(config);
+}
+export function setToolsDangerouslyAcceptAll(accept) {
+    setDangerouslyAcceptAll(accept);
+    setDangerouslyAcceptAllFileOps(accept);
+}