better-auth-studio 1.0.49-beta.1 → 1.0.49-beta.10

package/dist/routes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../src/routes.ts"],"names":[],"mappings":"AAOA,OAAO,EAA+B,MAAM,EAAE,MAAM,SAAS,CAAC;AAS9D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AA8D9C,wBAAsB,oBAAoB,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,CA8I/E;AAwBD,wBAAgB,YAAY,CAC1B,UAAU,EAAE,UAAU,EACtB,UAAU,CAAC,EAAE,MAAM,EACnB,SAAS,CAAC,EAAE,MAAM,GACjB,MAAM,CA8uJR"}
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../src/routes.ts"],"names":[],"mappings":"AAOA,OAAO,EAA+B,MAAM,EAAE,MAAM,SAAS,CAAC;AAS9D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AA8D9C,wBAAsB,oBAAoB,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,CA8I/E;AAwBD,wBAAgB,YAAY,CAC1B,UAAU,EAAE,UAAU,EACtB,UAAU,CAAC,EAAE,MAAM,EACnB,SAAS,CAAC,EAAE,MAAM,GACjB,MAAM,CAyiKR"}

package/dist/routes.js

@@ -1,5 +1,5 @@
 import { createHmac, randomBytes } from 'node:crypto';
-import { existsSync, readFileSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 // @ts-expect-error
@@ -4302,22 +4302,17 @@ export function createRoutes(authConfig, configPath, geoDbPath) {
             let filename;
             let contentType;
             if (exportFormat === 'csv') {
-                // Convert to CSV
                 const csvRows = [];
                 for (const [tableName, rows] of Object.entries(exportData)) {
                     if (rows.length === 0)
                         continue;
-                    // Add table header
                     csvRows.push(`\n=== ${tableName.toUpperCase()} ===\n`);
-                    // Get all unique keys from all rows
                     const allKeys = new Set();
                     rows.forEach((row) => {
                         Object.keys(row).forEach((key) => allKeys.add(key));
                     });
                     const headers = Array.from(allKeys);
-                    // Write CSV header
                     csvRows.push(headers.map((h) => `"${h}"`).join(','));
-                    // Write CSV rows
                     rows.forEach((row) => {
                         const values = headers.map((header) => {
                             const value = row[header];
@@ -4335,7 +4330,6 @@ export function createRoutes(authConfig, configPath, geoDbPath) {
                 contentType = 'text/csv';
             }
             else {
-                // JSON format
                 output = JSON.stringify(exportData, null, 2);
                 filename = `better-auth-export-${new Date().toISOString().split('T')[0]}.json`;
                 contentType = 'application/json';
@@ -4487,6 +4481,290 @@ export function createRoutes(authConfig, configPath, geoDbPath) {
             });
         }
     });
+    router.post('/api/tools/test-oauth-credentials', async (req, res) => {
+        try {
+            const { provider, clientId, clientSecret, redirectURI } = req.body || {};
+            if (!provider || !clientId || !clientSecret) {
+                return res.status(400).json({
+                    success: false,
+                    message: 'Provider, Client ID, and Client Secret are required',
+                });
+            }
+            if (provider.toLowerCase() === 'google') {
+                try {
+                    const tokenInfoUrl = `https://www.googleapis.com/oauth2/v1/tokeninfo?access_token=test`;
+                    const isValidClientIdFormat = /^[\d\w-]+\.apps\.googleusercontent\.com$|^\d+$/.test(clientId);
+                    if (!isValidClientIdFormat) {
+                        return res.json({
+                            success: false,
+                            message: 'Invalid Google Client ID format',
+                            details: {
+                                provider: 'google',
+                                clientIdFormat: 'Should end with .apps.googleusercontent.com or be numeric',
+                            },
+                        });
+                    }
+                    const discoveryUrl = 'https://accounts.google.com/.well-known/openid-configuration';
+                    const discoveryResponse = await fetch(discoveryUrl);
+                    if (!discoveryResponse.ok) {
+                        return res.json({
+                            success: false,
+                            message: 'Unable to reach Google OAuth service',
+                            details: {
+                                provider: 'google',
+                                error: 'Network error',
+                            },
+                        });
+                    }
+                    if (redirectURI) {
+                        try {
+                            new URL(redirectURI);
+                        }
+                        catch {
+                            return res.json({
+                                success: false,
+                                message: 'Invalid Redirect URI format',
+                                details: {
+                                    provider: 'google',
+                                    redirectURI: redirectURI,
+                                },
+                            });
+                        }
+                    }
+                    return res.json({
+                        success: true,
+                        message: 'Google OAuth credentials format is valid',
+                        details: {
+                            provider: 'google',
+                            clientId: clientId.substring(0, 20) + '...',
+                            redirectURI: redirectURI || 'Not configured',
+                            note: 'Credentials format validated. Test with actual OAuth flow to confirm.',
+                        },
+                    });
+                }
+                catch (error) {
+                    return res.json({
+                        success: false,
+                        message: 'Failed to validate Google OAuth credentials',
+                        details: {
+                            provider: 'google',
+                            error: error instanceof Error ? error.message : 'Unknown error',
+                        },
+                    });
+                }
+            }
+            if (!clientId.trim() || !clientSecret.trim()) {
+                return res.json({
+                    success: false,
+                    message: 'Client ID and Secret cannot be empty',
+                });
+            }
+            if (redirectURI) {
+                try {
+                    new URL(redirectURI);
+                }
+                catch {
+                    return res.json({
+                        success: false,
+                        message: 'Invalid Redirect URI format',
+                        details: {
+                            provider: provider,
+                            redirectURI: redirectURI,
+                        },
+                    });
+                }
+            }
+            return res.json({
+                success: true,
+                message: `${provider} OAuth credentials format is valid`,
+                details: {
+                    provider: provider,
+                    clientId: clientId.substring(0, 20) + '...',
+                    redirectURI: redirectURI || 'Not configured',
+                    note: 'Credentials format validated. Test with actual OAuth flow to confirm.',
+                },
+            });
+        }
+        catch (error) {
+            res.status(500).json({
+                success: false,
+                message: error instanceof Error ? error.message : 'Failed to test OAuth credentials',
+            });
+        }
+    });
+    router.post('/api/tools/generate-secret', async (_req, res) => {
+        try {
+            const { length = 32, format = 'hex' } = _req.body || {};
+            const secretLength = typeof length === 'number' && length >= 16 && length <= 128 ? length : 32;
+            const secretFormat = format === 'base64' ? 'base64' : 'hex';
+            const secretBytes = randomBytes(secretLength);
+            const secret = secretFormat === 'hex' ? secretBytes.toString('hex') : secretBytes.toString('base64');
+            const entropy = secretLength * 8; // bits of entropy
+            res.json({
+                success: true,
+                secret,
+                format: secretFormat,
+                length: secretLength,
+                entropy,
+                envFormat: `BETTER_AUTH_SECRET=${secret}`,
+            });
+        }
+        catch (error) {
+            res.status(500).json({
+                success: false,
+                message: error instanceof Error ? error.message : 'Failed to generate secret',
+            });
+        }
+    });
+    router.post('/api/tools/check-env-credentials', async (req, res) => {
+        try {
+            const { provider } = req.body || {};
+            if (!provider) {
+                return res.status(400).json({
+                    success: false,
+                    message: 'Provider is required',
+                });
+            }
+            const envPath = join(process.cwd(), '.env');
+            const envLocalPath = join(process.cwd(), '.env.local');
+            // Try .env.local first, then .env
+            const targetPath = existsSync(envLocalPath) ? envLocalPath : envPath;
+            const envContent = existsSync(targetPath) ? readFileSync(targetPath, 'utf-8') : '';
+            // Generate environment variable names
+            const providerUpper = provider.toUpperCase();
+            const clientIdKey = `${providerUpper}_CLIENT_ID`;
+            const clientSecretKey = `${providerUpper}_CLIENT_SECRET`;
+            // Parse existing .env file
+            const envLines = envContent.split('\n');
+            const existingCredentials = {};
+            envLines.forEach((line) => {
+                const trimmed = line.trim();
+                if (!trimmed || trimmed.startsWith('#'))
+                    return;
+                const match = trimmed.match(/^([^=#]+)=(.*)$/);
+                if (match) {
+                    const key = match[1].trim();
+                    const value = match[2].trim();
+                    if (key === clientIdKey || key === clientSecretKey) {
+                        existingCredentials[key] = value;
+                    }
+                }
+            });
+            const hasExisting = existingCredentials[clientIdKey] || existingCredentials[clientSecretKey];
+            res.json({
+                success: true,
+                hasExisting,
+                existingCredentials: hasExisting ? existingCredentials : {},
+                path: targetPath,
+            });
+        }
+        catch (error) {
+            res.status(500).json({
+                success: false,
+                message: error instanceof Error ? error.message : 'Failed to check credentials',
+            });
+        }
+    });
+    router.post('/api/tools/write-env-credentials', async (req, res) => {
+        try {
+            const { provider, clientId, clientSecret, action = 'override' } = req.body || {};
+            if (!provider || !clientId || !clientSecret) {
+                return res.status(400).json({
+                    success: false,
+                    message: 'Provider, Client ID, and Client Secret are required',
+                });
+            }
+            const envPath = join(process.cwd(), '.env');
+            const envLocalPath = join(process.cwd(), '.env.local');
+            const targetPath = existsSync(envLocalPath) ? envLocalPath : envPath;
+            const envContent = existsSync(targetPath) ? readFileSync(targetPath, 'utf-8') : '';
+            const envLines = envContent.split('\n');
+            const envMap = new Map();
+            const newLines = [];
+            envLines.forEach((line, index) => {
+                const trimmed = line.trim();
+                if (!trimmed || trimmed.startsWith('#')) {
+                    newLines.push(line);
+                    return;
+                }
+                const match = trimmed.match(/^([^=#]+)=(.*)$/);
+                if (match) {
+                    const key = match[1].trim();
+                    const value = match[2].trim();
+                    envMap.set(key, { line, index });
+                    newLines.push(line);
+                }
+                else {
+                    newLines.push(line);
+                }
+            });
+            const providerUpper = provider.toUpperCase();
+            let clientIdKey = `${providerUpper}_CLIENT_ID`;
+            let clientSecretKey = `${providerUpper}_CLIENT_SECRET`;
+            if (action === 'append') {
+                let suffix = 2;
+                while (envMap.has(clientIdKey) || envMap.has(clientSecretKey)) {
+                    clientIdKey = `${providerUpper}_CLIENT_ID_${suffix}`;
+                    clientSecretKey = `${providerUpper}_CLIENT_SECRET_${suffix}`;
+                    suffix++;
+                }
+            }
+            let updated = false;
+            if (action === 'override' && envMap.has(clientIdKey)) {
+                const existing = envMap.get(clientIdKey);
+                newLines[existing.index] = `${clientIdKey}=${clientId}`;
+                updated = true;
+            }
+            else if (!envMap.has(clientIdKey)) {
+                // Remove trailing empty lines
+                while (newLines.length > 0 && !newLines[newLines.length - 1].trim()) {
+                    newLines.pop();
+                }
+                if (newLines.length > 0 &&
+                    newLines[newLines.length - 1] &&
+                    !newLines[newLines.length - 1].endsWith('\n')) {
+                    if (!newLines[newLines.length - 1].endsWith('\r\n') &&
+                        !newLines[newLines.length - 1].endsWith('\n')) {
+                        newLines.push('');
+                    }
+                }
+                newLines.push(`${clientIdKey}=${clientId}`);
+                updated = true;
+            }
+            if (action === 'override' && envMap.has(clientSecretKey)) {
+                const existing = envMap.get(clientSecretKey);
+                newLines[existing.index] = `${clientSecretKey}=${clientSecret}`;
+                updated = true;
+            }
+            else if (!envMap.has(clientSecretKey)) {
+                const clientIdIndex = newLines.findIndex((line) => line.startsWith(`${clientIdKey}=`));
+                if (clientIdIndex >= 0) {
+                    newLines.splice(clientIdIndex + 1, 0, `${clientSecretKey}=${clientSecret}`);
+                }
+                else {
+                    newLines.push(`${clientSecretKey}=${clientSecret}`);
+                }
+                updated = true;
+            }
+            const newContent = newLines.join('\n');
+            writeFileSync(targetPath, newContent, 'utf-8');
+            res.json({
+                success: true,
+                message: 'OAuth credentials written successfully',
+                path: targetPath,
+                variables: {
+                    [clientIdKey]: clientId,
+                    [clientSecretKey]: '***',
+                },
+            });
+        }
+        catch (error) {
+            res.status(500).json({
+                success: false,
+                message: error instanceof Error ? error.message : 'Failed to write credentials to .env',
+            });
+        }
+    });
     return router;
 }
 //# sourceMappingURL=routes.js.map