@brainfish-ai/devdoc 0.1.41 → 0.1.43

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

@@ -1,100 +0,0 @@
-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

@@ -1,158 +0,0 @@
-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

@@ -1,181 +0,0 @@
-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/keys/regenerate/route.ts

@@ -1,80 +0,0 @@
-import { NextRequest, NextResponse } from 'next/server'
-import { 
-  validateApiKey, 
-  regenerateApiKey,
-  projectExists 
-} from '@/lib/storage/blob'
-
-/**
- * POST /api/keys/regenerate
- * Regenerate API key for a project
- * 
- * Headers:
- *   Authorization: Bearer <current_api_key>
- * Body:
- *   { slug: string }
- */
-export async function POST(request: NextRequest) {
-  try {
-    const body = await request.json()
-    const { slug } = body
-    
-    if (!slug || typeof slug !== 'string') {
-      return NextResponse.json(
-        { error: 'Missing or invalid project slug' },
-        { status: 400 }
-      )
-    }
-    
-    // Validate current API key
-    const authHeader = request.headers.get('Authorization')
-    const currentKey = authHeader?.replace('Bearer ', '')
-    
-    if (!currentKey) {
-      return NextResponse.json(
-        { error: 'API key required' },
-        { status: 401 }
-      )
-    }
-    
-    // Check project exists
-    const exists = await projectExists(slug)
-    if (!exists) {
-      return NextResponse.json(
-        { error: 'Project not found' },
-        { status: 404 }
-      )
-    }
-    
-    // Validate the provided key belongs to this project
-    const validatedSlug = await validateApiKey(currentKey)
-    if (validatedSlug !== slug) {
-      return NextResponse.json(
-        { error: 'Invalid API key for this project' },
-        { status: 403 }
-      )
-    }
-    
-    // Regenerate the key
-    const newKey = await regenerateApiKey(slug, currentKey)
-    
-    if (!newKey) {
-      return NextResponse.json(
-        { error: 'Failed to regenerate API key' },
-        { status: 500 }
-      )
-    }
-    
-    return NextResponse.json({
-      success: true,
-      apiKey: newKey,
-    })
-    
-  } catch (error) {
-    console.error('[Keys API] Error:', error)
-    return NextResponse.json(
-      { error: 'Internal server error' },
-      { status: 500 }
-    )
-  }
-}

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

@@ -1,122 +0,0 @@
-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'
-}