@brainfish-ai/devdoc 0.1.29 → 0.1.31

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

@@ -0,0 +1,100 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { 
+  validateApiKey,
+  getProjectCustomDomain,
+  removeCustomDomain,
+} from '@/lib/storage/blob'
+import { normalizeDomain } from '@/lib/docs/config'
+
+/**
+ * DELETE /api/domains/remove
+ * 
+ * Remove a custom domain from a project.
+ * 
+ * Headers:
+ *   Authorization: Bearer <api_key>
+ * 
+ * Body:
+ *   { customDomain: "docs.example.com" }  // Optional, removes project's domain if not specified
+ * 
+ * Response:
+ *   {
+ *     success: true,
+ *     message: "Domain docs.example.com removed successfully"
+ *   }
+ */
+export async function DELETE(request: NextRequest) {
+  try {
+    // Validate API key
+    const authHeader = request.headers.get('Authorization')
+    const apiKey = authHeader?.replace('Bearer ', '')
+    
+    if (!apiKey) {
+      return NextResponse.json(
+        { error: 'API key required. Provide via Authorization header.' },
+        { status: 401 }
+      )
+    }
+    
+    const projectSlug = await validateApiKey(apiKey)
+    if (!projectSlug) {
+      return NextResponse.json(
+        { error: 'Invalid API key' },
+        { status: 403 }
+      )
+    }
+    
+    // Parse request body
+    const body = await request.json().catch(() => ({}))
+    let customDomain = body.customDomain ? normalizeDomain(body.customDomain) : null
+    
+    // If no domain specified, get the project's custom domain
+    if (!customDomain) {
+      const projectDomain = await getProjectCustomDomain(projectSlug)
+      if (!projectDomain) {
+        return NextResponse.json(
+          { error: 'No custom domain configured for this project' },
+          { status: 404 }
+        )
+      }
+      customDomain = projectDomain.customDomain
+    }
+    
+    // Remove the domain
+    const result = await removeCustomDomain(customDomain, projectSlug)
+    
+    if (!result.success) {
+      return NextResponse.json(
+        { error: result.error },
+        { status: 400 }
+      )
+    }
+    
+    // TODO: In production, also remove from Vercel via API
+    // await vercelApi.removeDomain(customDomain)
+    
+    return NextResponse.json({
+      success: true,
+      message: `Domain ${customDomain} removed successfully`,
+      domain: customDomain,
+      projectSlug,
+    })
+    
+  } catch (error) {
+    console.error('[Domains API] Error removing domain:', error)
+    const message = error instanceof Error ? error.message : String(error)
+    return NextResponse.json(
+      { error: 'Failed to remove domain', details: message },
+      { status: 500 }
+    )
+  }
+}
+
+/**
+ * POST /api/domains/remove
+ * 
+ * Alternative method for removing domain (some clients don't support DELETE with body)
+ */
+export async function POST(request: NextRequest) {
+  return DELETE(request)
+}

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

@@ -0,0 +1,158 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { 
+  validateApiKey,
+  getProjectCustomDomain,
+  getCustomDomainEntry,
+} from '@/lib/storage/blob'
+import { normalizeDomain, getDnsInstructions } from '@/lib/docs/config'
+import { getProjectUrl } from '@/lib/multi-tenant/context'
+
+/**
+ * GET /api/domains/status
+ * 
+ * Get the status of a custom domain.
+ * 
+ * Headers:
+ *   Authorization: Bearer <api_key>
+ * 
+ * Query:
+ *   ?domain=docs.example.com  // Optional, uses project's domain if not specified
+ * 
+ * Response:
+ *   {
+ *     domain: "docs.example.com",
+ *     status: "active",
+ *     projectSlug: "my-project",
+ *     projectUrl: "https://my-project.devdoc.sh",
+ *     customUrl: "https://docs.example.com",
+ *     createdAt: "2026-01-24T...",
+ *     verifiedAt: "2026-01-24T..."
+ *   }
+ */
+export async function GET(request: NextRequest) {
+  try {
+    // Validate API key
+    const authHeader = request.headers.get('Authorization')
+    const apiKey = authHeader?.replace('Bearer ', '')
+    
+    if (!apiKey) {
+      return NextResponse.json(
+        { error: 'API key required. Provide via Authorization header.' },
+        { status: 401 }
+      )
+    }
+    
+    const projectSlug = await validateApiKey(apiKey)
+    if (!projectSlug) {
+      return NextResponse.json(
+        { error: 'Invalid API key' },
+        { status: 403 }
+      )
+    }
+    
+    // Get domain from query or use project's domain
+    const { searchParams } = new URL(request.url)
+    let customDomain = searchParams.get('domain')
+    
+    if (customDomain) {
+      customDomain = normalizeDomain(customDomain)
+    }
+    
+    let domainEntry
+    
+    if (customDomain) {
+      // Get specific domain
+      domainEntry = await getCustomDomainEntry(customDomain)
+      
+      if (!domainEntry) {
+        return NextResponse.json(
+          { error: `Domain ${customDomain} not found` },
+          { status: 404 }
+        )
+      }
+      
+      // Verify domain belongs to this project
+      if (domainEntry.projectSlug !== projectSlug) {
+        return NextResponse.json(
+          { error: `Domain ${customDomain} does not belong to this project` },
+          { status: 403 }
+        )
+      }
+    } else {
+      // Get project's custom domain
+      domainEntry = await getProjectCustomDomain(projectSlug)
+      
+      if (!domainEntry) {
+        return NextResponse.json({
+          hasCustomDomain: false,
+          projectSlug,
+          projectUrl: getProjectUrl(projectSlug),
+          message: 'No custom domain configured. Use /api/domains/add to add one.',
+        })
+      }
+    }
+    
+    // Build response based on status
+    const projectUrl = getProjectUrl(projectSlug)
+    const response: Record<string, unknown> = {
+      hasCustomDomain: true,
+      domain: domainEntry.customDomain,
+      status: domainEntry.status,
+      projectSlug,
+      projectUrl,
+      createdAt: domainEntry.createdAt,
+    }
+    
+    // Add status-specific information
+    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"'
+        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}`
+        response.verifiedAt = domainEntry.verifiedAt
+        break
+        
+      case 'error':
+        response.message = 'Domain configuration error'
+        response.error = domainEntry.errorMessage
+        response.nextStep = 'Check DNS configuration and try verifying again'
+        break
+    }
+    
+    response.lastCheckedAt = domainEntry.lastCheckedAt
+    
+    return NextResponse.json(response)
+    
+  } catch (error) {
+    console.error('[Domains API] Error getting status:', error)
+    const message = error instanceof Error ? error.message : String(error)
+    return NextResponse.json(
+      { error: 'Failed to get domain status', details: message },
+      { status: 500 }
+    )
+  }
+}

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

@@ -0,0 +1,181 @@
+import { NextRequest, 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)
+
+/**
+ * POST /api/domains/verify
+ * 
+ * Verify DNS configuration for a custom domain.
+ * Checks CNAME and TXT records, then triggers SSL provisioning.
+ * 
+ * Headers:
+ *   Authorization: Bearer <api_key>
+ * 
+ * Body:
+ *   { customDomain: "docs.example.com" }  // Optional, uses project's domain if not specified
+ * 
+ * Response:
+ *   {
+ *     success: true,
+ *     domain: "docs.example.com",
+ *     status: "dns_verified",
+ *     checks: {
+ *       cname: { found: true, value: "cname.devdoc-dns.com" },
+ *       txt: { found: true, verified: true }
+ *     }
+ *   }
+ */
+export async function POST(request: NextRequest) {
+  try {
+    // Validate API key
+    const authHeader = request.headers.get('Authorization')
+    const apiKey = authHeader?.replace('Bearer ', '')
+    
+    if (!apiKey) {
+      return NextResponse.json(
+        { error: 'API key required. Provide via Authorization header.' },
+        { status: 401 }
+      )
+    }
+    
+    const projectSlug = await validateApiKey(apiKey)
+    if (!projectSlug) {
+      return NextResponse.json(
+        { error: 'Invalid API key' },
+        { status: 403 }
+      )
+    }
+    
+    // Parse request body
+    const body = await request.json().catch(() => ({}))
+    let customDomain = body.customDomain ? normalizeDomain(body.customDomain) : null
+    
+    // If no domain specified, get the project's custom domain
+    if (!customDomain) {
+      const projectDomain = await getProjectCustomDomain(projectSlug)
+      if (!projectDomain) {
+        return NextResponse.json(
+          { error: 'No custom domain configured for this project. Add one first with /api/domains/add' },
+          { status: 404 }
+        )
+      }
+      customDomain = projectDomain.customDomain
+    }
+    
+    // Get domain entry
+    const domainEntry = await getCustomDomainEntry(customDomain)
+    if (!domainEntry) {
+      return NextResponse.json(
+        { error: `Domain ${customDomain} not found` },
+        { status: 404 }
+      )
+    }
+    
+    // Verify domain belongs to this project
+    if (domainEntry.projectSlug !== projectSlug) {
+      return NextResponse.json(
+        { error: `Domain ${customDomain} does not belong to this project` },
+        { status: 403 }
+      )
+    }
+    
+    // Check DNS records
+    const checks = {
+      cname: { found: false, value: null as string | 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
+    }
+    
+    // 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
+        )
+      }
+    } catch {
+      // TXT not found or DNS error
+    }
+    
+    // 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.'
+    } else {
+      message = 'DNS records not found. Please add the required CNAME and TXT records.'
+    }
+    
+    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)
+    return NextResponse.json(
+      { error: 'Failed to verify domain', details: message },
+      { status: 500 }
+    )
+  }
+}

package/renderer/app/api/local-assets/[...path]/route.ts

@@ -0,0 +1,122 @@
+import { NextRequest, NextResponse } from 'next/server'
+import path from 'path'
+import fs from 'fs'
+
+/**
+ * Local asset server for devdoc dev mode
+ * 
+ * Serves assets from the user's project folder (STARTER_PATH/assets/)
+ * This allows /assets/images/logo.png to work in local development
+ */
+export async function GET(
+  request: NextRequest,
+  { params }: { params: Promise<{ path: string[] }> }
+) {
+  try {
+    const { path: pathSegments } = await params
+    
+    if (!pathSegments || pathSegments.length === 0) {
+      return NextResponse.json(
+        { error: 'Invalid asset path' },
+        { status: 400 }
+      )
+    }
+    
+    // Get the project path from environment
+    const projectPath = process.env.STARTER_PATH
+    
+    if (!projectPath) {
+      return NextResponse.json(
+        { error: 'Not in local development mode' },
+        { status: 404 }
+      )
+    }
+    
+    // Build file path - assets are in projectPath/assets/
+    const assetPath = pathSegments.join('/')
+    const filePath = path.join(projectPath, 'assets', assetPath)
+    
+    // Security: ensure we're not escaping the assets directory
+    const resolvedPath = path.resolve(filePath)
+    const assetsDir = path.resolve(path.join(projectPath, 'assets'))
+    
+    if (!resolvedPath.startsWith(assetsDir)) {
+      return NextResponse.json(
+        { error: 'Invalid path' },
+        { status: 403 }
+      )
+    }
+    
+    // Check if file exists
+    if (!fs.existsSync(resolvedPath)) {
+      // Also try without 'assets' prefix (for /assets/images/x.png -> images/x.png)
+      const altPath = path.join(projectPath, assetPath)
+      const resolvedAltPath = path.resolve(altPath)
+      
+      if (resolvedAltPath.startsWith(path.resolve(projectPath)) && fs.existsSync(resolvedAltPath)) {
+        const fileBuffer = fs.readFileSync(resolvedAltPath)
+        const contentType = getContentType(assetPath)
+        
+        return new NextResponse(fileBuffer, {
+          status: 200,
+          headers: {
+            'Content-Type': contentType,
+            'Cache-Control': 'no-cache',
+          },
+        })
+      }
+      
+      return NextResponse.json(
+        { error: 'Asset not found', path: assetPath },
+        { status: 404 }
+      )
+    }
+    
+    const fileBuffer = fs.readFileSync(resolvedPath)
+    const contentType = getContentType(assetPath)
+    
+    return new NextResponse(fileBuffer, {
+      status: 200,
+      headers: {
+        'Content-Type': contentType,
+        'Cache-Control': 'no-cache', // No caching in dev
+      },
+    })
+    
+  } catch (error) {
+    console.error('[Local Assets] Error:', error)
+    return NextResponse.json(
+      { error: 'Failed to serve asset' },
+      { status: 500 }
+    )
+  }
+}
+
+/**
+ * Get content type from file extension
+ */
+function getContentType(fileName: string): string {
+  const ext = fileName.split('.').pop()?.toLowerCase()
+  const types: Record<string, string> = {
+    'jpg': 'image/jpeg',
+    'jpeg': 'image/jpeg',
+    'png': 'image/png',
+    'gif': 'image/gif',
+    'webp': 'image/webp',
+    'svg': 'image/svg+xml',
+    'ico': 'image/x-icon',
+    'pdf': 'application/pdf',
+    'mp4': 'video/mp4',
+    'webm': 'video/webm',
+    'mp3': 'audio/mpeg',
+    'wav': 'audio/wav',
+    'woff': 'font/woff',
+    'woff2': 'font/woff2',
+    'ttf': 'font/ttf',
+    'otf': 'font/otf',
+    'json': 'application/json',
+    'css': 'text/css',
+    'js': 'application/javascript',
+  }
+  return types[ext || ''] || 'application/octet-stream'
+}

package/renderer/app/globals.css

@@ -150,6 +150,15 @@
     @apply bg-background text-foreground;
   }
   
+  /* Prevent iOS zoom on input focus - ensure minimum 16px font size */
+  @media screen and (max-width: 768px) {
+    input,
+    select,
+    textarea {
+      font-size: 16px !important;
+    }
+  }
+  
   /* Custom scrollbar - light and thin */
   * {
     scrollbar-width: thin;

package/renderer/app/layout.tsx

@@ -1,4 +1,4 @@
-import type { Metadata } from "next";
+import type { Metadata, Viewport } from "next";
 import { Geist, Geist_Mono } from "next/font/google";
 import { ThemeProvider } from "@/components/theme-provider";
 import "./globals.css";
@@ -23,6 +23,13 @@ export const metadata: Metadata = {
   },
 };
 
+export const viewport: Viewport = {
+  width: "device-width",
+  initialScale: 1,
+  maximumScale: 1,
+  userScalable: false,
+};
+
 export default function RootLayout({
   children,
 }: Readonly<{

package/renderer/components/docs/mdx/cards.tsx

@@ -17,10 +17,11 @@ import { useDocsNavigation } from '@/lib/docs-navigation-context'
 interface CardProps {
   title: string
   children?: React.ReactNode
-  icon?: string
+  icon?: string | React.ReactNode  // Icon name (string) or custom React node
+  iconSize?: 'sm' | 'md' | 'lg' | 'xl'  // Size of icon container: sm=32px, md=40px (default), lg=48px, xl=64px
   href?: string
   horizontal?: boolean
-  img?: string
+  img?: string  // Full-width header image
   cta?: string
   arrow?: boolean
   className?: string
@@ -41,10 +42,19 @@ function getIcon(iconName: string): React.ComponentType<{ className?: string; we
   return Icon || null
 }
 
+// Icon size configurations
+const ICON_SIZES = {
+  sm: { container: 'h-8 w-8', icon: 'h-4 w-4', img: 'h-5 w-5' },
+  md: { container: 'h-10 w-10', icon: 'h-5 w-5', img: 'h-6 w-6' },
+  lg: { container: 'h-12 w-12', icon: 'h-6 w-6', img: 'h-8 w-8' },
+  xl: { container: 'h-16 w-16', icon: 'h-8 w-8', img: 'h-12 w-12' },
+}
+
 export function Card({
   title,
   children,
   icon,
+  iconSize = 'md',
   href,
   horizontal = false,
   img,
@@ -52,7 +62,11 @@ export function Card({
   arrow,
   className,
 }: CardProps) {
-  const Icon = icon ? getIcon(icon) : null
+  // Check if icon is a string (icon name) or React node
+  const isIconString = typeof icon === 'string'
+  const Icon = isIconString ? getIcon(icon) : null
+  const hasCustomIcon = !isIconString && icon != null
+  const sizeConfig = ICON_SIZES[iconSize]
   const isExternal = href?.startsWith('http') || href?.startsWith('//')
   const docsNav = useDocsNavigation()
   
@@ -116,21 +130,35 @@ export function Card({
         </div>
       )}
       
-      {/* Icon */}
+      {/* Icon (Phosphor icon from string) */}
       {Icon && (
         <div
           className={cn(
-            'docs-card-icon flex h-10 w-10 shrink-0 items-center justify-center rounded-lg',
+            'docs-card-icon flex shrink-0 items-center justify-center rounded-lg',
+            sizeConfig.container,
             'bg-primary/10 text-primary',
             horizontal && 'mt-0.5'
           )}
         >
-          <Icon className="h-5 w-5" weight="duotone" />
+          <Icon className={sizeConfig.icon} weight="duotone" />
+        </div>
+      )}
+      
+      {/* Custom Icon (React node - image, svg, etc.) */}
+      {hasCustomIcon && (
+        <div
+          className={cn(
+            'docs-card-icon flex shrink-0 items-center justify-center rounded-lg overflow-hidden',
+            sizeConfig.container,
+            horizontal && 'mt-0.5'
+          )}
+        >
+          {icon}
         </div>
       )}
       
       {/* Content */}
-      <div className={cn('docs-card-content min-w-0', horizontal && 'flex-1', !horizontal && Icon && 'mt-3')}>
+      <div className={cn('docs-card-content min-w-0', horizontal && 'flex-1', !horizontal && (Icon || hasCustomIcon) && 'mt-3')}>
         <div className="flex items-center gap-2">
           <h3 className="docs-card-title font-semibold text-foreground group-hover:text-primary transition-colors">
             {title}