neoagent 2.4.0 → 2.4.1-beta.10

package/server/services/manager.js

@@ -383,8 +383,14 @@ function createScreenRecorder(app) {
 
     const extensionRegistry = app.locals.browserExtensionRegistry;
     if (extensionRegistry?.connectionsByUser instanceof Map) {
-      for (const connection of extensionRegistry.connectionsByUser.values()) {
-        if (typeof connection?.isOpen === 'function' && connection.isOpen()) {
+      for (const value of extensionRegistry.connectionsByUser.values()) {
+        if (value instanceof Map) {
+          for (const connection of value.values()) {
+            if (typeof connection?.isOpen === 'function' && connection.isOpen()) {
+              return true;
+            }
+          }
+        } else if (typeof value?.isOpen === 'function' && value.isOpen()) {
           return true;
         }
       }
@@ -438,6 +444,7 @@ function configureRealtime(app, io, services) {
     recordingManager: services.recordingManager,
     memoryManager: services.memoryManager,
     voiceRuntimeManager: services.voiceRuntimeManager,
+    streamHub: app.locals.streamHub || services.streamHub || null,
     app,
   });
   app.locals.io = io;
@@ -516,6 +523,7 @@ async function startServices(app, io) {
       recordingManager,
       memoryManager,
       voiceRuntimeManager,
+      streamHub: app.locals.streamHub || null,
     });
 
     resumePendingRecordingSessions(recordingManager);
@@ -541,6 +549,15 @@ async function stopServices(app) {
     }
   }
 
+  if (app.locals.streamHub) {
+    try {
+      await app.locals.streamHub.shutdown();
+      logServiceReady('Stream hub stopped');
+    } catch (err) {
+      console.error('[StreamHub] Shutdown error:', getErrorMessage(err));
+    }
+  }
+
   if (app.locals.memoryIngestionService) {
     try {
       app.locals.memoryIngestionService.stop();

package/server/services/runtime/backends/local-vm.js

@@ -253,6 +253,12 @@ class VmBrowserProvider {
   extract(selector, attribute, all = false) { return this.client.request('POST', '/browser/extract', { selector, attribute, all }); }
   evaluate(script) { return this.client.request('POST', '/browser/execute', { code: script }); }
   async screenshot(options = {}) { return this.#materialize(await this.client.request('POST', '/browser/screenshot', options)); }
+  async screenshotJpeg(quality = 80, options = {}) {
+    const result = await this.client.request('POST', '/browser/screenshot-jpeg', { ...options, quality });
+    const content = String(result?.contentBase64 || '');
+    if (!content) throw new Error('VM browser screenshot-jpeg returned no data.');
+    return Buffer.from(content, 'base64');
+  }
   launch(options = {}) { return this.client.request('POST', '/browser/launch', options); }
   closeBrowser() { return this.client.request('POST', '/browser/close'); }
   fill(selector, value) { return this.type(selector, value); }

package/server/services/runtime/docker-vm-manager.js

@@ -102,17 +102,38 @@ const server = http.createServer(async (req, res) => {
 
     // ── CLI execution ──────────────────────────────────────────────────────
     if (req.method === 'POST' && url === '/exec') {
+      const timeoutMs = Math.min(Number(b.timeout) || 15 * 60 * 1000, 20 * 60 * 1000);
       const child = spawn('sh', ['-c', b.command || 'true'], {
         cwd: b.cwd || '/tmp',
         env: { ...process.env, ...b.env },
       });
       const pid = child.pid;
-      let stdout = '', stderr = '';
+      let stdout = '', stderr = '', settled = false;
       procs.set(pid, child);
       child.stdout.on('data', d => { stdout += d; });
       child.stderr.on('data', d => { stderr += d; });
-      child.on('close', code => { procs.delete(pid); json(res, { stdout, stderr, code: code ?? 1, pid }); });
-      child.on('error', err => { procs.delete(pid); json(res, { stdout, stderr, code: 1, pid, error: err.message }); });
+      const timer = setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        procs.delete(pid);
+        try { child.kill('SIGKILL'); } catch {}
+        json(res, { stdout, stderr, exitCode: null, code: null, pid, timedOut: true, killed: true });
+      }, timeoutMs);
+      child.on('close', code => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        procs.delete(pid);
+        const exitCode = code ?? 1;
+        json(res, { stdout, stderr, exitCode, code: exitCode, pid, timedOut: false, killed: false });
+      });
+      child.on('error', err => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        procs.delete(pid);
+        json(res, { stdout, stderr, exitCode: 1, code: 1, pid, error: err.message, timedOut: false, killed: false });
+      });
       return;
     }
 
@@ -268,6 +289,7 @@ class DockerVMManager {
     this.image = options.image || CONTAINER_IMAGE;
     this.memoryMb = options.memoryMb || 2048;
     this.cpus = options.cpus || 2;
+    this.guestToken = String(options.guestToken || process.env.NEOAGENT_VM_GUEST_TOKEN || '').trim();
     this.#cleanupOrphans();
   }
 
@@ -309,6 +331,7 @@ class DockerVMManager {
       '--cpus', String(this.cpus),
       '-p', `127.0.0.1:${port}:${port}`,
       '-e', `AGENT_PORT=${port}`,
+      ...(this.guestToken ? ['-e', `NEOAGENT_VM_GUEST_TOKEN=${this.guestToken}`] : []),
       '--shm-size=2g',
       '--security-opt', 'no-new-privileges',
       '--label', CONTAINER_LABEL,

package/server/services/runtime/manager.js

@@ -31,10 +31,11 @@ class RuntimeManager {
     this.artifactStore = options.artifactStore || null;
 
     this.getExtensionBrowserProvider = options.getExtensionBrowserProvider
-      || ((userId) => new ExtensionBrowserProvider({
+      || ((userId, providerOptions = {}) => new ExtensionBrowserProvider({
         registry: options.browserExtensionRegistry,
         artifactStore: options.artifactStore,
         userId,
+        tokenId: providerOptions.tokenId || null,
       }));
 
     this.getDesktopCliProvider = options.getDesktopCliProvider
@@ -51,10 +52,11 @@ class RuntimeManager {
   }
 
   hasActiveExtensionBrowser(userId) {
+    const settings = this.getSettings(userId);
     return Boolean(
       this.browserExtensionRegistry
       && typeof this.browserExtensionRegistry.isConnected === 'function'
-      && this.browserExtensionRegistry.isConnected(userId)
+      && this.browserExtensionRegistry.isConnected(userId, settings.browser_extension_token_id)
     );
   }
 
@@ -92,7 +94,9 @@ class RuntimeManager {
   async getBrowserProviderForUser(userId) {
     const settings = this.getSettings(userId);
     if (settings.browser_backend === 'extension' && this.hasActiveExtensionBrowser(userId)) {
-      return this.getExtensionBrowserProvider(userId);
+      return this.getExtensionBrowserProvider(userId, {
+        tokenId: settings.browser_extension_token_id,
+      });
     }
     return this.browserBackend.getBrowserProviderForUser(userId);
   }
@@ -100,9 +104,36 @@ class RuntimeManager {
   async getCliProviderForUser(userId) {
     const settings = this.getSettings(userId);
     if (settings.cli_backend === 'desktop' && this.hasActiveDesktopCompanion(userId)) {
-      return this.getDesktopCliProvider(userId);
+      const desktopProvider = this.getDesktopCliProvider(userId);
+      const preferredDeviceId = settings.cli_desktop_device_id;
+      if (preferredDeviceId) {
+        desktopProvider.selectDevice(preferredDeviceId);
+      }
+      return {
+        backend: 'desktop-companion',
+        execute: (command, options = {}) => desktopProvider.executeCommand(command, options),
+        executeInteractive: (command, inputs = [], options = {}) => desktopProvider.executeCommand(command, { ...options, inputs }),
+        kill: () => Promise.resolve(false),
+      };
     }
-    return this.browserBackend.getCommandExecutorForUser(userId);
+    const executor = await this.browserBackend.getCommandExecutorForUser(userId);
+    return { ...executor, backend: 'vm' };
+  }
+
+  async executeCliCommand(userId, command, options = {}) {
+    const provider = await this.getCliProviderForUser(userId);
+    const result = await (options.pty === true && provider.executeInteractive
+      ? provider.executeInteractive(command, options.inputs || [], options)
+      : provider.execute(command, options));
+    return { ...result, backend: provider.backend };
+  }
+
+  getActiveBrowserBackend(userId) {
+    const settings = this.getSettings(userId);
+    if (settings.browser_backend === 'extension' && this.hasActiveExtensionBrowser(userId)) {
+      return 'extension';
+    }
+    return 'vm';
   }
 
   async getAndroidProviderForUser(userId) {

package/server/services/runtime/settings.js

@@ -10,6 +10,9 @@ function createDefaultRuntimeSettings() {
     android_backend: policy.runtimeDefaults.android_backend,
     mcp_backend: policy.runtimeDefaults.mcp_backend,
     cli_backend: policy.runtimeDefaults.cli_backend ?? 'vm',
+    browser_extension_token_id: null,
+    selected_browser_extension_token_id: null,
+    cli_desktop_device_id: null,
   };
 }
 
@@ -26,6 +29,9 @@ const BASE_FALLBACK_SETTINGS = Object.freeze({
   android_backend: 'host',
   mcp_backend: 'host-remote',
   cli_backend: 'vm',
+  browser_extension_token_id: null,
+  selected_browser_extension_token_id: null,
+  cli_desktop_device_id: null,
 });
 
 const RUNTIME_SETTING_KEYS = Object.freeze(Object.keys(DEFAULT_RUNTIME_SETTINGS));
@@ -35,6 +41,11 @@ function normalizeChoice(value, allowed, fallback) {
   return allowed.includes(normalized) ? normalized : fallback;
 }
 
+function normalizeOptionalString(value) {
+  const normalized = String(value || '').trim();
+  return normalized || null;
+}
+
 function deriveDefaultsForProfile(profile) {
   switch (profile) {
     case 'secure-vm':
@@ -57,6 +68,9 @@ function normalizeRuntimeSettings(raw = {}) {
   const runtimeBackend = normalizeChoice(raw.runtime_backend, ['vm'], derived.runtime_backend);
   const browserBackend = normalizeChoice(raw.browser_backend, ['vm', 'extension'], derived.browser_backend);
   const cliBackend = normalizeChoice(raw.cli_backend, ['vm', 'desktop'], derived.cli_backend ?? 'vm');
+  const selectedExtensionTokenId = normalizeOptionalString(
+    raw.browser_extension_token_id || raw.selected_browser_extension_token_id,
+  );
   const androidBackend = 'host';
   return {
     runtime_profile: profile === 'trusted-host' ? 'secure-vm' : profile,
@@ -65,6 +79,9 @@ function normalizeRuntimeSettings(raw = {}) {
     android_backend: androidBackend,
     mcp_backend: 'host-remote',
     cli_backend: cliBackend === 'desktop' ? 'desktop' : 'vm',
+    browser_extension_token_id: selectedExtensionTokenId,
+    selected_browser_extension_token_id: selectedExtensionTokenId,
+    cli_desktop_device_id: normalizeOptionalString(raw.cli_desktop_device_id),
   };
 }
 

package/server/services/streaming/android-stream.js

@@ -0,0 +1,298 @@
+'use strict';
+
+const path = require('path');
+const { spawn } = require('child_process');
+const { EventEmitter } = require('events');
+const sharp = require('sharp');
+
+// Derive the full path to the `adb` binary the same way the Android controller does.
+function resolveAdbBin(sdkDir) {
+  if (sdkDir) {
+    return path.join(sdkDir, 'platform-tools', process.platform === 'win32' ? 'adb.exe' : 'adb');
+  }
+  return process.platform === 'win32' ? 'adb.exe' : 'adb'; // fall back to PATH
+}
+
+function clampInt(value, fallback, min, max) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) return fallback;
+  return Math.min(max, Math.max(min, Math.floor(parsed)));
+}
+
+// ---------------------------------------------------------------------------
+// JpegFrameParser — extracts complete JPEG images from a raw byte stream.
+// ffmpeg writes MJPEG to stdout as a continuous stream of JPEG frames, each
+// delimited by SOI (FF D8) and EOI (FF D9) markers.  We buffer incoming
+// chunks and emit a 'frame' event for every complete JPEG found.
+// ---------------------------------------------------------------------------
+class JpegFrameParser extends EventEmitter {
+  constructor() {
+    super();
+    this._buf = null; // Buffer | null
+  }
+
+  push(chunk) {
+    if (!chunk?.length) return;
+    this._buf = this._buf ? Buffer.concat([this._buf, chunk]) : Buffer.from(chunk);
+    let start = 0;
+
+    while (start < this._buf.length - 1) {
+      // Locate SOI marker (0xFF 0xD8).
+      let soiIdx = -1;
+      for (let i = start; i < this._buf.length - 1; i++) {
+        if (this._buf[i] === 0xff && this._buf[i + 1] === 0xd8) {
+          soiIdx = i;
+          break;
+        }
+      }
+      if (soiIdx === -1) {
+        // No SOI found – discard everything.
+        this._buf = null;
+        return;
+      }
+
+      // Locate EOI marker (0xFF 0xD9) that comes after SOI.
+      let eoiIdx = -1;
+      for (let i = soiIdx + 2; i < this._buf.length - 1; i++) {
+        if (this._buf[i] === 0xff && this._buf[i + 1] === 0xd9) {
+          eoiIdx = i;
+          break;
+        }
+      }
+      if (eoiIdx === -1) {
+        // SOI found but no matching EOI yet – keep buffered from SOI onward.
+        this._buf = soiIdx > 0 ? this._buf.slice(soiIdx) : this._buf;
+        return;
+      }
+
+      // Emit the complete JPEG (inclusive of both markers).
+      this.emit('frame', this._buf.slice(soiIdx, eoiIdx + 2));
+      start = eoiIdx + 2;
+    }
+
+    // Retain any leftover bytes that haven't formed a complete frame yet.
+    this._buf = start < this._buf.length ? this._buf.slice(start) : null;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// AndroidStream
+//
+// Streams the Android emulator screen by:
+//   1. Running `adb exec-out screenrecord --output-format=h264 -` to get a
+//      continuous H.264 bitstream at up to 30 fps with no per-frame process
+//      overhead (replacing the previous one-shot screencap-per-frame approach).
+//   2. Piping the bitstream through `ffmpeg` which decodes H.264 and re-encodes
+//      each frame as MJPEG at the requested fps / quality.
+//   3. Parsing complete JPEG frames from ffmpeg stdout via JpegFrameParser and
+//      forwarding them to StreamHub.
+//   4. Auto-restarting when Android's built-in 3-minute screenrecord limit
+//      expires (~170 s to give a small safety margin).
+//   5. Falling back to screencap polling when H.264 streaming cannot start
+//      (e.g. older device without screenrecord stdout support).
+// ---------------------------------------------------------------------------
+class AndroidStream {
+  constructor({ userId, deviceId, controller, streamHub, fps = 12, quality = 75 }) {
+    this.userId = String(userId || '');
+    this.deviceId = String(deviceId || '');
+    this.controller = controller;
+    this.streamHub = streamHub;
+    this.fps = clampInt(fps, 12, 1, 30);
+    this.quality = clampInt(quality, 75, 30, 95);
+
+    this._stopped = true;
+    this._adbProc = null;
+    this._ffmpegProc = null;
+    this._restartTimer = null;
+    this._seq = 0;
+    this._lastErrorLogAt = 0;
+    this._usePollingFallback = false; // set true when H.264 fails to start
+  }
+
+  start() {
+    if (!this._stopped) return;
+    this._stopped = false;
+    if (this._usePollingFallback) {
+      this._startPollingFallback();
+    } else {
+      this._launchH264();
+    }
+  }
+
+  stop() {
+    this._stopped = true;
+    this._killProcesses();
+  }
+
+  // ── H.264 streaming (primary path) ─────────────────────────────────────
+
+  _launchH264() {
+    if (this._stopped) return;
+
+    const adb = resolveAdbBin(this.controller?.sdkDir);
+    // deviceId is the ADB serial (emulator-5554, etc.)
+    const serial = this.deviceId;
+    const adbArgs = [
+      '-s', serial,
+      'exec-out',
+      'screenrecord',
+      '--output-format=h264',
+      '--bit-rate=2000000',
+      '--size=1280x720',
+      '-',
+    ];
+
+    try {
+      this._adbProc = spawn(adb, adbArgs, { stdio: ['ignore', 'pipe', 'ignore'] });
+    } catch (err) {
+      this._logError('Failed to spawn adb for H.264 streaming, falling back to screencap', err);
+      this._fallback();
+      return;
+    }
+
+    // Map our 30–95 quality range to ffmpeg q:v 2–20 (lower = better quality).
+    const ffmpegQ = Math.round(2 + ((95 - this.quality) / (95 - 30)) * 18);
+    const ffmpegArgs = [
+      '-loglevel', 'error',
+      '-f', 'h264',
+      '-i', 'pipe:0',
+      '-f', 'image2pipe',
+      '-vcodec', 'mjpeg',
+      '-q:v', String(ffmpegQ),
+      '-vf', `fps=${this.fps}`,
+      'pipe:1',
+    ];
+
+    try {
+      this._ffmpegProc = spawn('ffmpeg', ffmpegArgs, { stdio: ['pipe', 'pipe', 'ignore'] });
+    } catch (err) {
+      this._logError('ffmpeg not found, falling back to screencap', err);
+      try { this._adbProc?.kill('SIGTERM'); } catch {}
+      this._adbProc = null;
+      this._fallback();
+      return;
+    }
+
+    // Wire adb stdout → ffmpeg stdin.
+    this._adbProc.stdout.pipe(this._ffmpegProc.stdin);
+
+    // Parse JPEG frames from ffmpeg stdout and forward to StreamHub.
+    const parser = new JpegFrameParser();
+    this._ffmpegProc.stdout.on('data', (chunk) => parser.push(chunk));
+    parser.on('frame', (jpeg) => {
+      if (this._stopped) return;
+      this.streamHub.handleFrame(this.userId, this.deviceId, {
+        jpeg,
+        platform: 'android',
+        seq: this._seq++ >>> 0,
+        ts: Date.now() >>> 0,
+        flags: 1,
+      });
+    });
+
+    this._adbProc.on('error', (err) => {
+      this._logError('adb process error', err);
+    });
+    this._ffmpegProc.on('error', (err) => {
+      this._logError('ffmpeg process error', err);
+    });
+
+    // Android screenrecord's hard limit is 180 s — restart at 170 s so there
+    // is no gap in the stream.
+    this._restartTimer = setTimeout(() => {
+      if (!this._stopped) {
+        this._killProcesses();
+        this._launchH264();
+      }
+    }, 170_000);
+    this._restartTimer.unref?.();
+
+    // If adb exits early (e.g. emulator restart), attempt recovery.
+    this._adbProc.on('close', (code) => {
+      if (this._stopped) return;
+      // If it exited immediately with a bad code, the device likely does not
+      // support stdout screenrecord — fall back to screencap polling.
+      if (code !== 0 && this._seq === 0) {
+        this._logError(`screenrecord exited (code ${code}) before producing any frames — using screencap fallback`);
+        this._killProcesses();
+        this._fallback();
+        return;
+      }
+      this._logError(`adb screenrecord exited (code ${code}), restarting in 2 s`);
+      this._killProcesses();
+      this._scheduleRestart(2000, () => this._launchH264());
+    });
+  }
+
+  _fallback() {
+    this._usePollingFallback = true;
+    if (!this._stopped) this._startPollingFallback();
+  }
+
+  // ── Screencap polling fallback ──────────────────────────────────────────
+  // Used when H.264 streaming is unavailable.  Runs a tight continuous loop
+  // (no fixed interval) so there is never idle time waiting between captures.
+
+  _startPollingFallback() {
+    // Fire and forget — the loop runs until this._stopped is set.
+    void this._pollLoop();
+  }
+
+  async _pollLoop() {
+    while (!this._stopped) {
+      try {
+        if (!this.controller || typeof this.controller.capturePng !== 'function') {
+          throw new Error('Android streaming requires a controller with capturePng().');
+        }
+        const png = await this.controller.capturePng({ deviceId: this.deviceId });
+        if (this._stopped || !png?.length) continue;
+        const jpeg = await sharp(png)
+          .jpeg({ quality: this.quality, mozjpeg: false })
+          .toBuffer();
+        if (this._stopped) return;
+        this.streamHub.handleFrame(this.userId, this.deviceId, {
+          jpeg,
+          platform: 'android',
+          seq: this._seq++ >>> 0,
+          ts: Date.now() >>> 0,
+          flags: 1,
+        });
+      } catch (error) {
+        this._logError('screencap poll failed', error);
+        // Brief pause before retrying to avoid a tight spin on persistent errors.
+        await new Promise((r) => setTimeout(r, 500));
+      }
+    }
+  }
+
+  // ── Helpers ─────────────────────────────────────────────────────────────
+
+  _scheduleRestart(delayMs, fn) {
+    this._restartTimer = setTimeout(fn, delayMs);
+    this._restartTimer.unref?.();
+  }
+
+  _killProcesses() {
+    clearTimeout(this._restartTimer);
+    this._restartTimer = null;
+    // Kill ffmpeg first so it stops reading; then kill adb.
+    try { this._ffmpegProc?.kill('SIGTERM'); } catch {}
+    try { this._adbProc?.kill('SIGTERM'); } catch {}
+    this._ffmpegProc = null;
+    this._adbProc = null;
+  }
+
+  _logError(msg, err) {
+    const now = Date.now();
+    if (now - this._lastErrorLogAt > 10_000) {
+      this._lastErrorLogAt = now;
+      console.warn(`[AndroidStream] ${msg}`, {
+        userId: this.userId,
+        deviceId: this.deviceId,
+        error: err ? String(err?.message || err) : undefined,
+      });
+    }
+  }
+}
+
+module.exports = { AndroidStream };

package/server/services/streaming/browser-stream.js

@@ -0,0 +1,87 @@
+'use strict';
+
+const fs = require('fs');
+const sharp = require('sharp');
+
+function clampInt(value, fallback, min, max) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) return fallback;
+  return Math.min(max, Math.max(min, Math.floor(parsed)));
+}
+
+class BrowserStream {
+  constructor({ userId, deviceId = 'browser', controller, streamHub, fps = 15, quality = 80 }) {
+    this.userId = String(userId || '');
+    this.deviceId = String(deviceId || 'browser');
+    this.controller = controller;
+    this.streamHub = streamHub;
+    this.fps = clampInt(fps, 15, 1, 20);
+    this.quality = clampInt(quality, 80, 30, 95);
+    this._timer = null;
+    this._capturing = false;
+    this._seq = 0;
+  }
+
+  start() {
+    if (this._timer) return;
+    const interval = Math.max(1, Math.floor(1000 / this.fps));
+    this._timer = setInterval(() => {
+      void this._captureOnce();
+    }, interval);
+    this._timer.unref?.();
+    void this._captureOnce();
+  }
+
+  stop() {
+    if (this._timer) {
+      clearInterval(this._timer);
+      this._timer = null;
+    }
+  }
+
+  async _captureOnce() {
+    if (this._capturing) return;
+    this._capturing = true;
+    try {
+      const jpeg = await this._captureJpeg();
+      if (!jpeg?.length) return;
+      this.streamHub.handleFrame(this.userId, this.deviceId, {
+        jpeg,
+        platform: 'browser',
+        seq: this._seq++ >>> 0,
+        ts: Date.now() >>> 0,
+        flags: 1,
+      });
+    } catch (error) {
+      console.warn('[BrowserStream] frame capture failed', {
+        userId: this.userId,
+        deviceId: this.deviceId,
+        error: String(error?.message || error),
+      });
+    } finally {
+      this._capturing = false;
+    }
+  }
+
+  async _captureJpeg() {
+    if (!this.controller) {
+      throw new Error('Browser controller is unavailable.');
+    }
+    if (typeof this.controller.screenshotJpeg === 'function') {
+      return this.controller.screenshotJpeg(this.quality);
+    }
+    if (typeof this.controller.screenshot !== 'function') {
+      throw new Error('Browser streaming requires a screenshot-capable controller.');
+    }
+    const result = await this.controller.screenshot({ fullPage: false });
+    if (!result?.fullPath || !fs.existsSync(result.fullPath)) {
+      throw new Error('Browser screenshot did not produce a readable file.');
+    }
+    const png = fs.readFileSync(result.fullPath);
+    return sharp(png).jpeg({ quality: this.quality }).toBuffer();
+  }
+}
+
+module.exports = {
+  BrowserStream,
+};