@remcp/runtime 0.2.232 → 0.2.234

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 0.2.234 — 2026-11-05
+
+- Publish the unchanged local runtime with the compatible 0.2.234 ReMCP agent update.
+- The agent reconnect and memory-bound transport improvements add no new runtime tools, device permissions or protocol privileges.
+
 ## 0.2.194 — 2026-10-28
 
 - Ship the unchanged 84-tool runtime alongside the compatible 0.2.194 ReMCP agent with terminal QR pairing.

package/README.md

@@ -31,7 +31,7 @@ node ./src/compact.mjs --print-tools  # compact local façade for scanners/local
 
 ## Tools
 
-84 tools are implemented in this repository: the original 44 filesystem/search/terminal/process tools
+87 tools are implemented in this repository: the original 44 filesystem/search/terminal/process tools
 plus 40 computer-use, browser, diagnostics, and document tools. The release contract contains all 84;
 the live local MCP `tools/list` omits optional platform-specific tools that the current computer cannot
 support and emits `notifications/tools/list_changed` when that capability set changes. The stdio server is dual-era: existing 2025-era clients continue to work unchanged, while clients that negotiate MCP `2026-07-28` use `server/discover`, cache hints, unrestricted structured output validation, and `subscriptions/listen` for list-change delivery.
@@ -52,10 +52,10 @@ support and emits `notifications/tools/list_changed` when that capability set ch
 | Diagnostics | `service`, `event_log`, `network`, `installed_apps`, `environment`, `audio`, `power_action`, `record_screen` — `audio` returns stable structured `volume`, `muted`, `action`, and `backend` fields across supported OS backends |
 | Documents | `read_document`, `edit_spreadsheet`, `edit_document`, `pdf_action` |
 
-The hosted ReMCP endpoint does not append those 84 granular operation names to its discovery list.
+The hosted ReMCP endpoint does not append those 87 granular operation names to its discovery list.
 Current production runs with `REMCP_CUSTOM_WIDGETS_ENABLED=false` and exposes **10 hosted tool definitions**,
 all model-visible: 8 device-facing façade tools plus 2 account/fleet tools. Those compact definitions route
-to the same **84 granular runtime operations** after the selected computer's live capabilities are checked.
+to the same **87 granular runtime operations** after the selected computer's live capabilities are checked.
 If custom widgets are explicitly re-enabled, hosted discovery expands to **15 definitions** by adding
 **5 app-only** UI helpers. Cached legacy clients can still call supported granular aliases without inflating
 discovery for new clients.
@@ -90,7 +90,7 @@ errors. Linux `display_inventory` follows the real monitor backend chain (GNOME
 backend (Wayland grim/GNOME/portal path or X11 ImageMagick), not merely because `ffmpeg` is installed.
 
 The generated hosted reference covers the current **10 hosted production definitions**, all model-visible
-and routing to the 84 granular runtime operations described above; the optional widget-enabled surface is 15.
+and routing to the 87 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) 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`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remcp/runtime",
-  "version": "0.2.232",
+  "version": "0.2.234",
   "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-catalog.mjs

@@ -15,6 +15,7 @@ export const compactRuntimeGroups = Object.freeze({
     'computer_snapshot','list_windows','ui_snapshot','ui_find','wait_for_ui','display_inventory',
     'computer_action','window_action','launch_app','ui_action','type_text','keyboard','pointer','drag_drop','scroll',
     'clipboard','open_path','reveal_path','notification','record_screen',
+    'desktop_webrtc_offer','desktop_webrtc_heartbeat','desktop_webrtc_stop',
   ]),
   view_image: Object.freeze(['read_image','take_screenshot','screenshot_region']),
   control_browser: Object.freeze([

package/src/extended/catalog.mjs

@@ -12,8 +12,10 @@ import { waylandPortalCandidate } from '../wayland-remote-desktop.mjs';
 import { commandExists, desktopSessionAvailable, runFile } from './common.mjs';
 import { desktopHandlers } from './desktop.mjs';
 import { displayInventoryAvailable, regionScreenshotBackends } from './desktop-linux.mjs';
+import { hydrateLinuxDesktopEnv } from './desktop-linux-session-env.mjs';
 import { diagnosticHandlers, gnomeScreencastSupported, recordScreenAvailable } from './diagnostics.mjs';
 import { documentHandlers } from './documents.mjs';
+import { desktopWebRtcHandlers, webRtcWorkerAvailable } from './desktop-webrtc-bridge.mjs';
 
 function define(name, title, description, inputSchema, annotations, handler, requires = []) {
   const enriched = enrichSchemaDescriptions(inputSchema);
@@ -157,6 +159,12 @@ export const extendedToolDefinitions = [
   define('clipboard', 'Clipboard', 'Read, write, or clear the system text clipboard using native operating-system clipboard facilities.', o({ action:e(['read','write','clear']), text:s('Text to write.') }, ['action']), mutating, desktopHandlers.clipboard, ['clipboard']),
   define('display_inventory', 'Display inventory', 'List connected displays/monitors and their geometry and primary-display status using native display tools.', o(), readOnlyLive, desktopHandlers.display_inventory, ['displays']),
   define('screenshot_region', 'Screenshot region', 'Capture a desktop rectangle, a selected top-level window, or a selected monitor and return it as an inline PNG. This avoids full-desktop screenshots when only one UI area matters.', o({ x:n(), y:n(), width:n(), height:n(), window_id:s('Window id returned by list_windows.'), pid:n(), app:s(), title:s(), monitor:s('Monitor name substring, or "primary".'), monitor_index:n('Zero-based monitor index from display_inventory.'), padding:n('Optional pixels added around the resolved rectangle; 0..200.') }), readOnlyLive, desktopHandlers.screenshot_region, ['screen_region']),
+  define('desktop_webrtc_offer', 'WebRTC desktop offer (dev only)', 'Use this only after the device owner explicitly requests a live view-only session: negotiate one OS-consented video stream with the installed local aiortc worker. No embedded HTTP server, clipboard or input.',
+    o({session_id:s('Server-issued UUID.'),mode:e(['view'],'One-way view-only media. Input control uses the separate authenticated device RPC route.'),sdp:s('ICE-complete video-only SDP offer.')},['session_id','mode','sdp']),mutatingNonDestructive,desktopWebRtcHandlers.desktop_webrtc_offer,['webrtc_pilot']),
+  define('desktop_webrtc_heartbeat', 'WebRTC video heartbeat (dev only)', 'Use this only to extend the existing authorized WebRTC video session; it cannot start capture or grant input.',
+    o({session_id:s('Existing session UUID.')},['session_id']),mutatingNonDestructive,desktopWebRtcHandlers.desktop_webrtc_heartbeat,['webrtc_pilot']),
+  define('desktop_webrtc_stop', 'WebRTC video stop (dev only)', 'Use this when the user or host must end the matching WebRTC video session and release its peer, GStreamer stream and OS ScreenCast grant.',
+    o({session_id:s('Existing session UUID.')},['session_id']),mutatingNonDestructive,desktopWebRtcHandlers.desktop_webrtc_stop,['webrtc_pilot']),
   define('open_path', 'Open path', 'Open a permitted local file or directory in its system-associated desktop application. Filesystem confinement is checked before opening.', o({ path:s('File or directory to open.') }, ['path']), additive, desktopHandlers.open_path, ['desktop_open']),
   define('reveal_path', 'Reveal path', 'Reveal a permitted local file or directory in Finder, Explorer, or the Linux file manager after applying ReMCP filesystem confinement.', o({ path:s('File or directory to reveal.') }, ['path']), additive, desktopHandlers.reveal_path, ['desktop_open']),
   define('notification', 'Desktop notification', 'Show a native desktop notification or user-visible popup on the paired computer.', o({ title:s(), message:s('Notification message.'), timeout_seconds:n() }, ['message']), additive, desktopHandlers.notification, ['notifications']),
@@ -250,6 +258,7 @@ export async function capabilitySnapshot() {
   const win = process.platform === 'win32';
   const mac = process.platform === 'darwin';
   const linux = process.platform === 'linux';
+  if(linux)await hydrateLinuxDesktopEnv();
   const desktopShellCapabilities = desktopShellCapabilitySnapshot();
   const desktopSession = desktopShellCapabilities.desktop_session;
   const pyAtSpi = linux && desktopSession ? await linuxHasPyAtSpi() : false;
@@ -263,6 +272,7 @@ export async function capabilitySnapshot() {
   const documentCapabilities = documentCapabilitySnapshot();
   return {
     ...desktopShellCapabilities,
+    webrtc_pilot:linux && desktopSession && webRtcWorkerAvailable(),
     windows: win || mac || (desktopSession && (commandExists('wdotool') || commandExists('wmctrl') || (wayland && pyAtSpi))),
     ui: win || mac || (desktopSession && pyAtSpi),
     input: win || mac || (desktopSession && (portalInput || x11Input || (wayland && commandExists('wtype')))),

package/src/extended/desktop-linux-displays.mjs

@@ -29,8 +29,8 @@ export function unwrapDbus(value) {
   return value;
 }
 
-export async function mutterDisplayInventory() {
-  if (!isWaylandSession()) return null;
+export async function mutterDisplayInventory({ allowUnknownSession = false } = {}) {
+  if (!allowUnknownSession && !isWaylandSession()) return null;
   let dbus;
   try { dbus = await import('@jellybrick/dbus-next'); } catch { return null; }
   const bus = dbus.sessionBus();
@@ -233,6 +233,16 @@ export async function resolveLinuxDisplayInventory({
     }
   }
 
+  // A systemd user agent can start before GNOME exports DISPLAY and
+  // XDG_SESSION_TYPE to its service. The authenticated user bus still
+  // exposes Mutter's real geometry; do not guess coordinates or use XTEST.
+  if (!wayland && !env.DISPLAY && !env.WAYLAND_DISPLAY
+      && !env.XDG_SESSION_TYPE
+      && env.DBUS_SESSION_BUS_ADDRESS && env.XDG_RUNTIME_DIR) {
+    const mutter = await mutterProbe({ allowUnknownSession:true }).catch(() => null);
+    if (Array.isArray(mutter) && mutter.length) return mutter;
+  }
+
   if (commandExistsFn('xrandr')) {
     const result = await runFileFn('xrandr', ['--query'], { label:'display inventory', allowFailure:true, timeout:2500, maxBuffer:4*1024*1024 });
     if (result.code === 0) {

package/src/extended/desktop-linux-session-env.mjs

@@ -0,0 +1,87 @@
+// A ReMCP user service can start before GNOME imports its graphical
+// session into systemd --user. Restore only verified current-user Wayland
+// environment keys; do not read arbitrary files or import secrets.
+import process from 'node:process';
+import { lstat, realpath } from 'node:fs/promises';
+import { posix } from 'node:path';
+import { runFile } from './common.mjs';
+
+const SESSION_KEYS=new Set([
+  'DISPLAY','WAYLAND_DISPLAY','XDG_SESSION_TYPE','XDG_CURRENT_DESKTOP',
+]);
+
+function sessionKeys(text) {
+  const result=Object.create(null);
+  for(const line of String(text || '').split(/\r?\n/)){
+    const idx=line.indexOf('=');
+    if(idx<1)continue;
+    const key=line.slice(0,idx);
+    if(SESSION_KEYS.has(key))result[key]=line.slice(idx+1);
+  }
+  return result;
+}
+
+export async function hydrateLinuxDesktopEnv({
+  platform=process.platform,
+  uid=typeof process.getuid==='function'?process.getuid():null,
+  env=process.env,
+  runFileFn=runFile,
+  lstatFn=lstat,
+  realpathFn=realpath,
+}={}){
+  if(platform!=='linux'||env.DISPLAY||env.WAYLAND_DISPLAY||
+     (env.XDG_SESSION_TYPE && env.XDG_SESSION_TYPE!=='wayland')||
+     !env.DBUS_SESSION_BUS_ADDRESS||!env.XDG_RUNTIME_DIR||
+     !Number.isSafeInteger(uid)||!posix.isAbsolute(env.XDG_RUNTIME_DIR)){
+    return false;
+  }
+  // Snapshot the authenticated session context before any awaited operation.
+  const runtimeDir=env.XDG_RUNTIME_DIR;
+  const busAddress=env.DBUS_SESSION_BUS_ADDRESS;
+  const sessionType=env.XDG_SESSION_TYPE;
+  let result;
+  try{
+    result=await runFileFn('systemctl',['--user','show-environment'],{
+      label:'user graphical session environment',allowFailure:true,
+      timeout:1500,maxBuffer:64*1024,
+    });
+  }catch{return false;}
+  if(result?.code!==0)return false;
+  const values=sessionKeys(result.stdout);
+  const socketName=values.WAYLAND_DISPLAY;
+  if(values.XDG_SESSION_TYPE!=='wayland'||
+     typeof socketName!=='string'||socketName.length<1||
+     socketName.length>64||socketName.includes('..')||
+     !/^[A-Za-z0-9_.-]+$/.test(socketName)){
+    return false;
+  }
+  try{
+    // A trailing slash makes lstat(path) follow a symlink on Linux. Resolve
+    // the *whole* path first to reject aliases via the final component or
+    // any parent directory; never import a display from an ambiguous root.
+    if(await realpathFn(runtimeDir)!==posix.resolve(runtimeDir))return false;
+    // The XDG runtime directory itself must be private (mode 0700),
+    // user-owned and not a symlink, in addition to the socket's owner.
+    const dir=await lstatFn(runtimeDir);
+    if(!dir.isDirectory()||dir.uid!==uid||(dir.mode&0o777)!==0o700)
+      return false;
+    const socket=await lstatFn(posix.join(runtimeDir,socketName));
+    if(!socket.isSocket()||socket.uid!==uid)return false;
+  }catch{return false;}
+  // A graphical login or session switch may complete during systemctl/lstat.
+  // Never overwrite its newer environment with an earlier snapshot.
+  if(env.DISPLAY||env.WAYLAND_DISPLAY||env.XDG_SESSION_TYPE!==sessionType||
+     env.XDG_RUNTIME_DIR!==runtimeDir||env.DBUS_SESSION_BUS_ADDRESS!==busAddress)
+    return false;
+  env.XDG_SESSION_TYPE='wayland';
+  env.WAYLAND_DISPLAY=socketName;
+  if(/^:[0-9]{1,4}(?:\.[0-9]{1,2})?$/.test(values.DISPLAY||'')){
+    env.DISPLAY=values.DISPLAY;
+  }
+  const desktop=values.XDG_CURRENT_DESKTOP;
+  if(typeof desktop==='string'&&desktop.length<=96&&
+     /^[A-Za-z0-9:_-]+$/.test(desktop)){
+    env.XDG_CURRENT_DESKTOP=desktop;
+  }
+  return true;
+}

package/src/extended/desktop-webrtc-bridge.mjs

@@ -0,0 +1,205 @@
+// Explicitly opt-in Linux proof: ReMCP device RPC -> isolated aiortc worker
+// via stdio, never a public/native HTTP listener. No OS permission bypass.
+// Not an installed production runtime feature.
+import {spawn} from 'node:child_process';
+import {existsSync,lstatSync} from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import {jsonResult} from './common.mjs';
+
+const UUID=/^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/i;
+const MAX_SDP=60_000, MAX_LINE=70_000;
+const MAX_IDLE_MS=45_000, MAX_AGE_MS=600_000;
+const SOURCE=new Set(['portal','synthetic','gst-test']);
+
+function trustedLocalFile(filename){
+  if(!filename||!path.isAbsolute(filename)||!existsSync(filename))return false;
+  try{
+    const info=lstatSync(filename);
+    return info.isFile()&&!info.isSymbolicLink()&&(info.mode&0o022)===0&&
+      (typeof process.getuid!=='function'||info.uid===process.getuid()||info.uid===0);
+  }catch{return false;}
+}
+
+export function webRtcWorkerAvailable(env=process.env,platform=process.platform){
+  if(platform!=='linux'||env.REMCP_WEBRTC_RUNTIME_PILOT!=='1')return false;
+  if(!trustedLocalFile(env.REMCP_WEBRTC_WORKER_SCRIPT)||
+     !path.isAbsolute(env.REMCP_WEBRTC_PYTHON||''))return false;
+  const source=env.REMCP_WEBRTC_DEV_SOURCE||'portal';
+  if(!SOURCE.has(source))return false;
+  if(source!=='portal'&&env.REMCP_WEBRTC_ALLOW_TEST_SOURCE!=='1')return false;
+  return existsSync(env.REMCP_WEBRTC_PYTHON);
+}
+
+export function createDesktopWebRtcBridge({
+  env=process.env,platform=process.platform,spawnChild=spawn,
+  now=Date.now,setIntervalFn=setInterval,clearIntervalFn=clearInterval,
+}={}){
+  let child=null, current=null, active=false, started=0, seen=0;
+  let stdout='', sequence=0, clock=null;
+  const waits=new Map();
+
+  function rejectWaits(){
+    for(const pending of waits.values()){
+      clearTimeout(pending.timer);
+      pending.reject(new Error('WebRTC worker disconnected'));
+    }
+    waits.clear();
+  }
+  function shutdown(){
+    if(clock){clearIntervalFn(clock);clock=null;}
+    const target=child;
+    child=null;current=null;active=false;stdout='';
+    rejectWaits();
+    if(target&&!target.killed){
+      try{target.stdin.end();target.kill('SIGTERM');}catch{}
+    }
+  }
+  function receive(chunk){
+    stdout+=chunk.toString('utf8');
+    if(Buffer.byteLength(stdout)>MAX_LINE*2)return shutdown();
+    for(let index; (index=stdout.indexOf('\n'))!==-1;){
+      const line=stdout.slice(0,index);stdout=stdout.slice(index+1);
+      if(Buffer.byteLength(line)>MAX_LINE)return shutdown();
+      let message;
+      try{message=JSON.parse(line);}catch{return shutdown();}
+      const entry=waits.get(message?.requestId);
+      if(!entry)continue;
+      waits.delete(message.requestId);
+      clearTimeout(entry.timer);
+      if(message.ok===true)entry.resolve(message);
+      else {
+        const code=['PermissionError','ValueError','WorkerFailed','Cancelled']
+          .includes(message.error)?message.error:'InvalidResponse';
+        entry.reject(new Error('WebRTC worker refused command: '+code));
+      }
+    }
+  }
+  function expired(){
+    return current!==null&&(now()-seen>=MAX_IDLE_MS||now()-started>=MAX_AGE_MS);
+  }
+  function send(op,sid,args={},timeout=5000){
+    if(!child||child.killed||!child.stdin.writable)
+      return Promise.reject(new Error('WebRTC worker unavailable'));
+    const requestId=++sequence;
+    const message=JSON.stringify({requestId,op,session_id:sid,...args})+'\n';
+    if(Buffer.byteLength(message)>MAX_LINE)
+      return Promise.reject(new Error('WebRTC request too large'));
+    return new Promise((resolve,reject)=>{
+      const timer=setTimeout(()=>{
+        waits.delete(requestId);
+        reject(new Error('WebRTC worker request timed out'));
+      },timeout);
+      timer.unref?.();
+      waits.set(requestId,{timer,resolve,reject});
+      try{
+        child.stdin.write(message,error=>{
+          if(!error)return;
+          if(!waits.delete(requestId))return;
+          clearTimeout(timer);
+          reject(new Error('WebRTC worker pipe write failed'));
+        });
+      }catch{
+        waits.delete(requestId);
+        clearTimeout(timer);
+        reject(new Error('WebRTC worker pipe write failed'));
+      }
+    });
+  }
+  function start(){
+    if(!webRtcWorkerAvailable(env,platform))
+      throw new Error('WebRTC capture is not installed or not enabled');
+    const source=env.REMCP_WEBRTC_DEV_SOURCE||'portal';
+    // Do not leak paired-device OAuth/agent credentials into an optional
+    // native media subprocess. Only desktop-session and Python/GStreamer
+    // environment required for OS ScreenCast may cross this boundary.
+    const allowed=[
+      'HOME','PATH','LANG','LC_ALL','LC_CTYPE','TZ',
+      'XDG_RUNTIME_DIR','XDG_CURRENT_DESKTOP','XDG_SESSION_TYPE',
+      'XDG_DATA_DIRS','DBUS_SESSION_BUS_ADDRESS','WAYLAND_DISPLAY',
+      'DISPLAY','GDK_BACKEND','GI_TYPELIB_PATH','PYTHONPATH',
+      'GST_PLUGIN_PATH','GST_PLUGIN_SYSTEM_PATH_1_0',
+      'REMCP_WEBRTC_USE_PORTAL_GRANT','REMCP_WEBRTC_ALLOW_TEST_SOURCE',
+    ];
+    const workerEnv=Object.fromEntries(allowed.filter(key=>typeof env[key]==='string')
+      .map(key=>[key,env[key]]));
+    // aiortc may live in a Python venv while Ubuntu supplies GObject
+    // introspection only as a distro package. Extend the worker's import
+    // path, not the agent/system environment; never install with sudo.
+    if(source==='portal'&&platform==='linux'&&existsSync('/usr/lib/python3/dist-packages')){
+      const systemPath='/usr/lib/python3/dist-packages';
+      const existing=String(workerEnv.PYTHONPATH||'').split(path.delimiter).filter(Boolean);
+      if(!existing.includes(systemPath))existing.push(systemPath);
+      workerEnv.PYTHONPATH=existing.join(path.delimiter);
+    }
+    const worker=spawnChild(env.REMCP_WEBRTC_PYTHON,
+      [env.REMCP_WEBRTC_WORKER_SCRIPT,'--source',source],{
+        stdio:['pipe','pipe','ignore'],shell:false,windowsHide:true,
+        env:workerEnv,
+      });
+    child=worker;stdout='';
+    worker.stdout.on('data',chunk=>{if(child===worker)receive(chunk);});
+    worker.once('error',()=>{if(child===worker)shutdown();});
+    worker.once('exit',()=>{if(child===worker)shutdown();});
+  }
+
+  async function offer({session_id:sid,mode,sdp},extra={}){
+    if(!UUID.test(String(sid))||mode!=='view'||typeof sdp!=='string'||
+       Buffer.byteLength(sdp)>MAX_SDP||sdp.length<100)
+      throw new Error('Invalid view-only WebRTC offer');
+    if(current!==null||child)throw new Error('Another WebRTC session is active');
+    current=sid;started=seen=now();active=false;
+    let cancelled=false;
+    const cancel=()=>{cancelled=true;shutdown();};
+    extra.signal?.addEventListener('abort',cancel,{once:true});
+    try{
+      start();
+      clock=setIntervalFn(()=>{if(expired())shutdown();},1000);
+      clock.unref?.();
+      const answer=await send('offer',sid,{sdp},19_000);
+      if(cancelled||!child||current!==sid||answer.sessionId!==sid||
+         answer.type!=='answer'||typeof answer.sdp!=='string'||
+         Buffer.byteLength(answer.sdp)>MAX_SDP||expired())
+        throw new Error('Invalid WebRTC worker answer');
+      active=true;seen=now();
+      return jsonResult({sessionId:sid,type:'answer',sdp:answer.sdp});
+    }catch(error){
+      shutdown();
+      throw error;
+    }finally{
+      extra.signal?.removeEventListener('abort',cancel);
+    }
+  }
+  async function heartbeat({session_id:sid}){
+    if(!UUID.test(String(sid))||sid!==current||!active||expired()){
+      if(expired())shutdown();
+      throw new Error('WebRTC viewer session is not active');
+    }
+    try{
+      const reply=await send('heartbeat',sid,{},4000);
+      if(reply.sessionId!==sid||!child||expired())
+        throw new Error('Invalid WebRTC lease acknowledgement');
+      seen=now();
+      return jsonResult({ok:true,sessionId:sid});
+    }catch(error){shutdown();throw error;}
+  }
+  async function stop({session_id:sid}){
+    if(!UUID.test(String(sid))||sid!==current||!child)
+      throw new Error('WebRTC viewer session not found');
+    try{
+      const reply=await send('stop',sid,{},4000);
+      if(reply.sessionId!==sid)throw new Error('Invalid WebRTC stop acknowledgement');
+      return jsonResult({ok:true,sessionId:sid});
+    }finally{shutdown();}
+  }
+  return {offer,heartbeat,stop,shutdown,
+    get activeSession(){return current;},
+  };
+}
+
+const bridge=createDesktopWebRtcBridge();
+export const desktopWebRtcHandlers={
+  desktop_webrtc_offer:(args,extra)=>bridge.offer(args,extra),
+  desktop_webrtc_heartbeat:args=>bridge.heartbeat(args),
+  desktop_webrtc_stop:args=>bridge.stop(args),
+};