@yeaft/webchat-agent 1.0.417 → 1.0.418

package/browser-runtime/browser-install.js

@@ -31,25 +31,64 @@ export const BROWSER_RUNTIME_CHROME_ARCHIVES = Object.freeze({
   linux: Object.freeze({
     fileName: 'chrome-linux64.zip',
     sha256: '6bd04aab53fba1544ce6027d9daddb24137295033124a61ecdf9840d785792e9',
+    downloadBytes: 193_285_407,
   }),
   mac: Object.freeze({
     fileName: 'chrome-mac-x64.zip',
     sha256: 'bedcd79ae533fed218c26232b74e73cffec2a7277fce42cafcf5ec7280e4f81c',
+    downloadBytes: 197_094_599,
   }),
   mac_arm: Object.freeze({
     fileName: 'chrome-mac-arm64.zip',
     sha256: '1c516b5d6c00a074034d5ce03dc1cc9bd2cde2a09293d9613244e0bc153cb80f',
+    downloadBytes: 187_099_652,
   }),
   win32: Object.freeze({
     fileName: 'chrome-win32.zip',
     sha256: '338f15dcf19d457f93f692c279843477a92324f0f91f78bf5380d3fe00a9796f',
+    downloadBytes: 175_083_534,
   }),
   win64: Object.freeze({
     fileName: 'chrome-win64.zip',
     sha256: '7ea2e94833ef710026c8cb08d0d2dafcb13f5d304d9c475ac07a3fa8c11d846c',
+    downloadBytes: 201_082_763,
   }),
 });
 
+function browserPlatformForRuntime(platform, arch) {
+  if (platform === 'linux' && arch === 'x64') return 'linux';
+  if (platform === 'darwin' && arch === 'x64') return 'mac';
+  if (platform === 'darwin' && arch === 'arm64') return 'mac_arm';
+  if (platform === 'win32' && arch === 'ia32') return 'win32';
+  if (platform === 'win32' && arch === 'x64') return 'win64';
+  return null;
+}
+
+/** Static, side-effect-free metadata shown before an explicit managed-browser install. */
+export function managedBrowserDownloadInfo({
+  platform = process.platform,
+  arch = process.arch,
+  archives = BROWSER_RUNTIME_CHROME_ARCHIVES,
+} = {}) {
+  const browserPlatform = browserPlatformForRuntime(platform, arch);
+  const archive = browserPlatform ? archives[browserPlatform] : null;
+  if (!archive) {
+    return Object.freeze({
+      supported: false,
+      buildId: BROWSER_RUNTIME_CHROME_BUILD,
+      platform: browserPlatform,
+      downloadBytes: 0,
+    });
+  }
+  return Object.freeze({
+    supported: true,
+    buildId: BROWSER_RUNTIME_CHROME_BUILD,
+    platform: browserPlatform,
+    fileName: archive.fileName,
+    downloadBytes: Number(archive.downloadBytes) || 0,
+  });
+}
+
 export function defaultBrowserCacheDir(yeaftDir) {
   if (!yeaftDir) throw new Error('yeaftDir required');
   return join(yeaftDir, 'managed-browser');

package/browser-runtime/messages.js

@@ -1,6 +1,10 @@
 import ctx from '../context.js';
+import { BrowserRuntimeError } from './errors.js';
 
 const BROWSER_MESSAGE_TYPES = new Set([
+  'browser_runtime_status',
+  'browser_runtime_install',
+  'browser_runtime_enable',
   'browser_session_create',
   'browser_session_get',
   'browser_session_list',
@@ -12,9 +16,11 @@ const BROWSER_MESSAGE_TYPES = new Set([
 ]);
 
 function errorMessage(msg, error) {
-  const peerScoped = String(msg?.type || '').startsWith('browser_peer_');
+  const type = String(msg?.type || '');
+  const peerScoped = type.startsWith('browser_peer_');
+  const setupScoped = type.startsWith('browser_runtime_');
   return {
-    type: peerScoped ? 'browser_peer_error' : 'browser_session_error',
+    type: peerScoped ? 'browser_peer_error' : setupScoped ? 'browser_runtime_error' : 'browser_session_error',
     requestId: msg?.requestId || null,
     browserSessionId: msg?.browserSessionId || null,
     ...(peerScoped ? {
@@ -26,6 +32,15 @@ function errorMessage(msg, error) {
   };
 }
 
+function assertSetupIdentity(message) {
+  const identity = message?.serverIdentity;
+  if (!identity || typeof identity !== 'object'
+      || !identity.ownerUserId || !identity.clientId
+      || !identity.webConnectionId || !identity.webConnectionGeneration) {
+    throw new BrowserRuntimeError('browser_identity_required');
+  }
+}
+
 /** Route one authenticated Server command into the Agent-local Browser Runtime. */
 export async function handleBrowserRuntimeMessage(msg, dependencies = {}) {
   if (!BROWSER_MESSAGE_TYPES.has(msg?.type)) return false;
@@ -37,6 +52,41 @@ export async function handleBrowserRuntimeMessage(msg, dependencies = {}) {
   }
   try {
     switch (msg.type) {
+      case 'browser_runtime_status':
+        assertSetupIdentity(msg);
+        await send?.({
+          type: 'browser_runtime_status_result',
+          requestId: msg.requestId || null,
+          ...(await runtime.setupStatus()),
+        });
+        break;
+      case 'browser_runtime_install': {
+        assertSetupIdentity(msg);
+        const progress = async value => send?.({
+          type: 'browser_runtime_install_progress',
+          requestId: msg.requestId || null,
+          ...value,
+        });
+        const result = await runtime.installAndEnable({
+          confirmedBuildId: msg.confirmedBuildId,
+          confirmedDownloadBytes: msg.confirmedDownloadBytes,
+          onProgress: progress,
+        });
+        await send?.({
+          type: 'browser_runtime_status_result',
+          requestId: msg.requestId || null,
+          ...result,
+        });
+        break;
+      }
+      case 'browser_runtime_enable':
+        assertSetupIdentity(msg);
+        await send?.({
+          type: 'browser_runtime_status_result',
+          requestId: msg.requestId || null,
+          ...(await runtime.enableAndProbe()),
+        });
+        break;
       case 'browser_session_create':
         await runtime.createSession(msg);
         break;

package/browser-runtime/service.js

@@ -1,12 +1,18 @@
 import { createHash, randomUUID } from 'node:crypto';
 import { normaliseBrowserRuntimeSection } from './config.js';
-import { defaultBrowserCacheDir } from './browser-install.js';
+import {
+  defaultBrowserCacheDir,
+  installManagedBrowser,
+  managedBrowserDownloadInfo,
+  resolveBrowserExecutable,
+} from './browser-install.js';
 import { probeBrowserRuntime } from './probe.js';
 import { BrowserRuntimeError } from './errors.js';
 import { BrowserExtensionBridge } from './local-bridge.js';
 import { launchBrowserSession } from './chromium.js';
 
 const REQUEST_TTL_MS = 10 * 60_000;
+const MAX_INSTALL_PROGRESS_LISTENERS = 8;
 
 function clean(value, max = 512) {
   return typeof value === 'string' ? value.trim().slice(0, max) : '';
@@ -89,47 +95,156 @@ export class BrowserRuntimeService {
     yeaftDir,
     config,
     probe = probeBrowserRuntime,
+    resolveBrowser = resolveBrowserExecutable,
+    installBrowser = installManagedBrowser,
+    downloadInfo = managedBrowserDownloadInfo,
+    saveSettings = null,
+    onCapabilitiesChanged = null,
     bridge = new BrowserExtensionBridge(),
     launchSession = launchBrowserSession,
     send = null,
     platform = process.platform,
+    arch = process.arch,
   } = {}) {
     if (!yeaftDir) throw new Error('yeaftDir required');
     this.yeaftDir = yeaftDir;
     this.config = normaliseBrowserRuntimeSection(config);
     this.config.cacheDir ||= defaultBrowserCacheDir(yeaftDir);
     this.probe = probe;
+    this.resolveBrowser = resolveBrowser;
+    this.installBrowser = installBrowser;
+    this.downloadInfo = downloadInfo;
+    this.saveSettings = typeof saveSettings === 'function' ? saveSettings : null;
+    this.onCapabilitiesChanged = typeof onCapabilitiesChanged === 'function' ? onCapabilitiesChanged : null;
     this.bridge = bridge;
     this.launchSession = launchSession;
     this.send = typeof send === 'function' ? send : () => 'dropped';
     this.platform = platform;
+    this.arch = arch;
+    const download = this.downloadInfo({ platform, arch });
+    this.setupInfo = Object.freeze({
+      ...download,
+      // Phase 1 advertises only the real Linux tab-capture data plane. The CLI
+      // may manage pinned binaries on more platforms, but Web must not offer an
+      // install that can never produce a ready capability.
+      supported: download.supported === true && platform === 'linux' && arch === 'x64',
+    });
     this.sessions = new Map();
     this.requests = new Map();
     this.probeResult = null;
+    this.installProgress = null;
+    this.lastSetupError = null;
     this.state = this.config.enabled ? 'unprobed' : 'disabled';
     this.#probePromise = null;
     this.#probeAbort = null;
+    this.#installPromise = null;
+    this.#installAbort = null;
+    this.#installListeners = new Set();
+    this.#lastInstallProgressAt = 0;
     this.#shutdownPromise = null;
   }
 
   #probePromise;
   #probeAbort;
+  #installPromise;
+  #installAbort;
+  #installListeners;
+  #lastInstallProgressAt;
   #shutdownPromise;
 
   get enabled() { return this.config.enabled === true; }
   get ready() { return this.state === 'ready' && this.probeResult?.ok === true; }
 
+  setupCapabilities() {
+    return this.setupInfo.supported ? ['browser_runtime_setup'] : [];
+  }
+
   capabilities() {
     if (!this.ready || this.platform !== 'linux' || this.probeResult?.captureMode !== 'tab') return [];
     return ['browser_runtime', 'browser_webrtc', 'browser_capture_tab'];
   }
 
-  async startupProbe() {
+  async #notifyCapabilitiesChanged() {
+    try {
+      await this.onCapabilitiesChanged?.();
+    } catch (error) {
+      console.warn(`[BrowserRuntime] capability refresh failed: ${error?.message || error}`);
+    }
+  }
+
+  async #persistEnabled({ managed = false } = {}) {
+    const update = {
+      enabled: true,
+      ...(managed ? { executablePath: null } : {}),
+    };
+    if (this.saveSettings) {
+      const saved = await this.saveSettings(update);
+      if (saved?.error) {
+        throw new BrowserRuntimeError('browser_config_update_failed', saved.error);
+      }
+      this.config = {
+        ...this.config,
+        ...normaliseBrowserRuntimeSection(saved),
+        cacheDir: this.config.cacheDir,
+      };
+    } else {
+      this.config = { ...this.config, ...update };
+    }
+    this.config.enabled = true;
+    if (managed) this.config.executablePath = null;
+  }
+
+  async setupStatus() {
+    let executablePath = null;
+    if (this.setupInfo.supported) {
+      try {
+        executablePath = await this.resolveBrowser({
+          executablePath: this.config.executablePath,
+          cacheDir: this.config.cacheDir,
+        });
+        if (this.lastSetupError?.source === 'status') this.lastSetupError = null;
+      } catch (error) {
+        if (!this.lastSetupError || this.lastSetupError.source === 'status') {
+          this.lastSetupError = {
+            source: 'status',
+            code: error?.code || 'browser_status_failed',
+            safeError: String(error?.message || error).slice(0, 500),
+          };
+        }
+      }
+    }
+    const installed = !!executablePath;
+    if (this.ready) this.lastSetupError = null;
+    const state = !this.setupInfo.supported ? 'unsupported'
+      : this.ready ? 'ready'
+        : this.#installPromise ? 'installing'
+          : this.state === 'probing' ? 'probing'
+            : this.probeResult && this.config.enabled ? 'unavailable'
+              : installed ? 'disabled'
+                : 'not_installed';
+    return Object.freeze({
+      supported: this.setupInfo.supported,
+      state,
+      installed,
+      enabled: this.enabled,
+      ready: this.ready,
+      buildId: this.setupInfo.buildId,
+      platform: this.setupInfo.platform,
+      downloadBytes: this.setupInfo.downloadBytes,
+      downloadedBytes: Number(this.installProgress?.downloadedBytes) || 0,
+      totalBytes: Number(this.installProgress?.totalBytes) || this.setupInfo.downloadBytes,
+      probeCode: this.probeResult?.code || null,
+      safeError: this.lastSetupError?.safeError || this.probeResult?.safeError || null,
+    });
+  }
+
+  async startupProbe({ force = false } = {}) {
     if (!this.enabled) return { ok: false, code: 'browser_runtime_disabled' };
     if (this.#probePromise) return this.#probePromise;
+    if (!force && this.ready) return this.probeResult;
     this.state = 'probing';
     this.#probeAbort = new AbortController();
-    this.#probePromise = this.probe({
+    const probePromise = this.probe({
       executablePath: this.config.executablePath,
       cacheDir: this.config.cacheDir,
       headless: this.config.headless,
@@ -148,8 +263,105 @@ export class BrowserRuntimeService {
       });
       this.state = 'unavailable';
       return this.probeResult;
+    }).finally(() => {
+      if (this.#probePromise === probePromise) this.#probePromise = null;
+      this.#probeAbort = null;
     });
-    return this.#probePromise;
+    this.#probePromise = probePromise;
+    return probePromise;
+  }
+
+  async enableAndProbe() {
+    if (!this.setupInfo.supported) throw new BrowserRuntimeError('browser_platform_unsupported');
+    this.lastSetupError = null;
+    try {
+      const executablePath = await this.resolveBrowser({
+        executablePath: this.config.executablePath,
+        cacheDir: this.config.cacheDir,
+      });
+      if (!executablePath) throw new BrowserRuntimeError('browser_executable_missing');
+      await this.#persistEnabled();
+      this.probeResult = null;
+      const probe = await this.startupProbe({ force: true });
+      await this.#notifyCapabilitiesChanged();
+      return { ...(await this.setupStatus()), probeCode: probe.code || null };
+    } catch (error) {
+      this.lastSetupError = {
+        source: 'enable',
+        code: error?.code || 'browser_enable_failed',
+        safeError: String(error?.message || error).slice(0, 500),
+      };
+      throw error;
+    }
+  }
+
+  async installAndEnable({ confirmedBuildId, confirmedDownloadBytes, onProgress = null } = {}) {
+    if (!this.setupInfo.supported) throw new BrowserRuntimeError('browser_platform_unsupported');
+    if (confirmedBuildId !== this.setupInfo.buildId
+        || Number(confirmedDownloadBytes) !== this.setupInfo.downloadBytes) {
+      throw new BrowserRuntimeError('browser_install_confirmation_stale');
+    }
+    if (typeof onProgress === 'function') {
+      if (this.#installListeners.size >= MAX_INSTALL_PROGRESS_LISTENERS) {
+        throw new BrowserRuntimeError('browser_install_observer_limit');
+      }
+      this.#installListeners.add(onProgress);
+    }
+    if (!this.#installPromise) {
+      this.state = 'installing';
+      this.lastSetupError = null;
+      this.installProgress = Object.freeze({
+        downloadedBytes: 0,
+        totalBytes: this.setupInfo.downloadBytes,
+      });
+      this.#installAbort = new AbortController();
+      const installPromise = (async () => {
+        await this.installBrowser({
+          cacheDir: this.config.cacheDir,
+          signal: this.#installAbort.signal,
+          onProgress: (downloadedBytes, totalBytes) => {
+            const total = Number(totalBytes) || this.setupInfo.downloadBytes;
+            this.installProgress = Object.freeze({
+              downloadedBytes: Number(downloadedBytes) || 0,
+              totalBytes: total,
+            });
+            const now = Date.now();
+            if (now - this.#lastInstallProgressAt < 250 && downloadedBytes < total) return;
+            this.#lastInstallProgressAt = now;
+            for (const listener of this.#installListeners) {
+              try {
+                Promise.resolve(listener(this.installProgress)).catch(() => {});
+              } catch {}
+            }
+          },
+        });
+        await this.#persistEnabled({ managed: true });
+        this.probeResult = null;
+        await this.startupProbe({ force: true });
+        await this.#notifyCapabilitiesChanged();
+        return this.setupStatus();
+      })().catch(error => {
+        this.lastSetupError = {
+          source: 'install',
+          code: error?.code || 'browser_install_failed',
+          safeError: String(error?.message || error).slice(0, 500),
+        };
+        this.state = 'unavailable';
+        throw error;
+      }).finally(() => {
+        if (this.#installPromise === installPromise) {
+          this.#installPromise = null;
+          this.#installAbort = null;
+        }
+        this.#installListeners.clear();
+      });
+      this.#installPromise = installPromise;
+    }
+    try {
+      return await this.#installPromise;
+    } finally {
+      if (typeof onProgress === 'function') this.#installListeners.delete(onProgress);
+    }
   }
 
   #emit(message) {
@@ -625,7 +837,11 @@ export class BrowserRuntimeService {
   async shutdown() {
     if (this.#shutdownPromise) return this.#shutdownPromise;
     this.#probeAbort?.abort(new BrowserRuntimeError('browser_runtime_shutdown'));
-    this.#shutdownPromise = Promise.resolve(this.#probePromise).catch(() => {}).then(async () => {
+    this.#installAbort?.abort(new BrowserRuntimeError('browser_runtime_shutdown'));
+    this.#shutdownPromise = Promise.allSettled([
+      Promise.resolve(this.#probePromise),
+      Promise.resolve(this.#installPromise),
+    ]).then(async () => {
       await Promise.allSettled([...this.sessions.values()]
         .map(session => this.closeSessionRecord(session, 'browser_runtime_shutdown', { emit: false })));
       await this.bridge.close();

package/index.js

@@ -23,6 +23,7 @@ import { connect } from './connection.js';
 import { loadMcpServers } from './mcp.js';
 import { SAFE_REMOTE_UPGRADE_CAPABILITY } from './upgrade-command.js';
 import { loadConfig as loadYeaftConfig } from './yeaft/config.js';
+import { updateBrowserRuntimeSettings } from './yeaft/config-api.js';
 import { bootBrowserRuntime, shutdownBrowserRuntime } from './browser-runtime/index.js';
 import {
   ensureManagedCliTools,
@@ -164,7 +165,9 @@ async function detectCapabilities() {
   if (process.platform === 'linux') capabilities.push('work_item_attachments');
   const pty = await loadNodePty();
   if (pty) capabilities.push('terminal');
-  if (ctx.browserRuntime) capabilities.push(...ctx.browserRuntime.capabilities());
+  if (ctx.browserRuntime) {
+    capabilities.push(...ctx.browserRuntime.setupCapabilities(), ...ctx.browserRuntime.capabilities());
+  }
 
   console.log(`[Capabilities] Detected: ${capabilities.join(', ')}`);
   return capabilities;
@@ -404,6 +407,14 @@ process.on('SIGTERM', async () => {
     ctx.browserRuntime = await bootBrowserRuntime({
       yeaftDir: YEAFT_DIR,
       config: runtimeConfig,
+      saveSettings: update => updateBrowserRuntimeSettings(update, YEAFT_DIR),
+      onCapabilitiesChanged: async () => {
+        ctx.agentCapabilities = await detectCapabilities();
+        ctx.sendToServer?.({
+          type: 'agent_capabilities_updated',
+          capabilities: ctx.agentCapabilities,
+        });
+      },
       send: message => ctx.sendToServer?.(message) || 'dropped',
     });
     const probe = ctx.browserRuntime.snapshot().probe;

package/local-runtime/server/browser-runtime-routes.js

@@ -6,6 +6,7 @@ const MAX_ROUTES = 2048;
 const MAX_PEERS = 4096;
 const MAX_CREATE_REQUESTS = 4096;
 const CREATE_REQUEST_TTL_MS = 10 * 60_000;
+const INSTALL_REQUEST_TTL_MS = 60 * 60_000;
 
 export const browserRoutes = new Map();
 export const browserPeers = new Map();
@@ -66,7 +67,13 @@ export function pruneBrowserRuntimeRoutes(now = Date.now()) {
   }
 }
 
-export function registerBrowserCreateRequest({ agentId, client, requestId, digest }) {
+export function registerBrowserCreateRequest({
+  agentId,
+  client,
+  requestId,
+  digest,
+  kind = 'browser_session_create',
+}) {
   pruneBrowserRuntimeRoutes();
   const requestKey = createKey(agentId, client.connectionId, requestId);
   const existing = browserRequests.get(requestKey);
@@ -84,17 +91,29 @@ export function registerBrowserCreateRequest({ agentId, client, requestId, diges
     webConnectionId: client.connectionId,
     webConnectionGeneration: client.connectionGeneration,
     digest,
+    kind,
     state: 'pending',
     response: null,
-    expiresAt: Date.now() + CREATE_REQUEST_TTL_MS,
+    expiresAt: Date.now() + (kind === 'browser_runtime_install'
+      ? INSTALL_REQUEST_TTL_MS
+      : CREATE_REQUEST_TTL_MS),
   };
   browserRequests.set(requestKey, request);
   return { request };
 }
 
-export function completeBrowserRequest(agentId, msg, { consume = false } = {}) {
+export function findBrowserRequest(agentId, serverRequestId) {
+  for (const request of browserRequests.values()) {
+    if (request.agentId === agentId && request.serverRequestId === serverRequestId) return request;
+  }
+  return null;
+}
+
+export function completeBrowserRequest(agentId, msg, { consume = false, kinds = null } = {}) {
+  const allowedKinds = kinds == null ? null : new Set(Array.isArray(kinds) ? kinds : [kinds]);
   for (const [requestKey, request] of browserRequests) {
     if (request.agentId !== agentId || request.serverRequestId !== msg.requestId || request.state !== 'pending') continue;
+    if (allowedKinds && !allowedKinds.has(request.kind)) continue;
     request.state = msg.type.endsWith('_error') ? 'failed' : 'completed';
     request.response = { ...msg, requestId: request.requestId };
     request.expiresAt = Date.now() + CREATE_REQUEST_TTL_MS;

package/local-runtime/server/client-protocol.js

@@ -1,5 +1,6 @@
 export const WORKBENCH_ROUTE_PROTOCOL = 1;
 export const BROWSER_RUNTIME_PROTOCOL = 1;
+export const BROWSER_RUNTIME_SETUP_PROTOCOL = 1;
 
 /**
  * Apply the explicit browser protocol hello to one Server-owned client record.
@@ -14,5 +15,8 @@ export function applyClientHello(client, message) {
   if (message.browserRuntimeProtocol === BROWSER_RUNTIME_PROTOCOL) {
     client.browserRuntimeProtocol = BROWSER_RUNTIME_PROTOCOL;
   }
+  if (message.browserRuntimeSetupProtocol === BROWSER_RUNTIME_SETUP_PROTOCOL) {
+    client.browserRuntimeSetupProtocol = BROWSER_RUNTIME_SETUP_PROTOCOL;
+  }
   return true;
 }

package/local-runtime/server/handlers/agent-browser.js

@@ -5,6 +5,7 @@ import {
   browserRoutes,
   completeBrowserRequest,
   deleteBrowserPeer,
+  findBrowserRequest,
   deleteBrowserRoute,
   getBrowserPeer,
   getBrowserRoute,
@@ -12,6 +13,9 @@ import {
 } from '../browser-runtime-routes.js';
 
 const AGENT_BROWSER_TYPES = new Set([
+  'browser_runtime_status_result',
+  'browser_runtime_install_progress',
+  'browser_runtime_error',
   'browser_session_created',
   'browser_session_error',
   'browser_session_snapshot',
@@ -56,6 +60,50 @@ function sessionSnapshot(msg) {
   };
 }
 
+function safeByteCount(value) {
+  const number = Number(value);
+  if (!Number.isSafeInteger(number) || number < 0) return 0;
+  return Math.min(number, 4 * 1024 * 1024 * 1024);
+}
+
+function publicRuntimeMessage(agentId, requestId, msg) {
+  if (msg?.type === 'browser_runtime_error') {
+    return {
+      type: msg.type,
+      agentId,
+      requestId,
+      code: clean(msg.code, 128) || 'browser_runtime_error',
+      safeError: clean(msg.safeError, 500) || null,
+    };
+  }
+  if (msg?.type === 'browser_runtime_install_progress') {
+    return {
+      type: msg.type,
+      agentId,
+      requestId,
+      downloadedBytes: safeByteCount(msg.downloadedBytes),
+      totalBytes: safeByteCount(msg.totalBytes),
+    };
+  }
+  return {
+    type: 'browser_runtime_status_result',
+    agentId,
+    requestId,
+    supported: msg?.supported === true,
+    state: clean(msg?.state, 32) || 'unknown',
+    installed: msg?.installed === true,
+    enabled: msg?.enabled === true,
+    ready: msg?.ready === true,
+    buildId: clean(msg?.buildId, 128) || null,
+    platform: clean(msg?.platform, 32) || null,
+    downloadBytes: safeByteCount(msg?.downloadBytes),
+    downloadedBytes: safeByteCount(msg?.downloadedBytes),
+    totalBytes: safeByteCount(msg?.totalBytes),
+    probeCode: clean(msg?.probeCode, 128) || null,
+    safeError: clean(msg?.safeError, 500) || null,
+  };
+}
+
 function publicSessionMessage(agentId, msg) {
   if (msg?.type === 'browser_session_error') {
     return {
@@ -84,7 +132,7 @@ function publicSessionMessage(agentId, msg) {
 }
 
 async function sendCreateResponse(agentId, msg) {
-  const request = completeBrowserRequest(agentId, msg);
+  const request = completeBrowserRequest(agentId, msg, { kinds: 'browser_session_create' });
   if (!request) return true;
   const client = browserClientForPeer({
     clientId: request.clientId,
@@ -130,13 +178,47 @@ async function sendCreateResponse(agentId, msg) {
 /** Agent-authenticated Browser events routed only through Server-owned ledgers. */
 export async function handleAgentBrowser(agentId, agent, msg) {
   if (!AGENT_BROWSER_TYPES.has(msg?.type)) return false;
+  if (msg.type === 'browser_runtime_install_progress') {
+    const request = findBrowserRequest(agentId, msg.requestId);
+    if (!request || request.state !== 'pending' || request.kind !== 'browser_runtime_install') return true;
+    const client = browserClientForPeer({
+      clientId: request.clientId,
+      webConnectionId: request.webConnectionId,
+      webConnectionGeneration: request.webConnectionGeneration,
+    });
+    if (client?.userId === request.ownerUserId) {
+      await sendToWebClient(client, publicRuntimeMessage(agentId, request.requestId, msg));
+    }
+    return true;
+  }
+  if (msg.type === 'browser_runtime_status_result' || msg.type === 'browser_runtime_error') {
+    const pendingRequest = findBrowserRequest(agentId, msg.requestId);
+    const request = completeBrowserRequest(agentId, msg, {
+      consume: pendingRequest?.kind === 'browser_runtime_status',
+      kinds: ['browser_runtime_status', 'browser_runtime_install', 'browser_runtime_enable'],
+    });
+    if (!request) return true;
+    const client = browserClientForPeer({
+      clientId: request.clientId,
+      webConnectionId: request.webConnectionId,
+      webConnectionGeneration: request.webConnectionGeneration,
+    });
+    if (client?.userId !== request.ownerUserId) return true;
+    const response = publicRuntimeMessage(agentId, request.requestId, msg);
+    request.response = response;
+    await sendToWebClient(client, response);
+    return true;
+  }
   if (msg.type === 'browser_session_created'
       || (msg.type === 'browser_session_error' && msg.requestId)) {
     return sendCreateResponse(agentId, msg);
   }
 
   if (msg.type === 'browser_session_list_result') {
-    const request = completeBrowserRequest(agentId, msg, { consume: true });
+    const request = completeBrowserRequest(agentId, msg, {
+      consume: true,
+      kinds: 'browser_session_list',
+    });
     if (!request) return true;
     for (const snapshot of Array.isArray(msg.sessions) ? msg.sessions : []) {
       if (!snapshot?.browserSessionId) continue;
@@ -154,7 +236,10 @@ export async function handleAgentBrowser(agentId, agent, msg) {
   }
 
   if (msg.type === 'browser_session_snapshot' && msg.requestId) {
-    const request = completeBrowserRequest(agentId, msg, { consume: true });
+    const request = completeBrowserRequest(agentId, msg, {
+      consume: true,
+      kinds: ['browser_session_get', 'browser_session_close'],
+    });
     if (!request) return true;
     const client = browserClientForPeer({
       clientId: request.clientId,