neoagent 2.4.0 → 2.4.1-beta.11

package/flutter_app/lib/src/stream_renderer.dart

@@ -0,0 +1,286 @@
+import 'dart:async';
+import 'dart:typed_data';
+
+import 'package:flutter/material.dart';
+import 'package:socket_io_client/socket_io_client.dart' as io;
+
+class StreamRenderer extends StatefulWidget {
+  const StreamRenderer({
+    super.key,
+    required this.socket,
+    required this.deviceId,
+    required this.platform,
+    this.remoteResolution,
+    this.onTap,
+    this.onSwipe,
+    this.onType,
+    this.onHover,
+    this.fit = BoxFit.contain,
+    this.alignment = Alignment.center,
+  });
+
+  final io.Socket socket;
+  final String deviceId;
+  final String platform;
+  final Size? remoteResolution;
+  final void Function(double x, double y)? onTap;
+  final void Function(double x1, double y1, double x2, double y2)? onSwipe;
+  final void Function(String text)? onType;
+  final void Function(double x, double y)? onHover;
+  final BoxFit fit;
+  final Alignment alignment;
+
+  @override
+  State<StreamRenderer> createState() => _StreamRendererState();
+}
+
+class _StreamRendererState extends State<StreamRenderer> {
+  Uint8List? _frame;
+  Size? _frameSize;
+  ImageStream? _imageStream;
+  ImageStreamListener? _imageListener;
+  Offset? _dragStart;
+  Offset? _dragEnd;
+
+  Timer? _hoverThrottleTimer;
+  Offset? _pendingHoverOffset;
+  DateTime _lastHoverTime = DateTime.fromMillisecondsSinceEpoch(0);
+
+  @override
+  void initState() {
+    super.initState();
+    widget.socket.on('stream:frame', _onFrame);
+    widget.socket.emit('stream:subscribe', <String, Object?>{
+      'deviceId': widget.deviceId,
+      'platform': widget.platform,
+    });
+  }
+
+  @override
+  void didUpdateWidget(StreamRenderer oldWidget) {
+    super.didUpdateWidget(oldWidget);
+    if (oldWidget.socket == widget.socket &&
+        oldWidget.deviceId == widget.deviceId &&
+        oldWidget.platform == widget.platform) {
+      return;
+    }
+    _frameSize = null;
+    _detachImageListener();
+    oldWidget.socket.off('stream:frame', _onFrame);
+    oldWidget.socket.emit('stream:unsubscribe', <String, Object?>{
+      'deviceId': oldWidget.deviceId,
+      'platform': oldWidget.platform,
+    });
+    widget.socket.on('stream:frame', _onFrame);
+    widget.socket.emit('stream:subscribe', <String, Object?>{
+      'deviceId': widget.deviceId,
+      'platform': widget.platform,
+    });
+  }
+
+  void _onFrame(dynamic data) {
+    Object? meta;
+    Object? bytes;
+    if (data is List && data.length >= 2) {
+      meta = data[0];
+      bytes = data[1];
+    }
+    if (meta is Map) {
+      final frameDeviceId = meta['deviceId']?.toString() ?? '';
+      final framePlatform = meta['platform']?.toString() ?? '';
+      if (frameDeviceId.isNotEmpty && frameDeviceId != widget.deviceId) {
+        return;
+      }
+      if (framePlatform.isNotEmpty && framePlatform != widget.platform) {
+        return;
+      }
+    }
+    final frame = switch (bytes) {
+      Uint8List value => value,
+      List<int> value => Uint8List.fromList(value),
+      ByteBuffer value => Uint8List.view(value),
+      _ => null,
+    };
+    if (frame == null || frame.isEmpty || !mounted) return;
+    if (_frameSize == null) {
+      _resolveFrameSize(frame);
+    }
+    setState(() => _frame = frame);
+  }
+
+  void _resolveFrameSize(Uint8List frame) {
+    _detachImageListener();
+    final provider = MemoryImage(frame);
+    final stream = provider.resolve(const ImageConfiguration());
+    final listener = ImageStreamListener((image, _) {
+      if (!mounted || _frameSize != null) return;
+      setState(() {
+        _frameSize = Size(
+          image.image.width.toDouble(),
+          image.image.height.toDouble(),
+        );
+      });
+      _detachImageListener();
+    });
+    _imageStream = stream;
+    _imageListener = listener;
+    stream.addListener(listener);
+  }
+
+  void _detachImageListener() {
+    if (_imageStream != null && _imageListener != null) {
+      _imageStream!.removeListener(_imageListener!);
+    }
+    _imageStream = null;
+    _imageListener = null;
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final frame = _frame;
+    if (frame == null) {
+      return const Center(child: CircularProgressIndicator());
+    }
+    return LayoutBuilder(
+      builder: (context, constraints) {
+        return MouseRegion(
+          onHover: widget.onHover == null
+              ? null
+              : (event) => _handleHoverEvent(event.localPosition, constraints.biggest),
+          child: GestureDetector(
+            behavior: HitTestBehavior.opaque,
+            onTapDown: widget.onTap == null
+                ? null
+                : (details) => _handleTap(details, constraints.biggest),
+            onPanStart: widget.onSwipe == null
+                ? null
+                : (details) {
+                    _dragStart = details.localPosition;
+                    _dragEnd = details.localPosition;
+                  },
+            onPanUpdate: widget.onSwipe == null
+                ? null
+                : (details) {
+                    _dragEnd = details.localPosition;
+                  },
+            onPanEnd: widget.onSwipe == null
+                ? null
+                : (_) {
+                    final start = _dragStart;
+                    final end = _dragEnd;
+                    _dragStart = null;
+                    _dragEnd = null;
+                    if (start == null ||
+                        end == null ||
+                        (start - end).distance < 12) {
+                      return;
+                    }
+                    _handleSwipe(start, end, constraints.biggest);
+                  },
+            child: Image.memory(
+              frame,
+              gaplessPlayback: true,
+              fit: widget.fit,
+              alignment: widget.alignment,
+              width: constraints.maxWidth,
+              height: constraints.maxHeight,
+            ),
+          ),
+        );
+      },
+    );
+  }
+
+  void _handleHoverEvent(Offset localPosition, Size boxSize) {
+    if (widget.onHover == null) return;
+    _pendingHoverOffset = localPosition;
+    final now = DateTime.now();
+    final elapsed = now.difference(_lastHoverTime);
+    const throttleDuration = Duration(milliseconds: 70);
+    
+    if (elapsed >= throttleDuration) {
+      _sendPendingHover(boxSize);
+    } else {
+      _hoverThrottleTimer ??= Timer(throttleDuration - elapsed, () {
+        _hoverThrottleTimer = null;
+        _sendPendingHover(boxSize);
+      });
+    }
+  }
+
+  void _sendPendingHover(Size boxSize) {
+    final offset = _pendingHoverOffset;
+    if (offset == null) return;
+    _pendingHoverOffset = null;
+    _lastHoverTime = DateTime.now();
+    
+    final point = _mapToRemote(offset, boxSize);
+    if (point != null) {
+      widget.onHover?.call(point.dx, point.dy);
+    }
+  }
+
+  void _handleTap(TapDownDetails details, Size boxSize) {
+    final point = _mapToRemote(details.localPosition, boxSize);
+    if (point == null) {
+      return;
+    }
+    widget.onTap?.call(point.dx, point.dy);
+  }
+
+  void _handleSwipe(Offset start, Offset end, Size boxSize) {
+    final mappedStart = _mapToRemote(start, boxSize);
+    final mappedEnd = _mapToRemote(end, boxSize);
+    if (mappedStart == null || mappedEnd == null) {
+      return;
+    }
+    widget.onSwipe?.call(
+      mappedStart.dx,
+      mappedStart.dy,
+      mappedEnd.dx,
+      mappedEnd.dy,
+    );
+  }
+
+  Offset? _mapToRemote(Offset localPosition, Size boxSize) {
+    final remote = widget.remoteResolution ?? _frameSize;
+    if (remote == null ||
+        remote.width <= 0 ||
+        remote.height <= 0 ||
+        boxSize.width <= 0 ||
+        boxSize.height <= 0) {
+      return null;
+    }
+    final remoteSize = Size(remote.width, remote.height);
+    final fitted = applyBoxFit(widget.fit, remoteSize, boxSize);
+    final sourceRect = widget.alignment.inscribe(
+      fitted.source,
+      Offset.zero & remoteSize,
+    );
+    final destRect = widget.alignment.inscribe(
+      fitted.destination,
+      Offset.zero & boxSize,
+    );
+    if (!destRect.contains(localPosition)) {
+      return null;
+    }
+    final localX = localPosition.dx - destRect.left;
+    final localY = localPosition.dy - destRect.top;
+    return Offset(
+      sourceRect.left + localX * fitted.source.width / destRect.width,
+      sourceRect.top + localY * fitted.source.height / destRect.height,
+    );
+  }
+
+  @override
+  void dispose() {
+    _hoverThrottleTimer?.cancel();
+    widget.socket.emit('stream:unsubscribe', <String, Object?>{
+      'deviceId': widget.deviceId,
+      'platform': widget.platform,
+    });
+    widget.socket.off('stream:frame', _onFrame);
+    _detachImageListener();
+    super.dispose();
+  }
+}

package/flutter_app/macos/Runner/AppDelegate.swift

@@ -106,6 +106,36 @@ final class DesktopCompanionNativePlugin: NSObject {
         displayId: displayId
       )
       result(nil)
+    case "mouseMove":
+      guard isAccessibilityTrusted() else {
+        result(
+          FlutterError(
+            code: "accessibility_permission_denied",
+            message: "Accessibility permission is required for input control.",
+            details: nil
+          )
+        )
+        return
+      }
+      guard let arguments = call.arguments as? [String: Any],
+            let x = arguments["x"] as? NSNumber,
+            let y = arguments["y"] as? NSNumber else {
+        result(
+          FlutterError(
+            code: "invalid_arguments",
+            message: "Missing mouseMove coordinates.",
+            details: nil
+          )
+        )
+        return
+      }
+      let displayId = arguments["displayId"] as? String
+      performMouseMove(
+        x: x.doubleValue,
+        y: y.doubleValue,
+        displayId: displayId
+      )
+      result(nil)
     case "drag":
       guard isAccessibilityTrusted() else {
         result(
@@ -316,7 +346,18 @@ final class DesktopCompanionNativePlugin: NSObject {
   }
 
   private func isAccessibilityTrusted() -> Bool {
-    AXIsProcessTrusted()
+    if AXIsProcessTrusted() { return true }
+    // AXIsProcessTrusted() may cache false on macOS 14+ after a System Settings grant.
+    // Probe with a live AX read: .apiDisabled is the error returned when the process
+    // lacks accessibility permission (AXError has no .notTrusted case in the macOS SDK).
+    let sysElement = AXUIElementCreateSystemWide()
+    var value: CFTypeRef?
+    let status = AXUIElementCopyAttributeValue(
+      sysElement,
+      kAXFocusedApplicationAttribute as CFString,
+      &value
+    )
+    return status != .apiDisabled
   }
 
   private func resolveDisplayId(_ raw: String?) -> CGDirectDisplayID {
@@ -406,6 +447,20 @@ final class DesktopCompanionNativePlugin: NSObject {
     up.post(tap: .cghidEventTap)
   }
 
+  private func performMouseMove(x: Double, y: Double, displayId: String?) {
+    let point = nativePointForCapturedPixel(x: x, y: y, displayId: displayId)
+    CGWarpMouseCursorPosition(point)
+    guard let moveEvent = CGEvent(
+      mouseEventSource: nil,
+      mouseType: .mouseMoved,
+      mouseCursorPosition: point,
+      mouseButton: .left
+    ) else {
+      return
+    }
+    moveEvent.post(tap: .cghidEventTap)
+  }
+
   private func performDrag(
     x1: Double,
     y1: Double,

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "neoagent",
-  "version": "2.4.0",
+  "version": "2.4.1-beta.11",
   "description": "Proactive personal AI agent with no limits",
-  "license": "MIT",
+  "license": "AGPL-3.0-only",
   "main": "server/index.js",
   "engines": {
     "node": ">=20"

package/server/guest_agent.js

@@ -62,7 +62,18 @@ function isInsideAllowedRoots(targetPath) {
 }
 
 function requireToken(req, res, next) {
-  next();
+  if (!AUTH_TOKEN) {
+    // Token not configured in this environment — allow but unauthenticated.
+    // Pass NEOAGENT_VM_GUEST_TOKEN to the container to enforce auth.
+    return next();
+  }
+  const header = String(req.headers?.authorization || '').trim();
+  const prefix = 'Bearer ';
+  const provided = header.startsWith(prefix) ? header.slice(prefix.length).trim() : '';
+  if (!provided || provided !== AUTH_TOKEN) {
+    return res.status(401).json({ error: 'Unauthorized.' });
+  }
+  return next();
 }
 
 function sanitizeError(err) {
@@ -184,6 +195,13 @@ function requireCapability(controller, name) {
 app.post('/browser/launch', async (req, res) => handle(res, () => requireCapability(browserController, 'browser').launch(req.body || {})));
 app.post('/browser/navigate', async (req, res) => handle(res, () => requireCapability(browserController, 'browser').navigate(req.body?.url, req.body || {})));
 app.post('/browser/screenshot', async (req, res) => handle(res, () => requireCapability(browserController, 'browser').screenshot(req.body || {})));
+app.post('/browser/screenshot-jpeg', async (req, res) => handle(res, async () => {
+  const jpeg = await requireCapability(browserController, 'browser').screenshotJpeg(req.body?.quality, req.body || {});
+  return {
+    contentType: 'image/jpeg',
+    contentBase64: Buffer.from(jpeg).toString('base64'),
+  };
+}));
 app.post('/browser/click', async (req, res) => handle(res, () => requireCapability(browserController, 'browser').click(req.body?.selector, req.body?.text, req.body?.screenshot !== false)));
 app.post('/browser/click-point', async (req, res) => handle(res, () => requireCapability(browserController, 'browser').clickPoint(req.body?.x, req.body?.y, req.body?.screenshot !== false)));
 app.post('/browser/fill', async (req, res) => handle(res, () => requireCapability(browserController, 'browser').type(req.body?.selector, String(req.body?.value ?? req.body?.text ?? ''), req.body || {})));

package/server/http/routes.js

@@ -25,6 +25,7 @@ const routeRegistry = [
   { basePath: '/api/browser-extension', modulePath: '../routes/browser_extension' },
   { basePath: '/api/android', modulePath: '../routes/android' },
   { basePath: '/api/desktop', modulePath: '../routes/desktop' },
+  { basePath: '/api/stream', modulePath: '../routes/stream' },
   { basePath: '/api/recordings', modulePath: '../routes/recordings' },
   { basePath: '/api/social-video', modulePath: '../routes/social_video' },
   { basePath: '/api/voice-assistant', modulePath: '../routes/voice_assistant' },
@@ -67,6 +68,196 @@ function registerApiRoutes(app) {
     });
   });
 
+  app.get('/api/system/health-check', requireAuth, async (req, res) => {
+    const userId = req.session?.userId;
+    const runtimeManager = req.app?.locals?.runtimeManager;
+    const desktopRegistry = req.app?.locals?.desktopCompanionRegistry;
+    const extensionRegistry = req.app?.locals?.browserExtensionRegistry;
+    const results = [];
+
+    // 1. Backend connectivity — trivially true if we got here.
+    results.push({ id: 'backend', label: 'Backend server', passed: true, detail: 'Reachable' });
+
+    // 2. Cloud VM runtime availability.
+    const runtimeValidation = getRuntimeValidation(runtimeManager);
+    const runtimeReady = Boolean(runtimeValidation?.ready);
+    results.push({
+      id: 'vm_runtime',
+      label: 'Cloud VM runtime',
+      passed: runtimeReady,
+      detail: runtimeReady ? 'Available' : String(runtimeValidation?.issues?.[0] || 'Not configured'),
+    });
+
+    // 3. Cloud VM CLI execution — actually run a command.
+    if (runtimeManager && typeof runtimeManager.executeCommand === 'function') {
+      try {
+        const cmdResult = await runtimeManager.executeCommand(userId, 'echo "health_check_ok"', { timeout: 15000 });
+        const exitOk = cmdResult?.exitCode === 0;
+        const outputOk = String(cmdResult?.stdout || '').includes('health_check_ok');
+        results.push({
+          id: 'vm_cli',
+          label: 'Cloud VM — command execution',
+          passed: exitOk && outputOk,
+          detail: exitOk && outputOk
+            ? 'Commands running'
+            : `Exit ${cmdResult?.exitCode ?? '?'}: ${String(cmdResult?.stderr || cmdResult?.stdout || '').slice(0, 120)}`,
+        });
+      } catch (err) {
+        results.push({ id: 'vm_cli', label: 'Cloud VM — command execution', passed: false, detail: String(err?.message || err).slice(0, 120) });
+      }
+    } else {
+      results.push({ id: 'vm_cli', label: 'Cloud VM — command execution', passed: false, detail: 'VM runtime unavailable' });
+    }
+
+    // 4. Desktop companion (macOS app / remote device) connectivity + permissions.
+    if (desktopRegistry) {
+      try {
+        const desktopStatus = desktopRegistry.getStatus(userId);
+        const connected = Boolean(desktopStatus?.connected);
+        results.push({
+          id: 'desktop_connected',
+          label: 'Desktop companion',
+          passed: connected,
+          detail: connected
+            ? `${desktopStatus.onlineCount} device${desktopStatus.onlineCount !== 1 ? 's' : ''} connected`
+            : 'No device connected — open the desktop app',
+        });
+
+        if (connected && Array.isArray(desktopStatus?.devices)) {
+          const onlineDevice = desktopStatus.devices.find((d) => d.online && !d.revokedAt);
+          const perms = onlineDevice?.permissions || {};
+          const screenOk = Boolean(perms.screenCapture || perms.screen_capture);
+          const inputOk = Boolean(perms.accessibility || perms.inputControl || perms.input_control);
+          results.push({
+            id: 'desktop_screen',
+            label: 'Desktop — screen capture',
+            passed: screenOk,
+            detail: screenOk ? 'Granted' : 'Not granted — open System Settings › Privacy › Screen Recording',
+          });
+          results.push({
+            id: 'desktop_input',
+            label: 'Desktop — input control',
+            passed: inputOk,
+            detail: inputOk ? 'Granted' : 'Not granted — open System Settings › Privacy › Accessibility',
+          });
+        }
+      } catch (err) {
+        results.push({ id: 'desktop_connected', label: 'Desktop companion', passed: false, detail: String(err?.message || err).slice(0, 120) });
+      }
+    }
+
+    // 5. Chrome extension connectivity.
+    if (extensionRegistry) {
+      try {
+        const extStatus = extensionRegistry.getStatus(userId);
+        const extConnected = Boolean(extStatus?.connected);
+        results.push({
+          id: 'chrome_extension',
+          label: 'Chrome extension',
+          passed: extConnected,
+          detail: extConnected ? 'Connected' : 'Not connected — install the NeoAgent extension in Chrome',
+        });
+      } catch (err) {
+        results.push({ id: 'chrome_extension', label: 'Chrome extension', passed: false, detail: String(err?.message || err).slice(0, 120) });
+      }
+    }
+
+    const allPassed = results.every((r) => r.passed);
+    res.json({ passed: allPassed, results });
+  });
+
+  // Targeted runtime self-tests — one check per endpoint so the UI can embed
+  // results inline next to the relevant settings control.
+
+  app.get('/api/system/test/cli', requireAuth, async (req, res) => {
+    const userId = req.session?.userId;
+    const runtimeManager = req.app?.locals?.runtimeManager;
+    if (!runtimeManager || typeof runtimeManager.executeCommand !== 'function') {
+      return res.json({ passed: false, backendUsed: 'vm', detail: 'Runtime not configured on this server.' });
+    }
+    // Note: executeCommand always routes through the VM backend regardless of
+    // the cli_backend setting — desktop CLI routing is not yet implemented.
+    try {
+      const result = await runtimeManager.executeCommand(userId, 'echo "cli_test_ok"', { timeout: 15000 });
+      const exitOk = result?.exitCode === 0;
+      const outputOk = String(result?.stdout || '').includes('cli_test_ok');
+      return res.json({
+        passed: exitOk && outputOk,
+        backendUsed: 'vm',
+        detail: exitOk && outputOk
+          ? 'Command executed successfully'
+          : `Exit ${result?.exitCode ?? '?'}: ${String(result?.stderr || result?.stdout || '').slice(0, 120)}`,
+      });
+    } catch (err) {
+      return res.json({ passed: false, backendUsed: 'vm', detail: String(err?.message || err).slice(0, 120) });
+    }
+  });
+
+  app.get('/api/system/test/extension', requireAuth, (req, res) => {
+    const userId = req.session?.userId;
+    const extensionRegistry = req.app?.locals?.browserExtensionRegistry;
+    if (!extensionRegistry) {
+      return res.json({ passed: false, detail: 'Extension registry not available on this server.' });
+    }
+    try {
+      const status = extensionRegistry.getStatus(userId);
+      const connected = Boolean(status?.connected);
+      return res.json({
+        passed: connected,
+        detail: connected ? 'Extension is connected and live' : 'Extension is not connected',
+        tokenId: status?.activeTokenId || null,
+        meta: status?.connectedMeta || null,
+      });
+    } catch (err) {
+      return res.json({ passed: false, detail: String(err?.message || err).slice(0, 120) });
+    }
+  });
+
+  app.get('/api/system/test/desktop', requireAuth, (req, res) => {
+    const userId = req.session?.userId;
+    const desktopRegistry = req.app?.locals?.desktopCompanionRegistry;
+    if (!desktopRegistry) {
+      return res.json({ passed: false, detail: 'Desktop registry not available on this server.' });
+    }
+    try {
+      const status = desktopRegistry.getStatus(userId);
+      const connected = Boolean(status?.connected);
+      const devices = Array.isArray(status?.devices)
+        ? status.devices.filter((d) => d.online && !d.revokedAt)
+        : [];
+      const selected = status?.selectedDeviceId || null;
+      const activeDevice = selected
+        ? devices.find((d) => d.deviceId === selected)
+        : devices.length === 1 ? devices[0] : null;
+      const perms = activeDevice?.permissions || {};
+      const screenOk = Boolean(perms.screenCapture || perms.screen_capture);
+      const inputOk = Boolean(perms.accessibility || perms.inputControl || perms.input_control);
+      return res.json({
+        passed: connected,
+        connected,
+        onlineCount: devices.length,
+        selectedDeviceId: selected,
+        activeDevice: activeDevice ? {
+          deviceId: activeDevice.deviceId,
+          label: activeDevice.label || activeDevice.hostname || activeDevice.deviceId,
+          platform: activeDevice.platform || null,
+          paused: activeDevice.paused || false,
+          permissions: { screenCapture: screenOk, inputControl: inputOk },
+        } : null,
+        multipleOnline: devices.length > 1 && !activeDevice,
+        detail: !connected
+          ? 'No device connected'
+          : devices.length > 1 && !activeDevice
+            ? `${devices.length} devices online — select one in Desktop settings`
+            : activeDevice?.paused
+              ? `${activeDevice.label || 'Device'} is paused`
+              : `${activeDevice?.label || 'Device'} connected`,
+      });
+    } catch (err) {
+      return res.json({ passed: false, detail: String(err?.message || err).slice(0, 120) });
+    }
+  });
+
   app.get('/api/version', requireAuth, (req, res) => {
     res.json(getVersionInfo());
   });

package/server/http/socket.js

@@ -8,7 +8,7 @@ function createSocketServer(httpServer, { validateOrigin }) {
     pingInterval: Number(process.env.NEOAGENT_SOCKET_PING_INTERVAL_MS || 25000),
     pingTimeout: Number(process.env.NEOAGENT_SOCKET_PING_TIMEOUT_MS || 20000),
     connectTimeout: Number(process.env.NEOAGENT_SOCKET_CONNECT_TIMEOUT_MS || 10000),
-    maxHttpBufferSize: Number(process.env.NEOAGENT_SOCKET_MAX_HTTP_BUFFER_BYTES || 1_000_000),
+    maxHttpBufferSize: Number(process.env.NEOAGENT_SOCKET_MAX_HTTP_BUFFER_BYTES || 8 * 1024 * 1024),
     cors: {
       origin(origin, callback) {
         return validateOrigin(origin, callback, { allowMissingOrigin: true });

package/server/index.js

@@ -34,6 +34,7 @@ const { startServices, stopServices } = require('./services/manager');
 const { bindBrowserExtensionGateway } = require('./services/browser/extension/gateway');
 const { bindDesktopCompanionGateway } = require('./services/desktop/gateway');
 const { bindWearableGateway } = require('./services/wearable/gateway');
+const { StreamHub } = require('./services/streaming/stream-hub');
 
 function parseBooleanFlag(value, fallback = false) {
   const normalized = String(value || '').trim().toLowerCase();
@@ -89,6 +90,8 @@ const app = express();
 app.disable('x-powered-by');
 const httpServer = createServer(app);
 const io = createSocketServer(httpServer, { validateOrigin });
+const streamHub = new StreamHub(io);
+app.locals.streamHub = streamHub;
 app.locals.httpRuntimeConfig = {
   secureCookies: SECURE_COOKIES,
   trustProxy: TRUST_PROXY,
@@ -112,7 +115,7 @@ registerApiRoutes(app);
 registerStaticRoutes(app);
 registerErrorHandler(app);
 bindBrowserExtensionGateway(httpServer, app);
-bindDesktopCompanionGateway(httpServer, app, sessionMiddleware);
+bindDesktopCompanionGateway(httpServer, app, sessionMiddleware, streamHub);
 bindWearableGateway(httpServer, app, sessionMiddleware);
 
 let shuttingDown = false;

package/server/public/.last_build_id

@@ -1 +1 @@
-18f90bb9a4d3bcea22e501f688e05b77
+178383462d4c7125ce032b3783b45564

package/server/public/flutter_bootstrap.js

@@ -37,6 +37,6 @@ _flutter.buildConfig = {"engineRevision":"4c525dac5ebe5971c5708ef73558ed8edcf4a3
 
 _flutter.loader.load({
   serviceWorkerSettings: {
-    serviceWorkerVersion: "1600220817" /* Flutter's service worker is deprecated and will be removed in a future Flutter release. */
+    serviceWorkerVersion: "559469558" /* Flutter's service worker is deprecated and will be removed in a future Flutter release. */
   }
 });