@brainfish-ai/devdoc 0.1.50 → 0.1.52

package/renderer/app/api/domains/add/route.js

@@ -1,17 +1,17 @@
 import { NextResponse } from 'next/server';
 import { validateApiKey, addCustomDomain, isCustomDomainRegistered, updateCustomDomainStatus } from '@/lib/storage/blob';
 import { isValidDomain, normalizeDomain } from '@/lib/docs/config';
-import { addDomainToProject, isVercelIntegrationEnabled, formatVerificationInstructions, getDomainType } from '@/lib/vercel/domains';
+import { addDomainToProject, isVercelIntegrationEnabled, formatVerificationInstructions } from '@/lib/vercel/domains';
 /**
  * POST /api/domains/add
  * 
- * Add a custom domain to a project.
+ * Add a custom domain to a project via Vercel Domains API.
  * Each project can have ONE custom domain (free).
  * 
- * When Vercel integration is enabled (VERCEL_API_TOKEN + VERCEL_PROJECT_ID):
- * - Domain is added to Vercel project
- * - Real DNS verification instructions from Vercel are returned
- * - SSL is provisioned automatically by Vercel after verification
+ * Requires environment variables:
+ * - VERCEL_API_TOKEN (or VERCEL_TOKEN)
+ * - VERCEL_PROJECT_ID
+ * - VERCEL_TEAM_ID (optional)
  * 
  * Headers:
  *   Authorization: Bearer <api_key>
@@ -25,7 +25,7 @@ import { addDomainToProject, isVercelIntegrationEnabled, formatVerificationInstr
  *     domain: "docs.example.com",
  *     status: "pending",
  *     verification: [
- *       { type: "TXT", domain: "_vercel.docs.example.com", value: "vc-domain-verify=..." }
+ *       { type: "TXT", name: "_vercel.example.com", value: "vc-domain-verify=..." }
  *     ]
  *   }
  */ export async function POST(request) {
@@ -77,115 +77,79 @@ import { addDomainToProject, isVercelIntegrationEnabled, formatVerificationInstr
                 status: 409
             });
         }
-        // Check if Vercel integration is enabled
-        if (isVercelIntegrationEnabled()) {
-            // Add domain to Vercel project
-            const vercelResult = await addDomainToProject(customDomain);
-            if (!vercelResult.success) {
-                return NextResponse.json({
-                    error: vercelResult.error,
-                    vercelError: vercelResult.vercelError
-                }, {
-                    status: 400
-                });
-            }
-            const vercelDomain = vercelResult.domain;
-            // Add to our internal registry with Vercel data
-            const result = await addCustomDomain(projectSlug, customDomain);
-            if (!result.success) {
-                // Rollback: Try to remove from Vercel if we couldn't add to registry
-                console.error('[Domains API] Failed to add to registry, domain added to Vercel:', customDomain);
-                return NextResponse.json({
-                    error: result.error
-                }, {
-                    status: 400
-                });
-            }
-            // Update with Vercel domain ID
-            await updateCustomDomainStatus(customDomain, vercelDomain.verified ? 'active' : 'pending', {
-                vercelDomainId: vercelDomain.projectId
+        // Require Vercel integration
+        if (!isVercelIntegrationEnabled()) {
+            return NextResponse.json({
+                error: 'Vercel integration not configured. Set VERCEL_API_TOKEN and VERCEL_PROJECT_ID environment variables.'
+            }, {
+                status: 503
             });
-            // If Vercel already verified the domain (e.g., previously configured DNS)
-            if (vercelDomain.verified) {
-                return NextResponse.json({
-                    success: true,
-                    domain: customDomain,
-                    projectSlug,
-                    status: 'active',
-                    verified: true,
-                    message: 'Domain is already verified and active!'
-                });
-            }
-            // Format Vercel's verification instructions
-            const verification = vercelDomain.verification || [];
-            const { records, instructions } = formatVerificationInstructions(verification);
-            // Add CNAME instruction for subdomains (Vercel may not always include it)
-            const domainType = getDomainType(customDomain);
-            const parts = customDomain.split('.');
-            const subdomain = parts.length > 2 ? parts[0] : '@';
-            const cnameInstruction = domainType === 'subdomain' ? `\nAlso add a CNAME record:\n   Name: ${subdomain}\n   Value: cname.vercel-dns.com` : `\nFor apex domains, add an A record:\n   Name: @\n   Value: 76.76.21.21`;
+        }
+        // Add domain to Vercel project
+        const vercelResult = await addDomainToProject(customDomain);
+        if (!vercelResult.success) {
             return NextResponse.json({
-                success: true,
-                domain: customDomain,
-                projectSlug,
-                status: 'pending',
-                verified: false,
-                verification: records,
-                instructions: [
-                    ...instructions,
-                    cnameInstruction
-                ],
-                vercelVerification: verification
+                error: vercelResult.error,
+                vercelError: vercelResult.vercelError
+            }, {
+                status: 400
             });
-        } else {
-            // Fallback: No Vercel integration, use legacy behavior
-            console.warn('[Domains API] Vercel integration not configured, using legacy mode');
-            const result = await addCustomDomain(projectSlug, customDomain);
-            if (!result.success) {
-                return NextResponse.json({
-                    error: result.error
-                }, {
-                    status: 400
-                });
-            }
-            // Legacy hardcoded DNS instructions
-            const parts = customDomain.split('.');
-            const subdomain = parts.length > 2 ? parts[0] : '@';
+        }
+        const vercelDomain = vercelResult.domain;
+        // Add to our internal registry with Vercel data
+        const result = await addCustomDomain(projectSlug, customDomain);
+        if (!result.success) {
+            // Rollback: Try to remove from Vercel if we couldn't add to registry
+            console.error('[Domains API] Failed to add to registry, domain added to Vercel:', customDomain);
+            return NextResponse.json({
+                error: result.error
+            }, {
+                status: 400
+            });
+        }
+        // Update with Vercel domain ID
+        await updateCustomDomainStatus(customDomain, vercelDomain.verified ? 'active' : 'pending', {
+            vercelDomainId: vercelDomain.projectId
+        });
+        // If Vercel already verified the domain (e.g., previously configured DNS)
+        if (vercelDomain.verified) {
             return NextResponse.json({
                 success: true,
                 domain: customDomain,
                 projectSlug,
-                status: result.entry.status,
-                verified: false,
-                verification: [
-                    {
-                        type: 'CNAME',
-                        name: subdomain,
-                        value: 'cname.vercel-dns.com'
-                    },
-                    {
-                        type: 'TXT',
-                        name: `_devdoc-verify.${customDomain}`,
-                        value: result.entry.verificationToken || ''
-                    }
-                ],
-                instructions: [
-                    'Add the following DNS records to your domain:',
-                    '',
-                    '1. CNAME Record:',
-                    `   Name: ${subdomain}`,
-                    '   Value: cname.vercel-dns.com',
-                    '',
-                    '2. TXT Record (for verification):',
-                    `   Name: _devdoc-verify.${customDomain}`,
-                    `   Value: ${result.entry.verificationToken || ''}`,
-                    '',
-                    'After adding DNS records, run "devdoc domain verify" to verify.',
-                    '',
-                    'Note: Vercel integration not configured. Set VERCEL_API_TOKEN and VERCEL_PROJECT_ID for automatic SSL.'
-                ]
+                status: 'active',
+                verified: true,
+                message: 'Domain is already verified and active!'
             });
         }
+        // Format Vercel's verification instructions
+        const verification = vercelDomain.verification || [];
+        const { records } = formatVerificationInstructions(verification);
+        // Add CNAME/A record for routing (Vercel only returns TXT for verification)
+        const parts = customDomain.split('.');
+        const isApexDomain = parts.length <= 2;
+        const subdomain = parts.length > 2 ? parts[0] : '@';
+        // Add routing record first, then verification records
+        const allRecords = [
+            isApexDomain ? {
+                type: 'A',
+                name: '@',
+                value: '76.76.21.21'
+            } : {
+                type: 'CNAME',
+                name: subdomain,
+                value: 'cname.vercel-dns.com'
+            },
+            ...records
+        ];
+        return NextResponse.json({
+            success: true,
+            domain: customDomain,
+            projectSlug,
+            status: 'pending',
+            verified: false,
+            verification: allRecords
+        });
     } catch (error) {
         console.error('[Domains API] Error adding domain:', error);
         const message = error instanceof Error ? error.message : String(error);

package/renderer/app/api/domains/remove/route.js

@@ -5,11 +5,13 @@ import { removeDomain as vercelRemoveDomain, isVercelIntegrationEnabled } from '
 /**
  * DELETE /api/domains/remove
  * 
- * Remove a custom domain from a project.
+ * Remove a custom domain from a project via Vercel API.
+ * Removes from both Vercel and internal registry.
  * 
- * When Vercel integration is enabled:
- * - Removes domain from Vercel project
- * - Removes from internal registry
+ * Requires environment variables:
+ * - VERCEL_API_TOKEN (or VERCEL_TOKEN)
+ * - VERCEL_PROJECT_ID
+ * - VERCEL_TEAM_ID (optional)
  * 
  * Headers:
  *   Authorization: Bearer <api_key>
@@ -57,15 +59,21 @@ import { removeDomain as vercelRemoveDomain, isVercelIntegrationEnabled } from '
             }
             customDomain = projectDomain.customDomain;
         }
-        // Remove from Vercel if integration is enabled
-        if (isVercelIntegrationEnabled()) {
-            const vercelResult = await vercelRemoveDomain(customDomain);
-            if (!vercelResult.success) {
-                // Log warning but continue - domain might not exist in Vercel
-                console.warn('[Domains API] Failed to remove from Vercel:', vercelResult.error);
-            } else {
-                console.log('[Domains API] Domain removed from Vercel:', customDomain);
-            }
+        // Require Vercel integration
+        if (!isVercelIntegrationEnabled()) {
+            return NextResponse.json({
+                error: 'Vercel integration not configured. Set VERCEL_API_TOKEN and VERCEL_PROJECT_ID environment variables.'
+            }, {
+                status: 503
+            });
+        }
+        // Remove from Vercel
+        const vercelResult = await vercelRemoveDomain(customDomain);
+        if (!vercelResult.success) {
+            // Log warning but continue - domain might not exist in Vercel
+            console.warn('[Domains API] Failed to remove from Vercel:', vercelResult.error);
+        } else {
+            console.log('[Domains API] Domain removed from Vercel:', customDomain);
         }
         // Remove from internal registry
         const result = await removeCustomDomain(customDomain, projectSlug);

package/renderer/app/api/domains/status/route.js

@@ -1,11 +1,17 @@
 import { NextResponse } from 'next/server';
 import { validateApiKey, getProjectCustomDomain, getCustomDomainEntry } from '@/lib/storage/blob';
-import { normalizeDomain, getDnsInstructions } from '@/lib/docs/config';
+import { normalizeDomain } from '@/lib/docs/config';
 import { getProjectUrl } from '@/lib/multi-tenant/context';
+import { getDomainConfig, isVercelIntegrationEnabled, formatVerificationInstructions } from '@/lib/vercel/domains';
 /**
  * GET /api/domains/status
  * 
- * Get the status of a custom domain.
+ * Get the status of a custom domain via Vercel API.
+ * 
+ * Requires environment variables:
+ * - VERCEL_API_TOKEN (or VERCEL_TOKEN)
+ * - VERCEL_PROJECT_ID
+ * - VERCEL_TEAM_ID (optional)
  * 
  * Headers:
  *   Authorization: Bearer <api_key>
@@ -94,26 +100,18 @@ import { getProjectUrl } from '@/lib/multi-tenant/context';
         switch(domainEntry.status){
             case 'pending':
                 {
-                    const dnsInstructions = getDnsInstructions(domainEntry.customDomain);
-                    dnsInstructions.txt.value = domainEntry.verificationToken || '';
                     response.message = 'Waiting for DNS configuration';
-                    response.dnsRecords = {
-                        cname: dnsInstructions.cname,
-                        txt: dnsInstructions.txt
-                    };
-                    response.nextStep = 'Add the DNS records above, then run "devdoc domain verify"';
+                    response.nextStep = 'Add the DNS records below, then run "devdoc domain verify"';
+                    // Get verification instructions from Vercel if available
+                    if (isVercelIntegrationEnabled()) {
+                        const configResult = await getDomainConfig(domainEntry.customDomain);
+                        if (configResult.success && configResult.domain?.verification) {
+                            const { records } = formatVerificationInstructions(configResult.domain.verification);
+                            response.verification = records;
+                        }
+                    }
                     break;
                 }
-            case 'dns_verified':
-                response.message = 'DNS verified, SSL certificate provisioning in progress';
-                response.verifiedAt = domainEntry.verifiedAt;
-                response.nextStep = 'SSL certificate should be ready within 1-24 hours';
-                break;
-            case 'ssl_provisioning':
-                response.message = 'SSL certificate being provisioned';
-                response.verifiedAt = domainEntry.verifiedAt;
-                response.nextStep = 'Almost ready! Check back in a few minutes';
-                break;
             case 'active':
                 response.message = 'Domain is active and working';
                 response.customUrl = `https://${domainEntry.customDomain}`;

package/renderer/app/api/domains/verify/route.js

@@ -2,21 +2,16 @@ import { NextResponse } from 'next/server';
 import { validateApiKey, getProjectCustomDomain, getCustomDomainEntry, updateCustomDomainStatus } from '@/lib/storage/blob';
 import { normalizeDomain } from '@/lib/docs/config';
 import { verifyDomain as vercelVerifyDomain, getDomainConfig, isVercelIntegrationEnabled, formatVerificationInstructions } from '@/lib/vercel/domains';
-import dns from 'dns';
-import { promisify } from 'util';
-const resolveCname = promisify(dns.resolveCname);
-const resolveTxt = promisify(dns.resolveTxt);
 /**
  * POST /api/domains/verify
  * 
- * Verify DNS configuration for a custom domain.
+ * Verify DNS configuration for a custom domain via Vercel API.
+ * Vercel handles DNS verification and automatic SSL provisioning.
  * 
- * When Vercel integration is enabled:
- * - Calls Vercel's verify endpoint directly
- * - Vercel handles DNS verification and SSL provisioning
- * 
- * Legacy mode (no Vercel integration):
- * - Checks CNAME and TXT records manually
+ * Requires environment variables:
+ * - VERCEL_API_TOKEN (or VERCEL_TOKEN)
+ * - VERCEL_PROJECT_ID
+ * - VERCEL_TEAM_ID (optional)
  * 
  * Headers:
  *   Authorization: Bearer <api_key>
@@ -84,142 +79,71 @@ const resolveTxt = promisify(dns.resolveTxt);
                 status: 403
             });
         }
-        // Use Vercel integration if available
-        if (isVercelIntegrationEnabled()) {
-            // Call Vercel's verify endpoint
-            const verifyResult = await vercelVerifyDomain(customDomain);
-            if (!verifyResult.success) {
-                // Get current domain config to show what's needed
-                const configResult = await getDomainConfig(customDomain);
-                const verification = configResult.domain?.verification || [];
-                let instructions = [];
-                if (verification.length > 0) {
-                    const formatted = formatVerificationInstructions(verification);
-                    instructions = formatted.instructions;
-                }
-                return NextResponse.json({
-                    success: false,
-                    domain: customDomain,
-                    projectSlug,
-                    status: domainEntry.status,
-                    verified: false,
-                    message: verifyResult.error || 'DNS verification failed. Please check your DNS records.',
-                    verification: verification.map((v)=>({
-                            type: v.type,
-                            name: v.domain,
-                            value: v.value
-                        })),
-                    instructions
-                });
-            }
-            // Domain verified successfully
-            if (verifyResult.verified) {
-                // Update our registry to mark as active
-                await updateCustomDomainStatus(customDomain, 'active');
-                return NextResponse.json({
-                    success: true,
-                    domain: customDomain,
-                    projectSlug,
-                    status: 'active',
-                    verified: true,
-                    message: 'Domain verified! SSL certificate will be provisioned automatically by Vercel.'
-                });
-            } else {
-                // Vercel didn't verify yet, return what's needed
-                const verification = verifyResult.domain?.verification || [];
-                const { instructions } = formatVerificationInstructions(verification);
-                return NextResponse.json({
-                    success: false,
-                    domain: customDomain,
-                    projectSlug,
-                    status: 'pending',
-                    verified: false,
-                    message: 'DNS records not yet propagated. This can take up to 48 hours.',
-                    verification: verification.map((v)=>({
-                            type: v.type,
-                            name: v.domain,
-                            value: v.value
-                        })),
-                    instructions
-                });
-            }
-        }
-        // Legacy verification (no Vercel integration)
-        console.warn('[Domains API] Vercel integration not configured, using legacy DNS verification');
-        // Check DNS records manually
-        const checks = {
-            cname: {
-                found: false,
-                value: null,
-                expected: 'cname.vercel-dns.com'
-            },
-            txt: {
-                found: false,
-                verified: false,
-                expected: domainEntry.verificationToken
-            }
-        };
-        // Check CNAME record
-        try {
-            const cnameRecords = await resolveCname(customDomain);
-            if (cnameRecords && cnameRecords.length > 0) {
-                checks.cname.found = true;
-                checks.cname.value = cnameRecords[0];
-            }
-        } catch  {
-        // CNAME not found or DNS error
+        // Require Vercel integration
+        if (!isVercelIntegrationEnabled()) {
+            return NextResponse.json({
+                error: 'Vercel integration not configured. Set VERCEL_API_TOKEN and VERCEL_PROJECT_ID environment variables.'
+            }, {
+                status: 503
+            });
         }
-        // Check TXT record for verification
-        const txtRecordName = `_devdoc-verify.${customDomain}`;
-        try {
-            const txtRecords = await resolveTxt(txtRecordName);
-            if (txtRecords && txtRecords.length > 0) {
-                checks.txt.found = true;
-                // TXT records can be arrays, flatten and check
-                const allTxtValues = txtRecords.flat();
-                checks.txt.verified = allTxtValues.some((val)=>val === domainEntry.verificationToken);
+        // Call Vercel's verify endpoint
+        const verifyResult = await vercelVerifyDomain(customDomain);
+        if (!verifyResult.success) {
+            // Get current domain config to show what's needed
+            const configResult = await getDomainConfig(customDomain);
+            const verification = configResult.domain?.verification || [];
+            let instructions = [];
+            if (verification.length > 0) {
+                const formatted = formatVerificationInstructions(verification);
+                instructions = formatted.instructions;
             }
-        } catch  {
-        // TXT not found or DNS error
+            return NextResponse.json({
+                success: false,
+                domain: customDomain,
+                projectSlug,
+                status: domainEntry.status,
+                verified: false,
+                message: verifyResult.error || 'DNS verification failed. Please check your DNS records.',
+                verification: verification.map((v)=>({
+                        type: v.type,
+                        name: v.domain,
+                        value: v.value
+                    })),
+                instructions
+            });
         }
-        // Determine overall status
-        const cnameValid = checks.cname.found && checks.cname.value?.toLowerCase().includes('vercel');
-        const txtValid = checks.txt.found && checks.txt.verified;
-        let newStatus = domainEntry.status;
-        let message = '';
-        if (cnameValid && txtValid) {
-            // DNS is verified
-            newStatus = 'active';
-            message = 'DNS verified! Domain is now active.';
+        // Domain verified successfully
+        if (verifyResult.verified) {
+            // Update our registry to mark as active
             await updateCustomDomainStatus(customDomain, 'active');
-        } else if (cnameValid && !txtValid) {
-            message = 'CNAME record found, but TXT verification record is missing or incorrect.';
-        } else if (!cnameValid && txtValid) {
-            message = 'TXT verification found, but CNAME record is missing or incorrect.';
+            return NextResponse.json({
+                success: true,
+                domain: customDomain,
+                projectSlug,
+                status: 'active',
+                verified: true,
+                message: 'Domain verified! SSL certificate will be provisioned automatically by Vercel.'
+            });
         } else {
-            message = 'DNS records not found. Please add the required CNAME and TXT records.';
+            // Vercel didn't verify yet, return what's needed
+            const verification = verifyResult.domain?.verification || [];
+            const { instructions } = formatVerificationInstructions(verification);
+            return NextResponse.json({
+                success: false,
+                domain: customDomain,
+                projectSlug,
+                status: 'pending',
+                verified: false,
+                message: 'DNS records not yet propagated. This can take up to 48 hours.',
+                verification: verification.map((v)=>({
+                        type: v.type,
+                        name: v.domain,
+                        value: v.value
+                    })),
+                instructions
+            });
         }
-        return NextResponse.json({
-            success: cnameValid && txtValid,
-            domain: customDomain,
-            projectSlug,
-            status: newStatus,
-            verified: cnameValid && txtValid,
-            message,
-            checks: {
-                cname: {
-                    found: checks.cname.found,
-                    value: checks.cname.value,
-                    valid: cnameValid,
-                    expected: checks.cname.expected
-                },
-                txt: {
-                    found: checks.txt.found,
-                    verified: checks.txt.verified,
-                    expected: checks.txt.expected
-                }
-            }
-        });
     } catch (error) {
         console.error('[Domains API] Error verifying domain:', error);
         const message = error instanceof Error ? error.message : String(error);

package/renderer/app/api/upload/spec/route.js

@@ -0,0 +1,101 @@
+import { NextResponse } from 'next/server';
+import { put } from '@vercel/blob';
+import { validateApiKey } from '@/lib/storage/blob';
+/**
+ * POST /api/upload/spec
+ * 
+ * Upload OpenAPI specs or GraphQL schemas to blob storage using multipart form data.
+ * All specs/schemas are stored in blob storage for multi-tenant support.
+ * 
+ * Headers:
+ *   Authorization: Bearer <api_key>
+ * 
+ * Form Data:
+ *   slug: string - Project slug
+ *   fileName: string - File name (without extension)
+ *   type: 'openapi' | 'graphql' - Type of schema
+ *   file: File - The spec/schema file content
+ * 
+ * Response:
+ *   { success: true, url: string, path: string, type: string }
+ */ export async function POST(request) {
+    try {
+        // Validate API key
+        const authHeader = request.headers.get('Authorization');
+        const apiKey = authHeader?.replace('Bearer ', '');
+        if (!apiKey) {
+            return NextResponse.json({
+                error: 'API key required'
+            }, {
+                status: 401
+            });
+        }
+        const projectSlug = await validateApiKey(apiKey);
+        if (!projectSlug) {
+            return NextResponse.json({
+                error: 'Invalid API key'
+            }, {
+                status: 403
+            });
+        }
+        // Parse multipart form data
+        const formData = await request.formData();
+        const slug = formData.get('slug');
+        const fileName = formData.get('fileName');
+        const type = formData.get('type') || 'openapi' // Default to openapi for backwards compatibility
+        ;
+        const file = formData.get('file');
+        if (!slug || !fileName || !file) {
+            return NextResponse.json({
+                error: 'Missing slug, fileName, or file'
+            }, {
+                status: 400
+            });
+        }
+        // Validate type
+        if (type !== 'openapi' && type !== 'graphql') {
+            return NextResponse.json({
+                error: 'Invalid type. Must be "openapi" or "graphql"'
+            }, {
+                status: 400
+            });
+        }
+        // Verify slug matches API key's project
+        if (slug !== projectSlug) {
+            return NextResponse.json({
+                error: 'API key does not match project slug'
+            }, {
+                status: 403
+            });
+        }
+        // Determine blob path and content type based on type
+        const isGraphQL = type === 'graphql';
+        const extension = isGraphQL ? 'graphql' : 'json';
+        const contentType = isGraphQL ? 'text/plain' : 'application/json';
+        const folder = isGraphQL ? 'schemas' : 'specs';
+        const blobPath = `projects/${slug}/${folder}/${fileName}.${extension}`;
+        const blob = await put(blobPath, file.stream(), {
+            access: 'public',
+            contentType,
+            addRandomSuffix: false
+        });
+        console.log(`[Upload Schema] Uploaded ${type} ${fileName} for ${slug}: ${blob.url}`);
+        return NextResponse.json({
+            success: true,
+            url: blob.url,
+            path: blobPath,
+            type
+        });
+    } catch (error) {
+        console.error('[Upload Schema] Error:', error);
+        const message = error instanceof Error ? error.message : String(error);
+        return NextResponse.json({
+            error: 'Failed to upload schema',
+            details: message
+        }, {
+            status: 500
+        });
+    }
+}
+// Allow longer duration for large uploads
+export const maxDuration = 60;