neoagent 2.4.0 → 2.4.1-beta.10

package/server/services/browser/extension/registry.js

@@ -8,6 +8,8 @@ const {
 
 const DEFAULT_PAIRING_TTL_MS = 10 * 60 * 1000;
 const DEFAULT_COMMAND_TIMEOUT_MS = 30 * 1000;
+const DEFAULT_HEARTBEAT_INTERVAL_MS = 25 * 1000;
+const DEFAULT_HEARTBEAT_TIMEOUT_MS = 75 * 1000;
 
 function sha256(value) {
   return crypto.createHash('sha256').update(String(value || '')).digest('hex');
@@ -42,9 +44,20 @@ class BrowserExtensionRegistry {
     this.db = options.db || db;
     this.commandTimeoutMs = Number(options.commandTimeoutMs || process.env.NEOAGENT_BROWSER_EXTENSION_COMMAND_TIMEOUT_MS || DEFAULT_COMMAND_TIMEOUT_MS);
     this.pairingTtlMs = Number(options.pairingTtlMs || process.env.NEOAGENT_BROWSER_EXTENSION_PAIRING_TTL_MS || DEFAULT_PAIRING_TTL_MS);
+    this.heartbeatIntervalMs = Number(options.heartbeatIntervalMs || process.env.NEOAGENT_BROWSER_EXTENSION_HEARTBEAT_INTERVAL_MS || DEFAULT_HEARTBEAT_INTERVAL_MS);
+    this.heartbeatTimeoutMs = Number(options.heartbeatTimeoutMs || process.env.NEOAGENT_BROWSER_EXTENSION_HEARTBEAT_TIMEOUT_MS || DEFAULT_HEARTBEAT_TIMEOUT_MS);
     this.connectionsByUser = new Map();
   }
 
+  #getUserConnections(userId, create = false) {
+    const key = String(userId || '').trim();
+    if (!key) return null;
+    if (!this.connectionsByUser.has(key) && create) {
+      this.connectionsByUser.set(key, new Map());
+    }
+    return this.connectionsByUser.get(key) || null;
+  }
+
   createPairingRequest(options = {}) {
     const pairingId = crypto.randomUUID();
     const pairingSecret = randomSecret(48);
@@ -129,16 +142,42 @@ class BrowserExtensionRegistry {
     };
 
     const tx = this.db.transaction(() => {
+      // Find other active tokens with the same name for this user.
+      // If they are currently offline, revoke them to clean up old installs/duplicates.
+      const duplicates = this.db.prepare(
+        `SELECT id FROM browser_extension_tokens
+         WHERE user_id = ? AND name = ? AND status = 'active'`
+      ).all(row.user_id, extensionName);
+
+      for (const dup of duplicates) {
+        if (!this.isConnected(row.user_id, dup.id)) {
+          this.db.prepare(
+            `UPDATE browser_extension_tokens
+             SET status = 'revoked', revoked_at = datetime('now')
+             WHERE id = ?`
+          ).run(dup.id);
+        }
+      }
+
       this.db.prepare(
         `UPDATE browser_extension_pairing_requests
          SET status = 'claimed', claimed_at = datetime('now')
          WHERE id = ?`
       ).run(row.id);
+      
       this.db.prepare(
         `INSERT INTO browser_extension_tokens (
            id, user_id, token_hash, name, status, metadata_json
          ) VALUES (?, ?, ?, ?, 'active', ?)`
       ).run(tokenId, row.user_id, sha256(token), extensionName, safeJson(metadata));
+
+      // Auto-select the newly paired token on claim
+      const write = this.db.prepare(
+        `INSERT INTO user_settings (user_id, key, value) VALUES (?, ?, ?)
+         ON CONFLICT(user_id, key) DO UPDATE SET value = excluded.value`
+      );
+      write.run(row.user_id, 'browser_extension_token_id', tokenId);
+      write.run(row.user_id, 'selected_browser_extension_token_id', tokenId);
     });
     tx();
 
@@ -164,7 +203,8 @@ class BrowserExtensionRegistry {
 
   registerConnection(tokenRow, ws, meta = {}) {
     const userId = String(tokenRow.user_id);
-    const existing = this.connectionsByUser.get(userId);
+    const userMap = this.#getUserConnections(userId, true);
+    const existing = userMap.get(tokenRow.id);
     if (existing && existing.ws !== ws) {
       existing.close('replaced by a newer extension connection');
     }
@@ -176,8 +216,10 @@ class BrowserExtensionRegistry {
       tokenId: tokenRow.id,
       meta: { ...tokenRow.metadata, ...meta },
       timeoutMs: this.commandTimeoutMs,
+      heartbeatIntervalMs: this.heartbeatIntervalMs,
+      heartbeatTimeoutMs: this.heartbeatTimeoutMs,
     });
-    this.connectionsByUser.set(userId, connection);
+    userMap.set(tokenRow.id, connection);
     this.db.prepare(
       `UPDATE browser_extension_tokens
        SET last_connected_at = datetime('now'), last_seen_at = datetime('now')
@@ -188,21 +230,93 @@ class BrowserExtensionRegistry {
 
   unregisterConnection(connection) {
     const userId = String(connection.userId);
-    if (this.connectionsByUser.get(userId) === connection) {
-      this.connectionsByUser.delete(userId);
+    const userMap = this.#getUserConnections(userId);
+    if (userMap?.get(connection.tokenId) === connection) {
+      userMap.delete(connection.tokenId);
+      if (userMap.size === 0) {
+        this.connectionsByUser.delete(userId);
+      }
     }
   }
 
-  getConnection(userId) {
-    return this.connectionsByUser.get(String(userId));
+  getSelectedTokenId(userId) {
+    const value = this.db.prepare(
+      `SELECT value FROM user_settings WHERE user_id = ? AND key = ?`
+    ).get(userId, 'browser_extension_token_id')?.value || null;
+    const normalized = String(value || '').trim();
+    if (!normalized || normalized === 'null') return null;
+    const existing = this.db.prepare(
+      `SELECT id FROM browser_extension_tokens WHERE user_id = ? AND id = ? AND status = 'active'`
+    ).get(userId, normalized);
+    if (!existing) return null;
+    return normalized;
   }
 
-  isConnected(userId) {
-    return Boolean(this.getConnection(userId)?.isOpen());
+  setSelectedTokenId(userId, tokenId) {
+    const normalized = String(tokenId || '').trim();
+    if (!normalized) {
+      const error = new Error('Browser extension token id is required.');
+      error.status = 400;
+      throw error;
+    }
+    const existing = this.db.prepare(
+      `SELECT id FROM browser_extension_tokens WHERE user_id = ? AND id = ? AND status = 'active'`
+    ).get(userId, normalized);
+    if (!existing) {
+      const error = new Error('Browser extension device not found.');
+      error.status = 404;
+      throw error;
+    }
+    const write = this.db.prepare(
+      `INSERT INTO user_settings (user_id, key, value) VALUES (?, ?, ?)
+       ON CONFLICT(user_id, key) DO UPDATE SET value = excluded.value`
+    );
+    write.run(userId, 'browser_extension_token_id', normalized);
+    write.run(userId, 'selected_browser_extension_token_id', normalized);
+    return { success: true, selectedTokenId: normalized };
+  }
+
+  getConnection(userId, tokenId = null) {
+    const userMap = this.#getUserConnections(userId);
+    if (!userMap) return null;
+    const explicit = String(tokenId || '').trim();
+    if (explicit) return userMap.get(explicit) || null;
+
+    const selected = this.getSelectedTokenId(userId);
+    if (selected && userMap.get(selected)?.isOpen()) {
+      return userMap.get(selected);
+    }
+
+    // Auto-select online connection if selected is offline/unset
+    const online = Array.from(userMap.values()).filter((connection) => connection.isOpen());
+    if (online.length > 0) {
+      online.sort((a, b) => String(b.connectedAt || '').localeCompare(String(a.connectedAt || '')));
+      const activeConnection = online[0];
+      try {
+        const write = this.db.prepare(
+          `INSERT INTO user_settings (user_id, key, value) VALUES (?, ?, ?)
+           ON CONFLICT(user_id, key) DO UPDATE SET value = excluded.value`
+        );
+        write.run(userId, 'browser_extension_token_id', activeConnection.tokenId);
+        write.run(userId, 'selected_browser_extension_token_id', activeConnection.tokenId);
+      } catch (err) {
+        console.error('[Registry] failed to auto-select online extension', err);
+      }
+      return activeConnection;
+    }
+
+    if (selected) {
+      return userMap.get(selected) || null;
+    }
+    return null;
+  }
+
+  isConnected(userId, tokenId = null) {
+    return Boolean(this.getConnection(userId, tokenId)?.isOpen());
   }
 
   async dispatch(userId, command, payload = {}, options = {}) {
-    const connection = this.getConnection(userId);
+    const connection = this.getConnection(userId, options.tokenId || payload.tokenId || null);
     if (!connection || !connection.isOpen()) {
       throw new ExtensionBrowserUnavailableError();
     }
@@ -214,20 +328,35 @@ class BrowserExtensionRegistry {
   }
 
   getStatus(userId) {
-    const connected = this.getConnection(userId);
+    const userMap = this.#getUserConnections(userId);
+    const selectedTokenId = this.getSelectedTokenId(userId);
+    const connected = selectedTokenId
+      ? userMap?.get(selectedTokenId)
+      : this.getConnection(userId);
+    const effectiveSelectedTokenId = selectedTokenId || connected?.tokenId || null;
     const tokens = this.db.prepare(
       `SELECT id, name, status, last_connected_at, last_seen_at, revoked_at, created_at, metadata_json
        FROM browser_extension_tokens
        WHERE user_id = ?
        ORDER BY created_at DESC`
-    ).all(userId).map((row) => ({
-      ...row,
-      metadata: parseJson(row.metadata_json),
-      metadata_json: undefined,
-    }));
+    ).all(userId).map((row) => {
+      const connection = userMap?.get(row.id) || null;
+      return {
+        ...row,
+        tokenId: row.id,
+        deviceId: row.id,
+        connected: Boolean(connection?.isOpen()),
+        online: Boolean(connection?.isOpen()),
+        selected: row.id === effectiveSelectedTokenId,
+        metadata: parseJson(row.metadata_json),
+        connectedMeta: connection?.meta || null,
+        metadata_json: undefined,
+      };
+    });
     return {
       connected: Boolean(connected?.isOpen()),
       activeTokenId: connected?.tokenId || null,
+      selectedTokenId: effectiveSelectedTokenId,
       tokens,
       connectedMeta: connected?.meta || null,
     };
@@ -249,7 +378,7 @@ class BrowserExtensionRegistry {
       ).run(userId);
     }
 
-    const connection = this.getConnection(userId);
+    const connection = this.getConnection(userId, targetTokenId);
     if (connection && (!targetTokenId || connection.tokenId === targetTokenId)) {
       connection.close('extension token revoked');
     }
@@ -258,25 +387,38 @@ class BrowserExtensionRegistry {
 
   closeAll() {
     for (const connection of this.connectionsByUser.values()) {
-      connection.close('server shutdown');
+      if (connection instanceof Map) {
+        for (const nested of connection.values()) {
+          nested.close('server shutdown');
+        }
+      } else {
+        connection.close('server shutdown');
+      }
     }
     this.connectionsByUser.clear();
   }
 }
 
 class ExtensionBrowserConnection {
-  constructor({ registry, ws, userId, tokenId, meta, timeoutMs }) {
+  constructor({ registry, ws, userId, tokenId, meta, timeoutMs, heartbeatIntervalMs, heartbeatTimeoutMs }) {
     this.registry = registry;
     this.ws = ws;
     this.userId = userId;
     this.tokenId = tokenId;
     this.meta = meta || {};
     this.timeoutMs = timeoutMs;
+    this.heartbeatIntervalMs = heartbeatIntervalMs;
+    this.heartbeatTimeoutMs = heartbeatTimeoutMs;
     this.pending = new Map();
+    this.connectedAt = new Date().toISOString();
+    this.lastPongAt = Date.now();
+    this.heartbeatTimer = null;
 
     ws.on('message', (data) => this.#handleMessage(data));
+    ws.on('pong', () => { this.lastPongAt = Date.now(); });
     ws.on('close', () => this.#closePending(new ExtensionBrowserUnavailableError('Extension browser disconnected.')));
     ws.on('error', (error) => this.#closePending(error));
+    this.#startHeartbeat();
   }
 
   isOpen() {
@@ -317,6 +459,7 @@ class ExtensionBrowserConnection {
   }
 
   #handleMessage(data) {
+    this.lastPongAt = Date.now();
     let message;
     try {
       message = parseExtensionMessage(data);
@@ -339,12 +482,39 @@ class ExtensionBrowserConnection {
 
   #closePending(error) {
     this.registry.unregisterConnection(this);
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
     for (const pending of this.pending.values()) {
       clearTimeout(pending.timer);
       pending.reject(error);
     }
     this.pending.clear();
   }
+
+  #startHeartbeat() {
+    const intervalMs = Number(this.heartbeatIntervalMs);
+    const timeoutMs = Number(this.heartbeatTimeoutMs);
+    if (!Number.isFinite(intervalMs) || intervalMs <= 0) return;
+    this.heartbeatTimer = setInterval(() => {
+      if (!this.isOpen()) {
+        this.#closePending(new ExtensionBrowserUnavailableError('Extension browser disconnected.'));
+        return;
+      }
+      if (Number.isFinite(timeoutMs) && timeoutMs > 0 && Date.now() - this.lastPongAt > timeoutMs) {
+        try { this.ws.terminate(); } catch {}
+        this.#closePending(new ExtensionBrowserUnavailableError('Extension browser heartbeat timed out.'));
+        return;
+      }
+      try {
+        this.ws.ping();
+      } catch (error) {
+        this.#closePending(error);
+      }
+    }, intervalMs);
+    this.heartbeatTimer.unref?.();
+  }
 }
 
 module.exports = {

package/server/services/desktop/gateway.js

@@ -1,5 +1,11 @@
 const { WebSocketServer } = require('ws');
-const { DESKTOP_COMPANION_WS_PATH, parseDesktopMessage } = require('./protocol');
+const {
+  DESKTOP_COMPANION_WS_PATH,
+  FRAME_TYPE_VIDEO,
+  MAX_DESKTOP_STREAM_FRAME_BYTES,
+  parseBinaryFrame,
+  parseDesktopMessage,
+} = require('./protocol');
 const {
   assertDesktopHelloAuth,
   isDesktopCompanionHello,
@@ -72,8 +78,11 @@ function createUpgradeThrottleObserver() {
   return { record, snapshot };
 }
 
-function bindDesktopCompanionGateway(httpServer, app, sessionMiddleware) {
-  const wss = new WebSocketServer({ noServer: true });
+function bindDesktopCompanionGateway(httpServer, app, sessionMiddleware, streamHub = null) {
+  const wss = new WebSocketServer({
+    noServer: true,
+    maxPayload: MAX_DESKTOP_STREAM_FRAME_BYTES,
+  });
   const upgradeAttempts = new Map();
   const upgradeThrottleObserver = createUpgradeThrottleObserver();
 
@@ -173,6 +182,22 @@ function bindDesktopCompanionGateway(httpServer, app, sessionMiddleware) {
               device,
             }));
             ws.on('message', (nextData) => {
+              const activeStreamHub = streamHub || app?.locals?.streamHub || null;
+              if (
+                activeStreamHub
+                && Buffer.isBuffer(nextData)
+                && nextData.length > 10
+                && nextData[0] === FRAME_TYPE_VIDEO
+              ) {
+                const frame = parseBinaryFrame(nextData);
+                if (frame) {
+                  activeStreamHub.handleFrame(req.session.userId, device.deviceId, {
+                    ...frame,
+                    platform: 'desktop',
+                  });
+                }
+                return;
+              }
               let parsed;
               try {
                 parsed = parseDesktopMessage(nextData);

package/server/services/desktop/protocol.js

@@ -3,6 +3,8 @@ const DESKTOP_COMPANION_WS_PATH = '/api/desktop/ws';
 const DESKTOP_COMMANDS = Object.freeze({
   GET_STATUS: 'getStatus',
   CAPTURE_FRAME: 'captureFrame',
+  STREAM_START: 'startStream',
+  STREAM_STOP: 'stopStream',
   OBSERVE: 'observe',
   CLICK: 'click',
   DRAG: 'drag',
@@ -14,9 +16,14 @@ const DESKTOP_COMMANDS = Object.freeze({
   SELECT_DISPLAY: 'selectDisplay',
   GET_TREE: 'getTree',
   PAUSE_CONTROL: 'pauseControl',
+  EXECUTE_COMMAND: 'executeCommand',
   PING: 'ping',
+  MOUSE_MOVE: 'mouseMove',
 });
 
+const FRAME_TYPE_VIDEO = 0x01;
+const MAX_DESKTOP_STREAM_FRAME_BYTES = 8 * 1024 * 1024;
+
 class DesktopCompanionUnavailableError extends Error {
   constructor(message = 'Desktop companion is not connected.') {
     super(message);
@@ -54,11 +61,38 @@ function parseDesktopMessage(data) {
   }
 }
 
+function parseBinaryFrame(buffer) {
+  if (
+    !Buffer.isBuffer(buffer)
+    || buffer.length <= 10
+    || buffer.length > MAX_DESKTOP_STREAM_FRAME_BYTES
+    || buffer[0] !== FRAME_TYPE_VIDEO
+  ) {
+    return null;
+  }
+  const jpeg = buffer.subarray(10);
+  const hasJpegMarkers = jpeg.length >= 4
+    && jpeg[0] === 0xff
+    && jpeg[1] === 0xd8
+    && jpeg[jpeg.length - 2] === 0xff
+    && jpeg[jpeg.length - 1] === 0xd9;
+  if (!hasJpegMarkers) return null;
+  return {
+    seq: buffer.readUInt32BE(1),
+    ts: buffer.readUInt32BE(5),
+    flags: buffer.readUInt8(9),
+    jpeg,
+  };
+}
+
 module.exports = {
   DESKTOP_COMPANION_WS_PATH,
   DESKTOP_COMMANDS,
+  FRAME_TYPE_VIDEO,
+  MAX_DESKTOP_STREAM_FRAME_BYTES,
   DesktopCompanionUnavailableError,
   DesktopCompanionSelectionError,
   createDesktopCommandMessage,
+  parseBinaryFrame,
   parseDesktopMessage,
 };

package/server/services/desktop/provider.js

@@ -130,6 +130,16 @@ class DesktopProvider {
     return this._dispatch(DESKTOP_COMMANDS.CAPTURE_FRAME, options);
   }
 
+  startStream(options = {}) {
+    this._assertReady();
+    return this.registry.startStream(this.userId, options.deviceId || null, options);
+  }
+
+  stopStream(options = {}) {
+    this._assertReady();
+    return this.registry.stopStream(this.userId, options.deviceId || null);
+  }
+
   observe(options = {}) {
     return this._dispatch(DESKTOP_COMMANDS.OBSERVE, options);
   }
@@ -138,6 +148,10 @@ class DesktopProvider {
     return this._dispatch(DESKTOP_COMMANDS.CLICK, { ...options, x, y });
   }
 
+  mouseMove(x, y, options = {}) {
+    return this._dispatch(DESKTOP_COMMANDS.MOUSE_MOVE, { ...options, x, y });
+  }
+
   drag(options = {}) {
     return this._dispatch(DESKTOP_COMMANDS.DRAG, options);
   }
@@ -169,6 +183,17 @@ class DesktopProvider {
   getAccessibilityTree(options = {}) {
     return this._dispatch(DESKTOP_COMMANDS.GET_TREE, options);
   }
+
+  executeCommand(command, options = {}) {
+    return this._dispatch(DESKTOP_COMMANDS.EXECUTE_COMMAND, {
+      command,
+      cwd: options.cwd || null,
+      timeout: options.timeout || null,
+      stdin_input: options.stdinInput || null,
+      pty: options.pty === true,
+      inputs: options.inputs || [],
+    });
+  }
 }
 
 module.exports = {

package/server/services/desktop/registry.js

@@ -1,6 +1,8 @@
 const crypto = require('crypto');
 const db = require('../../db/database');
 const {
+  DESKTOP_COMMANDS,
+  FRAME_TYPE_VIDEO,
   DesktopCompanionSelectionError,
   DesktopCompanionUnavailableError,
   createDesktopCommandMessage,
@@ -127,6 +129,16 @@ class DesktopCompanionRegistry {
       now,
     );
 
+    // Remove stale offline entries for the same machine (e.g. after a re-install
+    // that generated a new device_id but kept the same hostname).
+    const hostname = hello.hostname ? String(hello.hostname).trim() : null;
+    if (hostname) {
+      this.db.prepare(
+        `DELETE FROM desktop_companion_devices
+         WHERE user_id = ? AND hostname = ? AND device_id != ? AND status = 'offline'`
+      ).run(userId, hostname, hello.deviceId);
+    }
+
     return this.getDeviceRecordByDeviceId(userId, hello.deviceId);
   }
 
@@ -172,9 +184,6 @@ class DesktopCompanionRegistry {
     const record = this._upsertDeviceRecord(userId, hello, sessionId);
     const userMap = this._getUserMap(userId, true);
     const existing = userMap.get(record.deviceId);
-    if (existing && existing.ws !== ws) {
-      existing.close('replaced by a newer desktop companion connection');
-    }
 
     const connection = new DesktopCompanionConnection({
       registry: this,
@@ -192,7 +201,16 @@ class DesktopCompanionRegistry {
       },
       timeoutMs: this.commandTimeoutMs,
     });
+    // Install the new connection in the map BEFORE closing the old one.
+    // This ensures that when the old socket's async 'close' event fires and
+    // calls unregisterConnection, it sees the new connection as the owner and
+    // skips the DB status='offline' write — preventing a false offline report.
     userMap.set(record.deviceId, connection);
+
+    if (existing && existing.ws !== ws) {
+      existing.close('replaced by a newer desktop companion connection');
+    }
+
     return {
       connection,
       device: this.getDeviceRecordByDeviceId(userId, record.deviceId),
@@ -201,17 +219,21 @@ class DesktopCompanionRegistry {
 
   unregisterConnection(connection) {
     const userMap = this._getUserMap(connection.userId);
-    if (userMap && userMap.get(connection.deviceId) === connection) {
+    const isOwner = userMap != null && userMap.get(connection.deviceId) === connection;
+    if (isOwner) {
       userMap.delete(connection.deviceId);
       if (userMap.size === 0) {
         this.connectionsByUser.delete(String(connection.userId));
       }
+      // Only mark offline in the DB when this connection is still the active owner.
+      // If a newer connection has already taken over (reconnect race), its
+      // _upsertDeviceRecord already wrote status='online' and we must not clobber it.
+      this.db.prepare(
+        `UPDATE desktop_companion_devices
+         SET status = 'offline', updated_at = datetime('now')
+         WHERE user_id = ? AND device_id = ?`
+      ).run(connection.userId, connection.deviceId);
     }
-    this.db.prepare(
-      `UPDATE desktop_companion_devices
-       SET status = 'offline', updated_at = datetime('now')
-       WHERE user_id = ? AND device_id = ?`
-    ).run(connection.userId, connection.deviceId);
   }
 
   touchConnection(userId, deviceId, patch = {}) {
@@ -253,6 +275,11 @@ class DesktopCompanionRegistry {
     return this.getDeviceRecordByDeviceId(userId, deviceId);
   }
 
+  isConnected(userId) {
+    const userMap = this._getUserMap(userId);
+    return userMap != null && userMap.size > 0;
+  }
+
   getConnection(userId, deviceId) {
     const userMap = this._getUserMap(userId);
     if (!userMap) return null;
@@ -348,12 +375,58 @@ class DesktopCompanionRegistry {
     };
   }
 
+  async startStream(userId, deviceId, options = {}) {
+    const device = this.resolveDevice(userId, deviceId);
+    const connection = this.getConnection(userId, device.deviceId);
+    if (!connection || !connection.isOpen()) {
+      throw new DesktopCompanionUnavailableError();
+    }
+    const result = await connection.sendCommand(DESKTOP_COMMANDS.STREAM_START, {
+      fps: options.fps,
+      quality: options.quality,
+      displayId: options.displayId || device.activeDisplayId || null,
+    }, options);
+    connection._streaming = true;
+    return {
+      ...result,
+      success: result?.success !== false,
+      deviceId: device.deviceId,
+      device: this.getDeviceRecordByDeviceId(userId, device.deviceId),
+    };
+  }
+
+  async stopStream(userId, deviceId) {
+    const device = this.resolveDevice(userId, deviceId);
+    const connection = this.getConnection(userId, device.deviceId);
+    if (!connection || !connection.isOpen()) {
+      throw new DesktopCompanionUnavailableError();
+    }
+    const result = await connection.sendCommand(DESKTOP_COMMANDS.STREAM_STOP, {});
+    connection._streaming = false;
+    return {
+      ...result,
+      success: result?.success !== false,
+      deviceId: device.deviceId,
+      device: this.getDeviceRecordByDeviceId(userId, device.deviceId),
+    };
+  }
+
   getStatus(userId) {
     const devices = this.listDevices(userId);
     const onlineDevices = devices.filter((device) => device.online);
+    let selectedDeviceId = this.getSelectedDeviceId(userId);
+
+    // Auto-select the most-recently-online device when there is no valid selection.
+    // listDevices returns online devices first, ordered by last_seen_at DESC.
+    const selectionIsOnline = selectedDeviceId && onlineDevices.some((d) => d.deviceId === selectedDeviceId);
+    if (!selectionIsOnline && onlineDevices.length > 0) {
+      selectedDeviceId = onlineDevices[0].deviceId;
+      this.setSelectedDeviceId(userId, selectedDeviceId);
+    }
+
     return {
       connected: onlineDevices.length > 0,
-      selectedDeviceId: this.getSelectedDeviceId(userId),
+      selectedDeviceId,
       onlineCount: onlineDevices.length,
       devices,
     };
@@ -446,6 +519,8 @@ class DesktopCompanionConnection {
         this.ws.close(1000, String(reason || 'closing').slice(0, 120));
       }
     } catch {}
+    // unregisterConnection is intentionally called here (not inside _closePending)
+    // so it runs synchronously before any async ws 'close' event can fire.
     this.registry.unregisterConnection(this);
     this._closePending(new DesktopCompanionUnavailableError('Desktop companion disconnected.'));
   }
@@ -474,6 +549,9 @@ class DesktopCompanionConnection {
   }
 
   _handleMessage(data) {
+    if (Buffer.isBuffer(data) && data.length > 0 && data[0] === FRAME_TYPE_VIDEO) {
+      return;
+    }
     let message;
     try {
       message = parseDesktopMessage(data);
@@ -512,6 +590,10 @@ class DesktopCompanionConnection {
       pending.reject(error);
     }
     this.pending.clear();
+    // unregisterConnection is idempotent (ownership-checked) so calling it
+    // here is safe whether we arrived via close(), the ws 'close' event, or
+    // both. It ensures natural socket drops (no explicit close() call) still
+    // mark the device offline.
     this.registry.unregisterConnection(this);
   }
 }