@remcp/runtime 0.2.130 → 0.2.132

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## 0.2.132 — 2026-10-02
+
+- `computer_action` now exposes `type`, `scroll`, `drag`, and `target=window` in its MCP schema while keeping specialist tools available when the backend is already known.
+- Auto `type` uses accessibility-only semantic editing before CDP and never falls through to unverified physical text input merely because a native selector failed.
+- Browser DOM typing separates `browser_text` locator semantics from the `text` payload; legacy locator-in-`text` calls remain compatible when `value`/`text_value` carries the payload.
+- `browser_action scroll` performs bounded page or nearest-scrollable-ancestor scrolling with the same delta/direction vocabulary as native `scroll`; `computer_action scroll` can route to it automatically.
+- Action-specific schemas validate type targets/text, scroll deltas/directions, drag endpoints, and explicit backend/target compatibility before handler execution. Window targets require a window selector; UI/coordinate scroll and drag require target-appropriate fields; browser/OCR drag is rejected before dispatch.
+- macOS `service action=list` now uses explicit launchd domains so `scope=user` reads `gui/<uid>` and `scope=system` reads `system`; the old legacy `launchctl list` path could not honor system scope.
+- Public macOS release CI exercises the system launchd domain in addition to document/network backends. Runtime tool names remain unchanged at 83.
+
+## 0.2.131 — 2026-10-02
+
+- `network action=summary` is now bounded for Docker-heavy hosts: non-container interfaces are prioritized, at most eight interfaces and four addresses per interface are returned, and count/truncation metadata shows what was omitted.
+- `network action=interfaces` remains the complete adapter/address inventory. The MCP schema and tool names remain compatible; stable count/truncation fields are now declared for chaining.
+
 ## 0.2.130 — 2026-10-02
 
 - `computer_snapshot` now skips desktop-only probes on headless Linux and returns stable empty/unavailable desktop fields without false error noise. The shared `desktopSessionAvailable()` helper keeps this behavior aligned with live capability discovery.

package/README.md

@@ -60,7 +60,9 @@ If custom widgets are explicitly re-enabled, hosted discovery expands to **15 de
 **5 app-only** UI helpers. Cached legacy clients can still call supported granular aliases without inflating
 discovery for new clients.
 
-`computer_snapshot` and `computer_action` keep OCR inside the compact high-level surface: when a local `tesseract` binary is available, snapshot can return bounded OCR text/boxes and click targeting can fall back through Accessibility → browser DOM/CDP → OCR → coordinates. OCR is optional and never adds another MCP tool or bundled OCR dependency.
+`computer_snapshot` and `computer_action` keep OCR inside the compact high-level surface: when a local `tesseract` binary is available, snapshot can return bounded OCR text/boxes and click targeting can fall back through Accessibility → browser DOM/CDP → OCR → coordinates. `computer_action` also exposes backend-uncertain `type`, `scroll`, and `drag` plus explicit window targeting; it prefers semantic Accessibility, can route browser selectors through CDP, and keeps native coordinate/UI gestures as the fallback. When the backend is already known, the specialist UI/browser/type/scroll/drag/window tools keep their full controls. OCR is optional and never adds another MCP tool or bundled OCR dependency.
+
+For browser typing, `browser_text` is the visible DOM locator while `text` is the Unicode payload. `browser_action(action="scroll")` accepts page/element deltas or direction/wheel steps and scrolls the page or nearest scrollable ancestor; `scroll_into_view` remains the separate semantic reveal operation.
 
 For frontend QA, use semantic data to operate the page and rendered pixels to verify it: `browser_action(action="set_viewport")` sets an exact responsive-test viewport, `browser_wait` waits for the real application state, and `browser_snapshot(include_screenshot=true, selector=...)` recenters the component, returns its bounds, and attaches the real CDP-rendered viewport PNG. This intentionally treats screenshots as the visual oracle without making screenshot-driven coordinate guessing the primary control path.
 

package/package.json

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

package/src/extended/browser.mjs

@@ -1045,6 +1045,47 @@ export async function browserFind(args) {
   });
 }
 
+const PAGE_SCROLL_ACTION = `function(selector, needle, deltaX, deltaY) {
+  let target = selector ? document.querySelector(selector) : null;
+  if (!target && needle) {
+    const lower = String(needle).toLowerCase();
+    target = Array.from(document.querySelectorAll('*')).find(node =>
+      String(node.innerText || node.textContent || '').trim().toLowerCase().includes(lower)
+    ) || null;
+  }
+  if ((selector || needle) && !target) throw new Error('Element not found');
+
+  let scroller = document.scrollingElement || document.documentElement;
+  if (target) {
+    let current = target;
+    while (current && current !== document.documentElement) {
+      const style = getComputedStyle(current);
+      const scrollX = /(auto|scroll|overlay)/.test(String(style.overflowX || '')) && current.scrollWidth > current.clientWidth;
+      const scrollY = /(auto|scroll|overlay)/.test(String(style.overflowY || '')) && current.scrollHeight > current.clientHeight;
+      if (scrollX || scrollY) {
+        scroller = current;
+        break;
+      }
+      current = current.parentElement;
+    }
+  }
+
+  const beforeX = Number(scroller.scrollLeft || 0);
+  const beforeY = Number(scroller.scrollTop || 0);
+  scroller.scrollLeft = beforeX + Number(deltaX || 0);
+  scroller.scrollTop = beforeY + Number(deltaY || 0);
+  return {
+    target: target ? target.tagName.toLowerCase() : 'page',
+    scroller: scroller === document.scrollingElement || scroller === document.documentElement ? 'page' : scroller.tagName.toLowerCase(),
+    before_x: beforeX,
+    before_y: beforeY,
+    after_x: Number(scroller.scrollLeft || 0),
+    after_y: Number(scroller.scrollTop || 0),
+    delta_x: Number(deltaX || 0),
+    delta_y: Number(deltaY || 0),
+  };
+}`;
+
 const PAGE_ELEMENT_ACTION = `function(selector, needle, action, value) {
   let el = selector ? document.querySelector(selector) : null;
   if (!el && needle) {
@@ -1081,14 +1122,46 @@ const PAGE_ELEMENT_ACTION = `function(selector, needle, action, value) {
   };
 }`;
 
+export function browserActionLocatorText(args = {}, action = '') {
+  const explicit = optionalString(args.browser_text || args.match_text);
+  if (explicit) return explicit;
+  if (action === 'type') {
+    // Legacy type calls used text as the locator and value/text_value as the payload.
+    if (!optionalString(args.selector) && (args.value != null || args.text_value != null)) return optionalString(args.text);
+    return null;
+  }
+  return optionalString(args.text);
+}
+
 export function browserActionInputValue(args = {}, action = '') {
-  // text is the public field models naturally use for type, while set_value/select historically
-  // used value/text_value. Keep all aliases compatible but give each action its semantic field.
-  return String(action === 'type' ? (args.text ?? args.text_value ?? args.value ?? '') : (args.value ?? args.text_value ?? args.text ?? ''));
+  if (action === 'type') {
+    if (!optionalString(args.selector) && !optionalString(args.browser_text || args.match_text) && (args.value != null || args.text_value != null)) {
+      return String(args.text_value ?? args.value ?? '');
+    }
+    return String(args.text ?? args.text_value ?? args.value ?? '');
+  }
+  return String(args.value ?? args.text_value ?? args.text ?? '');
+}
+
+export function browserScrollDeltas(args = {}) {
+  const direction = optionalString(args.direction);
+  const hasDelta = [args.delta_x,args.delta_y,args.delta].some(value => value != null && Number.isFinite(Number(value)));
+  if (!direction && !hasDelta) return null;
+  const times = clamp(args.wheel_times, 1, 1, 50);
+  let deltaX = Number(args.delta_x || 0);
+  let deltaY = Number(args.delta_y ?? args.delta ?? 0);
+  if (direction) {
+    const normalized = requireEnum(direction, 'direction', ['up','down','left','right']);
+    if (normalized === 'up') deltaY = -120 * times;
+    if (normalized === 'down') deltaY = 120 * times;
+    if (normalized === 'left') deltaX = -120 * times;
+    if (normalized === 'right') deltaX = 120 * times;
+  }
+  return { delta_x:deltaX, delta_y:deltaY };
 }
 
 export async function browserAction(args) {
-  const action = requireEnum(args.action, 'action', ['click', 'focus', 'type', 'set_value', 'select', 'scroll_into_view', 'upload', 'press', 'set_viewport']);
+  const action = requireEnum(args.action, 'action', ['click', 'focus', 'type', 'set_value', 'select', 'scroll', 'scroll_into_view', 'upload', 'press', 'set_viewport']);
   return withTarget(args, async (session, target) => {
     if (action === 'set_viewport') {
       const width = clamp(args.width, 1280, 200, 8192);
@@ -1126,11 +1199,22 @@ export async function browserAction(args) {
       return jsonResult({ target_id: target.id, action, key });
     }
     const selector = optionalString(args.selector);
-    const needle = optionalString(args.text);
-    if (!selector && !needle) throw new Error('selector or text is required');
+    const needle = browserActionLocatorText(args, action);
     const value = browserActionInputValue(args, action);
     const option = String(args.option ?? value);
 
+    if (action === 'scroll') {
+      const deltas = browserScrollDeltas(args);
+      if (!deltas) throw new Error('browser_action scroll requires direction or a delta');
+      return jsonResult({
+        target_id: target.id,
+        action,
+        result: await callPageFunction(session, PAGE_SCROLL_ACTION, [selector, needle, deltas.delta_x, deltas.delta_y]),
+      });
+    }
+
+    if (!selector && !needle) throw new Error('selector or browser_text/text locator is required');
+
     if (action === 'click') {
       const rect = await callPageFunction(session, PAGE_ELEMENT_ACTION, [selector, needle, 'click', '']);
       const x = Number(rect.x) + Number(rect.width) / 2;
@@ -1143,6 +1227,7 @@ export async function browserAction(args) {
 
     if (action === 'type') {
       const focused = await callPageFunction(session, PAGE_ELEMENT_ACTION, [selector, needle, 'type', '']);
+      if (args.clear === true) await callPageFunction(session, PAGE_ELEMENT_ACTION, [selector, needle, 'set_value', '']);
       await session.send('Input.insertText', { text:value });
       const current = await callPageFunction(session, PAGE_ELEMENT_ACTION, [selector, needle, 'read_value', '']);
       return jsonResult({ target_id:target.id, action, result:{ ...focused, value:current.value } });

package/src/extended/catalog.mjs

@@ -30,7 +30,7 @@ const o = (properties = {}, required = []) => ({ type: 'object', properties, ...
 
 const AI_TOOL_DESCRIPTIONS = Object.freeze({
   computer_snapshot: 'Use this for the first look at an unfamiliar desktop state when you need one compact bundle of windows, semantic UI, displays, clipboard metadata and optional pixels/browser/OCR. Prefer it over repeated screenshots; narrow later with ui_find, browser_find or screenshot_region.',
-  computer_action: 'Use this only when one semantic click/edit/focus/selection action must work across an uncertain target backend and may need Accessibility → browser DOM/CDP → OCR → coordinate fallback, or when multi_select/multi_edit avoids many identical native UI calls. Do not use it when the backend or operation is already known: use ui_action for native controls, browser_action for page DOM, type_text for prose, keyboard for shortcuts, pointer for raw pointer gestures, drag_drop or scroll for those gestures, window_action for windows, and the dedicated clipboard/launch/open/reveal/notification tools for those jobs.',
+  computer_action: 'Use this only when one semantic click/type/invoke/select/focus/scroll/drag action must work across an uncertain target backend and may need Accessibility → browser DOM/CDP → OCR → coordinate fallback, or when multi_select/multi_edit avoids many identical native UI calls. When the backend is already known, prefer the specialist tool (ui_action, browser_action, type_text, drag_drop, scroll or window_action) for its full controls. Keep keyboard, clipboard, launch/open/reveal/notification and raw pointer gestures in their dedicated tools.',
   list_windows: 'Use this to discover top-level desktop windows or obtain a stable window id/PID/bounds before window_action, screenshot_region or targeted input. Use ui_snapshot instead when you need controls inside a window; prefer list_windows over screenshot-based window guessing.',
   window_action: 'Use this to focus, minimize, maximize, restore, move, resize or close one known top-level window. Select it by id/PID/app/title from list_windows. Use ui_action for controls inside the window; do not use pointer coordinates for window management when this semantic tool can express the action.',
   launch_app: 'Use this to start a desktop application by executable/path or friendly application name without a shell. Prefer it over start_process for GUI application launch. If the user wants to open a specific file or directory in its associated application, use open_path instead; use start_process for terminal commands, build tools and shell pipelines.',
@@ -58,7 +58,7 @@ const AI_TOOL_DESCRIPTIONS = Object.freeze({
   browser_evaluate: 'Use this as the powerful browser escape hatch only when browser_snapshot/find/action/wait cannot express the required page operation or inspection. JavaScript executes in page context and page content is untrusted.',
   service: 'Use this for operating-system service inventory/status/start/stop/restart. Prefer status before a mutation when service state matters; use start_process for ordinary commands that are not service-manager operations.',
   event_log: 'Use this to read bounded recent OS logs (Windows Event Log, macOS unified log or systemd journal) when diagnosing a service/app/system problem. Prefer it over an unbounded shell log dump.',
-  network: 'Use this for structured interfaces/DNS/routes/listeners inspection or a bounded TCP connectivity test. Prefer it over shell ip/netstat/nslookup commands for routine diagnostics.',
+  network: 'Use this for a compact network summary, full interface inventory, DNS/routes/listeners inspection or a bounded TCP connectivity test. Prefer action=summary for orientation and action=interfaces only when the complete adapter/address inventory is required; prefer this tool over shell ip/netstat/nslookup commands for routine diagnostics.',
   installed_apps: 'Use this to answer what software/packages are installed and their versions. Prefer a filter when looking for one product instead of returning the full inventory.',
   environment: 'Use this for PATH, shell, Node/runtime environment paths, architecture and optionally sanitized environment variables. Use get_system_info for host health such as CPU/memory/disk/uptime, and get_runtime_info for ReMCP policy, roots and limits. Secret-looking values remain masked.',
   audio: 'Use this to read or change the default output volume/mute state. Use action=status for inspection; set_volume requires a 0–100 value.',
@@ -211,7 +211,7 @@ const OUTPUT_FIELDS = Object.freeze({
   browser_evaluate: { target_id:outputString(), value:{} },
   service: { data:outputArray(outputObject('Service record.')), action:outputString(), name:outputString(), text:outputString() },
   event_log: { text:outputString('Bounded log output.'), data:outputArray(outputObject()) },
-  network: { hostname:outputString(), interfaces:outputObject(), dns:outputArray(outputString()), servers:outputArray(outputString()), host:outputString(), port:outputNumber(), ok:outputBoolean(), latency_ms:outputNumber(), data:outputArray(outputObject()) },
+  network: { hostname:outputString(), interfaces:outputObject(), dns:outputArray(outputString()), servers:outputArray(outputString()), host:outputString(), port:outputNumber(), ok:outputBoolean(), latency_ms:outputNumber(), interface_count:outputNumber(), interface_count_returned:outputNumber(), address_count:outputNumber(), address_count_returned:outputNumber(), interfaces_truncated:outputBoolean(), addresses_truncated:outputBoolean(), data:outputArray(outputObject()) },
   installed_apps: { data:outputArray(outputObject('Installed app/package with name/version/path where available.')) },
   environment: { platform:outputString(), arch:outputString(), hostname:outputString(), release:outputString(), shell:outputString(), path:outputString(), node:outputString(), env:outputObject() },
   audio: { volume:outputNumber(), muted:outputBoolean(), action:outputString(), text:outputString() },
@@ -247,8 +247,18 @@ function requiredAny(...groups) {
 function applySchemaRules(name, schema) {
   const next = structuredClone(schema);
   if (name === 'computer_action') {
-    const semanticTarget = requiredAny(['id'], ['label'], ['name'], ['role'], ['automation_id'], ['selector'], ['browser_text']);
+    const nativeTarget = requiredAny(['id'], ['label'], ['name'], ['role'], ['automation_id']);
+    const browserElementTarget = requiredAny(['selector'], ['browser_text'], ['name']);
+    const windowTarget = requiredAny(['window_id'], ['pid'], ['app'], ['window_title'], ['title']);
+    const semanticTarget = [...nativeTarget, ...browserElementTarget];
     next.allOf = [
+      {
+        if:{ properties:{ target:{ const:'window' } }, required:['target'] },
+        then:{
+          properties:{ action:{ enum:['type','focus','scroll','drag'] } },
+          anyOf:windowTarget,
+        },
+      },
       {
         if:{ properties:{ action:{ const:'click' } }, required:['action'] },
         then:{ anyOf:[...semanticTarget, { required:['ocr_text'] }, { required:['x','y'] }] },
@@ -259,7 +269,60 @@ function applySchemaRules(name, schema) {
       },
       {
         if:{ properties:{ action:{ const:'focus' } }, required:['action'] },
-        then:{ anyOf:[...semanticTarget, ...requiredAny(['pid'], ['app'], ['window_title'], ['title'])] },
+        then:{ anyOf:[...semanticTarget, ...requiredAny(['window_id'], ['pid'], ['app'], ['window_title'], ['title'])] },
+      },
+      {
+        if:{ properties:{ action:{ const:'type' } }, required:['action'] },
+        then:{
+          required:['text'],
+          properties:{ target:{ enum:['auto','ui','ui_element','browser','window'] } },
+          allOf:[
+            { anyOf:[...semanticTarget, ...windowTarget] },
+            {
+              if:{ properties:{ target:{ enum:['ui','ui_element'] } }, required:['target'] },
+              then:{ anyOf:nativeTarget },
+            },
+            {
+              if:{ properties:{ target:{ const:'browser' } }, required:['target'] },
+              then:{ anyOf:browserElementTarget },
+            },
+          ],
+        },
+      },
+      {
+        if:{ properties:{ action:{ const:'scroll' } }, required:['action'] },
+        then:{
+          properties:{ target:{ enum:['auto','ui','ui_element','browser','coordinates','window'] } },
+          allOf:[
+            { anyOf:requiredAny(['delta_x'], ['delta_y'], ['delta'], ['direction']) },
+            {
+              if:{ properties:{ target:{ enum:['ui','ui_element'] } }, required:['target'] },
+              then:{ anyOf:nativeTarget },
+            },
+            {
+              if:{ properties:{ target:{ const:'coordinates' } }, required:['target'] },
+              then:{ required:['x','y'] },
+            },
+          ],
+        },
+      },
+      {
+        if:{ properties:{ action:{ const:'drag' } }, required:['action'] },
+        then:{
+          properties:{ target:{ enum:['auto','ui','ui_element','coordinates','window'] } },
+          allOf:[
+            { anyOf:requiredAny(['from_id'], ['from_x','from_y']) },
+            { anyOf:requiredAny(['to_id'], ['to_x','to_y']) },
+            {
+              if:{ properties:{ target:{ enum:['ui','ui_element'] } }, required:['target'] },
+              then:{ required:['from_id','to_id'] },
+            },
+            {
+              if:{ properties:{ target:{ const:'coordinates' } }, required:['target'] },
+              then:{ required:['from_x','from_y','to_x','to_y'] },
+            },
+          ],
+        },
       },
       {
         if:{ properties:{ action:{ enum:['set_value','set_range_value'] } }, required:['action'] },
@@ -357,8 +420,19 @@ function applySchemaRules(name, schema) {
   } else if (name === 'browser_action') {
     next.allOf = [
       {
-        if:{ properties:{ action:{ enum:['click','focus','type','set_value','select','scroll_into_view'] } }, required:['action'] },
-        then:{ anyOf:requiredAny(['selector'], ['text']) },
+        if:{ properties:{ action:{ enum:['click','focus','set_value','select','scroll_into_view'] } }, required:['action'] },
+        then:{ anyOf:requiredAny(['selector'], ['text'], ['browser_text']) },
+      },
+      {
+        if:{ properties:{ action:{ const:'type' } }, required:['action'] },
+        then:{
+          required:['text'],
+          anyOf:requiredAny(['selector'], ['browser_text'], ['value'], ['text_value']),
+        },
+      },
+      {
+        if:{ properties:{ action:{ const:'scroll' } }, required:['action'] },
+        then:{ anyOf:requiredAny(['delta_x'], ['delta_y'], ['delta'], ['direction']) },
       },
       {
         if:{ properties:{ action:{ const:'upload' } }, required:['action'] },
@@ -477,22 +551,38 @@ export const extendedToolDefinitions = [
     'Perform one semantic cross-backend action when the target may require Accessibility → browser DOM/CDP → OCR → coordinate fallback.',
     o({
       action:e([
-        'click','invoke','focus','set_value','select','toggle','expand','collapse',
+        'click','type','invoke','focus','select','scroll','drag','set_value','toggle','expand','collapse',
         'scroll_into_view','set_range_value','add_to_selection','remove_from_selection',
         'multi_select','multi_edit',
       ]),
       target:e(
-        ['auto','ui','ui_element','browser','ocr','coordinates'],
-        'Optional target type. auto tries native accessibility first, then browser DOM/CDP, OCR text when requested, then coordinates for click.',
+        ['auto','ui','ui_element','browser','ocr','coordinates','window'],
+        'Optional target type. auto prefers native accessibility, then browser DOM/CDP, then OCR/coordinates where supported. Use window for explicit top-level window focus/text/scroll targeting.',
       ),
       ...uiSelector,
-      title:s('Optional browser page title substring when target=browser.'),
-      text:s('Text used by multi_edit or as a compatibility value for a semantic edit.'),
+      title:s('Optional browser page title substring or top-level window title when target=window.'),
+      window_id:s('Top-level window id returned by list_windows when target=window.'),
+      text:s('Unicode text to enter for action=type, or text used by multi_edit.'),
+      clear:b('For action=type, clear the current semantic/browser value before inserting text when supported.'),
       value:s('New value for set_value, set_range_value, or select.'),
-      x:n('Virtual-desktop X coordinate used only by the final click fallback.'),
-      y:n('Virtual-desktop Y coordinate used only by the final click fallback.'),
+      x:n('Virtual-desktop X coordinate used by click/scroll coordinate targeting.'),
+      y:n('Virtual-desktop Y coordinate used by click/scroll coordinate targeting.'),
       selector:s('CSS selector when the fallback target is a browser element.'),
-      browser_text:s('Visible browser text used to locate a DOM fallback target.'),
+      browser_text:s('Visible browser text used only to locate a DOM target; for action=type, text remains the value to enter.'),
+      delta_x:n('Horizontal scroll delta; positive means right.'),
+      delta_y:n('Vertical scroll delta; positive means down.'),
+      delta:n('Alias for delta_y.'),
+      direction:e(['up','down','left','right']),
+      wheel_times:n('Number of 120-unit wheel steps for direction; 1..50.'),
+      from_x:n('Drag source X coordinate.'),
+      from_y:n('Drag source Y coordinate.'),
+      to_x:n('Drag destination X coordinate.'),
+      to_y:n('Drag destination Y coordinate.'),
+      from_id:s('Source semantic UI element id for action=drag.'),
+      to_id:s('Destination semantic UI element id for action=drag.'),
+      button:e(['left','right','middle']),
+      hold_ms:n('Delay after pointer down before moving during action=drag.'),
+      duration_ms:n('Drag movement duration.'),
       ocr_text:s('Visible text to find in rendered pixels for the OCR click fallback.'),
       ocr_region:{
         type:'array',
@@ -556,13 +646,13 @@ export const extendedToolDefinitions = [
   define('browser_navigate', 'Browser navigate', 'Open a new debuggable tab or navigate a selected browser page by URL, history back/forward, or reload through Chrome DevTools Protocol.', o({ ...browserTarget, action:e(['url','new_tab','back','forward','reload'], 'Default url when url is provided, otherwise reload. new_tab creates the first page target when needed.'), url:s('Destination URL for action=url or action=new_tab.'), wait:b('Wait for the page load event; default true.'), ignore_cache:b('Reload without cache when action=reload.') }), openMutatingNonDestructive, browserHandlers.browser_navigate, ['browser_cdp']),
   define('browser_snapshot', 'Browser snapshot', 'Return the selected browser page accessibility tree through Chrome DevTools Protocol and, when requested, attach a real rendered viewport PNG for visual verification. A selector is temporarily recentered for capture, its exact viewport bounds are returned, and the prior scroll position is restored before return.', o({ ...browserTarget, max_nodes:n('Maximum AX nodes; default 1500.'), include_screenshot:b('Attach a real CDP-rendered viewport PNG screenshot; default false.'), selector:s('When include_screenshot=true, center this CSS-selected element before capture and report its viewport bounds.') }), readOnlyLive, browserHandlers.browser_snapshot, ['browser_cdp']),
   define('browser_find', 'Find browser element', 'Find visible DOM elements by CSS selector, text, or ARIA role and return reusable selectors plus text, value, and bounding boxes.', o({ ...browserTarget, selector:s('CSS selector.'), text:s('Visible text substring.'), role:s('ARIA role.'), limit:n() }), readOnlyLive, browserHandlers.browser_find, ['browser_cdp']),
-  define('browser_action', 'Browser element action', 'Click, focus, type/set a value, select, scroll to, upload files, press a key, or set an exact responsive-test viewport in a debuggable browser page using DOM/CDP semantics.', o({ ...browserTarget, action:e(['click','focus','type','set_value','select','scroll_into_view','upload','press','set_viewport']), selector:s('CSS selector for the target element; prefer the reusable selector returned by browser_find.'), text:s('For action=type, Unicode text to insert. For element actions without selector, visible text may identify the target.'), value:s('Value for action=set_value; also accepted as a compatibility fallback for action=type.'), text_value:s('Compatibility alias for the type/set_value text value.'), option:s(), path:s(), paths:{type:'array',items:{type:'string'}}, key:s(), width:n('CSS viewport width for set_viewport.'), height:n('CSS viewport height for set_viewport.'), device_scale_factor:n('Device scale factor for set_viewport; default 1.'), mobile:b('Enable mobile emulation for set_viewport.') }, ['action']), openMutating, browserHandlers.browser_action, ['browser_cdp']),
+  define('browser_action', 'Browser element action', 'Click, focus, type/set a value, select, scroll a page or scrollable element, scroll an element into view, upload files, press a key, or set an exact responsive-test viewport in a debuggable browser page using DOM/CDP semantics.', o({ ...browserTarget, action:e(['click','focus','type','set_value','select','scroll','scroll_into_view','upload','press','set_viewport']), selector:s('CSS selector for the target element; prefer the reusable selector returned by browser_find.'), browser_text:s('Visible text used only to locate a DOM element; use this instead of overloading text for action=type.'), text:s('For action=type, Unicode text to insert. For non-type element actions without selector/browser_text, visible text may identify the target.'), clear:b('For action=type, clear the current value before inserting text.'), value:s('Value for action=set_value; also accepted as a legacy type payload when text is used as the locator.'), text_value:s('Compatibility alias for the type/set_value text value.'), option:s(), delta_x:n('Horizontal scroll delta; positive means right.'), delta_y:n('Vertical scroll delta; positive means down.'), delta:n('Alias for delta_y.'), direction:e(['up','down','left','right']), wheel_times:n('Number of 120-unit wheel steps for direction; 1..50.'), path:s(), paths:{type:'array',items:{type:'string'}}, key:s(), width:n('CSS viewport width for set_viewport.'), height:n('CSS viewport height for set_viewport.'), device_scale_factor:n('Device scale factor for set_viewport; default 1.'), mobile:b('Enable mobile emulation for set_viewport.') }, ['action']), openMutating, browserHandlers.browser_action, ['browser_cdp']),
   define('browser_wait', 'Wait for browser', 'Wait for DOM state, page text, URL, completed loading, a navigation away from the current URL, or a short network-idle period in a debuggable browser page. Use browser_evaluate separately for JavaScript predicates or page-specific inspection.', o({ ...browserTarget, condition:e(['selector','text','url_contains','load','navigation','network_idle']), selector:s(), text:s(), value:s(), poll_ms:n(), idle_ms:n('Required zero-in-flight network quiet window for network_idle; default 500 ms.') }), readOnlyLive, browserHandlers.browser_wait, ['browser_cdp']),
   define('browser_evaluate', 'Evaluate browser JavaScript', 'Evaluate JavaScript in a selected debuggable browser page and return its serializable value. This is a powerful escape hatch for page-specific automation.', o({ ...browserTarget, expression:s('JavaScript expression.'), await_promise:b('Await a returned Promise; default true.') }, ['expression']), openMutating, browserHandlers.browser_evaluate, ['browser_evaluate']),
 
   define('service', 'Service control', 'List, inspect, start, stop, or restart operating-system services using Service Control Manager, launchctl, or systemd. Mutating actions pass through ReMCP command policy.', o({ action:e(['list','status','start','stop','restart']), name:s('Service/unit/launchd label.'), scope:e(['user','system']) }, ['action']), mutating, diagnosticHandlers.service, ['services']),
   define('event_log', 'Event logs', 'Read recent Windows Event Log, macOS unified log, or systemd journal entries with bounded time and result limits.', o({ log:s('Windows log name.'), since:s('Time window such as 30s, 10m, 2h, or 1d.'), filter:s(), query:s(), limit:n() }), readOnlyLive, diagnosticHandlers.event_log, ['logs']),
-  define('network', 'Network diagnostics', 'Inspect interfaces, DNS servers, routes and listening sockets, or perform a bounded TCP connectivity test to a host and port.', o({ action:e(['summary','interfaces','dns','routes','listeners','test']), host:s(), port:n(), timeout_ms:n() }), readOnlyOpen, diagnosticHandlers.network),
+  define('network', 'Network diagnostics', 'Inspect a bounded network summary, full interface inventory, DNS servers, routes and listening sockets, or perform a bounded TCP connectivity test to a host and port. Use action=interfaces when the complete adapter/address inventory is needed.', o({ action:e(['summary','interfaces','dns','routes','listeners','test']), host:s(), port:n(), timeout_ms:n() }), readOnlyOpen, diagnosticHandlers.network),
   define('installed_apps', 'Installed applications', 'Inventory installed applications or packages with versions and publishers where available using native package/application inventories.', o({ filter:s('Name substring.'), limit:n('Maximum results; default 1000.') }), readOnly, diagnosticHandlers.installed_apps, ['apps']),
   define('environment', 'Runtime environment', 'Report platform, architecture, Node version, working/home/temp paths, shell, PATH, and optionally environment variables. Environment variables are opt-in and secret-looking or credential-bearing values are masked.', o({ include_env:b('Include sanitized environment variables; default false.') }), readOnly, diagnosticHandlers.environment),
   define('audio', 'Audio control', 'Read or change default output volume or mute state using native operating-system audio controls when available.', o({ action:e(['status','set_volume','mute','unmute']), volume:n('0..100 for set_volume.') }, ['action']), mutatingNonDestructive, diagnosticHandlers.audio, ['audio']),

package/src/extended/desktop.mjs

@@ -1263,6 +1263,7 @@ function browserComputerAction(args, action) {
     set_value:'set_value',
     select:'select',
     type:'type',
+    scroll:'scroll',
   }[action];
   if (!mapped) throw new Error(`Browser target does not support computer_action action: ${action}`);
   const visibleText = optionalString(args.browser_text)
@@ -1276,10 +1277,17 @@ function browserComputerAction(args, action) {
     timeout_ms: args.timeout_ms,
     action: mapped,
     selector: args.selector,
-    ...(visibleText ? { text: visibleText } : {}),
+    ...(visibleText ? { browser_text: visibleText } : {}),
     ...(args.value != null ? { value: args.value } : {}),
     ...(args.option != null ? { option: args.option } : {}),
-    ...(action === 'type' && args.text != null ? { value: args.text } : {}),
+    ...(action === 'type' && args.text != null ? { text: args.text, clear:args.clear === true } : {}),
+    ...(action === 'scroll' ? {
+      delta_x:args.delta_x,
+      delta_y:args.delta_y,
+      delta:args.delta,
+      direction:args.direction,
+      wheel_times:args.wheel_times,
+    } : {}),
   });
 }
 
@@ -1362,21 +1370,84 @@ export async function computerAction(args = {}) {
   if (action === 'ui') return uiAction(nested);
   if (action === 'pointer') return pointer(nested);
   if (action === 'window') return windowAction(nested);
-  if (action === 'type') return target === 'browser' ? browserComputerAction(args, 'type') : typeText(args);
+
+  const windowTarget = () => ({
+    ...args,
+    ...(args.window_id ? { id:args.window_id } : {}),
+    ...(args.window_title && !args.title ? { title:args.window_title } : {}),
+  });
+
+  if (action === 'type') {
+    if (target === 'browser') return browserComputerAction(args, 'type');
+    if (target === 'ocr' || target === 'coordinates') {
+      throw new Error('computer_action type requires a native UI, browser, or window target');
+    }
+    if (target === 'window') return typeText(windowTarget());
+    if (!automatic) return typeText({ ...args, method:args.method || 'accessibility' });
+
+    const failures = [];
+    if (hasUi) {
+      try { return await typeText({ ...args, method:'accessibility' }); }
+      catch (error) { failures.push(`accessibility: ${String(error?.message || error).slice(0, 300)}`); }
+    }
+    if (hasBrowser) {
+      if (await browserCapabilityAvailable(args.endpoint, 300)) {
+        try { return await browserComputerAction(args, 'type'); }
+        catch (error) { failures.push(`browser DOM: ${String(error?.message || error).slice(0, 300)}`); }
+      } else {
+        failures.push('browser DOM: no local CDP endpoint is available');
+      }
+    }
+    if (args.window_id || args.pid != null || args.app || args.window_title || args.title) {
+      try { return await typeText(windowTarget()); }
+      catch (error) { failures.push(`window: ${String(error?.message || error).slice(0, 300)}`); }
+    }
+    if (failures.length) throw new Error(`computer_action type targeting failed: ${failures.join('; ')}`);
+    throw new Error('computer_action type requires a native UI, browser, or window target');
+  }
+
   if (action === 'keyboard') {
     if (target === 'browser' && args.key && !args.shortcut && !Array.isArray(args.keys)) {
       return browserAction({ ...args, action:'press' });
     }
     return keyboard(args);
   }
+
   if (action === 'scroll') {
-    if (target === 'browser' && (args.selector || args.browser_text)) {
-      return browserAction({ ...args, action:'scroll_into_view', text:args.browser_text });
+    if (target === 'browser') return browserComputerAction(args, 'scroll');
+    if (target === 'ocr') throw new Error('computer_action scroll does not support OCR targets; use browser/UI/window/coordinates');
+
+    if (automatic) {
+      let uiError = null;
+      if (hasUi) {
+        try { return await scroll(args); }
+        catch (error) { uiError = error; }
+      }
+      if (hasBrowser) {
+        if (await browserCapabilityAvailable(args.endpoint, 300)) return browserComputerAction(args, 'scroll');
+        if (uiError) throw new Error(`computer_action scroll targeting failed: accessibility: ${String(uiError?.message || uiError).slice(0, 300)}; browser DOM: no local CDP endpoint is available`);
+        throw new Error('computer_action scroll browser target is unavailable because no local CDP endpoint is available');
+      }
+      if (args.window_id || args.pid != null || args.app || args.window_title || args.title) {
+        await windowAction({ ...windowTarget(), action:'focus' });
+      }
+      return scroll(args);
+    }
+
+    if (target === 'window') {
+      await windowAction({ ...windowTarget(), action:'focus' });
+      return scroll(args);
     }
-    if (args.id || args.name || args.role || args.automation_id) await uiAction({ ...args, action:'focus' }).catch(() => null);
     return scroll(args);
   }
-  if (action === 'drag') return dragDrop(args);
+
+  if (action === 'drag') {
+    if (target === 'browser' || target === 'ocr') {
+      throw new Error('computer_action drag currently requires native UI element ids or desktop coordinates; browser/OCR drag is not advertised');
+    }
+    if (target === 'window') await windowAction({ ...windowTarget(), action:'focus' });
+    return dragDrop(args);
+  }
   if (action === 'clipboard') return clipboard(nested);
   if (action === 'launch_app') return launchApp(args);
   if (action === 'open_path') return openPath(args);
@@ -1423,7 +1494,7 @@ export async function computerAction(args = {}) {
       }
       return uiAction({ ...args, action:'focus' });
     }
-    return windowAction({ ...args, action:'focus' });
+    return windowAction({ ...windowTarget(), action:'focus' });
   }
 
   if (['minimize','maximize','restore','move_resize','resize','close'].includes(action)) {

package/src/extended/diagnostics.mjs

@@ -32,6 +32,11 @@ function durationSpec(value) {
   return raw;
 }
 
+export function macosLaunchctlDomain(scope = 'user', uid = process.getuid?.() ?? 0) {
+  const normalized = requireEnum(scope, 'scope', ['user','system']);
+  return normalized === 'system' ? 'system' : `gui/${uid}`;
+}
+
 export async function serviceTool(args) {
   const action = requireEnum(args.action || 'list', 'action', ['list','status','start','stop','restart']);
   const name = optionalString(args.name);
@@ -55,8 +60,8 @@ export async function serviceTool(args) {
   }
 
   if (process.platform === 'darwin') {
-    if (action === 'list') return text((await runFile('/bin/launchctl', ['list'], { label: 'launchctl list' })).stdout);
-    const domain = scope === 'system' ? 'system' : `gui/${process.getuid?.() ?? 0}`;
+    const domain = macosLaunchctlDomain(scope);
+    if (action === 'list') return text((await runFile('/bin/launchctl', ['print', domain], { label: `launchctl print ${domain}` })).stdout);
     const target = `${domain}/${name}`;
     if (action === 'status') {
       const result = await runFile('/bin/launchctl', ['print', target], { label: 'launchctl print', allowFailure: true });
@@ -133,11 +138,59 @@ export function linuxListenerBackend({ commandExistsFn = commandExists } = {}) {
   return null;
 }
 
+const CONTAINER_INTERFACE_PATTERN = /^(?:veth|docker\d*$|br-[0-9a-f]{6,}$)/i;
+
+export function compactNetworkSummary({
+  hostname = os.hostname(),
+  interfaces = os.networkInterfaces(),
+  dnsServers = dns.getServers(),
+  maxInterfaces = 8,
+  maxAddressesPerInterface = 4,
+} = {}) {
+  const entries = Object.entries(interfaces || {}).map(([name, rows], index) => {
+    const normalizedRows = Array.isArray(rows) ? rows.filter(Boolean) : [];
+    const hasExternal = normalizedRows.some(row => row?.internal !== true);
+    const rank = hasExternal
+      ? (CONTAINER_INTERFACE_PATTERN.test(name) ? 1 : 0)
+      : 2;
+    return { name, rows:normalizedRows, index, rank };
+  });
+  entries.sort((left, right) => left.rank - right.rank || left.index - right.index);
+
+  const interfaceLimit = clamp(maxInterfaces, 8, 1, 64);
+  const addressLimit = clamp(maxAddressesPerInterface, 4, 1, 16);
+  const selected = entries.slice(0, interfaceLimit);
+  const compact = {};
+  let addressCount = 0;
+  let addressCountReturned = 0;
+  let addressesTruncated = false;
+
+  for (const entry of entries) addressCount += entry.rows.length;
+  for (const entry of selected) {
+    const rows = entry.rows.slice(0, addressLimit);
+    compact[entry.name] = rows;
+    addressCountReturned += rows.length;
+    if (entry.rows.length > rows.length) addressesTruncated = true;
+  }
+
+  return {
+    hostname,
+    dns:Array.isArray(dnsServers) ? dnsServers : [],
+    interfaces:compact,
+    interface_count:entries.length,
+    interface_count_returned:selected.length,
+    address_count:addressCount,
+    address_count_returned:addressCountReturned,
+    interfaces_truncated:entries.length > selected.length,
+    addresses_truncated:addressesTruncated,
+  };
+}
+
 export async function networkTool(args) {
   const action = requireEnum(args.action || 'summary', 'action', ['summary','interfaces','dns','routes','listeners','test']);
   if (action === 'interfaces') return jsonResult(os.networkInterfaces());
   if (action === 'dns') return jsonResult({ servers:dns.getServers(), hostname:os.hostname() });
-  if (action === 'summary') return jsonResult({ hostname:os.hostname(), interfaces:os.networkInterfaces(), dns:dns.getServers() });
+  if (action === 'summary') return jsonResult(compactNetworkSummary());
   if (action === 'test') {
     const host = optionalString(args.host); if (!host) throw new Error('host is required for action=test');
     return jsonResult(await connectivityTest(host, clamp(args.port, 443, 1, 65535), clamp(args.timeout_ms, 3000, 100, 30_000)));