better-auth-studio 1.0.79-beta.5 → 1.0.79-beta.50

package/dist/routes.js

@@ -7,6 +7,7 @@ import { hex } from '@better-auth/utils/hex';
 import { scryptAsync } from '@noble/hashes/scrypt.js';
 import { Router } from 'express';
 import { createJiti } from 'jiti';
+import { createRequire } from 'module';
 import { createMockAccount, createMockSession, createMockUser, createMockVerification, getAuthAdapter, } from './auth-adapter.js';
 import { possiblePaths } from './config.js';
 import { getAuthData } from './data.js';
@@ -57,6 +58,20 @@ function getStudioVersion() {
             const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
             return packageJson.version || '1.0.0';
         }
+        const nodeModulesPath = join(process.cwd(), 'node_modules/better-auth-studio/package.json');
+        if (existsSync(nodeModulesPath)) {
+            const packageJson = JSON.parse(readFileSync(nodeModulesPath, 'utf-8'));
+            return packageJson.version || '1.0.0';
+        }
+        try {
+            const require = createRequire(import.meta.url);
+            const resolvedPath = require.resolve('better-auth-studio/package.json');
+            if (existsSync(resolvedPath)) {
+                const packageJson = JSON.parse(readFileSync(resolvedPath, 'utf-8'));
+                return packageJson.version || '1.0.0';
+            }
+        }
+        catch (_resolveError) { }
     }
     catch (_error) { }
     return '1.0.0';
@@ -252,7 +267,10 @@ async function findAuthConfigPath() {
 export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter, preloadedAuthOptions, accessConfig, authInstance) {
     const isSelfHosted = !!preloadedAdapter;
     const getAuthConfigSafe = async () => {
-        if (isSelfHosted && preloadedAuthOptions) {
+        if (isSelfHosted) {
+            return preloadedAuthOptions || authConfig || null;
+        }
+        if (preloadedAuthOptions) {
             return preloadedAuthOptions;
         }
         try {
@@ -270,7 +288,7 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
         catch (_error) {
             // Ignors errors
         }
-        return null;
+        return authConfig || null;
     };
     const router = Router();
     const base64UrlEncode = (value) => Buffer.from(value)
@@ -302,6 +320,10 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
             // For self-hosted studio, wrap the preloaded adapter to match expected interface
             return {
                 ...preloadedAdapter,
+                findUnique: preloadedAdapter.findUnique?.bind(preloadedAdapter),
+                findOne: preloadedAdapter.findOne?.bind(preloadedAdapter) ||
+                    preloadedAdapter.findUnique?.bind(preloadedAdapter),
+                findFirst: preloadedAdapter.findFirst?.bind(preloadedAdapter),
                 findMany: preloadedAdapter.findMany?.bind(preloadedAdapter),
                 create: preloadedAdapter.create?.bind(preloadedAdapter),
                 update: preloadedAdapter.update?.bind(preloadedAdapter),
@@ -476,7 +498,7 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
             if (!email || !password) {
                 return res.status(400).json({ success: false, message: 'Email and password required' });
             }
-            const adapter = await getAuthAdapter();
+            const adapter = await getAuthAdapterWithConfig();
             let signInResult = null;
             let signInError = null;
             try {
@@ -517,7 +539,6 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
                             message: 'Password not configured. Please reset your password.',
                         });
                     }
-                    console.log({ users, credentialAccount });
                     const isValidPassword = await verifyPassword(password, credentialAccount.password);
                     if (!isValidPassword) {
                         return res.status(401).json({ success: false, message: 'Invalid credentials' });
@@ -528,7 +549,7 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
                     if (!allowedRoles.includes(user.role)) {
                         return res.status(403).json({
                             success: false,
-                            message: `Access denied. Required role: ${allowedRoles.join(' or ')}`,
+                            message: `Access denied.`,
                             userRole: user.role || 'none',
                         });
                     }
@@ -577,7 +598,7 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
             if (!allowedRoles.includes(user.role)) {
                 return res.status(403).json({
                     success: false,
-                    message: `Access denied. Required role: ${allowedRoles.join(' or ')}`,
+                    message: `Access denied.`,
                     userRole: user.role || 'none',
                 });
             }
@@ -807,6 +828,19 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
             }
         }
         catch (_error) { }
+        let studioVersion = '1.0.0';
+        try {
+            const response = await fetch('https://registry.npmjs.org/better-auth-studio/latest', {
+                signal: AbortSignal.timeout(2000), // 2 second timeout
+            });
+            if (response.ok) {
+                const data = (await response.json());
+                studioVersion = data.version || '1.0.0';
+            }
+        }
+        catch (_npmError) {
+            studioVersion = getStudioVersion();
+        }
         if (databaseType === 'unknown' && !isSelfHosted) {
             const authConfigPath = configPath || (await findAuthConfigPath());
             if (authConfigPath) {
@@ -883,7 +917,7 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
             disabledPaths: effectiveConfig.disabledPaths || [],
             telemetry: effectiveConfig.telemetry,
             studio: {
-                version: getStudioVersion(),
+                version: studioVersion,
                 nodeVersion: process.version,
                 platform: process.platform,
                 uptime: process.uptime(),
@@ -893,7 +927,7 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
     });
     router.get('/api/stats', async (_req, res) => {
         try {
-            const stats = await getAuthData(authConfig, 'stats', undefined, configPath);
+            const stats = await getAuthData(authConfig, 'stats', undefined, configPath, preloadedAdapter);
             res.json(stats);
         }
         catch (_error) {
@@ -908,7 +942,7 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
                 type: type,
                 from: from,
                 to: to,
-            }, configPath);
+            }, configPath, preloadedAdapter);
             res.json(analytics);
         }
         catch (_error) {
@@ -925,26 +959,17 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
             let organizationPluginEnabled = false;
             let teamsPluginEnabled = false;
             try {
-                let betterAuthConfig = preloadedAuthOptions;
-                if (!betterAuthConfig && !isSelfHosted) {
-                    const authConfigPath = configPath || (await findAuthConfigPath());
-                    if (authConfigPath) {
-                        const { getConfig } = await import('./config.js');
-                        betterAuthConfig = await getConfig({
-                            cwd: process.cwd(),
-                            configPath: authConfigPath,
-                            shouldThrowOnError: false,
-                            noCache: true, // Disable cache for real-time plugin checks
-                        });
-                    }
-                }
+                const betterAuthConfig = preloadedAuthOptions || (await getAuthConfigSafe());
                 if (betterAuthConfig) {
                     const plugins = betterAuthConfig.plugins || [];
                     const organizationPlugin = plugins.find((plugin) => plugin.id === 'organization');
                     organizationPluginEnabled = !!organizationPlugin;
-                    teamsPluginEnabled = !!organizationPlugin?.options?.teams?.enabled;
                     if (organizationPlugin) {
-                        teamsPluginEnabled = organizationPlugin.options?.teams?.enabled === true;
+                        teamsPluginEnabled =
+                            organizationPlugin.options?.teams?.enabled === true ||
+                                organizationPlugin.teams?.enabled === true ||
+                                organizationPlugin.config?.teams?.enabled === true ||
+                                false;
                     }
                 }
             }
@@ -1045,7 +1070,7 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
     router.put('/api/users/:userId', async (req, res) => {
         try {
             const { userId } = req.params;
-            const { name, email, role } = req.body;
+            const { name, email, role, image } = req.body;
             const adapter = await getAuthAdapterWithConfig();
             if (!adapter || !adapter.update) {
                 return res.status(500).json({ error: 'Auth adapter not available' });
@@ -1054,6 +1079,9 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
             if (role !== undefined) {
                 updateData.role = role;
             }
+            if (image !== undefined) {
+                updateData.image = image;
+            }
             const user = await adapter.update({
                 model: 'user',
                 where: [{ field: 'id', value: userId }],
@@ -1073,9 +1101,36 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
                 return res.status(400).json({ error: 'Password is required' });
             }
             const adapter = await getAuthAdapterWithConfig();
-            if (!adapter || !adapter.update) {
+            if (!adapter) {
                 return res.status(500).json({ error: 'Auth adapter not available' });
             }
+            if (!adapter.update) {
+                return res.status(500).json({ error: 'Auth adapter update method not available' });
+            }
+            // Find the credential account first to get its unique id (fixes Prisma error)
+            let credentialAccount = null;
+            if (adapter.findFirst) {
+                credentialAccount = await adapter.findFirst({
+                    model: 'account',
+                    where: [
+                        { field: 'userId', value: userId },
+                        { field: 'providerId', value: 'credential' },
+                    ],
+                });
+            }
+            else if (adapter.findMany) {
+                const accounts = await adapter.findMany({
+                    model: 'account',
+                    where: [
+                        { field: 'userId', value: userId },
+                        { field: 'providerId', value: 'credential' },
+                    ],
+                });
+                credentialAccount = accounts && accounts.length > 0 ? accounts[0] : null;
+            }
+            if (!credentialAccount) {
+                return res.status(404).json({ error: 'Credential account not found' });
+            }
             let hashedPassword = password;
             try {
                 const salt = hex.encode(crypto.getRandomValues(new Uint8Array(16)));
@@ -1083,17 +1138,18 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
                 hashedPassword = `${salt}:${hex.encode(key)}`;
             }
             catch {
-                res.status(500).json({ error: 'Failed to hash password' });
+                return res.status(500).json({ error: 'Failed to hash password' });
             }
-            const account = await adapter.update({
+            // Update using the account's unique id to fix Prisma error
+            const updatedAccount = await adapter.update({
                 model: 'account',
-                where: [
-                    { field: 'userId', value: userId },
-                    { field: 'providerId', value: 'credential' },
-                ],
-                update: { password: hashedPassword },
+                where: [{ field: 'id', value: credentialAccount.id }],
+                update: {
+                    password: hashedPassword,
+                    updatedAt: new Date().toISOString(),
+                },
             });
-            res.json({ success: true, account });
+            res.json({ success: true, account: updatedAccount });
         }
         catch (error) {
             res.status(500).json({ error: 'Failed to update password', message: error?.message });
@@ -1471,7 +1527,7 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
                 }
             }
             catch (_adapterError) { }
-            const result = await getAuthData(authConfig, 'users', { page, limit, search }, configPath);
+            const result = await getAuthData(authConfig, 'users', { page, limit, search }, configPath, preloadedAdapter);
             const transformedUsers = (result.data || []).map((user) => ({
                 id: user.id,
                 email: user.email,
@@ -1496,7 +1552,7 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
         try {
             const page = parseInt(req.query.page, 10) || 1;
             const limit = parseInt(req.query.limit, 10) || 20;
-            const sessions = await getAuthData(authConfig, 'sessions', { page, limit }, configPath);
+            const sessions = await getAuthData(authConfig, 'sessions', { page, limit }, configPath, preloadedAdapter);
             res.json(sessions);
         }
         catch (_error) {
@@ -1505,7 +1561,7 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
     });
     router.get('/api/providers', async (_req, res) => {
         try {
-            const providers = await getAuthData(authConfig, 'providers', undefined, configPath);
+            const providers = await getAuthData(authConfig, 'providers', undefined, configPath, preloadedAdapter);
             res.json(providers);
         }
         catch (_error) {
@@ -1515,7 +1571,7 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
     router.delete('/api/users/:id', async (req, res) => {
         try {
             const { id } = req.params;
-            await getAuthData(authConfig, 'deleteUser', { id }, configPath);
+            await getAuthData(authConfig, 'deleteUser', { id }, configPath, preloadedAdapter);
             res.json({ success: true });
         }
         catch (_error) {
@@ -1524,60 +1580,82 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
     });
     router.get('/api/plugins', async (_req, res) => {
         try {
-            const authConfigPath = configPath
-                ? join(process.cwd(), configPath)
-                : await findAuthConfigPath();
-            if (!authConfigPath) {
+            const betterAuthConfig = preloadedAuthOptions || (await getAuthConfigSafe());
+            if (betterAuthConfig) {
+                const plugins = betterAuthConfig.plugins || [];
+                const pluginInfo = plugins.map((plugin) => ({
+                    id: plugin.id,
+                    name: plugin.name || plugin.id,
+                    description: plugin.description || `${plugin.id} plugin for Better Auth`,
+                    enabled: true,
+                }));
                 return res.json({
-                    plugins: [],
-                    error: 'No auth config found',
-                    configPath: null,
+                    plugins: pluginInfo,
+                    configPath: isSelfHosted ? null : configPath || null,
+                    totalPlugins: pluginInfo.length,
                 });
             }
-            try {
-                let authModule;
-                try {
-                    authModule = await safeImportAuthConfig(authConfigPath, true); // Disable cache for real-time plugin checks
+            if (!isSelfHosted) {
+                const authConfigPath = configPath
+                    ? join(process.cwd(), configPath)
+                    : await findAuthConfigPath();
+                if (!authConfigPath) {
+                    return res.json({
+                        plugins: [],
+                        error: 'No auth config found',
+                        configPath: null,
+                    });
                 }
-                catch (_importError) {
-                    const content = readFileSync(authConfigPath, 'utf-8');
-                    authModule = {
-                        auth: {
-                            options: {
-                                _content: content,
-                                plugins: [],
+                try {
+                    let authModule;
+                    try {
+                        authModule = await safeImportAuthConfig(authConfigPath, true); // Disable cache for real-time plugin checks
+                    }
+                    catch (_importError) {
+                        const content = readFileSync(authConfigPath, 'utf-8');
+                        authModule = {
+                            auth: {
+                                options: {
+                                    _content: content,
+                                    plugins: [],
+                                },
                             },
-                        },
-                    };
+                        };
+                    }
+                    const auth = authModule.auth || authModule.default;
+                    if (!auth) {
+                        return res.json({
+                            plugins: [],
+                            error: 'No auth export found',
+                            configPath: authConfigPath,
+                        });
+                    }
+                    const plugins = auth.options?.plugins || [];
+                    const pluginInfo = plugins.map((plugin) => ({
+                        id: plugin.id,
+                        name: plugin.name || plugin.id,
+                        description: plugin.description || `${plugin.id} plugin for Better Auth`,
+                        enabled: true,
+                    }));
+                    return res.json({
+                        plugins: pluginInfo,
+                        configPath: authConfigPath,
+                        totalPlugins: pluginInfo.length,
+                    });
                 }
-                const auth = authModule.auth || authModule.default;
-                if (!auth) {
+                catch (_error) {
                     return res.json({
                         plugins: [],
-                        error: 'No auth export found',
+                        error: 'Failed to load auth config - import failed and regex extraction unavailable',
                         configPath: authConfigPath,
                     });
                 }
-                const plugins = auth.options?.plugins || [];
-                const pluginInfo = plugins.map((plugin) => ({
-                    id: plugin.id,
-                    name: plugin.name || plugin.id,
-                    description: plugin.description || `${plugin.id} plugin for Better Auth`,
-                    enabled: true,
-                }));
-                res.json({
-                    plugins: pluginInfo,
-                    configPath: authConfigPath,
-                    totalPlugins: pluginInfo.length,
-                });
-            }
-            catch (_error) {
-                res.json({
-                    plugins: [],
-                    error: 'Failed to load auth config - import failed and regex extraction unavailable',
-                    configPath: authConfigPath,
-                });
             }
+            return res.json({
+                plugins: [],
+                error: 'No auth config found',
+                configPath: null,
+            });
         }
         catch (_error) {
             res.status(500).json({ error: 'Failed to fetch plugins' });
@@ -1585,6 +1663,13 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
     });
     router.get('/api/database/info', async (_req, res) => {
         try {
+            if (isSelfHosted && preloadedAuthOptions) {
+                const database = preloadedAuthOptions.database;
+                return res.json({
+                    database: database,
+                    configPath: null,
+                });
+            }
             const authConfigPath = configPath || (await findAuthConfigPath());
             if (!authConfigPath) {
                 return res.json({
@@ -1978,7 +2063,6 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
             });
         }
     });
-    // Database Detection endpoint - Auto-detect database from installed packages
     router.get('/api/database/detect', async (_req, res) => {
         try {
             const detectedDb = await detectDatabaseWithDialect();
@@ -2047,7 +2131,7 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
     });
     router.post('/api/admin/ban-user', async (req, res) => {
         try {
-            const auth = await getAuthConfigSafe();
+            const auth = preloadedAuthOptions || (await getAuthConfigSafe());
             if (!auth) {
                 return res.status(400).json({
                     success: false,
@@ -2086,7 +2170,7 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
     });
     router.post('/api/admin/unban-user', async (req, res) => {
         try {
-            const auth = await getAuthConfigSafe();
+            const auth = preloadedAuthOptions || (await getAuthConfigSafe());
             if (!auth) {
                 return res.status(400).json({
                     success: false,
@@ -2125,7 +2209,7 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
     });
     router.get('/api/admin/status', async (_req, res) => {
         try {
-            const betterAuthConfig = await getAuthConfigSafe();
+            const betterAuthConfig = preloadedAuthOptions || (await getAuthConfigSafe());
             if (!betterAuthConfig) {
                 return res.json({
                     enabled: false,
@@ -2149,8 +2233,6 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
             });
         }
     });
-    // Database Schema Visualization endpoint
-    // Now uses loadContextTables to dynamically load schema from Better Auth context
     const CONTEXT_CORE_TABLES = new Set(['user', 'session', 'account', 'verification']);
     async function resolveSchemaConfigPath() {
         if (configPath) {
@@ -2160,16 +2242,23 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
     }
     async function loadContextTables() {
         try {
+            if (isSelfHosted && authInstance?.$context) {
+                try {
+                    const context = await authInstance.$context;
+                    return context?.tables || null;
+                }
+                catch (_error) { }
+            }
             const authConfigPath = await resolveSchemaConfigPath();
             if (!authConfigPath) {
                 return null;
             }
             const authModule = await safeImportAuthConfig(authConfigPath);
-            const authInstance = authModule?.auth || authModule?.default;
-            if (!authInstance?.$context) {
+            const fileAuthInstance = authModule?.auth || authModule?.default;
+            if (!fileAuthInstance?.$context) {
                 return null;
             }
-            const context = await authInstance.$context;
+            const context = await fileAuthInstance.$context;
             return context?.tables || null;
         }
         catch (_error) {
@@ -2293,14 +2382,11 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
             if (!schema) {
                 return null;
             }
-            // Filter by plugin origin if plugins are specified
             if (selectedPlugins && selectedPlugins.length > 0) {
                 schema.tables = schema.tables.filter((table) => {
-                    // Include core tables
                     if (CONTEXT_CORE_TABLES.has(table.name)) {
                         return true;
                     }
-                    // Include tables from selected plugins
                     return selectedPlugins.includes(table.origin);
                 });
             }
@@ -2352,28 +2438,46 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
     });
     router.get('/api/plugins/teams/status', async (_req, res) => {
         try {
-            const betterAuthConfig = await getAuthConfigSafe();
+            const betterAuthConfig = preloadedAuthOptions || (await getAuthConfigSafe());
             if (!betterAuthConfig) {
                 return res.json({
                     enabled: false,
                     error: 'No auth config found',
-                    configPath: null,
+                    configPath: isSelfHosted ? null : configPath || null,
                 });
             }
             const plugins = betterAuthConfig.plugins || [];
             const organizationPlugin = plugins.find((plugin) => plugin.id === 'organization');
             if (organizationPlugin) {
-                const teamsEnabled = organizationPlugin.options?.teams?.enabled === true;
+                let teamsEnabled = false;
+                if (organizationPlugin.options?.teams?.enabled === true) {
+                    teamsEnabled = true;
+                }
+                else if (organizationPlugin.teams?.enabled === true) {
+                    teamsEnabled = true;
+                }
+                else if (organizationPlugin.config?.teams?.enabled === true) {
+                    teamsEnabled = true;
+                }
+                else if (organizationPlugin.options?.teams &&
+                    typeof organizationPlugin.options.teams === 'object') {
+                    teamsEnabled = organizationPlugin.options.teams.enabled === true;
+                }
+                else if (organizationPlugin.teams && typeof organizationPlugin.teams === 'object') {
+                    teamsEnabled = organizationPlugin.teams.enabled === true;
+                }
+                const teamSchema = organizationPlugin.schema;
+                teamsEnabled = 'team' in teamSchema;
                 return res.json({
                     enabled: teamsEnabled,
-                    configPath: configPath || null,
+                    configPath: isSelfHosted ? null : configPath || null,
                     organizationPlugin: organizationPlugin || null,
                 });
             }
             else {
                 return res.json({
                     enabled: false,
-                    configPath: configPath || null,
+                    configPath: isSelfHosted ? null : configPath || null,
                     organizationPlugin: null,
                     error: 'Organization plugin not found',
                 });
@@ -2648,6 +2752,26 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
             if (!adapter.update) {
                 return res.status(500).json({ error: 'Adapter update method not available' });
             }
+            let invitation = null;
+            try {
+                invitation = await adapter.findOne({
+                    model: 'invitation',
+                    where: [{ field: 'id', value: id }],
+                });
+            }
+            catch (_findError) {
+                if (typeof adapter.findMany === 'function') {
+                    const invitations = await adapter.findMany({
+                        model: 'invitation',
+                        where: [{ field: 'id', value: id }],
+                        limit: 1,
+                    });
+                    invitation = invitations && invitations.length > 0 ? invitations[0] : null;
+                }
+            }
+            if (!invitation) {
+                return res.status(404).json({ error: 'Invitation not found' });
+            }
             await adapter.update({
                 model: 'invitation',
                 where: [{ field: 'id', value: id }],
@@ -2658,8 +2782,245 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
             });
             res.json({ success: true });
         }
+        catch (error) {
+            console.error('Error resending invitation:', error);
+            const errorMessage = error instanceof Error ? error.message : 'Failed to resend invitation';
+            res.status(500).json({
+                error: 'Failed to resend invitation',
+                details: isSelfHosted ? errorMessage : undefined,
+            });
+        }
+    });
+    router.get('/api/users/:userId/invitations', async (req, res) => {
+        try {
+            const { userId } = req.params;
+            const adapter = await getAuthAdapterWithConfig();
+            if (!adapter) {
+                return res.status(500).json({ error: 'Auth adapter not available' });
+            }
+            let user;
+            try {
+                user = await adapter.findOne({
+                    model: 'user',
+                    where: [{ field: 'id', value: userId }],
+                });
+            }
+            catch (error) {
+                console.error('Error fetching user:', error);
+                return res.status(500).json({
+                    error: 'Failed to fetch user',
+                    details: error?.message || String(error),
+                });
+            }
+            if (!user || !user.email) {
+                return res.json({ success: true, invitations: [] });
+            }
+            if (typeof adapter.findMany !== 'function') {
+                return res.json({ success: true, invitations: [] });
+            }
+            let invitations;
+            try {
+                invitations = await adapter.findMany({
+                    model: 'invitation',
+                    where: [{ field: 'email', value: user.email }],
+                });
+            }
+            catch (error) {
+                console.error('Error fetching invitations:', error);
+                return res.json({ success: true, invitations: [] });
+            }
+            if (!invitations || invitations.length === 0) {
+                return res.json({ success: true, invitations: [] });
+            }
+            const transformedInvitations = await Promise.all(invitations.map(async (invitation) => {
+                let organizationName = 'Unknown';
+                let teamName;
+                try {
+                    if (invitation.organizationId &&
+                        (typeof adapter.findOne === 'function' || typeof adapter.findUnique === 'function')) {
+                        try {
+                            const findMethod = adapter.findOne || adapter.findUnique;
+                            const org = await findMethod({
+                                model: 'organization',
+                                where: [{ field: 'id', value: invitation.organizationId }],
+                            });
+                            organizationName = org?.name || 'Unknown';
+                        }
+                        catch (_orgError) {
+                            // Ignore org fetch errors
+                        }
+                    }
+                    if (invitation.teamId &&
+                        (typeof adapter.findOne === 'function' || typeof adapter.findUnique === 'function')) {
+                        try {
+                            const findMethod = adapter.findOne || adapter.findUnique;
+                            const team = await findMethod({
+                                model: 'team',
+                                where: [{ field: 'id', value: invitation.teamId }],
+                            });
+                            teamName = team?.name;
+                        }
+                        catch (_teamError) { }
+                    }
+                }
+                catch (_error) { }
+                return {
+                    id: invitation.id,
+                    email: invitation.email,
+                    role: invitation.role || 'member',
+                    status: invitation.status || 'pending',
+                    organizationId: invitation.organizationId,
+                    organizationName,
+                    teamId: invitation.teamId,
+                    teamName,
+                    inviterId: invitation.inviterId,
+                    expiresAt: invitation.expiresAt,
+                    createdAt: invitation.createdAt,
+                };
+            }));
+            res.json({ success: true, invitations: transformedInvitations });
+        }
+        catch (error) {
+            console.error('Error in /api/users/:userId/invitations:', error);
+            res.status(500).json({
+                error: 'Failed to fetch invitations',
+                details: error?.message || String(error),
+            });
+        }
+    });
+    router.post('/api/invitations/:id/accept', async (req, res) => {
+        try {
+            const { id } = req.params;
+            const { userId } = req.body;
+            const adapter = await getAuthAdapterWithConfig();
+            if (!adapter) {
+                return res.status(500).json({ error: 'Auth adapter not available' });
+            }
+            if (!userId) {
+                return res.status(400).json({ error: 'User ID is required' });
+            }
+            const invitation = await adapter.findOne({
+                model: 'invitation',
+                where: [{ field: 'id', value: id }],
+            });
+            if (!invitation) {
+                return res.status(404).json({ error: 'Invitation not found' });
+            }
+            if (invitation.status !== 'pending') {
+                return res.status(400).json({ error: 'Invitation is not pending' });
+            }
+            await adapter.update({
+                model: 'invitation',
+                where: [{ field: 'id', value: id }],
+                update: {
+                    status: 'accepted',
+                    updatedAt: new Date().toISOString(),
+                },
+            });
+            if (invitation.organizationId) {
+                try {
+                    // Check if member already exists
+                    let existingMember = null;
+                    if (typeof adapter.findFirst === 'function') {
+                        existingMember = await adapter.findFirst({
+                            model: 'member',
+                            where: [
+                                { field: 'organizationId', value: invitation.organizationId },
+                                { field: 'userId', value: userId },
+                            ],
+                        });
+                    }
+                    else if (typeof adapter.findMany === 'function') {
+                        const members = await adapter.findMany({
+                            model: 'member',
+                            where: [
+                                { field: 'organizationId', value: invitation.organizationId },
+                                { field: 'userId', value: userId },
+                            ],
+                        });
+                        existingMember = members && members.length > 0 ? members[0] : null;
+                    }
+                    if (!existingMember) {
+                        await adapter.create({
+                            model: 'member',
+                            data: {
+                                organizationId: invitation.organizationId,
+                                userId: userId,
+                                role: invitation.role || 'member',
+                                createdAt: new Date().toISOString(),
+                            },
+                        });
+                    }
+                }
+                catch (error) {
+                    console.error('Error creating member:', error);
+                    // Ignore errors creating membership
+                }
+            }
+            if (invitation.teamId) {
+                try {
+                    let existingMember = null;
+                    if (typeof adapter.findFirst === 'function') {
+                        existingMember = await adapter.findFirst({
+                            model: 'teamMember',
+                            where: [
+                                { field: 'teamId', value: invitation.teamId },
+                                { field: 'userId', value: userId },
+                            ],
+                        });
+                    }
+                    else if (typeof adapter.findMany === 'function') {
+                        const members = await adapter.findMany({
+                            model: 'teamMember',
+                            where: [
+                                { field: 'teamId', value: invitation.teamId },
+                                { field: 'userId', value: userId },
+                            ],
+                        });
+                        existingMember = members && members.length > 0 ? members[0] : null;
+                    }
+                    if (!existingMember) {
+                        await adapter.create({
+                            model: 'teamMember',
+                            data: {
+                                teamId: invitation.teamId,
+                                userId: userId,
+                                createdAt: new Date().toISOString(),
+                            },
+                        });
+                    }
+                }
+                catch (error) {
+                    console.error('Error creating team member:', error);
+                    // Ignore errors creating team membership
+                }
+            }
+            res.json({ success: true });
+        }
+        catch (error) {
+            console.error('Failed to accept invitation:', error);
+            res.status(500).json({ error: 'Failed to accept invitation' });
+        }
+    });
+    router.post('/api/invitations/:id/reject', async (req, res) => {
+        try {
+            const { id } = req.params;
+            const adapter = await getAuthAdapterWithConfig();
+            if (!adapter) {
+                return res.status(500).json({ error: 'Auth adapter not available' });
+            }
+            await adapter.update({
+                model: 'invitation',
+                where: [{ field: 'id', value: id }],
+                update: {
+                    status: 'rejected',
+                    updatedAt: new Date().toISOString(),
+                },
+            });
+            res.json({ success: true });
+        }
         catch (_error) {
-            res.status(500).json({ error: 'Failed to resend invitation' });
+            res.status(500).json({ error: 'Failed to reject invitation' });
         }
     });
     router.delete('/api/invitations/:id', async (req, res) => {
@@ -2689,7 +3050,13 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
     router.post('/api/organizations/:orgId/invitations', async (req, res) => {
         try {
             const { orgId } = req.params;
-            const { email, role = 'member', inviterId } = req.body;
+            const { email, role = 'member', inviterId, teamId } = req.body;
+            if (!email || typeof email !== 'string') {
+                return res.status(400).json({ error: 'Email is required' });
+            }
+            if (!orgId) {
+                return res.status(400).json({ error: 'Organization ID is required' });
+            }
             if (!inviterId) {
                 return res.status(400).json({ error: 'Inviter ID is required' });
             }
@@ -2697,60 +3064,143 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
             if (!adapter) {
                 return res.status(500).json({ error: 'Auth adapter not available' });
             }
+            if (!adapter.create) {
+                return res.status(500).json({ error: 'Adapter create method not available' });
+            }
+            try {
+                const organization = await adapter.findOne({
+                    model: 'organization',
+                    where: [{ field: 'id', value: orgId }],
+                });
+                if (!organization) {
+                    return res.status(404).json({ error: 'Organization not found' });
+                }
+            }
+            catch (orgError) {
+                try {
+                    if (typeof adapter.findMany === 'function') {
+                        const orgs = await adapter.findMany({
+                            model: 'organization',
+                            where: [{ field: 'id', value: orgId }],
+                            limit: 1,
+                        });
+                        if (!orgs || orgs.length === 0) {
+                            return res.status(404).json({ error: 'Organization not found' });
+                        }
+                    }
+                }
+                catch (_fallbackError) { }
+            }
+            try {
+                let existingInvitation = null;
+                if (typeof adapter.findFirst === 'function') {
+                    existingInvitation = await adapter.findFirst({
+                        model: 'invitation',
+                        where: [
+                            { field: 'email', value: email.toLowerCase() },
+                            { field: 'organizationId', value: orgId },
+                            { field: 'status', value: 'pending' },
+                        ],
+                    });
+                }
+                else if (typeof adapter.findMany === 'function') {
+                    const invitations = await adapter.findMany({
+                        model: 'invitation',
+                        where: [
+                            { field: 'email', value: email.toLowerCase() },
+                            { field: 'organizationId', value: orgId },
+                            { field: 'status', value: 'pending' },
+                        ],
+                        limit: 1,
+                    });
+                    existingInvitation = invitations && invitations.length > 0 ? invitations[0] : null;
+                }
+                if (existingInvitation) {
+                    return res
+                        .status(400)
+                        .json({ error: 'A pending invitation already exists for this email' });
+                }
+            }
+            catch (_duplicateCheckError) { }
             const invitationData = {
-                email,
+                email: email.toLowerCase(),
                 role,
                 organizationId: orgId,
                 status: 'pending',
                 expiresAt: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000), // 7 days
-                createdAt: new Date(),
                 inviterId: inviterId,
             };
-            const invitation = {
-                id: `inv_${Date.now()}`,
-                ...invitationData,
-            };
-            if (!adapter.create) {
-                return res.status(500).json({ error: 'Adapter create method not available' });
+            if (teamId) {
+                invitationData.teamId = teamId;
             }
-            await adapter.create({
+            const createdInvitation = await adapter.create({
                 model: 'invitation',
                 data: {
-                    organizationId: invitationData.organizationId,
-                    email: invitationData.email,
-                    role: invitationData.role,
-                    status: invitationData.status,
-                    inviterId: invitationData.inviterId,
-                    expiresAt: invitationData.expiresAt,
-                    createdAt: invitationData.createdAt,
+                    ...invitationData,
                 },
             });
-            res.json({ success: true, invitation });
+            if (!createdInvitation) {
+                return res.status(500).json({ error: 'Failed to create invitation' });
+            }
+            res.json({ success: true, invitation: createdInvitation });
         }
-        catch (_error) {
-            res.status(500).json({ error: 'Failed to create invitation' });
+        catch (error) {
+            console.error('Error creating invitation:', error);
+            const errorMessage = error instanceof Error ? error.message : 'Failed to create invitation';
+            res.status(500).json({
+                error: 'Failed to create invitation',
+                details: isSelfHosted ? errorMessage : undefined,
+            });
         }
     });
     router.get('/api/organizations/:orgId/teams', async (req, res) => {
         try {
             const { orgId } = req.params;
             const adapter = await getAuthAdapterWithConfig();
-            if (adapter && typeof adapter.findMany === 'function') {
+            if (!adapter) {
+                return res.status(500).json({
+                    success: false,
+                    error: 'Auth adapter not available',
+                    teams: [],
+                });
+            }
+            if (typeof adapter.findMany !== 'function') {
+                return res.status(500).json({
+                    success: false,
+                    error: 'Adapter findMany method not available',
+                    teams: [],
+                });
+            }
+            try {
+                let teams = [];
                 try {
-                    const teams = await adapter.findMany({
+                    teams = await adapter.findMany({
                         model: 'team',
                         where: [{ field: 'organizationId', value: orgId }],
                         limit: 10000,
                     });
-                    const transformedTeams = await Promise.all((teams || []).map(async (team) => {
-                        if (!adapter.findMany) {
-                            return null;
+                }
+                catch (whereError) {
+                    const allTeams = await adapter.findMany({
+                        model: 'team',
+                        limit: 10000,
+                    });
+                    teams = (allTeams || []).filter((team) => team.organizationId === orgId);
+                }
+                if (!teams || teams.length === 0) {
+                    return res.json({ success: true, teams: [] });
+                }
+                const transformedTeams = await Promise.all((teams || []).map(async (team) => {
+                    try {
+                        let memberCount = 0;
+                        if (adapter.findMany) {
+                            const teamMembers = await adapter.findMany({
+                                model: 'teamMember',
+                                where: [{ field: 'teamId', value: team.id }],
+                                limit: 10000,
+                            });
+                            memberCount = teamMembers ? teamMembers.length : 0;
                         }
-                        const teamMembers = await adapter.findMany({
-                            model: 'teamMember',
-                            where: [{ field: 'teamId', value: team.id }],
-                            limit: 10000,
-                        });
                         return {
                             id: team.id,
                             name: team.name,
@@ -2758,18 +3208,38 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
                             metadata: team.metadata,
                             createdAt: team.createdAt,
                             updatedAt: team.updatedAt,
-                            memberCount: teamMembers ? teamMembers.length : 0,
+                            memberCount: memberCount,
                         };
-                    }));
-                    res.json({ success: true, teams: transformedTeams });
-                    return;
-                }
-                catch (_error) { }
+                    }
+                    catch (_error) {
+                        return {
+                            id: team.id,
+                            name: team.name,
+                            organizationId: team.organizationId,
+                            metadata: team.metadata,
+                            createdAt: team.createdAt,
+                            updatedAt: team.updatedAt,
+                            memberCount: 0,
+                        };
+                    }
+                }));
+                const validTeams = transformedTeams.filter((team) => team !== null);
+                return res.json({ success: true, teams: validTeams });
+            }
+            catch (error) {
+                return res.json({
+                    success: true,
+                    teams: [],
+                    error: error?.message || 'Failed to fetch teams',
+                });
             }
-            res.json({ success: true, teams: [] });
         }
-        catch (_error) {
-            res.status(500).json({ error: 'Failed to fetch teams' });
+        catch (error) {
+            res.status(500).json({
+                success: false,
+                error: 'Failed to fetch teams',
+                message: error?.message || 'Unknown error',
+            });
         }
     });
     router.post('/api/organizations/:orgId/teams', async (req, res) => {
@@ -2794,7 +3264,7 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
             if (!adapter.create) {
                 return res.status(500).json({ error: 'Adapter create method not available' });
             }
-            await adapter.create({
+            const teamResult = await adapter.create({
                 model: 'team',
                 data: {
                     name: teamData.name,
@@ -2803,6 +3273,9 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
                     updatedAt: teamData.updatedAt,
                 },
             });
+            if (!teamResult) {
+                return res.status(500).json({ error: 'Failed to create team' });
+            }
             res.json({ success: true, team });
         }
         catch (_error) {
@@ -2872,39 +3345,83 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
                 return res.status(400).json({ error: 'userIds array is required' });
             }
             const adapter = await getAuthAdapterWithConfig();
-            if (!adapter || !adapter.create) {
+            if (!adapter) {
                 return res.status(500).json({ error: 'Adapter not available' });
             }
+            if (!adapter.create) {
+                return res.status(500).json({ error: 'Adapter create method not available' });
+            }
             const results = [];
             for (const userId of userIds) {
                 try {
+                    let existingMember = null;
+                    if (adapter.findMany) {
+                        try {
+                            const existing = await adapter.findMany({
+                                model: 'teamMember',
+                                where: [
+                                    { field: 'teamId', value: teamId },
+                                    { field: 'userId', value: userId },
+                                ],
+                                limit: 1,
+                            });
+                            existingMember = existing && existing.length > 0 ? existing[0] : null;
+                        }
+                        catch (_findError) {
+                            // if where clause isn't working.
+                            try {
+                                const allMembers = await adapter.findMany({
+                                    model: 'teamMember',
+                                    limit: 10000,
+                                });
+                                existingMember = (allMembers || []).find((m) => m.teamId === teamId && m.userId === userId);
+                            }
+                            catch (_fallbackError) { }
+                        }
+                    }
+                    if (existingMember) {
+                        results.push({
+                            success: false,
+                            userId,
+                            error: 'User is already a member of this team',
+                        });
+                        continue;
+                    }
+                    const now = new Date();
                     await adapter.create({
                         model: 'teamMember',
                         data: {
                             teamId,
                             userId,
                             role: 'member',
-                            createdAt: new Date(),
+                            createdAt: now,
+                            updatedAt: now,
                         },
                     });
                     results.push({ success: true, userId });
                 }
                 catch (error) {
+                    const errorMessage = error?.message || error?.toString() || 'Unknown error';
                     results.push({
                         success: false,
                         userId,
-                        error: error instanceof Error ? error.message : 'Unknown error',
+                        error: errorMessage,
                     });
                 }
             }
+            const successCount = results.filter((r) => r.success).length;
             res.json({
-                success: true,
-                message: `Added ${results.filter((r) => r.success).length} members`,
+                success: results.some((r) => r.success),
+                message: `Added ${successCount} member${successCount !== 1 ? 's' : ''}`,
                 results,
             });
         }
-        catch (_error) {
-            res.status(500).json({ error: 'Failed to add team members' });
+        catch (error) {
+            res.status(500).json({
+                success: false,
+                error: 'Failed to add team members',
+                message: error?.message || 'Unknown error',
+            });
         }
     });
     router.delete('/api/team-members/:id', async (req, res) => {
@@ -2974,7 +3491,7 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
     });
     router.get('/api/plugins/organization/status', async (_req, res) => {
         try {
-            const betterAuthConfig = await getAuthConfigSafe();
+            const betterAuthConfig = preloadedAuthOptions || (await getAuthConfigSafe());
             if (!betterAuthConfig) {
                 return res.json({
                     enabled: false,
@@ -3106,7 +3623,7 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
         try {
             const { id } = req.params;
             const userData = req.body;
-            const updatedUser = await getAuthData(authConfig, 'updateUser', { id, userData }, configPath);
+            const updatedUser = await getAuthData(authConfig, 'updateUser', { id, userData }, configPath, preloadedAdapter);
             res.json({ success: true, user: updatedUser });
         }
         catch (_error) {
@@ -3497,6 +4014,92 @@ export function createRoutes(authConfig, configPath, geoDbPath, preloadedAdapter
             res.status(500).json({ success: false, error: 'Failed to fetch OAuth providers' });
         }
     });
+    router.get('/api/tools/oauth/credentials', async (req, res) => {
+        try {
+            const { provider, origin } = req.query;
+            if (!provider || typeof provider !== 'string') {
+                return res.status(400).json({
+                    success: false,
+                    error: 'Provider is required',
+                });
+            }
+            if (!origin || typeof origin !== 'string') {
+                return res.status(400).json({
+                    success: false,
+                    error: 'Origin is required',
+                });
+            }
+            // TODO: Import getOAuthCredentials at the top of this file:
+            // import { getOAuthCredentials } from './path/to/your/oauth-config';
+            // For now, we'll access it from a function that should be provided
+            // This assumes getOAuthCredentials is available in the scope
+            // You need to import it: import { getOAuthCredentials } from './your-oauth-config-file';
+            // Placeholder - replace this with actual import at top of file
+            const getOAuthCredentials = global.getOAuthCredentials;
+            if (typeof getOAuthCredentials !== 'function') {
+                return res.status(500).json({
+                    success: false,
+                    error: 'OAuth credentials function not configured. Please import getOAuthCredentials function.',
+                });
+            }
+            const credentialsResult = getOAuthCredentials(provider, origin);
+            // Handle null return (provider not found)
+            if (credentialsResult === null) {
+                return res.status(404).json({
+                    success: false,
+                    error: 'No credential found',
+                });
+            }
+            // Handle error cases with proper messages as requested
+            if (credentialsResult.error) {
+                if (credentialsResult.error === 'NO_CREDENTIALS_FOUND') {
+                    return res.status(404).json({
+                        success: false,
+                        error: 'No credential found',
+                    });
+                }
+                else if (credentialsResult.error === 'INVALID_ORIGIN') {
+                    return res.status(400).json({
+                        success: false,
+                        error: 'Invalid origin. OAuth credentials are only available for localhost origins.',
+                    });
+                }
+                else {
+                    return res.status(400).json({
+                        success: false,
+                        error: credentialsResult.error || 'Failed to get OAuth credentials',
+                    });
+                }
+            }
+            // Check if result exists and has required fields
+            if (!credentialsResult.result) {
+                return res.status(404).json({
+                    success: false,
+                    error: 'No credential found',
+                });
+            }
+            const { clientId, clientSecret } = credentialsResult.result;
+            if (!clientId || !clientSecret) {
+                return res.status(404).json({
+                    success: false,
+                    error: 'No credential found',
+                });
+            }
+            res.json({
+                success: true,
+                clientId,
+                clientSecret,
+            });
+        }
+        catch (error) {
+            console.error('Failed to fetch OAuth credentials:', error);
+            res.status(500).json({
+                success: false,
+                error: 'Failed to fetch OAuth credentials',
+                details: error instanceof Error ? error.message : String(error),
+            });
+        }
+    });
     router.post('/api/tools/oauth/test', async (req, res) => {
         try {
             const { provider } = req.body;