@remcp/runtime 0.2.149 → 0.2.151

package/src/core-catalog-part1.mjs

@@ -0,0 +1,373 @@
+import { fileToolHandlers, searchToolHandlers, terminalToolHandlers, systemToolHandlers, statsToolHandlers, configToolHandlers, readOnly, readOnlyNonIdempotent, additive, mutating, command, TEXT_OUTPUT_SCHEMA, NULLABLE_NUMBER_SCHEMA, NULLABLE_STRING_SCHEMA, START_PROCESS_OUTPUT_SCHEMA, READ_PROCESS_OUTPUT_SCHEMA, WAIT_PROCESS_OUTPUT_SCHEMA, INTERACT_PROCESS_OUTPUT_SCHEMA, TERMINATE_PROCESS_OUTPUT_SCHEMA, LIST_SESSIONS_OUTPUT_SCHEMA } from './core-catalog-shared.mjs';
+
+export const coreToolDefinitionsPart1 = [
+  {
+    name: 'read_file',
+    title: 'Read file',
+    description: 'Read a plain text or line-oriented file on this computer: source, config, Markdown, scripts or logs. Use read_document for PDF, DOCX, XLSX and other structured documents. Legacy .docx/.pdf extraction remains supported for compatibility. Use offset and length to page through large text files; a negative offset reads from the end.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'Absolute path of the file to read. Relative paths resolve against the runtime working directory.' },
+        offset: { type: 'number', description: 'Zero-based first line to read. Negative values read the last N lines.' },
+        length: { type: 'number', description: 'Maximum number of lines to return.' },
+      },
+      required: ['path'],
+      additionalProperties: false,
+    },
+    annotations: readOnly,
+    handler: fileToolHandlers.read_file,
+  },
+  {
+    name: 'read_files',
+    title: 'Read files by glob',
+    description: 'Read the contents of files discovered by one glob under a directory, each section prefixed with its path and line count. Use this when the matched file contents are the result you want. Use start_search instead to find filenames or text matches without reading every matched file. If you already know the exact paths, use read_multiple_files; for one known path use read_file.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'Absolute directory (or single file) to start from.' },
+        pattern: { type: 'string', description: 'Glob matched against the relative path and the file name, such as "src/**/*.ts" or "*.md". Default **/* .' },
+        max_files: { type: 'number', description: 'Stop after this many files. Default 100, maximum 500.' },
+        max_lines_per_file: { type: 'number', description: 'Lines kept per file. Default 2000.' },
+        include_ignored: { type: 'boolean', description: 'Also descend into .git and node_modules. Default false.' },
+      },
+      additionalProperties: false,
+    },
+    annotations: readOnly,
+    handler: fileToolHandlers.read_files,
+  },
+  {
+    name: 'read_multiple_files',
+    title: 'Read multiple files',
+    description: 'Read several explicitly named text files in one call. Use this when the exact paths are already known; each file is returned separately and one failure does not stop the others. Do not use this for glob discovery: use read_files instead. For one path use read_file.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        paths: { type: 'array', items: { type: 'string' }, description: 'Absolute paths of the files to read, at most 50 per call.' },
+      },
+      required: ['paths'],
+      additionalProperties: false,
+    },
+    annotations: readOnly,
+    handler: fileToolHandlers.read_multiple_files,
+  },
+  {
+    name: 'read_image',
+    title: 'Read image',
+    description: 'Return an image file (PNG, JPEG, GIF, WebP, BMP, AVIF, or SVG) as native MCP image content so screenshots, photos, and diagrams can be inspected or shown. Use read_binary only for byte-for-byte transfer, not merely to display an image. Fails above the inline size limit.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'Absolute path of the image file.' },
+      },
+      required: ['path'],
+      additionalProperties: false,
+    },
+    annotations: readOnly,
+    handler: fileToolHandlers.read_image,
+  },
+  {
+    name: 'read_binary',
+    title: 'Read binary chunk',
+    description: 'Read any file as base64 chunks for byte-for-byte transfer of binaries, archives, documents, or oversized media. For a normal image that should be inspected or shown, use read_image instead. Returns size, offset, and nextOffsetBytes; call again with offset_bytes set to nextOffsetBytes until complete is true.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'Absolute path of the file to read.' },
+        offset_bytes: { type: 'number', description: 'Byte offset to start at. Default 0.' },
+        length_bytes: { type: 'number', description: 'Chunk size in bytes. Default and maximum 1048576 (1 MiB).' },
+      },
+      required: ['path'],
+      additionalProperties: false,
+    },
+    annotations: readOnly,
+    handler: fileToolHandlers.read_binary,
+  },
+  {
+    name: 'write_binary',
+    title: 'Write binary chunk',
+    description: 'Write base64 data to a file byte for byte, creating parent directories. Use mode "append" to send a large file as consecutive chunks. Replaces the file by default.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'Absolute path of the file to write.' },
+        data: { type: 'string', description: 'Base64-encoded content.' },
+        mode: { type: 'string', enum: ['rewrite', 'append'], description: 'rewrite replaces the file, append adds to the end. Default rewrite.' },
+      },
+      required: ['path', 'data'],
+      additionalProperties: false,
+    },
+    annotations: mutating,
+    handler: fileToolHandlers.write_binary,
+  },
+  {
+    name: 'hash_file',
+    title: 'Hash file',
+    description: 'Compute a checksum of a file without reading it into memory. Useful to verify a copy, compare two files, or confirm a download.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'Absolute path of the file to hash.' },
+        algorithm: { type: 'string', enum: ['sha256', 'sha1', 'md5'], description: 'Hash algorithm. Default sha256.' },
+      },
+      required: ['path'],
+      additionalProperties: false,
+    },
+    annotations: readOnly,
+    handler: fileToolHandlers.hash_file,
+  },
+  {
+    name: 'list_directory',
+    title: 'List directory',
+    description: 'List the files and directories at a path. Entries are prefixed with [DIR], [FILE], [LINK], or [DENIED] when a subdirectory cannot be read. depth controls how many directory levels are included and pattern filters file names by glob.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'Absolute path of the directory to list.' },
+        depth: { type: 'number', description: 'Directory levels to list, from 1 to 5. Default 1.' },
+        pattern: { type: 'string', description: 'Optional glob that filters file names, such as "*.log". Directories are always listed.' },
+      },
+      required: ['path'],
+      additionalProperties: false,
+    },
+    annotations: readOnly,
+    handler: fileToolHandlers.list_directory,
+  },
+  {
+    name: 'get_file_info',
+    title: 'Get file info',
+    description: 'Return metadata for a file or directory: type, size, timestamps, permissions, and for small text files the line count.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'Absolute path to inspect.' },
+      },
+      required: ['path'],
+      additionalProperties: false,
+    },
+    annotations: readOnly,
+    handler: fileToolHandlers.get_file_info,
+  },
+  {
+    name: 'write_file',
+    title: 'Write file',
+    description: 'Create or replace the complete contents of exactly one text file. Parent directories are created automatically; mode "append" adds to the end. For a small exact-block edit use edit_block, for a known line range use replace_lines, and when you already have a unified diff use apply_patch. Use write_files for two or more independent complete files, and write_binary for binary bytes.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'Absolute path of the file to write.' },
+        content: { type: 'string', description: 'Full file content, or the text to append.' },
+        mode: { type: 'string', enum: ['rewrite', 'append'], description: 'rewrite replaces the file content, append adds to the end. Default rewrite.' },
+      },
+      required: ['path', 'content'],
+      additionalProperties: false,
+    },
+    annotations: mutating,
+    handler: fileToolHandlers.write_file,
+  },
+  {
+    name: 'write_files',
+    title: 'Write multiple files',
+    description: 'Create or replace the complete contents of two or more text files in one batch, each with its own path, content, and optional mode. Use this for scaffolding or coherent multi-file writes; for one path use write_file. For partial edits use edit_block, replace_lines, replace_in_files, or apply_patch instead of rewriting whole files.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        files: {
+          type: 'array',
+          description: 'Files to write, at most 200 per call.',
+          items: {
+            type: 'object',
+            properties: {
+              path: { type: 'string', description: 'Absolute path of the file.' },
+              content: { type: 'string', description: 'Full file content.' },
+              mode: { type: 'string', enum: ['rewrite', 'append'], description: 'rewrite replaces the file (default), append adds to the end.' },
+            },
+            required: ['path', 'content'],
+            additionalProperties: false,
+          },
+        },
+      },
+      required: ['files'],
+      additionalProperties: false,
+    },
+    annotations: mutating,
+    handler: fileToolHandlers.write_files,
+  },
+  {
+    name: 'apply_patch',
+    title: 'Apply patch',
+    description: 'Apply an already-prepared unified diff to one file or several files, matching each hunk with a little fuzz so small offsets and whitespace differences still apply. Prefer this when the change is naturally patch-shaped; use edit_block for one exact text block and write_file only when replacing a complete file. Pass dry_run to see the result first.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        patch: { type: 'string', description: 'Unified diff, including ---/+++ headers and @@ hunks.' },
+        path: { type: 'string', description: 'Apply every hunk to this file, ignoring the patch headers.' },
+        dry_run: { type: 'boolean', description: 'Report the diff without writing. Default false.' },
+      },
+      required: ['patch'],
+      additionalProperties: false,
+    },
+    annotations: mutating,
+    handler: fileToolHandlers.apply_patch,
+  },
+  {
+    name: 'set_permissions',
+    title: 'Set permissions',
+    description: 'Change the permission mode of a file or directory, optionally recursively and optionally with a numeric owner. Use this to make a script executable after writing it.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'Absolute path whose permissions should change.' },
+        mode: { type: 'string', description: 'Octal mode such as "755" or "0644".' },
+        recursive: { type: 'boolean', description: 'Apply to a directory and everything inside it. Default false.' },
+        uid: { type: 'number', description: 'Optional numeric user id to set as owner.' },
+        gid: { type: 'number', description: 'Optional numeric group id to set as owner.' },
+      },
+      required: ['path', 'mode'],
+      additionalProperties: false,
+    },
+    annotations: mutating,
+    handler: fileToolHandlers.set_permissions,
+  },
+  {
+    name: 'edit_block',
+    title: 'Edit file',
+    description: 'Replace one known text block in one file. Provide enough surrounding context to make old_string unique; the call fails unless the number of matches equals expected_replacements. Use write_file for a whole-file replacement and replace_lines for a known line range. When exact text is not found, a whitespace-tolerant match is attempted and reported. Pass dry_run to preview without writing.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        file_path: { type: 'string', description: 'Absolute path of the file to edit.' },
+        old_string: { type: 'string', description: 'Exact existing text to replace.' },
+        new_string: { type: 'string', description: 'Replacement text.' },
+        expected_replacements: { type: 'number', description: 'Number of matches required for the edit to apply. Default 1.' },
+        allow_fuzzy: { type: 'boolean', description: 'Allow a whitespace-tolerant fallback when the exact text is not found. Default true.' },
+        dry_run: { type: 'boolean', description: 'Return the diff without changing the file. Default false.' },
+      },
+      required: ['file_path', 'old_string', 'new_string'],
+      additionalProperties: false,
+    },
+    annotations: mutating,
+    handler: fileToolHandlers.edit_block,
+  },
+  {
+    name: 'replace_lines',
+    title: 'Replace lines',
+    description: 'Replace an inclusive 1-based line range with new text. Use this when line numbers define the target; use edit_block when matching existing text and write_file for a complete rewrite. The rest of the file, including its line endings, is preserved. Pass dry_run to preview without writing.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'Absolute path of the file to edit.' },
+        start_line: { type: 'number', description: 'First line to replace, 1-based and inclusive.' },
+        end_line: { type: 'number', description: 'Last line to replace, 1-based and inclusive.' },
+        content: { type: 'string', description: 'Replacement text; an empty string deletes the range.' },
+        dry_run: { type: 'boolean', description: 'Return the diff without changing the file. Default false.' },
+      },
+      required: ['path', 'start_line', 'end_line', 'content'],
+      additionalProperties: false,
+    },
+    annotations: mutating,
+    handler: fileToolHandlers.replace_lines,
+  },
+  {
+    name: 'replace_in_files',
+    title: 'Replace in files',
+    description: 'Search and replace the same text or regular expression across multiple text files under a path and report what changed. Use edit_block for one known block in one file and write_file for one complete known file. Applies immediately; pass dry_run true to preview the affected files first.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'Absolute path of a file or directory to search.' },
+        pattern: { type: 'string', description: 'Text or regular expression to find.' },
+        replacement: { type: 'string', description: 'Replacement text. In regex mode, $1 and friends refer to capture groups.' },
+        filePattern: { type: 'string', description: 'Optional glob limiting which file names are changed, such as "*.ts".' },
+        regex: { type: 'boolean', description: 'Treat pattern as a regular expression. Default false (plain text).' },
+        dry_run: { type: 'boolean', description: 'Only report the files that would change. Default false.' },
+        maxFiles: { type: 'number', description: 'Stop after this many changed files. Default 100, maximum 500.' },
+      },
+      required: ['path', 'pattern', 'replacement'],
+      additionalProperties: false,
+    },
+    annotations: mutating,
+    handler: fileToolHandlers.replace_in_files,
+  },
+  {
+    name: 'diff_files',
+    title: 'Diff files',
+    description: 'Show a unified diff between two local text files, with line counts. Useful to check what changed before reporting or reverting it.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        left: { type: 'string', description: 'Absolute path of the original file.' },
+        right: { type: 'string', description: 'Absolute path of the file to compare against it.' },
+        context_lines: { type: 'number', description: 'Lines of context around each change. Default 3, maximum 20.' },
+      },
+      required: ['left', 'right'],
+      additionalProperties: false,
+    },
+    annotations: readOnly,
+    handler: fileToolHandlers.diff_files,
+  },
+  {
+    name: 'move_to_trash',
+    title: 'Move to trash',
+    description: 'Move a file or directory to the system trash instead of deleting it, so the change can be undone. When the trash is outside the device allowed roots, a .remcp-trash folder beside the file is used instead.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        source: { type: 'string', description: 'Absolute path to move to the trash.' },
+      },
+      required: ['source'],
+      additionalProperties: false,
+    },
+    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
+    handler: fileToolHandlers.move_to_trash,
+  },
+  {
+    name: 'create_directory',
+    title: 'Create directories',
+    description: 'Create one directory or many in a single call, including any missing parent directories. Succeeds when a directory already exists.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'Absolute path of the directory to create.' },
+        paths: { type: 'array', items: { type: 'string' }, description: 'Several directories to create at once, at most 200.' },
+      },
+      additionalProperties: false,
+    },
+    annotations: additive,
+    handler: fileToolHandlers.create_directory,
+  },
+  {
+    name: 'move_file',
+    title: 'Move or rename',
+    description: 'Move or rename exactly one file or directory from one source to one destination. Replaces an existing destination file by default; pass overwrite false to refuse instead. Use move_paths for two or more moves.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        source: { type: 'string', description: 'Absolute path to move.' },
+        destination: { type: 'string', description: 'Absolute destination path.' },
+        overwrite: { type: 'boolean', description: 'Replace an existing destination file. Default true.' },
+      },
+      required: ['source', 'destination'],
+      additionalProperties: false,
+    },
+    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
+    handler: fileToolHandlers.move_file,
+  },
+  {
+    name: 'copy_file',
+    title: 'Copy file',
+    description: 'Copy exactly one regular file to a new path. Directories are not copied recursively. Use copy_paths for directories or two or more copy operations; pass overwrite false to refuse an existing destination.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        source: { type: 'string', description: 'Absolute path of the file to copy.' },
+        destination: { type: 'string', description: 'Absolute destination path.' },
+        overwrite: { type: 'boolean', description: 'Replace the destination when it already exists. Default true.' },
+      },
+      required: ['source', 'destination'],
+      additionalProperties: false,
+    },
+    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
+    handler: fileToolHandlers.copy_file,
+  },
+];