@remcp/runtime 0.2.150 → 0.2.152

package/src/core-catalog-part2.mjs

@@ -0,0 +1,374 @@
+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 coreToolDefinitionsPart2 = [
+  {
+    name: 'copy_paths',
+    title: 'Copy paths',
+    description: 'Copy two or more paths, or copy a directory recursively, in one call. Each item has its own source and destination. For exactly one regular file use copy_file.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        paths: {
+          type: 'array',
+          description: 'Pairs to copy, at most 200 per call.',
+          items: {
+            type: 'object',
+            properties: {
+              source: { type: 'string', description: 'Absolute path to copy.' },
+              destination: { type: 'string', description: 'Absolute destination path.' },
+            },
+            required: ['source', 'destination'],
+            additionalProperties: false,
+          },
+        },
+        overwrite: { type: 'boolean', description: 'Replace an existing destination. Default true.' },
+      },
+      required: ['paths'],
+      additionalProperties: false,
+    },
+    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
+    handler: fileToolHandlers.copy_paths,
+  },
+  {
+    name: 'move_paths',
+    title: 'Move paths',
+    description: 'Move or rename two or more files/directories in one batch, each with its own source and destination. Falls back to copy-and-delete across filesystems. For one source/destination pair use move_file.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        paths: {
+          type: 'array',
+          description: 'Pairs to move, at most 200 per call.',
+          items: {
+            type: 'object',
+            properties: {
+              source: { type: 'string', description: 'Absolute path to move.' },
+              destination: { type: 'string', description: 'Absolute destination path.' },
+            },
+            required: ['source', 'destination'],
+            additionalProperties: false,
+          },
+        },
+        overwrite: { type: 'boolean', description: 'Replace an existing destination. Default true.' },
+      },
+      required: ['paths'],
+      additionalProperties: false,
+    },
+    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
+    handler: fileToolHandlers.move_paths,
+  },
+  {
+    name: 'delete_path',
+    title: 'Delete path',
+    description: 'Delete exactly one file or directory. Directories are removed with their contents unless recursive is false; the filesystem root is refused. Use delete_paths for two or more targets, or move_to_trash when deletion should be reversible.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'Absolute path to delete.' },
+        recursive: { type: 'boolean', description: 'Delete a non-empty directory with its contents. Default true.' },
+      },
+      required: ['path'],
+      additionalProperties: false,
+    },
+    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
+    handler: fileToolHandlers.delete_path,
+  },
+  {
+    name: 'delete_paths',
+    title: 'Delete paths',
+    description: 'Delete two or more files/directories in one batch and report each result. For one target use delete_path. Use move_to_trash instead when deletion should be reversible.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        paths: { type: 'array', items: { type: 'string' }, description: 'Absolute paths to delete, at most 500 per call.' },
+        recursive: { type: 'boolean', description: 'Delete non-empty directories with their contents. Default true.' },
+      },
+      required: ['paths'],
+      additionalProperties: false,
+    },
+    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
+    handler: fileToolHandlers.delete_paths,
+  },
+  {
+    name: 'create_archive',
+    title: 'Create archive',
+    description: 'Pack files and directories into a tar, tar.gz, or zip archive on the device, so a whole tree can be transferred or backed up in one call.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        paths: { type: 'array', items: { type: 'string' }, description: 'Absolute paths of the files and directories to include.' },
+        destination: { type: 'string', description: 'Absolute path of the archive to create.' },
+        format: { type: 'string', enum: ['tar', 'tar.gz', 'zip'], description: 'Archive format. Default tar.gz, or zip when the destination ends in .zip.' },
+      },
+      required: ['paths', 'destination'],
+      additionalProperties: false,
+    },
+    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
+    handler: fileToolHandlers.create_archive,
+  },
+  {
+    name: 'extract_archive',
+    title: 'Extract archive',
+    description: 'Extract a tar, tar.gz, tar.bz2, tar.xz, or zip archive on the device into a directory, creating it when needed.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        archive: { type: 'string', description: 'Absolute path of the archive to extract.' },
+        destination: { type: 'string', description: 'Absolute directory to extract into. Defaults to the archive directory.' },
+      },
+      required: ['archive'],
+      additionalProperties: false,
+    },
+    annotations: mutating,
+    handler: fileToolHandlers.extract_archive,
+  },
+  {
+    name: 'take_screenshot',
+    title: 'Take screenshot',
+    description: 'Capture the entire desktop only when full-screen pixels are actually needed. Prefer ui_snapshot or browser_snapshot for semantic inspection, and screenshot_region for one window, monitor, or rectangle. This tool uses the platform screenshot portal/utility and returns an image.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        directory: { type: 'string', description: 'Absolute directory to write the temporary PNG into. Defaults to the system temp directory.' },
+        keep: { type: 'boolean', description: 'Keep the PNG on disk instead of deleting it after it is returned. Default false.' },
+      },
+      additionalProperties: false,
+    },
+    // keep=true and oversized fallbacks persist a timestamped PNG, so a repeated call can add files.
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+    handler: fileToolHandlers.take_screenshot,
+  },
+  {
+    name: 'start_search',
+    title: 'Start search',
+    description: 'Start a filename or content search on this computer and return the first matches without reading every matched file in full. Use read_files instead when a glob is already known and the contents of all matching files are the desired result. Content searches return "path:line: text" rows. Use get_more_search_results to page and stop_search to stop a long search.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'Absolute path of the directory or file to search.' },
+        pattern: { type: 'string', description: 'Regular expression for content searches, or a glob such as "*.ts" when searchType is files.' },
+        searchType: { type: 'string', enum: ['content', 'files'], description: 'Search file contents (default) or file names.' },
+        filePattern: { type: 'string', description: 'Optional relative glob that limits which files are searched, such as "*.ts".' },
+        ignoreCase: { type: 'boolean', description: 'Case-insensitive content matching.' },
+        maxResults: { type: 'number', description: 'Stop the search after this many results. Default 200.' },
+        includeHidden: { type: 'boolean', description: 'Include hidden files and directories.' },
+        includeIgnored: { type: 'boolean', description: 'Also search directories normally skipped, such as node_modules, dist, build, and virtualenvs.' },
+        contextLines: { type: 'number', description: 'Number of context lines to return around each content match, up to 10.' },
+        literalSearch: { type: 'boolean', description: 'Treat the pattern as literal text instead of a regular expression.' },
+      },
+      required: ['path', 'pattern'],
+      additionalProperties: false,
+    },
+    annotations: readOnlyNonIdempotent,
+    handler: searchToolHandlers.start_search,
+  },
+  {
+    name: 'get_more_search_results',
+    title: 'Get more search results',
+    description: 'Read more results from a search started with start_search. Offset is zero-based; a negative offset returns the last N results.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        sessionId: { type: 'string', description: 'Search id returned by start_search.' },
+        offset: { type: 'number', description: 'Zero-based first result to return. Negative values read from the end.' },
+        length: { type: 'number', description: 'Maximum number of results to return. Default 100.' },
+      },
+      required: ['sessionId'],
+      additionalProperties: false,
+    },
+    annotations: readOnly,
+    handler: searchToolHandlers.get_more_search_results,
+  },
+  {
+    name: 'stop_search',
+    title: 'Stop search',
+    description: 'Stop a running search. Results collected so far stay readable until the search is cleaned up.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        sessionId: { type: 'string', description: 'Search id returned by start_search.' },
+      },
+      required: ['sessionId'],
+      additionalProperties: false,
+    },
+    annotations: additive,
+    handler: searchToolHandlers.stop_search,
+  },
+  {
+    name: 'list_searches',
+    title: 'List searches',
+    description: 'List active and recent searches on this computer with their status and result counts.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    annotations: readOnly,
+    handler: searchToolHandlers.list_searches,
+  },
+  {
+    name: 'start_process',
+    title: 'Start process',
+    description: 'Run a shell command, script, build, test suite, or terminal server and return its initial output. Prefer dedicated semantic tools for jobs they already cover: launch_app for GUI apps, service for service-manager operations, power_action for lock/sleep/restart/shutdown, network for routine network inspection/tests, event_log for OS logs, installed_apps for software inventory, environment for environment facts, and open_path/reveal_path for opening or revealing files. The process keeps running so read_process_output or interact_with_process can be used later.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        command: { type: 'string', description: 'Shell command to run.' },
+        timeout_ms: { type: 'number', description: 'How long to wait for initial output before returning, in milliseconds. Default 1000.' },
+      },
+      required: ['command'],
+      additionalProperties: false,
+    },
+    annotations: command,
+    outputSchema: START_PROCESS_OUTPUT_SCHEMA,
+    handler: terminalToolHandlers.start_process,
+  },
+  {
+    name: 'read_process_output',
+    title: 'Read process output',
+    description: 'Read buffered output from a session started with start_process. Without an offset it returns output produced since the previous read.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        pid: { type: 'number', description: 'Session pid returned by start_process.' },
+        offset: { type: 'number', description: 'Zero-based line number to start from, counted across everything the session has produced; a negative value reads the last N lines. Omit for new output. Lines evicted by the buffer cap are no longer available.' },
+        length: { type: 'number', description: 'Maximum number of lines to return.' },
+        timeout_ms: { type: 'number', description: 'How long to wait for new output when no offset is given, in milliseconds.' },
+      },
+      required: ['pid'],
+      additionalProperties: false,
+    },
+    // Reading without an explicit offset advances the session cursor, so retries can return
+    // different output even after the process exits. It never modifies user files.
+    annotations: readOnlyNonIdempotent,
+    outputSchema: READ_PROCESS_OUTPUT_SCHEMA,
+    handler: terminalToolHandlers.read_process_output,
+  },
+  {
+    name: 'interact_with_process',
+    title: 'Interact with process',
+    description: 'Send one line of input to a running session and return the output it produces. Use this for REPLs and other interactive commands.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        pid: { type: 'number', description: 'Session pid returned by start_process.' },
+        input: { type: 'string', description: 'Line of input to send; a newline is appended.' },
+        timeout_ms: { type: 'number', description: 'How long to wait for the response, in milliseconds. Default 1000.' },
+      },
+      required: ['pid', 'input'],
+      additionalProperties: false,
+    },
+    annotations: command,
+    outputSchema: INTERACT_PROCESS_OUTPUT_SCHEMA,
+    handler: terminalToolHandlers.interact_with_process,
+  },
+  {
+    name: 'wait_for_process_output',
+    title: 'Wait for process output',
+    description: 'Wait until output from a running session matches a regular expression or literal string, then return the output collected since the previous read. Use this instead of polling read_process_output in a loop.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        pid: { type: 'number', description: 'Session pid returned by start_process.' },
+        pattern: { type: 'string', description: 'Regular expression or literal text to wait for.' },
+        timeout_ms: { type: 'number', description: 'How long to wait before returning the output collected so far, in milliseconds. Default 10000.' },
+      },
+      required: ['pid', 'pattern'],
+      additionalProperties: false,
+    },
+    annotations: readOnlyNonIdempotent,
+    outputSchema: WAIT_PROCESS_OUTPUT_SCHEMA,
+    handler: terminalToolHandlers.wait_for_process_output,
+  },
+  {
+    name: 'force_terminate',
+    title: 'Stop session',
+    description: 'Stop a ReMCP terminal session started with start_process, escalating from SIGTERM to SIGKILL when it does not exit. Use kill_process for an arbitrary operating-system PID that is not a ReMCP terminal session.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        pid: { type: 'number', description: 'Session pid returned by start_process.' },
+      },
+      required: ['pid'],
+      additionalProperties: false,
+    },
+    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
+    outputSchema: TERMINATE_PROCESS_OUTPUT_SCHEMA,
+    handler: terminalToolHandlers.force_terminate,
+  },
+  {
+    name: 'list_sessions',
+    title: 'List sessions',
+    description: 'List only terminal sessions started through ReMCP start_process, with status and runtime. Use list_processes for the computer-wide operating-system process list.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    annotations: readOnly,
+    outputSchema: LIST_SESSIONS_OUTPUT_SCHEMA,
+    handler: terminalToolHandlers.list_sessions,
+  },
+  {
+    name: 'get_system_info',
+    title: 'Get system info',
+    description: 'Report machine health and host facts for the paired computer: operating system and kernel, CPU model/load, memory pressure, free disk space, uptime, and default shell. Use environment for PATH/shell/runtime environment variables and get_runtime_info for ReMCP-specific version, policy, roots, and limits.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    annotations: readOnly,
+    handler: systemToolHandlers.get_system_info,
+  },
+  {
+    name: 'list_processes',
+    title: 'List processes',
+    description: 'List the computer-wide operating-system processes, highest CPU first, with pid, parent pid, CPU/memory usage, and command. Use list_sessions when the question is only about commands started through ReMCP start_process. Values that look like secrets are masked.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        limit: { type: 'number', description: 'Maximum number of processes to return. Default 100, maximum 1000.' },
+      },
+      additionalProperties: false,
+    },
+    annotations: readOnly,
+    handler: systemToolHandlers.list_processes,
+  },
+  {
+    name: 'kill_process',
+    title: 'Kill process',
+    description: 'Terminate an arbitrary operating-system process by pid. If the pid belongs to a ReMCP terminal session created by start_process, prefer force_terminate so ReMCP updates the session consistently and handles its process tree. Terminates the process and its children on Windows.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        pid: { type: 'number', description: 'Process id to terminate.' },
+      },
+      required: ['pid'],
+      additionalProperties: false,
+    },
+    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
+    handler: systemToolHandlers.kill_process,
+  },
+  {
+    name: 'get_runtime_info',
+    title: 'Get runtime info',
+    description: 'Report this computer\'s local ReMCP runtime: version, allowed roots, command policy, output limits, settable preferences, and usage-metric setting. Use get_system_info for OS/CPU/memory/disk facts and hosted get_configuration for deployment/account configuration. Read-only; use set_config_value only for telemetryEnabled, maxReadLines, maxBufferedLines, or maxOutputBytes. Access roots and command security stay local to the computer.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    annotations: readOnly,
+    handler: statsToolHandlers.get_runtime_info,
+  },
+  {
+    name: 'get_runtime_stats',
+    title: 'Get runtime stats',
+    description: 'Report counters from the current local runtime session on this machine: tool calls/failures, blocked commands, active terminal/search sessions, and usage-metric queue state. Use hosted get_usage_statistics for account-level historical usage aggregated across devices and days.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    annotations: readOnly,
+    handler: statsToolHandlers.get_runtime_stats,
+  },
+  {
+    name: 'set_config_value',
+    title: 'Change runtime setting',
+    description: 'Change one of this local runtime’s own preferences on the selected computer: telemetryEnabled, maxReadLines, maxBufferedLines or maxOutputBytes. This is not account-level device administration; use hosted device_action for ping, rename, enable/disable or removal. Access roots, blocked commands, shell/guardrails and the write limit remain local-only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        key: { type: 'string', description: 'telemetryEnabled (true/false), maxReadLines, maxBufferedLines or maxOutputBytes.' },
+        value: { description: 'New value: a boolean for telemetryEnabled, a number for the limits.' },
+      },
+      required: ['key', 'value'],
+      additionalProperties: false,
+    },
+    // Preference only, and the same call twice leaves the same state.
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    handler: configToolHandlers.set_config_value,
+  },
+];

package/src/core-catalog-shared.mjs

@@ -0,0 +1,92 @@
+import { archiveBackendAvailable, fileToolHandlers } from './tools/files.mjs';
+import { searchToolHandlers } from './tools/search.mjs';
+import { terminalToolHandlers } from './tools/terminal.mjs';
+import { systemToolHandlers } from './tools/system.mjs';
+import { statsToolHandlers } from './tools/stats.mjs';
+import { configToolHandlers } from './tools/config.mjs';
+
+// Every tool answers with a text result (image tools add an image part as well), so the
+// declared output schema is the same shape everywhere and clients can rely on it.
+export const TEXT_OUTPUT_SCHEMA = {
+  type: 'object',
+  properties: {
+    text: { type: 'string', description: 'Human-readable result of the tool call.' },
+  },
+  required: ['text'],
+  additionalProperties: false,
+};
+
+export const NULLABLE_NUMBER_SCHEMA = { anyOf:[{ type:'number' }, { type:'null' }] };
+export const NULLABLE_STRING_SCHEMA = { anyOf:[{ type:'string' }, { type:'null' }] };
+export const TERMINAL_SESSION_PROPERTIES = {
+  pid:{ type:'number', description:'Process/session id used by follow-up terminal tools.' },
+  status:{ type:'string', description:'running or exited, with an exit code/signal when known.' },
+  runtimeMs:{ type:'number' },
+  lines:{ type:'number', description:'Total output lines produced by the session.' },
+  exited:{ type:'boolean' },
+  exitCode:NULLABLE_NUMBER_SCHEMA,
+  signal:NULLABLE_STRING_SCHEMA,
+};
+function terminalOutputSchema(extraProperties = {}, extraRequired = []) {
+  return {
+    type:'object',
+    properties:{ ...TERMINAL_SESSION_PROPERTIES, ...extraProperties },
+    required:['pid','status','runtimeMs','lines','exited','exitCode','signal', ...extraRequired],
+    additionalProperties:false,
+  };
+}
+export const START_PROCESS_OUTPUT_SCHEMA = terminalOutputSchema({
+  command:{ type:'string' },
+  output:{ type:'string' },
+  partial:{ type:'string' },
+  warning:{ type:'string' },
+}, ['command','output']);
+export const READ_PROCESS_OUTPUT_SCHEMA = terminalOutputSchema({
+  range:{ type:'string' },
+  output:{ type:'string' },
+  explicitOffset:{ type:'boolean' },
+}, ['range','output','explicitOffset']);
+export const WAIT_PROCESS_OUTPUT_SCHEMA = terminalOutputSchema({
+  pattern:{ type:'string' },
+  matched:{ type:'boolean' },
+  bufferedMatch:{ type:'boolean' },
+  timeoutMs:{ type:'number' },
+  output:{ type:'string' },
+}, ['pattern','matched','bufferedMatch','timeoutMs','output']);
+export const INTERACT_PROCESS_OUTPUT_SCHEMA = terminalOutputSchema({
+  output:{ type:'string' },
+}, ['output']);
+export const TERMINATE_PROCESS_OUTPUT_SCHEMA = terminalOutputSchema({
+  terminated:{ type:'boolean' },
+  alreadyExited:{ type:'boolean' },
+  escalated:{ type:'boolean' },
+}, ['terminated','alreadyExited','escalated']);
+export const LIST_SESSIONS_OUTPUT_SCHEMA = {
+  type:'object',
+  properties:{
+    sessions:{
+      type:'array',
+      items:{
+        type:'object',
+        properties:{
+          ...TERMINAL_SESSION_PROPERTIES,
+          blocked:{ type:'string' },
+          command:{ type:'string' },
+        },
+        required:['pid','status','runtimeMs','lines','exited','exitCode','signal','blocked','command'],
+        additionalProperties:false,
+      },
+    },
+  },
+  required:['sessions'],
+  additionalProperties:false,
+};
+
+export const readOnly = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+export const readOnlyNonIdempotent = { readOnlyHint: true, destructiveHint: false, idempotentHint: false, openWorldHint: false };
+export const additive = { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+export const mutating = { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false };
+export const command = { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true };
+
+
+export { archiveBackendAvailable, fileToolHandlers, searchToolHandlers, terminalToolHandlers, systemToolHandlers, statsToolHandlers, configToolHandlers };