@brainfish-ai/devdoc 0.1.49 → 0.1.51

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

@@ -1,15 +1,17 @@
 import { NextResponse } from 'next/server';
 import { validateApiKey, getProjectCustomDomain, getCustomDomainEntry, updateCustomDomainStatus } from '@/lib/storage/blob';
 import { normalizeDomain } from '@/lib/docs/config';
-import dns from 'dns';
-import { promisify } from 'util';
-const resolveCname = promisify(dns.resolveCname);
-const resolveTxt = promisify(dns.resolveTxt);
+import { verifyDomain as vercelVerifyDomain, getDomainConfig, isVercelIntegrationEnabled, formatVerificationInstructions } from '@/lib/vercel/domains';
 /**
  * POST /api/domains/verify
  * 
- * Verify DNS configuration for a custom domain.
- * Checks CNAME and TXT records, then triggers SSL provisioning.
+ * Verify DNS configuration for a custom domain via Vercel API.
+ * Vercel handles DNS verification and automatic SSL provisioning.
+ * 
+ * Requires environment variables:
+ * - VERCEL_API_TOKEN (or VERCEL_TOKEN)
+ * - VERCEL_PROJECT_ID
+ * - VERCEL_TEAM_ID (optional)
  * 
  * Headers:
  *   Authorization: Bearer <api_key>
@@ -21,11 +23,9 @@ const resolveTxt = promisify(dns.resolveTxt);
  *   {
  *     success: true,
  *     domain: "docs.example.com",
- *     status: "dns_verified",
- *     checks: {
- *       cname: { found: true, value: "cname.devdoc-dns.com" },
- *       txt: { found: true, verified: true }
- *     }
+ *     status: "active",
+ *     verified: true,
+ *     message: "Domain verified! SSL will be provisioned automatically."
  *   }
  */ export async function POST(request) {
     try {
@@ -62,7 +62,7 @@ const resolveTxt = promisify(dns.resolveTxt);
             }
             customDomain = projectDomain.customDomain;
         }
-        // Get domain entry
+        // Get domain entry from our registry
         const domainEntry = await getCustomDomainEntry(customDomain);
         if (!domainEntry) {
             return NextResponse.json({
@@ -79,82 +79,71 @@ const resolveTxt = promisify(dns.resolveTxt);
                 status: 403
             });
         }
-        // Check DNS records
-        const checks = {
-            cname: {
-                found: false,
-                value: null,
-                expected: 'cname.devdoc-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('devdoc');
-        const txtValid = checks.txt.found && checks.txt.verified;
-        let newStatus = domainEntry.status;
-        let message = '';
-        if (cnameValid && txtValid) {
-            // DNS is verified, update status
-            newStatus = 'dns_verified';
-            message = 'DNS verified! SSL certificate will be provisioned automatically (1-24 hours).';
-            await updateCustomDomainStatus(customDomain, 'dns_verified');
-        // In production, this would trigger Vercel API to add domain
-        // For now, we simulate SSL provisioning by updating status
-        // TODO: Integrate with Vercel Domains API
-        } 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.';
+        // 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 {
-            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,
-            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/schema/route.js

@@ -6,10 +6,6 @@ import { getProjectContent } from '@/lib/storage/blob';
 const STARTER_PATH = process.env.STARTER_PATH || 'devdoc-docs';
 // Get the docs directory - respects STARTER_PATH for local development
 function getDocsDir() {
-    const projectSlug = process.env.BRAINFISH_PROJECT_SLUG;
-    if (projectSlug) {
-        return join(process.cwd(), '.devdoc', projectSlug);
-    }
     // Use STARTER_PATH (can be absolute or relative)
     if (isAbsolute(STARTER_PATH)) {
         return STARTER_PATH;
@@ -43,22 +39,27 @@ export async function GET(request) {
         });
     }
     try {
-        // Try blob storage first (for deployed projects)
-        const projectSlug = process.env.BRAINFISH_PROJECT_SLUG;
+        // Get project slug from middleware header (multi-tenant) or env var (single-tenant)
+        const projectSlug = request.headers.get('x-devdoc-project') || process.env.BRAINFISH_PROJECT_SLUG;
+        // Try blob storage first (for deployed/multi-tenant projects)
         if (projectSlug) {
             const projectContent = await getProjectContent(projectSlug);
-            if (projectContent?.files) {
-                const file = projectContent.files.find((f)=>f.path === path || f.path === `/${path}`);
-                if (file?.content) {
-                    return new NextResponse(file.content, {
+            // Check dedicated graphqlSchemas map first (like OpenAPI specs)
+            if (projectContent?.graphqlSchemas) {
+                const schemaContent = projectContent.graphqlSchemas[path] || projectContent.graphqlSchemas[path.replace(/^\//, '')] // Try without leading slash
+                ;
+                if (schemaContent) {
+                    return new NextResponse(schemaContent, {
                         headers: {
                             'Content-Type': 'text/plain'
                         }
                     });
                 }
+                // Log for debugging - schema not found
+                console.log('[Schema API] Schema not found in graphqlSchemas:', path, 'Available:', Object.keys(projectContent.graphqlSchemas));
             }
         }
-        // Try local filesystem
+        // Try local filesystem (for local development)
         const docsDir = getDocsDir();
         const fullPath = join(docsDir, path);
         if (!existsSync(fullPath)) {

package/renderer/components/docs-header.js

@@ -7,9 +7,8 @@ import { ThemeToggle } from "@/components/theme-toggle";
 import { useMobile } from "@/lib/api-docs/mobile-context";
 import { Button } from "@/components/ui/button";
 import { cn } from "@/lib/utils";
-// Default logo fallback
-const DEFAULT_LOGO = {
-    url: 'https://cdn.prod.website-files.com/639181964f4fe88697a20a0a/67af64a5ba42bb659b8560c9_Logo%20(3).svg',
+// Default logo dimensions (no default URL - show name only if no logo configured)
+const DEFAULT_LOGO_DIMENSIONS = {
     alt: 'Logo',
     width: 80,
     height: 24
@@ -19,13 +18,14 @@ export function DocsHeader({ navigationTabs = [], activeTab, onTabChange, docsNa
     // Use config values with defaults
     // Support both single URL and separate light/dark logos
     const hasLightDarkLogos = docsLogo?.light && docsLogo?.dark;
+    const hasAnyLogo = docsLogo?.url || hasLightDarkLogos;
     const logo = {
-        url: docsLogo?.url || DEFAULT_LOGO.url,
+        url: docsLogo?.url,
         light: docsLogo?.light,
         dark: docsLogo?.dark,
-        alt: docsLogo?.alt || DEFAULT_LOGO.alt,
-        width: docsLogo?.width || DEFAULT_LOGO.width,
-        height: docsLogo?.height || DEFAULT_LOGO.height
+        alt: docsLogo?.alt || DEFAULT_LOGO_DIMENSIONS.alt,
+        width: docsLogo?.width || DEFAULT_LOGO_DIMENSIONS.width,
+        height: docsLogo?.height || DEFAULT_LOGO_DIMENSIONS.height
     };
     const showSearch = docsHeader?.showSearch !== false // Default true
     ;
@@ -87,7 +87,7 @@ export function DocsHeader({ navigationTabs = [], activeTab, onTabChange, docsNa
                                                 priority: true
                                             })
                                         ]
-                                    }) : /*#__PURE__*/ _jsx(Image, {
+                                    }) : logo.url ? /*#__PURE__*/ _jsx(Image, {
                                         src: logo.url,
                                         alt: logo.alt,
                                         width: logo.width,
@@ -97,14 +97,14 @@ export function DocsHeader({ navigationTabs = [], activeTab, onTabChange, docsNa
                                             height: logo.height
                                         },
                                         priority: true
-                                    }),
+                                    }) : null,
                                     docsName && /*#__PURE__*/ _jsxs(_Fragment, {
                                         children: [
-                                            /*#__PURE__*/ _jsx("div", {
+                                            hasAnyLogo && /*#__PURE__*/ _jsx("div", {
                                                 className: "hidden sm:block h-5 w-px bg-border"
                                             }),
                                             /*#__PURE__*/ _jsx("span", {
-                                                className: "docs-header-title hidden sm:inline text-sm font-medium text-muted-foreground pointer-events-none",
+                                                className: cn("docs-header-title text-sm font-medium pointer-events-none", hasAnyLogo ? "hidden sm:inline text-muted-foreground" : "text-foreground font-semibold"),
                                                 children: docsName
                                             })
                                         ]

package/renderer/lib/docs/config/domain-schema.js

@@ -143,19 +143,3 @@ export const domainConfigSchema = z.object({
     normalized = normalized.split(':')[0];
     return normalized;
 }
-/**
- * Get DNS instructions for a custom domain
- */ export function getDnsInstructions(customDomain) {
-    const parts = customDomain.split('.');
-    const subdomain = parts.length > 2 ? parts[0] : '@';
-    return {
-        cname: {
-            name: subdomain === '@' ? customDomain : subdomain,
-            value: 'cname.devdoc-dns.com'
-        },
-        txt: {
-            name: `_devdoc-verify.${customDomain}`,
-            value: ''
-        }
-    };
-}

package/renderer/lib/docs/config/index.js

@@ -1,6 +1,6 @@
 /**
  * Configuration Module Exports
  */ export { docsConfigSchema, parseDocsConfig, safeParseDocsConfig, getDefaultDocsConfig } from './schema';
-export { domainConfigSchema, parseDomainConfig, safeParseDomainConfig, isValidDomain, normalizeDomain, getDnsInstructions } from './domain-schema';
+export { domainConfigSchema, parseDomainConfig, safeParseDomainConfig, isValidDomain, normalizeDomain } from './domain-schema';
 export { loadDocsConfig, safeLoadDocsConfig, clearConfigCache, hasDocsConfig, getContentDir, resolvePagePath, loadPageContent, listMdxFiles } from './loader';
 export { isDevMode, isProductionMode, shouldShowItem } from './environment';

package/renderer/lib/storage/blob.js

@@ -30,7 +30,7 @@ function _getFileBlobPath(slug, filePath) {
 }
 /**
  * Store project content in Vercel Blob (or local filesystem in dev)
- */ export async function storeProjectContent(slug, name, docsJson, files, themeJson, openApiSpecs) {
+ */ export async function storeProjectContent(slug, name, docsJson, files, themeJson, openApiSpecs, graphqlSchemas) {
     const now = new Date().toISOString();
     const content = {
         slug,
@@ -41,6 +41,7 @@ function _getFileBlobPath(slug, filePath) {
                 k,
                 JSON.stringify(v)
             ])) : undefined,
+        graphqlSchemas,
         files,
         createdAt: now,
         updatedAt: now
@@ -92,7 +93,7 @@ function _getFileBlobPath(slug, filePath) {
 }
 /**
  * Update existing project content
- */ export async function updateProjectContent(slug, docsJson, files, themeJson, openApiSpecs) {
+ */ export async function updateProjectContent(slug, docsJson, files, themeJson, openApiSpecs, graphqlSchemas) {
     // Get existing content to preserve createdAt
     const existing = await getProjectContent(slug);
     const now = new Date().toISOString();
@@ -105,6 +106,7 @@ function _getFileBlobPath(slug, filePath) {
                 k,
                 JSON.stringify(v)
             ])) : undefined,
+        graphqlSchemas,
         files,
         createdAt: existing?.createdAt || now,
         updatedAt: now