@brainfish-ai/devdoc 0.1.21

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

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

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

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

@@ -0,0 +1,187 @@
+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')
+  
+  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)
+  }
+  
+  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)) {
+      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,
+      },
+      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): Promise<Response> {
+  try {
+    // Try .mdx then .md
+    let fileContent = await getProjectFile(projectSlug, `${slug}.mdx`)
+    if (!fileContent) {
+      fileContent = await getProjectFile(projectSlug, `${slug}.md`)
+    }
+    
+    if (!fileContent) {
+      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,
+      },
+      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/keys/regenerate/route.ts

@@ -0,0 +1,80 @@
+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 }
+    )
+  }
+}