@remcp/runtime 0.2.121 → 0.2.123

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.2.123 — 2026-10-01
+
+- The compact local MCP facade now tracks live capability changes after startup. It advertises `tools.listChanged`, refreshes grouped input/output schemas, and adds or removes domains such as `control_browser` when loopback CDP becomes available or unavailable.
+- Compact and granular capability polling now serializes discovery passes so a slow probe cannot overlap the next interval and apply a stale capability result out of order.
+- The underlying 83 granular runtime tool names, input/output schemas, annotations, and handlers remain unchanged from 0.2.122.
+
+## 0.2.122 — 2026-09-30
+
+- No runtime tool names, schemas, or device-side implementations change in this release. The runtime package version remains in lockstep with the Windows bootstrap release, which pins the private Windows Node execution engine for reproducible installs.
+
 ## 0.2.121 — 2026-09-29
 
 - record_screen gains a GNOME Shell Screencast backend for GNOME Wayland, so a native GNOME desktop no longer needs wf-recorder merely to advertise and perform bounded screen recording. The backend keeps start/stop on one D-Bus connection and produces WebM.

package/README.md

@@ -27,7 +27,7 @@ npx @remcp/runtime              # granular capability-aware MCP server over stdi
 node ./src/compact.mjs --print-tools  # compact local façade for scanners/local MCP hosts
 ```
 
-`src/compact.mjs` is a second stdio entrypoint over the **same real handlers**. It advertises `read_file` plus up to seven `verb_noun` domain tools (`manage_files`, `run_terminal`, `control_computer`, `view_image`, `control_browser`, `manage_system`, `manage_documents`) and narrows each operation enum to capabilities available on the current host. It exists for directory scanners and local MCP hosts that benefit from a small selection surface; the paired ReMCP agent continues to use the granular capability-aware entrypoint.
+`src/compact.mjs` is a second stdio entrypoint over the **same real handlers**. It advertises `read_file` plus up to seven `verb_noun` domain tools (`manage_files`, `run_terminal`, `control_computer`, `view_image`, `control_browser`, `manage_system`, `manage_documents`) and narrows each operation enum to capabilities available on the current host. It also tracks capability changes while running: grouped schemas are refreshed and `notifications/tools/list_changed` is emitted when a domain appears, disappears, or changes membership. It exists for directory scanners and local MCP hosts that benefit from a small selection surface; the paired ReMCP agent continues to use the granular capability-aware entrypoint.
 
 ## Tools
 
@@ -81,7 +81,7 @@ example: they are enabled only while the runtime can use a supported loopback br
 The generated hosted reference covers the current **10 hosted production definitions**, all model-visible
 and routing to the 83 granular runtime operations described above; the optional widget-enabled surface is 15.
 The separate compact local stdio entrypoint advertises `read_file` plus up to seven domain tools
-(up to 8 tools total) while the paired agent keeps using the capability-aware granular runtime.
+(up to 8 tools total) and keeps those groups capability-aware at runtime with `tools/list_changed`; the paired agent keeps using the capability-aware granular runtime.
 See https://remcp.site/docs#tools and public `docs/TOOLS.md`.
 
 ## No approval staircase

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remcp/runtime",
-  "version": "0.2.121",
+  "version": "0.2.123",
   "description": "First-party ReMCP local device runtime: filesystem, terminal, computer-use, browser, diagnostics and document tools over MCP.",
   "type": "module",
   "license": "MIT",

package/src/compact-mcp.mjs

@@ -1,6 +1,14 @@
+import process from 'node:process';
 import { compactRuntimeToolDefinitions, resolveCompactRuntimeCall } from './compact-catalog.mjs';
 import { invokeTool } from './invoke.mjs';
 
+const DEFAULT_CAPABILITY_POLL_MS = 3000;
+
+function pollIntervalMs() {
+  const requested = Number(process.env.REMCP_CAPABILITY_POLL_MS);
+  return Math.min(60_000, Math.max(250, Number.isFinite(requested) && requested > 0 ? requested : DEFAULT_CAPABILITY_POLL_MS));
+}
+
 function toolConfig(definition, fromJsonSchema) {
   return {
     title:definition.title,
@@ -11,20 +19,45 @@ function toolConfig(definition, fromJsonSchema) {
   };
 }
 
+function toolUpdate(definition, fromJsonSchema) {
+  return {
+    title:definition.title,
+    description:definition.description,
+    paramsSchema:fromJsonSchema(definition.inputSchema || { type:'object' }),
+    ...(definition.outputSchema ? { outputSchema:fromJsonSchema(definition.outputSchema) } : {}),
+    annotations:definition.annotations,
+    enabled:true,
+  };
+}
+
+function definitionSignature(definition) {
+  if (!definition) return '';
+  return JSON.stringify({
+    title:definition.title,
+    description:definition.description,
+    inputSchema:definition.inputSchema,
+    outputSchema:definition.outputSchema,
+    annotations:definition.annotations,
+  });
+}
+
 export async function startCompactRuntimeMcpServer({ version, instructions, onError = () => {} } = {}) {
   const [{ McpServer, fromJsonSchema }, { serveStdio }] = await Promise.all([
     import('@modelcontextprotocol/server'),
     import('@modelcontextprotocol/server/stdio'),
   ]);
-  const definitions = await compactRuntimeToolDefinitions();
+  let definitions = await compactRuntimeToolDefinitions();
+  const currentDefinitions = new Map(definitions.map(definition => [definition.name, definition]));
   let activeServer = null;
+  let capabilityTimer = null;
+  let capabilityPollRunning = false;
   let closed = false;
 
   const serverHandle = serveStdio(() => {
     const server = new McpServer(
       { name:'remcp-runtime-compact', version },
       {
-        capabilities:{ tools:{} },
+        capabilities:{ tools:{ listChanged:true } },
         instructions,
         cacheHints:{
           'tools/list':{ ttlMs:3000, cacheScope:'private' },
@@ -33,20 +66,78 @@ export async function startCompactRuntimeMcpServer({ version, instructions, onEr
       },
     );
     activeServer = server;
-    for (const definition of definitions) {
-      server.registerTool(
+    const registrations = new Map();
+
+    const registerDefinition = definition => {
+      const registered = server.registerTool(
         definition.name,
         toolConfig(definition, fromJsonSchema),
         async (args, context) => {
           try {
-            const resolved = resolveCompactRuntimeCall(definition.name, args || {}, definitions);
+            const activeDefinitions = [...currentDefinitions.values()];
+            const resolved = resolveCompactRuntimeCall(definition.name, args || {}, activeDefinitions);
             return await invokeTool(resolved.runtimeName, resolved.runtimeArguments, { signal:context?.mcpReq?.signal });
           } catch (error) {
             return { content:[{ type:'text', text:error instanceof Error ? error.message : String(error) }], isError:true };
           }
         },
       );
-    }
+      registrations.set(definition.name, registered);
+      return registered;
+    };
+
+    for (const definition of definitions) registerDefinition(definition);
+
+    capabilityTimer = setInterval(async () => {
+      if (closed || capabilityPollRunning) return;
+      capabilityPollRunning = true;
+      try {
+        const nextDefinitions = await compactRuntimeToolDefinitions();
+        const nextByName = new Map(nextDefinitions.map(definition => [definition.name, definition]));
+        const names = new Set([...registrations.keys(), ...nextByName.keys()]);
+
+        for (const name of names) {
+          const before = currentDefinitions.get(name);
+          const after = nextByName.get(name);
+          const registered = registrations.get(name);
+
+          if (!after) {
+            currentDefinitions.delete(name);
+            if (registered?.enabled) registered.disable();
+            continue;
+          }
+
+          if (!registered) {
+            currentDefinitions.set(name, after);
+            registerDefinition(after);
+            continue;
+          }
+
+          if (definitionSignature(before) === definitionSignature(after) && registered.enabled !== false) {
+            currentDefinitions.set(name, after);
+            continue;
+          }
+
+          const previous = before;
+          currentDefinitions.set(name, after);
+          try {
+            registered.update(toolUpdate(after, fromJsonSchema));
+          } catch (error) {
+            if (previous) currentDefinitions.set(name, previous);
+            else currentDefinitions.delete(name);
+            throw error;
+          }
+        }
+
+        definitions = nextDefinitions;
+      } catch (error) {
+        onError(error instanceof Error ? error : new Error(String(error)));
+      } finally {
+        capabilityPollRunning = false;
+      }
+    }, pollIntervalMs());
+    capabilityTimer.unref?.();
+
     return server;
   }, {
     legacy:'serve',
@@ -54,7 +145,7 @@ export async function startCompactRuntimeMcpServer({ version, instructions, onEr
   });
 
   return {
-    definitions,
+    get definitions() { return definitions; },
     async notification(notification) {
       if (!activeServer) return;
       await activeServer.server.notification(notification);
@@ -62,6 +153,8 @@ export async function startCompactRuntimeMcpServer({ version, instructions, onEr
     async close() {
       if (closed) return;
       closed = true;
+      if (capabilityTimer) clearInterval(capabilityTimer);
+      capabilityTimer = null;
       await serverHandle.close();
       activeServer = null;
     },

package/src/mcp-v2.mjs

@@ -32,6 +32,7 @@ export async function startRuntimeMcpServer({ version, instructions, onError = (
   ]);
   let activeServer = null;
   let capabilityTimer = null;
+  let capabilityPollRunning = false;
   let closed = false;
 
   const serverHandle = serveStdio(() => {
@@ -65,7 +66,8 @@ export async function startRuntimeMcpServer({ version, instructions, onError = (
 
     let lastSupported = initiallySupported;
     capabilityTimer = setInterval(async () => {
-      if (closed) return;
+      if (closed || capabilityPollRunning) return;
+      capabilityPollRunning = true;
       try {
         const next = new Set((await advertisedExtendedTools()).map(tool => tool.name));
         let changed = false;
@@ -87,6 +89,8 @@ export async function startRuntimeMcpServer({ version, instructions, onError = (
         if (changed) server.sendToolListChanged();
       } catch (error) {
         onError(error instanceof Error ? error : new Error(String(error)));
+      } finally {
+        capabilityPollRunning = false;
       }
     }, pollIntervalMs());
     capabilityTimer.unref?.();