neoagent 2.3.0 → 2.3.1-beta.10

package/server/services/integrations/manager.js

@@ -13,6 +13,22 @@ const {
 
 const OAUTH_STATE_PATTERN = /^[a-f0-9]{32,128}$/i;
 
+function isLikelyExpiredConnectionError(error) {
+  const message = String(error?.message || error || '').toLowerCase();
+  if (!message) return false;
+  return [
+    'invalid_grant',
+    'token refresh failed',
+    'token expired',
+    'access token is missing',
+    'refresh token is missing',
+    'reconnect this integration account',
+    'account is no longer authorized',
+    'reauthorize',
+    're-authorize',
+  ].some((hint) => message.includes(hint));
+}
+
 class IntegrationManager {
   constructor(options = {}) {
     this.app = options.app || null;
@@ -147,7 +163,12 @@ class IntegrationManager {
 
     return this.registry
       .list()
-      .map((provider) => provider.buildSnapshot(rowsByProvider.get(provider.key) || []));
+      .map((provider) =>
+        provider.buildSnapshot(rowsByProvider.get(provider.key) || [], {
+          userId,
+          agentId: scopedAgentId,
+        }),
+      );
   }
 
   async beginOAuth(userId, providerKey, options = {}) {
@@ -163,7 +184,10 @@ class IntegrationManager {
       throw new Error(`Unknown ${provider.label} app: ${appKey || 'missing app key'}`);
     }
 
-    const env = provider.getEnvStatus();
+    const env = provider.getEnvStatus({
+      userId,
+      agentId,
+    });
     if (!env.configured) {
       throw new Error(env.summary);
     }
@@ -389,7 +413,10 @@ class IntegrationManager {
   getToolDefinitions(userId, agentId = null) {
     const definitions = [];
     for (const provider of this.registry.list()) {
-      const env = provider.getEnvStatus();
+      const env = provider.getEnvStatus({
+        userId,
+        agentId,
+      });
       if (!env.configured) continue;
       const connections = this.listConnections(userId, provider.key, agentId);
       const connectedAppIds = Array.from(
@@ -411,9 +438,15 @@ class IntegrationManager {
     if (!provider) {
       throw new Error(`Unknown integration provider: ${providerKey}`);
     }
-    const env = provider.getEnvStatus();
+    const env = provider.getEnvStatus({
+      userId,
+      agentId,
+    });
     const connections = this.listConnections(userId, provider.key, agentId);
-    const snapshot = provider.buildSnapshot(connections);
+    const snapshot = provider.buildSnapshot(connections, {
+      userId,
+      agentId,
+    });
     const connectedAppIds = snapshot.apps
       .filter((app) => app.connection.connected)
       .map((app) => app.id);
@@ -582,7 +615,10 @@ class IntegrationManager {
     for (const provider of this.registry.list()) {
       if (!provider.supportsTool(toolName)) continue;
       foundSupportingProvider = true;
-      const env = provider.getEnvStatus();
+      const env = provider.getEnvStatus({
+        userId,
+        agentId,
+      });
       if (!env.configured) {
         return { error: env.summary };
       }
@@ -607,6 +643,17 @@ class IntegrationManager {
           selection.connection,
         );
       } catch (err) {
+        if (isLikelyExpiredConnectionError(err)) {
+          db.prepare(
+            `UPDATE integration_connections
+             SET status = 'expired', updated_at = datetime('now')
+             WHERE id = ? AND user_id = ? AND agent_id = ?`,
+          ).run(
+            selection.connection.id,
+            userId,
+            resolveAgentId(userId, agentId),
+          );
+        }
         return { error: err?.message || 'execution_error' };
       }
       if (!execution) {
@@ -641,7 +688,13 @@ class IntegrationManager {
   summarizeConnectedProviders(userId, agentId = null) {
     const providers = this.registry.list().map((provider) => ({
       provider,
-      snapshot: provider.buildSnapshot(this.listConnections(userId, provider.key, agentId)),
+      snapshot: provider.buildSnapshot(
+        this.listConnections(userId, provider.key, agentId),
+        {
+          userId,
+          agentId,
+        },
+      ),
     }));
 
     if (providers.length === 0) {
@@ -655,6 +708,9 @@ class IntegrationManager {
         }
 
         if (!snapshot?.env?.configured) {
+          if (snapshot?.env?.setupMode === 'user') {
+            return `${provider.label}: setup is not complete for this user yet. If the user wants to use it, tell them to finish setup in Official Integrations first.`;
+          }
           return `${provider.label}: available but not configured on the server yet. If the user wants to use it, tell them to finish setup in Official Integrations first.`;
         }
 

package/server/services/integrations/oauth_provider.js

@@ -247,8 +247,8 @@ function createOAuthProvider(options = {}) {
     getToolAppId(toolName) {
       return toolAppMap.get(String(toolName || '').trim()) || null;
     },
-    getEnvStatus() {
-      return options.getEnvStatus();
+    getEnvStatus(context = {}) {
+      return options.getEnvStatus(context);
     },
     getToolDefinitions(toolOptions = {}) {
       const connectedAppIds = new Set(toolOptions.connectedAppIds || []);
@@ -257,8 +257,8 @@ function createOAuthProvider(options = {}) {
     supportsTool(toolName) {
       return toolAppMap.has(String(toolName || '').trim());
     },
-    buildSnapshot(connectionRows) {
-      const env = this.getEnvStatus();
+    buildSnapshot(connectionRows, context = {}) {
+      const env = this.getEnvStatus(context);
       const byApp = new Map();
       for (const row of Array.isArray(connectionRows) ? connectionRows : []) {
         const appId = String(row.app_key || '').trim();
@@ -319,7 +319,7 @@ function createOAuthProvider(options = {}) {
         throw new Error(`Unknown ${this.label} app: ${appKey}`);
       }
       const normalizedState = assertValidOAuthState(state);
-      const env = this.getEnvStatus();
+      const env = this.getEnvStatus({ userId });
       if (!env.configured) {
         throw new Error(env.summary);
       }
@@ -343,7 +343,7 @@ function createOAuthProvider(options = {}) {
         userId,
         state: normalizedState,
         app,
-        env: this.getEnvStatus(),
+        env: this.getEnvStatus({ userId }),
       });
     },
     async disconnect(connectionRow) {
@@ -368,12 +368,16 @@ function createOAuthProvider(options = {}) {
         appId: toolAppMap.get(String(toolName || '').trim()) || connectionRow.app_key,
         connection: connectionRow,
         credentials,
+        env: this.getEnvStatus({ userId: connectionRow?.user_id }),
       });
     },
     summarizeConnection(connectionRows) {
       const snapshot = this.buildSnapshot(connectionRows);
       if (!snapshot.connection.connected) {
         if (snapshot.connection.status === 'env_not_configured') {
+          if (snapshot?.env?.setupMode === 'user') {
+            return `${this.label} still needs per-user setup before accounts can connect.`;
+          }
           return `${this.label} still needs administrator setup before accounts can connect.`;
         }
         return `${this.label} is not connected.`;
@@ -392,6 +396,9 @@ function createOAuthProvider(options = {}) {
     },
     summarizeForModel(snapshot) {
       if (!snapshot?.env?.configured) {
+        if (snapshot?.env?.setupMode === 'user') {
+          return `${this.label}: setup is user-managed and is not complete yet. If the user wants to use it, tell them to open Official Integrations and finish setup in their account first.`;
+        }
         return `${this.label}: workspace setup is not complete yet. If the user wants to use it, tell them to open Official Integrations and ask an administrator to finish setup first.`;
       }
 

package/server/services/integrations/provider_config_store.js

@@ -0,0 +1,76 @@
+'use strict';
+
+const db = require('../../db/database');
+const { decryptValue, encryptValue } = require('./secrets');
+
+function normalizeProviderKey(providerKey) {
+  return String(providerKey || '').trim();
+}
+
+function parseConfig(value) {
+  try {
+    const parsed = JSON.parse(decryptValue(value || '{}') || '{}');
+    return parsed && typeof parsed === 'object' ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+function getProviderConfig(userId, providerKey) {
+  const normalizedProviderKey = normalizeProviderKey(providerKey);
+  if (!Number.isInteger(Number(userId)) || Number(userId) <= 0 || !normalizedProviderKey) {
+    return {};
+  }
+
+  const row = db
+    .prepare(
+      `SELECT config_json
+       FROM integration_provider_configs
+       WHERE user_id = ? AND provider_key = ?`,
+    )
+    .get(Number(userId), normalizedProviderKey);
+
+  return parseConfig(row?.config_json);
+}
+
+function setProviderConfig(userId, providerKey, config) {
+  const normalizedProviderKey = normalizeProviderKey(providerKey);
+  if (!Number.isInteger(Number(userId)) || Number(userId) <= 0 || !normalizedProviderKey) {
+    throw new Error('A valid user and provider are required to save integration config.');
+  }
+
+  const payload = config && typeof config === 'object' ? config : {};
+  db.prepare(
+    `INSERT INTO integration_provider_configs (
+       user_id,
+       provider_key,
+       config_json,
+       created_at,
+       updated_at
+     ) VALUES (?, ?, ?, datetime('now'), datetime('now'))
+     ON CONFLICT(user_id, provider_key) DO UPDATE SET
+       config_json = excluded.config_json,
+       updated_at = excluded.updated_at`,
+  ).run(
+    Number(userId),
+    normalizedProviderKey,
+    encryptValue(JSON.stringify(payload)),
+  );
+}
+
+function deleteProviderConfig(userId, providerKey) {
+  const normalizedProviderKey = normalizeProviderKey(providerKey);
+  if (!Number.isInteger(Number(userId)) || Number(userId) <= 0 || !normalizedProviderKey) {
+    return;
+  }
+
+  db.prepare(
+    'DELETE FROM integration_provider_configs WHERE user_id = ? AND provider_key = ?',
+  ).run(Number(userId), normalizedProviderKey);
+}
+
+module.exports = {
+  deleteProviderConfig,
+  getProviderConfig,
+  setProviderConfig,
+};

package/server/services/integrations/registry.js

@@ -2,19 +2,29 @@
 
 const { createFigmaProvider } = require('./figma/provider');
 const { createGoogleWorkspaceProvider } = require('./google/provider');
+const { createGithubProvider } = require('./github/provider');
+const { createHomeAssistantProvider } = require('./home_assistant/provider');
 const { createMicrosoftProvider } = require('./microsoft/provider');
 const { createNotionProvider } = require('./notion/provider');
+const { createSpotifyProvider } = require('./spotify/provider');
 const { createSlackProvider } = require('./slack/provider');
+const { createWeatherProvider } = require('./weather/provider');
 const { createWhatsAppPersonalProvider } = require('./whatsapp');
+const { createCodexProvider } = require('./codex/provider');
 
 function createIntegrationRegistry(options = {}) {
   const providers = [
     createGoogleWorkspaceProvider(),
+    createGithubProvider(),
     createNotionProvider(),
     createMicrosoftProvider(),
     createSlackProvider(),
     createFigmaProvider(),
+    createHomeAssistantProvider(),
+    createWeatherProvider(),
+    createSpotifyProvider(),
     createWhatsAppPersonalProvider(options),
+    createCodexProvider(),
   ];
   const byKey = new Map(providers.map((provider) => [provider.key, provider]));