@remcp/runtime 0.2.47 → 0.2.48

package/src/helpers/wayland-eis-helper.py

@@ -0,0 +1,450 @@
+#!/usr/bin/env python3
+"""ReMCP XDG RemoteDesktop + libei sender helper.
+
+Owns the portal session and EIS file descriptor in one process so SCM_RIGHTS never
+has to cross Node's net.Socket implementation. JSON-lines are used only between
+this helper and the local ReMCP runtime.
+"""
+import ctypes
+import json
+import os
+import select
+import sys
+import time
+
+try:
+    import gi
+    gi.require_version("Gio", "2.0")
+    from gi.repository import Gio, GLib
+except Exception as exc:
+    print(json.dumps({"ready": False, "kind": "unsupported", "error": f"PyGObject/Gio unavailable: {exc}"}), flush=True)
+    sys.exit(78)
+
+PORTAL_NAME = "org.freedesktop.portal.Desktop"
+PORTAL_PATH = "/org/freedesktop/portal/desktop"
+REMOTE_IFACE = "org.freedesktop.portal.RemoteDesktop"
+REQUEST_IFACE = "org.freedesktop.portal.Request"
+SESSION_IFACE = "org.freedesktop.portal.Session"
+DEVICE_TYPES = 1 | 2  # keyboard | pointer in the portal API
+
+EI_CAP_POINTER = 1 << 0
+EI_CAP_POINTER_ABSOLUTE = 1 << 1
+EI_CAP_KEYBOARD = 1 << 2
+EI_CAP_SCROLL = 1 << 4
+EI_CAP_BUTTON = 1 << 5
+EI_EVENT_CONNECT = 1
+EI_EVENT_DISCONNECT = 2
+EI_EVENT_SEAT_ADDED = 3
+EI_EVENT_SEAT_REMOVED = 4
+EI_EVENT_DEVICE_ADDED = 5
+EI_EVENT_DEVICE_REMOVED = 6
+EI_EVENT_DEVICE_PAUSED = 7
+EI_EVENT_DEVICE_RESUMED = 8
+
+
+def emit(payload):
+    sys.stdout.write(json.dumps(payload, separators=(",", ":"), ensure_ascii=False) + "\n")
+    sys.stdout.flush()
+
+
+def deep_unwrap(value):
+    if isinstance(value, GLib.Variant):
+        return deep_unwrap(value.unpack())
+    if isinstance(value, dict):
+        return {str(k): deep_unwrap(v) for k, v in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [deep_unwrap(v) for v in value]
+    return value
+
+
+def token(prefix):
+    return f"{prefix}_{os.getpid()}_{time.monotonic_ns()}".replace("-", "_")
+
+
+class Portal:
+    def __init__(self, timeout_ms):
+        self.timeout_ms = timeout_ms
+        self.conn = Gio.bus_get_sync(Gio.BusType.SESSION, None)
+        self.context = GLib.MainContext.default()
+        self.responses = {}
+        self.session = None
+        self.subscription = self.conn.signal_subscribe(
+            PORTAL_NAME,
+            REQUEST_IFACE,
+            "Response",
+            None,
+            None,
+            Gio.DBusSignalFlags.NONE,
+            self._on_response,
+        )
+
+    def _on_response(self, _conn, _sender, object_path, _iface, _signal, params, _data=None):
+        try:
+            response, results = params.unpack()
+            self.responses[object_path] = (int(response), deep_unwrap(results))
+        except Exception as exc:
+            self.responses[object_path] = (2, {"error": str(exc)})
+
+    def _wait_response(self, request_path):
+        deadline = time.monotonic() + self.timeout_ms / 1000.0
+        while time.monotonic() < deadline:
+            while self.context.pending():
+                self.context.iteration(False)
+            if request_path in self.responses:
+                response, results = self.responses.pop(request_path)
+                if response == 1:
+                    raise RuntimeError("portal request cancelled")
+                if response != 0:
+                    raise RuntimeError(f"portal request denied (response {response})")
+                return results
+            self.context.iteration(False)
+            time.sleep(0.01)
+        raise TimeoutError(f"portal request timed out after {self.timeout_ms} ms")
+
+    def request(self, method, params):
+        reply = self.conn.call_sync(
+            PORTAL_NAME,
+            PORTAL_PATH,
+            REMOTE_IFACE,
+            method,
+            params,
+            GLib.VariantType.new("(o)"),
+            Gio.DBusCallFlags.NONE,
+            min(self.timeout_ms, 10000),
+            None,
+        )
+        request_path = reply.unpack()[0]
+        return self._wait_response(request_path)
+
+    def open(self, restore_token="", parent_window=""):
+        create_opts = {
+            "handle_token": GLib.Variant("s", token("create")),
+            "session_handle_token": GLib.Variant("s", token("session")),
+        }
+        created = self.request("CreateSession", GLib.Variant("(a{sv})", (create_opts,)))
+        self.session = created.get("session_handle")
+        if not isinstance(self.session, str) or not self.session.startswith("/"):
+            raise RuntimeError("portal returned no session handle")
+
+        select_opts = {
+            "handle_token": GLib.Variant("s", token("select")),
+            "types": GLib.Variant("u", DEVICE_TYPES),
+            "persist_mode": GLib.Variant("u", 2),
+        }
+        if restore_token:
+            select_opts["restore_token"] = GLib.Variant("s", restore_token)
+        self.request("SelectDevices", GLib.Variant("(oa{sv})", (self.session, select_opts)))
+
+        start_opts = {"handle_token": GLib.Variant("s", token("start"))}
+        started = self.request("Start", GLib.Variant("(osa{sv})", (self.session, parent_window or "", start_opts)))
+        devices = int(started.get("devices", 0))
+        if devices & DEVICE_TYPES != DEVICE_TYPES:
+            raise RuntimeError(f"portal did not grant keyboard and pointer access (devices={devices})")
+        return devices, str(started.get("restore_token") or "")
+
+    def connect_eis(self):
+        if not self.session:
+            raise RuntimeError("portal session is not open")
+        reply, fd_list = self.conn.call_with_unix_fd_list_sync(
+            PORTAL_NAME,
+            PORTAL_PATH,
+            REMOTE_IFACE,
+            "ConnectToEIS",
+            GLib.Variant("(oa{sv})", (self.session, {})),
+            GLib.VariantType.new("(h)"),
+            Gio.DBusCallFlags.NONE,
+            min(self.timeout_ms, 10000),
+            None,
+            None,
+        )
+        handle = int(reply.unpack()[0])
+        fd = fd_list.get(handle)
+        if fd < 0:
+            raise RuntimeError("ConnectToEIS returned an invalid file descriptor")
+        return fd
+
+    def close(self):
+        if self.session:
+            try:
+                self.conn.call_sync(
+                    PORTAL_NAME,
+                    self.session,
+                    SESSION_IFACE,
+                    "Close",
+                    None,
+                    None,
+                    Gio.DBusCallFlags.NONE,
+                    3000,
+                    None,
+                )
+            except Exception:
+                pass
+            self.session = None
+        try:
+            self.conn.signal_unsubscribe(self.subscription)
+        except Exception:
+            pass
+
+
+class EiSender:
+    def __init__(self, fd):
+        self.lib = ctypes.CDLL("libei.so.1")
+        c_void_p = ctypes.c_void_p
+        self.lib.ei_new_sender.argtypes = [c_void_p]
+        self.lib.ei_new_sender.restype = c_void_p
+        self.lib.ei_configure_name.argtypes = [c_void_p, ctypes.c_char_p]
+        self.lib.ei_setup_backend_fd.argtypes = [c_void_p, ctypes.c_int]
+        self.lib.ei_setup_backend_fd.restype = ctypes.c_int
+        self.lib.ei_get_fd.argtypes = [c_void_p]
+        self.lib.ei_get_fd.restype = ctypes.c_int
+        self.lib.ei_dispatch.argtypes = [c_void_p]
+        self.lib.ei_get_event.argtypes = [c_void_p]
+        self.lib.ei_get_event.restype = c_void_p
+        self.lib.ei_event_get_type.argtypes = [c_void_p]
+        self.lib.ei_event_get_type.restype = ctypes.c_int
+        self.lib.ei_event_get_seat.argtypes = [c_void_p]
+        self.lib.ei_event_get_seat.restype = c_void_p
+        self.lib.ei_event_get_device.argtypes = [c_void_p]
+        self.lib.ei_event_get_device.restype = c_void_p
+        self.lib.ei_event_unref.argtypes = [c_void_p]
+        self.lib.ei_event_unref.restype = c_void_p
+        self.lib.ei_device_ref.argtypes = [c_void_p]
+        self.lib.ei_device_ref.restype = c_void_p
+        self.lib.ei_device_unref.argtypes = [c_void_p]
+        self.lib.ei_device_unref.restype = c_void_p
+        self.lib.ei_device_has_capability.argtypes = [c_void_p, ctypes.c_int]
+        self.lib.ei_device_has_capability.restype = ctypes.c_bool
+        self.lib.ei_device_start_emulating.argtypes = [c_void_p, ctypes.c_uint32]
+        self.lib.ei_device_stop_emulating.argtypes = [c_void_p]
+        self.lib.ei_device_keyboard_key.argtypes = [c_void_p, ctypes.c_uint32, ctypes.c_bool]
+        self.lib.ei_device_pointer_motion.argtypes = [c_void_p, ctypes.c_double, ctypes.c_double]
+        self.lib.ei_device_button_button.argtypes = [c_void_p, ctypes.c_uint32, ctypes.c_bool]
+        self.lib.ei_device_scroll_discrete.argtypes = [c_void_p, ctypes.c_int32, ctypes.c_int32]
+        self.lib.ei_device_frame.argtypes = [c_void_p, ctypes.c_uint64]
+        self.lib.ei_now.argtypes = [c_void_p]
+        self.lib.ei_now.restype = ctypes.c_uint64
+        self.lib.ei_unref.argtypes = [c_void_p]
+        self.lib.ei_unref.restype = c_void_p
+        self.lib.ei_seat_has_capability.argtypes = [c_void_p, ctypes.c_int]
+        self.lib.ei_seat_has_capability.restype = ctypes.c_bool
+        # ei_seat_bind_capabilities is varargs: keep argtypes unset.
+        self.lib.ei_seat_bind_capabilities.restype = None
+
+        self.ei = self.lib.ei_new_sender(None)
+        if not self.ei:
+            raise RuntimeError("ei_new_sender failed")
+        self.lib.ei_configure_name(self.ei, b"ReMCP")
+        rc = int(self.lib.ei_setup_backend_fd(self.ei, fd))
+        if rc < 0:
+            raise RuntimeError(f"ei_setup_backend_fd failed ({rc})")
+        self.fd = int(self.lib.ei_get_fd(self.ei))
+        if self.fd < 0:
+            raise RuntimeError("ei_get_fd failed")
+        self.devices = {}
+        self.sequence = 1
+        self.connected = False
+
+    def _device_key(self, ptr):
+        return int(ptr or 0)
+
+    def _remember_device(self, ptr):
+        key = self._device_key(ptr)
+        if not key:
+            return None
+        if key not in self.devices:
+            retained = self.lib.ei_device_ref(ptr)
+            self.devices[key] = {"ptr": retained, "resumed": False, "emulating": False}
+        return self.devices[key]
+
+    def _drop_device(self, ptr):
+        key = self._device_key(ptr)
+        state = self.devices.pop(key, None)
+        if state:
+            if state["emulating"]:
+                try:
+                    self.lib.ei_device_stop_emulating(state["ptr"])
+                except Exception:
+                    pass
+            self.lib.ei_device_unref(state["ptr"])
+
+    def _bind_seat(self, seat):
+        caps = [EI_CAP_POINTER, EI_CAP_POINTER_ABSOLUTE, EI_CAP_KEYBOARD, EI_CAP_SCROLL, EI_CAP_BUTTON]
+        args = [ctypes.c_void_p(seat)]
+        args.extend(ctypes.c_int(cap) for cap in caps if self.lib.ei_seat_has_capability(seat, cap))
+        args.append(ctypes.c_void_p())
+        self.lib.ei_seat_bind_capabilities(*args)
+
+    def process_events(self):
+        self.lib.ei_dispatch(self.ei)
+        while True:
+            event = self.lib.ei_get_event(self.ei)
+            if not event:
+                break
+            try:
+                event_type = int(self.lib.ei_event_get_type(event))
+                if event_type == EI_EVENT_CONNECT:
+                    self.connected = True
+                elif event_type == EI_EVENT_DISCONNECT:
+                    raise RuntimeError("EIS server disconnected")
+                elif event_type == EI_EVENT_SEAT_ADDED:
+                    seat = self.lib.ei_event_get_seat(event)
+                    if seat:
+                        self._bind_seat(seat)
+                elif event_type == EI_EVENT_DEVICE_ADDED:
+                    device = self.lib.ei_event_get_device(event)
+                    if device:
+                        self._remember_device(device)
+                elif event_type == EI_EVENT_DEVICE_RESUMED:
+                    device = self.lib.ei_event_get_device(event)
+                    state = self._remember_device(device)
+                    if state:
+                        state["resumed"] = True
+                        if not state["emulating"]:
+                            self.lib.ei_device_start_emulating(state["ptr"], self.sequence)
+                            self.sequence = (self.sequence + 1) & 0xFFFFFFFF or 1
+                            state["emulating"] = True
+                elif event_type == EI_EVENT_DEVICE_PAUSED:
+                    device = self.lib.ei_event_get_device(event)
+                    state = self.devices.get(self._device_key(device))
+                    if state:
+                        state["resumed"] = False
+                        state["emulating"] = False
+                elif event_type == EI_EVENT_DEVICE_REMOVED:
+                    self._drop_device(self.lib.ei_event_get_device(event))
+            finally:
+                self.lib.ei_event_unref(event)
+
+    def wait_ready(self, timeout_s=10.0):
+        deadline = time.monotonic() + timeout_s
+        while time.monotonic() < deadline:
+            if (
+                self.connected
+                and self.capability_ready(EI_CAP_KEYBOARD)
+                and self.capability_ready(EI_CAP_POINTER)
+                and self.capability_ready(EI_CAP_BUTTON)
+                and self.capability_ready(EI_CAP_SCROLL)
+            ):
+                return
+            readable, _, _ = select.select([self.fd], [], [], min(0.1, max(0.0, deadline - time.monotonic())))
+            if readable:
+                self.process_events()
+        raise TimeoutError(f"EIS devices did not become ready; capabilities={self.capabilities()}")
+
+    def capability_ready(self, cap):
+        return any(state["resumed"] and self.lib.ei_device_has_capability(state["ptr"], cap) for state in self.devices.values())
+
+    def capabilities(self):
+        names = {
+            EI_CAP_POINTER: "pointer",
+            EI_CAP_POINTER_ABSOLUTE: "pointer_absolute",
+            EI_CAP_KEYBOARD: "keyboard",
+            EI_CAP_SCROLL: "scroll",
+            EI_CAP_BUTTON: "button",
+        }
+        return {name: self.capability_ready(cap) for cap, name in names.items()}
+
+    def device_for(self, cap):
+        for state in self.devices.values():
+            if state["resumed"] and state["emulating"] and self.lib.ei_device_has_capability(state["ptr"], cap):
+                return state["ptr"]
+        raise RuntimeError(f"no resumed EIS device with capability {cap}")
+
+    def frame(self, device):
+        self.lib.ei_device_frame(device, self.lib.ei_now(self.ei))
+
+    def command(self, payload):
+        op = str(payload.get("op") or "")
+        if op == "key":
+            device = self.device_for(EI_CAP_KEYBOARD)
+            self.lib.ei_device_keyboard_key(device, int(payload["keycode"]), bool(payload.get("pressed")))
+            self.frame(device)
+        elif op == "motion":
+            device = self.device_for(EI_CAP_POINTER)
+            self.lib.ei_device_pointer_motion(device, float(payload.get("dx", 0)), float(payload.get("dy", 0)))
+            self.frame(device)
+        elif op == "button":
+            device = self.device_for(EI_CAP_BUTTON)
+            self.lib.ei_device_button_button(device, int(payload["button"]), bool(payload.get("pressed")))
+            self.frame(device)
+        elif op == "scroll":
+            device = self.device_for(EI_CAP_SCROLL)
+            self.lib.ei_device_scroll_discrete(device, int(payload.get("dx", 0)), int(payload.get("dy", 0)))
+            self.frame(device)
+        elif op == "ping":
+            pass
+        elif op == "close":
+            return False
+        else:
+            raise ValueError(f"unsupported EIS operation: {op}")
+        return True
+
+    def close(self):
+        for state in list(self.devices.values()):
+            if state["emulating"]:
+                try:
+                    self.lib.ei_device_stop_emulating(state["ptr"])
+                except Exception:
+                    pass
+            try:
+                self.lib.ei_device_unref(state["ptr"])
+            except Exception:
+                pass
+        self.devices.clear()
+        if self.ei:
+            self.lib.ei_unref(self.ei)
+            self.ei = None
+
+
+def main():
+    timeout_ms = max(1000, min(120000, int(os.environ.get("REMCP_EIS_TIMEOUT_MS", "30000"))))
+    restore_token = os.environ.get("REMCP_EIS_RESTORE_TOKEN", "")
+    parent_window = os.environ.get("REMCP_EIS_PARENT_WINDOW", "")
+    portal = None
+    sender = None
+    try:
+        portal = Portal(timeout_ms)
+        devices, new_restore_token = portal.open(restore_token, parent_window)
+        eis_fd = portal.connect_eis()
+        sender = EiSender(eis_fd)
+        sender.wait_ready(min(10.0, timeout_ms / 1000.0))
+        emit({
+            "ready": True,
+            "backend": "xdg-eis",
+            "devices": devices,
+            "restore_token": new_restore_token,
+            "capabilities": sender.capabilities(),
+        })
+
+        running = True
+        while running:
+            readable, _, _ = select.select([sys.stdin, sender.fd], [], [], 0.5)
+            if sender.fd in readable:
+                sender.process_events()
+            if sys.stdin in readable:
+                line = sys.stdin.readline()
+                if line == "":
+                    break
+                request = None
+                try:
+                    request = json.loads(line)
+                    request_id = request.get("id")
+                    running = sender.command(request)
+                    emit({"id": request_id, "ok": True, "capabilities": sender.capabilities()})
+                except Exception as exc:
+                    emit({"id": request.get("id") if isinstance(request, dict) else None, "ok": False, "error": str(exc)})
+    except OSError as exc:
+        emit({"ready": False, "kind": "unsupported", "error": f"libei unavailable: {exc}"})
+        return 78
+    except Exception as exc:
+        emit({"ready": False, "kind": "runtime", "error": str(exc)})
+        return 1
+    finally:
+        if sender:
+            sender.close()
+        if portal:
+            portal.close()
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/src/index.mjs

@@ -2,18 +2,25 @@
 import process from 'node:process';
 import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
-import { advertisedTools, toolDefinitions } from './catalog.mjs';
+import { advertisedTools as advertisedCoreTools, toolDefinitions as coreToolDefinitions } from './catalog.mjs';
+import { allExtendedTools, advertisedExtendedTools, extendedToolDefinitions } from './extended/catalog.mjs';
 import { describeConfig, configurationError, runtimeConfigDir } from './config.mjs';
-import { invokeTool } from './invoke.mjs';
 import { shutdownSessions, startSessionSweeper } from './sessions.mjs';
 import { flush, setTelemetrySink, shutdownTelemetry, telemetryEnabled } from './telemetry.mjs';
 import { VERSION } from './version.mjs';
 
-// The MCP SDK is imported lazily so that `--help`, `--version`, `--print-tools` and
-// `--describe` work from a bare checkout or a published tarball with no node_modules.
-// That is what lets CI diff the advertised tool contract against the package users get.
-
 const args = process.argv.slice(2);
+const allToolDefinitions = [...coreToolDefinitions, ...extendedToolDefinitions];
+
+async function advertisedRuntimeTools() {
+  return [...advertisedCoreTools(), ...await advertisedExtendedTools()];
+}
+
+async function writeStdout(value) {
+  await new Promise((resolve, reject) => {
+    process.stdout.write(value, error => error ? reject(error) : resolve());
+  });
+}
 
 if (args.includes('--help') || args.includes('-h')) {
   process.stdout.write([
@@ -22,7 +29,10 @@ if (args.includes('--help') || args.includes('-h')) {
     'Usage: remcp-runtime [--print-tools] [--describe] [--version]',
     '',
     'The runtime is normally started by the ReMCP device agent and speaks MCP over stdio.',
-    'It executes file, search, terminal, and process tools locally on this computer.',
+    'It executes file, search, terminal, process, desktop UI, browser, diagnostics, and document tools locally on this computer.',
+    '',
+    'Desktop capabilities are detected from the operating system and available native helpers.',
+    'The live MCP tool list changes when optional capabilities appear or disappear.',
     '',
     'Usage metrics are opt-out: only tool names, timings and outcomes are collected, and they',
     'travel to your own ReMCP account through the already-authenticated paired agent. Nothing is',
@@ -40,18 +50,22 @@ if (args.includes('--version')) {
 }
 
 if (args.includes('--print-tools')) {
-  process.stdout.write(`${JSON.stringify(advertisedTools(), null, 2)}\n`);
+  await writeStdout(`${JSON.stringify([...advertisedCoreTools(), ...allExtendedTools()], null, 2)}\n`);
   process.exit(0);
 }
 
 if (args.includes('--describe')) {
-  process.stdout.write(`${JSON.stringify({ version: VERSION, tools: toolDefinitions.length, ...describeConfig() }, null, 2)}\n`);
+  const supportedTools = (await advertisedRuntimeTools()).length;
+  await writeStdout(`${JSON.stringify({
+    version: VERSION,
+    tools: allToolDefinitions.length,
+    supportedTools,
+    extendedTools: extendedToolDefinitions.length,
+    ...describeConfig(),
+  }, null, 2)}\n`);
   process.exit(0);
 }
 
-// A configuration file the user cannot read must not be ignored: that is how allowedRoots
-// and an opt-out quietly disappear. Metadata commands above still work, so an operator can
-// inspect the device; the server itself refuses to start.
 const configProblem = configurationError();
 if (configProblem) {
   console.error(`ReMCP runtime refuses to start: ${configProblem}`);
@@ -69,33 +83,26 @@ function announceTelemetryOnce() {
   console.error('ReMCP runtime: anonymous usage metrics are on (tool names, timings, outcomes only - never file paths, commands or output). They go to your own ReMCP account through the paired agent. Disable with `remcp telemetry off`.');
 }
 
-const { Server } = await import('@modelcontextprotocol/sdk/server/index.js');
-const { StdioServerTransport } = await import('@modelcontextprotocol/sdk/server/stdio.js');
-const { CallToolRequestSchema, ListToolsRequestSchema } = await import('@modelcontextprotocol/sdk/types.js');
-
-const server = new Server(
-  { name: 'remcp-runtime', version: VERSION },
-  {
-    capabilities: { tools: {}, experimental: { 'remcp/telemetry': { version: 1, optOut: true } } },
-    instructions: [
-      'This runtime executes file, search, terminal, and process tools locally on a computer that its owner paired with ReMCP.',
-      'Inspect before changing: read and list first, then write, edit, move, or run commands only when the user asked for that side effect.',
-      'Paths are absolute or resolve against the runtime working directory; prefer absolute paths.',
-      'Commands matching the built-in catastrophic-command guardrail are refused before they run.',
-    ].join(' '),
+const runtimeInstructions = [
+  'This runtime executes file, search, terminal, process, desktop UI, browser, diagnostics, and document tools locally on a computer its owner paired with ReMCP.',
+  'Inspect before changing: read, snapshot, list or find first; then write, edit, click, move, launch, or run commands only when the user asked for that side effect.',
+  'Prefer accessibility or browser DOM targets over screen coordinates. Use screenshots as a visual fallback rather than the primary control plane.',
+  'Browser CDP endpoints are loopback-only; local file uploads and document operations still obey the runtime filesystem allowlist.',
+  'Paths are absolute or resolve against the runtime working directory; prefer absolute paths.',
+  'Commands matching the configured catastrophic-command guardrail are handled by the same policy layer as terminal commands.',
+].join(' ');
+
+const { startRuntimeMcpServer } = await import('./mcp-v2.mjs');
+const runtimeServer = await startRuntimeMcpServer({
+  version: VERSION,
+  instructions: runtimeInstructions,
+  onError(error) {
+    console.error(`ReMCP runtime MCP error: ${error instanceof Error ? error.message : String(error)}`);
   },
-);
-
-server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: advertisedTools() }));
-
-server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
-  return invokeTool(request.params.name, request.params.arguments, extra);
 });
 
-// Telemetry leaves this process only as an MCP notification to the agent that started
-// it. The runtime never opens a network connection of its own.
 setTelemetrySink(async payload => {
-  await server.notification({ method: 'notifications/remcp/telemetry', params: payload });
+  await runtimeServer.notification({ method: 'notifications/remcp/telemetry', params: payload });
 });
 
 const SHUTDOWN_BUDGET_MS = 1500;
@@ -106,19 +113,14 @@ async function shutdown(code = 0) {
   shutdownStarted = true;
   const deadline = Date.now() + SHUTDOWN_BUDGET_MS;
   shutdownSessions();
-  // The SDK gives a closing server about two seconds before it kills the process, so the
-  // telemetry flush is bounded and awaited instead of fire-and-forget: an unawaited
-  // notification() after close is an unhandled rejection.
   try {
     await Promise.race([flush(), new Promise(resolve => setTimeout(resolve, Math.max(0, deadline - Date.now())))]);
   } catch {}
   await shutdownTelemetry();
-  try { await server.close(); } catch {}
+  try { await runtimeServer.close(); } catch {}
   process.exit(code);
 }
 
-// A dead agent leaves a broken stdout pipe. Without this the process died on an
-// uncaught EPIPE with a stack trace and left its terminal children behind.
 process.stdout.on('error', error => {
   if (error?.code === 'EPIPE' || error?.code === 'ERR_STREAM_DESTROYED') void shutdown(0);
   else console.error(`ReMCP runtime stdout error: ${error instanceof Error ? error.message : String(error)}`);
@@ -134,8 +136,8 @@ process.on('SIGINT', () => void shutdown(0));
 process.on('SIGTERM', () => void shutdown(0));
 process.on('exit', () => { shutdownSessions(); });
 
-const transport = new StdioServerTransport();
-await server.connect(transport);
 startSessionSweeper();
 announceTelemetryOnce();
-console.error(`ReMCP runtime ${VERSION} ready with ${toolDefinitions.length} tools`);
+
+const supportedCount = (await advertisedRuntimeTools()).length;
+console.error(`ReMCP runtime ${VERSION} ready with ${supportedCount}/${allToolDefinitions.length} tools supported on this computer`);

package/src/invoke.mjs

@@ -1,10 +1,11 @@
 import { toolHandlers } from './catalog.mjs';
+import { extendedToolHandlers } from './extended/catalog.mjs';
 import { describeFilesystemFailure } from './permissions.mjs';
 import { recordEvent } from './telemetry.mjs';
 import { ToolError, text } from './util.mjs';
 
 export function hasTool(name) {
-  return toolHandlers.has(name);
+  return toolHandlers.has(name) || extendedToolHandlers.has(name);
 }
 
 function errorKind(error) {
@@ -15,7 +16,7 @@ function errorKind(error) {
 
 export async function invokeTool(name, args = {}, extra = {}) {
   const started = performance.now();
-  const definition = toolHandlers.get(name);
+  const definition = toolHandlers.get(name) || extendedToolHandlers.get(name);
   if (!definition) {
     recordEvent('tool_call', { tool: 'unknown_tool', success: false, errorKind: 'unknown_tool', durationMs: 0 });
     return text(`Unknown tool: ${name}`, true);
@@ -30,7 +31,6 @@ export async function invokeTool(name, args = {}, extra = {}) {
   } catch (error) {
     recordEvent('tool_call', { tool: definition.name, durationMs: performance.now() - started, success: false, errorKind: errorKind(error) });
     if (error instanceof ToolError) return text(error.message, true);
-    // A filesystem error arrives with a bare errno; the explanation is what the person can act on.
     return text(`Tool ${name} failed: ${describeFilesystemFailure(error, { path: error?.path })}`, true);
   }
 }