@brainfish-ai/devdoc 0.1.42 → 0.1.43

package/renderer/app/api/debug/route.ts

@@ -1,53 +0,0 @@
-import { NextRequest, NextResponse } from 'next/server'
-import { headers } from 'next/headers'
-import { getProjectContent, projectExists } from '@/lib/storage/blob'
-
-/**
- * Debug endpoint to check multi-tenant routing
- * 
- * GET /api/debug?slug=acme-api-docs-i2rjwv
- */
-export async function GET(request: NextRequest) {
-  const headersList = await headers()
-  const { searchParams } = new URL(request.url)
-  const testSlug = searchParams.get('slug')
-  
-  // Collect all headers
-  const allHeaders: Record<string, string> = {}
-  headersList.forEach((value, key) => {
-    allHeaders[key] = value
-  })
-  
-  // Check for project header
-  const projectSlug = headersList.get('x-devdoc-project')
-  
-  // Test Blob storage if slug provided
-  let blobTest = null
-  if (testSlug) {
-    try {
-      const exists = await projectExists(testSlug)
-      const content = exists ? await getProjectContent(testSlug) : null
-      blobTest = {
-        slug: testSlug,
-        exists,
-        hasContent: !!content,
-        filesCount: content?.files?.length || 0,
-        projectName: content?.name || null,
-      }
-    } catch (error) {
-      blobTest = {
-        slug: testSlug,
-        error: String(error),
-      }
-    }
-  }
-  
-  return NextResponse.json({
-    timestamp: new Date().toISOString(),
-    host: headersList.get('host'),
-    projectSlug,
-    hasBlobToken: !!process.env.BLOB_READ_WRITE_TOKEN,
-    blobTest,
-    headers: allHeaders,
-  })
-}

package/renderer/app/api/deploy/route.ts

@@ -1,234 +0,0 @@
-import { NextRequest, NextResponse } from 'next/server'
-import { 
-  storeProjectContent, 
-  updateProjectContent,
-  projectExists,
-  generateProjectSlug,
-  generateApiKey,
-  storeProjectApiKey,
-  validateApiKey,
-  getProjectApiKey,
-  type ProjectFile 
-} from '@/lib/storage/blob'
-import { getProjectUrl, isValidSlug } from '@/lib/multi-tenant/context'
-
-/**
- * Deploy API - receives content from CLI and stores in Vercel Blob
- * 
- * POST /api/deploy
- * Headers:
- *   Authorization: Bearer <api_key>  // Required for updates
- * Body: {
- *   name: string,           // Project name from docs.json
- *   slug?: string,          // Optional: existing slug for updates
- *   docsJson: object,       // The docs.json configuration
- *   files: Array<{          // MDX and other content files
- *     path: string,
- *     content: string
- *   }>
- * }
- */
-export async function POST(request: NextRequest) {
-  try {
-    const body = await request.json()
-    
-    // Validate request body
-    const { name, slug: existingSlug, docsJson, files } = body
-    
-    if (!name || typeof name !== 'string') {
-      return NextResponse.json(
-        { error: 'Missing or invalid project name' },
-        { status: 400 }
-      )
-    }
-    
-    if (!docsJson || typeof docsJson !== 'object') {
-      return NextResponse.json(
-        { error: 'Missing or invalid docs.json configuration' },
-        { status: 400 }
-      )
-    }
-    
-    if (!files || !Array.isArray(files)) {
-      return NextResponse.json(
-        { error: 'Missing or invalid files array' },
-        { status: 400 }
-      )
-    }
-    
-    // Validate files structure
-    const validFiles: ProjectFile[] = []
-    for (const file of files) {
-      if (!file.path || typeof file.path !== 'string') {
-        return NextResponse.json(
-          { error: `Invalid file entry: missing path` },
-          { status: 400 }
-        )
-      }
-      if (typeof file.content !== 'string') {
-        return NextResponse.json(
-          { error: `Invalid file entry for ${file.path}: content must be a string` },
-          { status: 400 }
-        )
-      }
-      validFiles.push({
-        path: file.path,
-        content: file.content,
-      })
-    }
-    
-    let slug: string
-    let isUpdate = false
-    let apiKey: string | null = null
-    
-    // Check if this is an update to an existing project
-    if (existingSlug) {
-      if (!isValidSlug(existingSlug)) {
-        return NextResponse.json(
-          { error: 'Invalid project slug format' },
-          { status: 400 }
-        )
-      }
-      
-      const exists = await projectExists(existingSlug)
-      if (!exists) {
-        return NextResponse.json(
-          { error: `Project with slug "${existingSlug}" not found` },
-          { status: 404 }
-        )
-      }
-      
-      // For updates, validate API key
-      const authHeader = request.headers.get('Authorization')
-      const providedKey = authHeader?.replace('Bearer ', '') || body.apiKey
-      
-      if (!providedKey) {
-        return NextResponse.json(
-          { error: 'API key required for project updates. Provide via Authorization header or apiKey field.' },
-          { status: 401 }
-        )
-      }
-      
-      const validatedSlug = await validateApiKey(providedKey)
-      if (validatedSlug !== existingSlug) {
-        return NextResponse.json(
-          { error: 'Invalid API key for this project' },
-          { status: 403 }
-        )
-      }
-      
-      slug = existingSlug
-      isUpdate = true
-    } else {
-      // Generate a new unique slug
-      slug = generateProjectSlug(name)
-      
-      // Ensure it doesn't already exist (very unlikely but possible)
-      let attempts = 0
-      while (await projectExists(slug) && attempts < 5) {
-        slug = generateProjectSlug(name)
-        attempts++
-      }
-      
-      if (attempts >= 5) {
-        return NextResponse.json(
-          { error: 'Failed to generate unique project slug' },
-          { status: 500 }
-        )
-      }
-      
-      // Generate API key for new project
-      apiKey = generateApiKey()
-    }
-    
-    // Store or update content
-    let result
-    if (isUpdate) {
-      result = await updateProjectContent(slug, docsJson, validFiles)
-    } else {
-      result = await storeProjectContent(slug, name, docsJson, validFiles)
-      // Store the API key for new projects
-      if (apiKey) {
-        await storeProjectApiKey(slug, apiKey)
-      }
-    }
-    
-    // Build response
-    const projectUrl = getProjectUrl(slug)
-    
-    // For new projects, include the API key in response
-    const response: {
-      success: boolean
-      slug: string
-      url: string
-      blobUrl: string
-      isUpdate: boolean
-      filesCount: number
-      apiKey?: string
-    } = {
-      success: true,
-      slug,
-      url: projectUrl,
-      blobUrl: result.url,
-      isUpdate,
-      filesCount: validFiles.length,
-    }
-    
-    if (apiKey) {
-      response.apiKey = apiKey
-    }
-    
-    return NextResponse.json(response)
-    
-  } catch (error) {
-    console.error('[Deploy API] Error:', error)
-    const message = error instanceof Error ? error.message : String(error)
-    
-    // Provide clearer error messages for common issues
-    let userMessage = 'Deployment failed'
-    if (message.includes('blob already exists')) {
-      userMessage = 'Storage conflict - please try again'
-    } else if (message.includes('network') || message.includes('fetch')) {
-      userMessage = 'Network error connecting to storage'
-    } else if (message.includes('unauthorized') || message.includes('401')) {
-      userMessage = 'Authentication failed'
-    }
-    
-    return NextResponse.json(
-      { error: userMessage, details: message },
-      { status: 500 }
-    )
-  }
-}
-
-/**
- * GET /api/deploy - Check deployment status or get project info
- */
-export async function GET(request: NextRequest) {
-  const { searchParams } = new URL(request.url)
-  const slug = searchParams.get('slug')
-  
-  if (!slug) {
-    return NextResponse.json(
-      { error: 'Missing slug parameter' },
-      { status: 400 }
-    )
-  }
-  
-  const exists = await projectExists(slug)
-  
-  if (!exists) {
-    return NextResponse.json(
-      { exists: false, slug },
-      { status: 404 }
-    )
-  }
-  
-  const projectUrl = getProjectUrl(slug)
-  
-  return NextResponse.json({
-    exists: true,
-    slug,
-    url: projectUrl,
-  })
-}

package/renderer/app/api/device/route.ts

@@ -1,42 +0,0 @@
-import { NextResponse } from 'next/server'
-import { cookies } from 'next/headers'
-
-const DEVICE_COOKIE_NAME = 'bf_device_id'
-const COOKIE_MAX_AGE = 60 * 60 * 24 * 365 // 1 year
-
-/**
- * Generate a unique device ID
- * Uses crypto.randomUUID for secure random generation
- */
-function generateDeviceId(): string {
-  return crypto.randomUUID()
-}
-
-/**
- * GET /api/device
- * Returns or creates a unique device ID for the client
- * The device ID is stored in an httpOnly cookie for security
- */
-export async function GET() {
-  const cookieStore = await cookies()
-  let deviceId = cookieStore.get(DEVICE_COOKIE_NAME)?.value
-
-  // Generate new device ID if not exists
-  if (!deviceId) {
-    deviceId = generateDeviceId()
-  }
-
-  // Create response with device ID
-  const response = NextResponse.json({ deviceId })
-
-  // Set/refresh the httpOnly cookie
-  response.cookies.set(DEVICE_COOKIE_NAME, deviceId, {
-    httpOnly: true,
-    secure: process.env.NODE_ENV === 'production',
-    sameSite: 'strict',
-    maxAge: COOKIE_MAX_AGE,
-    path: '/',
-  })
-
-  return response
-}

package/renderer/app/api/docs/route.ts

@@ -1,201 +0,0 @@
-import { NextRequest, NextResponse } from 'next/server'
-import { readFileSync, existsSync } from 'fs'
-import { join, isAbsolute } from 'path'
-import matter from 'gray-matter'
-import { serialize } from 'next-mdx-remote/serialize'
-import remarkGfm from 'remark-gfm'
-import rehypeSlug from 'rehype-slug'
-// Note: rehype-pretty-code is dynamically imported to handle serverless environments
-// where shiki may not be fully available
-import { getProjectFile } from '@/lib/storage/blob'
-
-const STARTER_PATH = process.env.STARTER_PATH || 'devdoc-docs'
-
-// Helper to get content root - supports both relative and absolute paths
-function getContentRoot(): string {
-  if (isAbsolute(STARTER_PATH)) {
-    return STARTER_PATH
-  }
-  return join(process.cwd(), STARTER_PATH)
-}
-
-// Shiki theme options for syntax highlighting
-const prettyCodeOptions = {
-  theme: 'github-dark',
-  keepBackground: true,
-  defaultLang: 'plaintext',
-}
-
-export async function GET(request: NextRequest) {
-  const searchParams = request.nextUrl.searchParams
-  const slug = searchParams.get('slug')
-  const is404Request = searchParams.get('is404') === 'true'
-  
-  if (!slug) {
-    return NextResponse.json(
-      { error: 'Missing slug parameter' },
-      { status: 400 }
-    )
-  }
-  
-  // Check for multi-tenant mode (project slug from middleware)
-  const projectSlug = request.headers.get('x-devdoc-project')
-  
-  // If multi-tenant, fetch from Blob Storage
-  if (projectSlug && !projectSlug.startsWith('custom:')) {
-    return handleMultiTenantDocs(projectSlug, slug, is404Request)
-  }
-  
-  try {
-    const starterDir = getContentRoot()
-    
-    // Try .mdx then .md
-    let fullPath = join(starterDir, `${slug}.mdx`)
-    if (!existsSync(fullPath)) {
-      fullPath = join(starterDir, `${slug}.md`)
-    }
-    
-    if (!existsSync(fullPath)) {
-      // For 404 page requests, return 404 status (not a server error)
-      // The client will handle showing the default 404 if custom doesn't exist
-      return NextResponse.json(
-        { error: 'Page not found' },
-        { status: 404 }
-      )
-    }
-    
-    const fileContent = readFileSync(fullPath, 'utf-8')
-    const { data: frontmatter, content } = matter(fileContent)
-    
-    // Serialize MDX for client-side rendering
-    // Note: rehype-pretty-code is dynamically imported to handle cases where shiki
-    // may not be available in serverless environments
-    let mdxSource
-    try {
-      // Try with syntax highlighting first
-      const rehypePrettyCodeModule = await import('rehype-pretty-code')
-      const rehypePrettyCode = rehypePrettyCodeModule.default
-      
-      mdxSource = await serialize(content, {
-        mdxOptions: {
-          remarkPlugins: [remarkGfm],
-          rehypePlugins: [
-            rehypeSlug,
-            [rehypePrettyCode, prettyCodeOptions],
-          ],
-        },
-        parseFrontmatter: false,
-      })
-    } catch (syntaxError) {
-      // Fallback: serialize without syntax highlighting if shiki is unavailable
-      console.warn('[Docs API] Syntax highlighting unavailable, using fallback:', syntaxError)
-      mdxSource = await serialize(content, {
-        mdxOptions: {
-          remarkPlugins: [remarkGfm],
-          rehypePlugins: [rehypeSlug],
-        },
-        parseFrontmatter: false,
-      })
-    }
-    
-    return NextResponse.json({
-      slug,
-      frontmatter: {
-        title: frontmatter.title || slug,
-        description: frontmatter.description,
-        icon: frontmatter.icon,
-        // Page mode and layout options
-        mode: frontmatter.mode || 'default',
-        hideHeader: frontmatter.hideHeader || false,
-        fullWidth: frontmatter.fullWidth || false,
-        background: frontmatter.background,
-      },
-      mdxSource,
-      rawContent: content, // Include raw content for changelog version extraction
-    })
-  } catch (error) {
-    console.error('[Docs API] Error loading page:', error)
-    return NextResponse.json(
-      { error: 'Failed to load page', details: error instanceof Error ? error.message : String(error) },
-      { status: 500 }
-    )
-  }
-}
-
-/**
- * Handle multi-tenant docs request - fetch from Blob Storage
- */
-async function handleMultiTenantDocs(projectSlug: string, slug: string, is404Request: boolean = false): Promise<Response> {
-  try {
-    // Try .mdx then .md
-    let fileContent = await getProjectFile(projectSlug, `${slug}.mdx`)
-    if (!fileContent) {
-      fileContent = await getProjectFile(projectSlug, `${slug}.md`)
-    }
-    
-    if (!fileContent) {
-      // For 404 page requests, return 404 status
-      return NextResponse.json(
-        { error: 'Page not found' },
-        { status: 404 }
-      )
-    }
-    
-    const { data: frontmatter, content } = matter(fileContent)
-    
-    // Serialize MDX for client-side rendering
-    // Note: rehype-pretty-code is dynamically imported to handle cases where shiki
-    // may not be available in serverless environments
-    let mdxSource
-    try {
-      // Try with syntax highlighting first
-      const rehypePrettyCodeModule = await import('rehype-pretty-code')
-      const rehypePrettyCode = rehypePrettyCodeModule.default
-      
-      mdxSource = await serialize(content, {
-        mdxOptions: {
-          remarkPlugins: [remarkGfm],
-          rehypePlugins: [
-            rehypeSlug,
-            [rehypePrettyCode, prettyCodeOptions],
-          ],
-        },
-        parseFrontmatter: false,
-      })
-    } catch (syntaxError) {
-      // Fallback: serialize without syntax highlighting if shiki is unavailable
-      console.warn('[Docs API] Multi-tenant syntax highlighting unavailable:', syntaxError)
-      mdxSource = await serialize(content, {
-        mdxOptions: {
-          remarkPlugins: [remarkGfm],
-          rehypePlugins: [rehypeSlug],
-        },
-        parseFrontmatter: false,
-      })
-    }
-    
-    return NextResponse.json({
-      slug,
-      frontmatter: {
-        title: frontmatter.title || slug,
-        description: frontmatter.description,
-        icon: frontmatter.icon,
-        // Page mode and layout options
-        mode: frontmatter.mode || 'default',
-        hideHeader: frontmatter.hideHeader || false,
-        fullWidth: frontmatter.fullWidth || false,
-        background: frontmatter.background,
-      },
-      mdxSource,
-      rawContent: content,
-      isMultiTenant: true,
-      projectSlug,
-    })
-  } catch (error) {
-    console.error('[Docs API] Multi-tenant error:', error)
-    return NextResponse.json(
-      { error: 'Failed to load page', details: error instanceof Error ? error.message : String(error) },
-      { status: 500 }
-    )
-  }
-}

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

@@ -1,132 +0,0 @@
-import { NextRequest, NextResponse } from 'next/server'
-import { 
-  validateApiKey,
-  addCustomDomain,
-  isCustomDomainRegistered,
-} from '@/lib/storage/blob'
-import { isValidDomain, normalizeDomain, getDnsInstructions } from '@/lib/docs/config'
-
-/**
- * POST /api/domains/add
- * 
- * Add a custom domain to a project.
- * Each project can have ONE custom domain (free).
- * 
- * Headers:
- *   Authorization: Bearer <api_key>
- * 
- * Body:
- *   { customDomain: "docs.example.com" }
- * 
- * Response:
- *   {
- *     success: true,
- *     domain: "docs.example.com",
- *     status: "pending",
- *     verification: {
- *       cname: { name: "docs", value: "cname.devdoc-dns.com" },
- *       txt: { name: "_devdoc-verify.docs.example.com", value: "devdoc-verify=xxx" }
- *     }
- *   }
- */
-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()
-    const { customDomain: rawDomain } = body
-    
-    if (!rawDomain || typeof rawDomain !== 'string') {
-      return NextResponse.json(
-        { error: 'Missing customDomain in request body' },
-        { status: 400 }
-      )
-    }
-    
-    // Normalize and validate domain
-    const customDomain = normalizeDomain(rawDomain)
-    const validation = isValidDomain(customDomain)
-    
-    if (!validation.valid) {
-      return NextResponse.json(
-        { error: validation.error },
-        { status: 400 }
-      )
-    }
-    
-    // Check if domain is already registered
-    const isRegistered = await isCustomDomainRegistered(customDomain)
-    if (isRegistered) {
-      return NextResponse.json(
-        { error: `Domain ${customDomain} is already registered to another project.` },
-        { status: 409 }
-      )
-    }
-    
-    // Add the custom domain
-    const result = await addCustomDomain(projectSlug, customDomain)
-    
-    if (!result.success) {
-      return NextResponse.json(
-        { error: result.error },
-        { status: 400 }
-      )
-    }
-    
-    // Get DNS instructions
-    const dnsInstructions = getDnsInstructions(customDomain)
-    
-    // Add verification token to TXT record
-    dnsInstructions.txt.value = result.entry!.verificationToken || ''
-    
-    return NextResponse.json({
-      success: true,
-      domain: customDomain,
-      projectSlug,
-      status: result.entry!.status,
-      verification: {
-        cname: dnsInstructions.cname,
-        txt: dnsInstructions.txt,
-      },
-      instructions: [
-        'Add the following DNS records to your domain:',
-        '',
-        `1. CNAME Record:`,
-        `   Name: ${dnsInstructions.cname.name}`,
-        `   Value: ${dnsInstructions.cname.value}`,
-        '',
-        `2. TXT Record (for verification):`,
-        `   Name: ${dnsInstructions.txt.name}`,
-        `   Value: ${dnsInstructions.txt.value}`,
-        '',
-        'After adding DNS records, run "devdoc domain verify" to verify.',
-      ],
-    })
-    
-  } catch (error) {
-    console.error('[Domains API] Error adding domain:', error)
-    const message = error instanceof Error ? error.message : String(error)
-    return NextResponse.json(
-      { error: 'Failed to add domain', details: message },
-      { status: 500 }
-    )
-  }
-}

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

@@ -1,43 +0,0 @@
-import { NextRequest, NextResponse } from 'next/server'
-import { lookupCustomDomain } from '@/lib/storage/blob'
-
-/**
- * GET /api/domains/lookup
- * 
- * Internal API for middleware to look up custom domains.
- * Returns the project slug for an active custom domain.
- * 
- * Query:
- *   ?domain=docs.example.com
- * 
- * Response:
- *   { found: true, projectSlug: "my-project" }
- *   or
- *   { found: false }
- */
-export async function GET(request: NextRequest) {
-  try {
-    const { searchParams } = new URL(request.url)
-    const domain = searchParams.get('domain')
-    
-    if (!domain) {
-      return NextResponse.json({ found: false, error: 'Missing domain parameter' })
-    }
-    
-    const entry = await lookupCustomDomain(domain)
-    
-    if (entry) {
-      return NextResponse.json({
-        found: true,
-        projectSlug: entry.projectSlug,
-        status: entry.status,
-      })
-    }
-    
-    return NextResponse.json({ found: false })
-    
-  } catch (error) {
-    console.error('[Domains Lookup] Error:', error)
-    return NextResponse.json({ found: false })
-  }
-}