neoagent 3.2.1-beta.1 → 3.2.1-beta.3

package/server/services/desktop/registry.js

@@ -1,5 +1,8 @@
+'use strict';
+
 const crypto = require('crypto');
 const db = require('../../db/database');
+const { createAbortError } = require('../../utils/abort');
 const {
   DESKTOP_COMMANDS,
   FRAME_TYPE_VIDEO,
@@ -66,6 +69,7 @@ class DesktopCompanionRegistry {
       || DEFAULT_PRESENCE_TOUCH_INTERVAL_MS,
     );
     this.connectionsByUser = new Map();
+    this.closed = false;
   }
 
   _getUserMap(userId, create = false) {
@@ -199,6 +203,9 @@ class DesktopCompanionRegistry {
   }
 
   registerConnection({ userId, sessionId, ws, hello, remoteAddress = null, userAgent = null }) {
+    if (this.closed) {
+      throw new DesktopCompanionUnavailableError('Desktop companion registry is shutting down.');
+    }
     const record = this._upsertDeviceRecord(userId, hello, sessionId);
     const userMap = this._getUserMap(userId, true);
     const existing = userMap.get(record.deviceId);
@@ -249,11 +256,15 @@ class DesktopCompanionRegistry {
       // 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);
+      try {
+        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);
+      } catch (error) {
+        console.warn('[DesktopCompanion] Failed to record disconnect:', error?.message);
+      }
     }
   }
 
@@ -300,18 +311,22 @@ class DesktopCompanionRegistry {
     const userMap = this._getUserMap(userId);
     const connection = userMap?.get(String(deviceId));
     if (!connection?.isOpen()) return;
-    this.db.prepare(
-      `UPDATE desktop_companion_devices
-       SET status = 'online',
-           last_seen_at = datetime('now'),
-           updated_at = datetime('now')
-       WHERE user_id = ? AND device_id = ? AND revoked_at IS NULL`
-    ).run(userId, deviceId);
+    try {
+      this.db.prepare(
+        `UPDATE desktop_companion_devices
+         SET status = 'online',
+             last_seen_at = datetime('now'),
+             updated_at = datetime('now')
+         WHERE user_id = ? AND device_id = ? AND revoked_at IS NULL`
+      ).run(userId, deviceId);
+    } catch (error) {
+      console.warn('[DesktopCompanion] Failed to update presence:', error?.message);
+    }
   }
 
   isConnected(userId) {
     const userMap = this._getUserMap(userId);
-    return userMap != null && userMap.size > 0;
+    return userMap != null && Array.from(userMap.values()).some((connection) => connection.isOpen());
   }
 
   getConnection(userId, deviceId) {
@@ -394,15 +409,19 @@ class DesktopCompanionRegistry {
       throw new DesktopCompanionUnavailableError();
     }
     const result = await connection.sendCommand(command, payload, options);
-    this.touchConnection(userId, device.deviceId, {
-      label: result?.device?.label,
-      paused: result?.paused === true,
-      activeDisplayId: result?.activeDisplayId || result?.device?.activeDisplayId,
-      permissions: result?.permissions,
-      capabilities: result?.capabilities,
-      displays: result?.displays || result?.device?.displays,
-      metadata: result?.device?.metadata,
-    });
+    try {
+      this.touchConnection(userId, device.deviceId, {
+        label: result?.device?.label,
+        paused: typeof result?.paused === 'boolean' ? result.paused : null,
+        activeDisplayId: result?.activeDisplayId || result?.device?.activeDisplayId,
+        permissions: result?.permissions,
+        capabilities: result?.capabilities,
+        displays: result?.displays || result?.device?.displays,
+        metadata: result?.device?.metadata,
+      });
+    } catch (error) {
+      console.warn('[DesktopCompanion] Failed to record command result:', error?.message);
+    }
     return {
       ...result,
       device: this.getDeviceRecordByDeviceId(userId, device.deviceId),
@@ -429,13 +448,13 @@ class DesktopCompanionRegistry {
     };
   }
 
-  async stopStream(userId, deviceId) {
+  async stopStream(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_STOP, {});
+    const result = await connection.sendCommand(DESKTOP_COMMANDS.STREAM_STOP, {}, options);
     connection._streaming = false;
     return {
       ...result,
@@ -489,7 +508,7 @@ class DesktopCompanionRegistry {
     return { success: true, deviceId: normalizedDeviceId };
   }
 
-  pause(userId, deviceId, paused = true) {
+  async pause(userId, deviceId, paused = true, options = {}) {
     const normalizedDeviceId = String(deviceId || '').trim();
     if (!normalizedDeviceId) {
       throw new DesktopCompanionUnavailableError();
@@ -500,27 +519,40 @@ class DesktopCompanionRegistry {
     if (!existing) {
       throw new DesktopCompanionUnavailableError();
     }
-    this.db.prepare(
-      `UPDATE desktop_companion_devices
-       SET paused = ?, updated_at = datetime('now')
-       WHERE user_id = ? AND device_id = ?`
-    ).run(paused ? 1 : 0, userId, normalizedDeviceId);
     const connection = this.getConnection(userId, normalizedDeviceId);
-    if (connection) {
-      void connection.sendCommand('pauseControl', { paused }).catch(() => {});
+    if (!connection?.isOpen()) {
+      throw new DesktopCompanionUnavailableError();
+    }
+    const result = await connection.sendCommand(
+      DESKTOP_COMMANDS.PAUSE_CONTROL,
+      { paused },
+      options,
+    );
+    if (result?.success !== false) {
+      try {
+        this.db.prepare(
+          `UPDATE desktop_companion_devices
+           SET paused = ?, updated_at = datetime('now')
+           WHERE user_id = ? AND device_id = ?`
+        ).run(paused ? 1 : 0, userId, normalizedDeviceId);
+      } catch (error) {
+        console.warn('[DesktopCompanion] Failed to record pause state:', error?.message);
+      }
     }
     return {
-      success: true,
+      ...result,
+      success: result?.success !== false,
       deviceId: normalizedDeviceId,
       paused,
     };
   }
 
   closeAll() {
-    for (const userMap of this.connectionsByUser.values()) {
-      for (const connection of userMap.values()) {
-        connection.close('server shutdown');
-      }
+    this.closed = true;
+    const connections = Array.from(this.connectionsByUser.values())
+      .flatMap((userMap) => Array.from(userMap.values()));
+    for (const connection of connections) {
+      connection.close('server shutdown');
     }
     this.connectionsByUser.clear();
   }
@@ -555,24 +587,37 @@ class DesktopCompanionConnection {
     this.lastPongAt = Date.now();
     this.lastPresenceTouchAt = 0;
     this.heartbeatTimer = null;
+    this.closed = false;
 
-    ws.on('message', (data) => this._handleMessage(data));
+    ws.on('message', (data) => {
+      try {
+        this._handleMessage(data);
+      } catch (error) {
+        try { ws.terminate(); } catch {}
+        this._closePending(error);
+      }
+    });
     ws.on('pong', () => {
       this.lastPongAt = Date.now();
       this.touchPresence();
     });
     ws.on('close', () => this._closePending(new DesktopCompanionUnavailableError('Desktop companion disconnected.')));
-    ws.on('error', (error) => this._closePending(error));
+    ws.on('error', (error) => {
+      try { ws.terminate(); } catch {}
+      this._closePending(error);
+    });
     this._startHeartbeat();
   }
 
   isOpen() {
-    return this.ws && this.ws.readyState === 1;
+    return !this.closed && this.ws && this.ws.readyState === 1;
   }
 
   close(reason) {
+    const wasOpen = this.isOpen();
+    this.closed = true;
     try {
-      if (this.isOpen()) {
+      if (wasOpen) {
         this.ws.close(1000, String(reason || 'closing').slice(0, 120));
       }
     } catch {}
@@ -602,19 +647,51 @@ class DesktopCompanionConnection {
       return Promise.reject(new DesktopCompanionUnavailableError());
     }
     const id = crypto.randomUUID();
-    const timeoutMs = Number(options.timeoutMs || this.timeoutMs);
+    const requestedTimeout = Number(options.timeoutMs || this.timeoutMs);
+    const timeoutMs = Number.isFinite(requestedTimeout)
+      ? Math.min(30 * 60 * 1000, Math.max(100, requestedTimeout))
+      : DEFAULT_COMMAND_TIMEOUT_MS;
     const message = createDesktopCommandMessage(id, command, payload);
     return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
+      const signal = options.signal || null;
+      const sendCancellation = () => {
+        if (!this.isOpen() || command === DESKTOP_COMMANDS.CANCEL_COMMAND) return;
+        try {
+          this.ws.send(JSON.stringify(createDesktopCommandMessage(
+            crypto.randomUUID(),
+            DESKTOP_COMMANDS.CANCEL_COMMAND,
+            { commandId: id },
+          )));
+        } catch {}
+      };
+      const cleanup = () => {
+        clearTimeout(timer);
+        signal?.removeEventListener('abort', onAbort);
         this.pending.delete(id);
-        reject(new Error(`Desktop companion command timed out: ${command}`));
+      };
+      const onAbort = () => {
+        cleanup();
+        sendCancellation();
+        reject(createAbortError(signal, `Desktop companion command aborted: ${command}`));
+      };
+      const timer = setTimeout(() => {
+        cleanup();
+        sendCancellation();
+        const error = new Error(`Desktop companion command timed out: ${command}`);
+        error.code = 'DESKTOP_COMPANION_COMMAND_TIMEOUT';
+        reject(error);
       }, timeoutMs);
-      this.pending.set(id, { resolve, reject, timer, command });
+      timer.unref?.();
+      if (signal?.aborted) {
+        onAbort();
+        return;
+      }
+      signal?.addEventListener('abort', onAbort, { once: true });
+      this.pending.set(id, { resolve, reject, timer, command, signal, onAbort });
       try {
         this.ws.send(JSON.stringify(message));
       } catch (error) {
-        clearTimeout(timer);
-        this.pending.delete(id);
+        cleanup();
         reject(error);
       }
     });
@@ -636,10 +713,14 @@ class DesktopCompanionConnection {
 
     if (message.type === 'event') {
       if (message.event === 'statusChanged' || message.event === 'permissionsChanged') {
-        this.registry.touchConnection(this.userId, this.deviceId, {
-          ...message.payload,
-          metadata: message.payload?.metadata,
-        });
+        try {
+          this.registry.touchConnection(this.userId, this.deviceId, {
+            ...message.payload,
+            metadata: message.payload?.metadata,
+          });
+        } catch (error) {
+          console.warn('[DesktopCompanion] Failed to record device event:', error?.message);
+        }
       }
       return;
     }
@@ -648,6 +729,7 @@ class DesktopCompanionConnection {
     const pending = this.pending.get(message.id);
     if (!pending) return;
     clearTimeout(pending.timer);
+    pending.signal?.removeEventListener('abort', pending.onAbort);
     this.pending.delete(message.id);
     if (message.ok === false) {
       const error = new Error(String(message.error || `Desktop companion command failed: ${pending.command}`));
@@ -655,16 +737,18 @@ class DesktopCompanionConnection {
       pending.reject(error);
       return;
     }
-    pending.resolve(message.payload || {});
+    pending.resolve(message.payload ?? {});
   }
 
   _closePending(error) {
+    this.closed = true;
     if (this.heartbeatTimer) {
       clearInterval(this.heartbeatTimer);
       this.heartbeatTimer = null;
     }
     for (const pending of this.pending.values()) {
       clearTimeout(pending.timer);
+      pending.signal?.removeEventListener('abort', pending.onAbort);
       pending.reject(error);
     }
     this.pending.clear();
@@ -702,5 +786,6 @@ class DesktopCompanionConnection {
 }
 
 module.exports = {
+  DesktopCompanionConnection,
   DesktopCompanionRegistry,
 };

package/server/services/integrations/figma/provider.js

@@ -158,25 +158,88 @@ function figmaUrl(path, query) {
   return url.toString();
 }
 
-async function figmaRequest(credentials, { method = 'GET', path, query, body }) {
-  return fetchJson(
+function expiresAtFromSeconds(expiresIn) {
+  return new Date(
+    Date.now() + Math.max(1, Number(expiresIn) || 3600) * 1000,
+  ).toISOString();
+}
+
+function tokenExpiresSoon(credentials) {
+  const expiresAt = Date.parse(String(credentials?.expires_at || ''));
+  return Number.isFinite(expiresAt) && expiresAt <= Date.now() + 60 * 1000;
+}
+
+async function refreshFigmaCredentials(credentials, signal) {
+  const refreshToken = String(credentials?.refresh_token || '').trim();
+  if (!refreshToken) {
+    throw new Error('Figma refresh token is missing. Reconnect this integration account.');
+  }
+  const config = resolveFigmaOAuthConfig();
+  const basic = Buffer.from(`${config.clientId}:${config.clientSecret}`).toString(
+    'base64',
+  );
+  const token = await fetchJson(
+    'https://api.figma.com/v1/oauth/token',
+    {
+      method: 'POST',
+      headers: { Authorization: `Basic ${basic}` },
+      form: {
+        grant_type: 'refresh_token',
+        refresh_token: refreshToken,
+      },
+      signal,
+    },
+    { serviceName: 'Figma token refresh' },
+  );
+  if (!String(token?.access_token || '').trim()) {
+    throw new Error('Figma token refresh did not return an access token.');
+  }
+  return {
+    ...credentials,
+    access_token: token.access_token,
+    refresh_token: token.refresh_token || refreshToken,
+    token_type: token.token_type || credentials.token_type || 'bearer',
+    expires_in: token.expires_in,
+    expires_at: expiresAtFromSeconds(token.expires_in),
+  };
+}
+
+async function figmaRequest(context, { method = 'GET', path, query, body }) {
+  const { signal } = context;
+  let credentials = context.credentials;
+  if (tokenExpiresSoon(credentials)) {
+    credentials = await refreshFigmaCredentials(credentials, signal);
+    context.updateCredentials(credentials);
+  }
+
+  const performRequest = (activeCredentials) => fetchJson(
     figmaUrl(path, query),
     {
       method: String(method || 'GET').toUpperCase(),
-      headers: { Authorization: `Bearer ${credentials.access_token}` },
+      headers: { Authorization: `Bearer ${activeCredentials.access_token}` },
       ...(body === undefined ? {} : { json: body }),
+      signal,
     },
     { serviceName: 'Figma' },
   );
+
+  try {
+    return await performRequest(credentials);
+  } catch (error) {
+    if (error?.status !== 401 || !credentials.refresh_token) throw error;
+    credentials = await refreshFigmaCredentials(credentials, signal);
+    context.updateCredentials(credentials);
+    return performRequest(credentials);
+  }
 }
 
-async function executeFigmaTool(toolName, args, { credentials }) {
+async function executeFigmaTool(toolName, args, context) {
   switch (toolName) {
     case 'figma_get_me':
-      return { result: await figmaRequest(credentials, { path: '/v1/me' }) };
+      return { result: await figmaRequest(context, { path: '/v1/me' }) };
     case 'figma_get_file':
       return {
-        result: await figmaRequest(credentials, {
+        result: await figmaRequest(context, {
           path: `/v1/files/${encodeURIComponent(requireText(args.file_key, 'file_key'))}`,
           query: {
             ids: args.ids || undefined,
@@ -186,14 +249,14 @@ async function executeFigmaTool(toolName, args, { credentials }) {
       };
     case 'figma_get_file_nodes':
       return {
-        result: await figmaRequest(credentials, {
+        result: await figmaRequest(context, {
           path: `/v1/files/${encodeURIComponent(requireText(args.file_key, 'file_key'))}/nodes`,
           query: { ids: requireText(args.ids, 'ids') },
         }),
       };
     case 'figma_get_file_images':
       return {
-        result: await figmaRequest(credentials, {
+        result: await figmaRequest(context, {
           path: `/v1/images/${encodeURIComponent(requireText(args.file_key, 'file_key'))}`,
           query: {
             ids: requireText(args.ids, 'ids'),
@@ -204,13 +267,13 @@ async function executeFigmaTool(toolName, args, { credentials }) {
       };
     case 'figma_get_comments':
       return {
-        result: await figmaRequest(credentials, {
+        result: await figmaRequest(context, {
           path: `/v1/files/${encodeURIComponent(requireText(args.file_key, 'file_key'))}/comments`,
         }),
       };
     case 'figma_post_comment':
       return {
-        result: await figmaRequest(credentials, {
+        result: await figmaRequest(context, {
           method: 'POST',
           path: `/v1/files/${encodeURIComponent(requireText(args.file_key, 'file_key'))}/comments`,
           body: {
@@ -221,7 +284,7 @@ async function executeFigmaTool(toolName, args, { credentials }) {
       };
     case 'figma_api_request':
       return {
-        result: await figmaRequest(credentials, {
+        result: await figmaRequest(context, {
           method: args.method,
           path: requireText(args.path, 'path'),
           query: args.query,
@@ -263,7 +326,7 @@ function createFigmaProvider() {
         appId: app.id,
       };
     },
-    async finishOAuth({ code, app }) {
+    async finishOAuth({ code, app, signal }) {
       const config = resolveFigmaOAuthConfig();
       const basic = Buffer.from(`${config.clientId}:${config.clientSecret}`).toString(
         'base64',
@@ -280,6 +343,7 @@ function createFigmaProvider() {
             code,
             grant_type: 'authorization_code',
           },
+          signal,
         },
         { serviceName: 'Figma' },
       );
@@ -290,6 +354,7 @@ function createFigmaProvider() {
           headers: {
             Authorization: `Bearer ${token.access_token}`,
           },
+          signal,
         },
         { serviceName: 'Figma' },
       );
@@ -307,6 +372,7 @@ function createFigmaProvider() {
           access_token: token.access_token,
           refresh_token: token.refresh_token,
           expires_in: token.expires_in,
+          expires_at: expiresAtFromSeconds(token.expires_in),
           token_type: token.token_type,
           scope: token.scope,
         },

package/server/services/integrations/github/common.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const crypto = require('crypto');
+const { fetchResponseText } = require('../http');
 
 function base64UrlSha256(value) {
   return crypto
@@ -46,15 +47,19 @@ async function githubApiRequest(auth, options = {}) {
     headers['Content-Type'] = 'application/json';
   }
 
-  const response = await fetch(url.toString(), {
-    method,
-    headers,
-    body: body ? JSON.stringify(body) : undefined,
-  });
+  const { response, text: rawBody } = await fetchResponseText(
+    url.toString(),
+    {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : undefined,
+      signal: options.signal || auth?.signal,
+    },
+    { serviceName: 'GitHub API' },
+  );
 
   let data = null;
   if (response.status !== 204 && response.status !== 205) {
-    const rawBody = await response.text();
     if (rawBody.trim()) {
       try {
         data = JSON.parse(rawBody);