@brainfish-ai/devdoc 0.1.21

package/renderer/app/api/proxy-stream/route.ts

@@ -0,0 +1,168 @@
+/**
+ * Streaming Proxy Route
+ * 
+ * Forwards requests and streams responses back for SSE endpoints.
+ * Auto-detects SSE based on response content-type.
+ */
+
+import { NextRequest } from 'next/server'
+
+// Headers that should not be forwarded
+const EXCLUDED_REQUEST_HEADERS = [
+  'host',
+  'connection',
+  'content-length',
+  'transfer-encoding',
+  'keep-alive',
+  'upgrade',
+  'proxy-connection',
+  'proxy-authorization',
+]
+
+export async function POST(request: NextRequest) {
+  const startTime = Date.now()
+  
+  try {
+    const body = await request.json()
+    
+    const { url, method, headers, requestBody } = body as {
+      url: string
+      method: string
+      headers: Record<string, string>
+      requestBody?: string | null
+    }
+
+    if (!url) {
+      return new Response(
+        JSON.stringify({ error: 'URL is required' }),
+        { status: 400, headers: { 'Content-Type': 'application/json' } }
+      )
+    }
+
+    // Validate URL
+    const parsedUrl = new URL(url)
+    const allowedProtocols = ['http:', 'https:']
+    if (!allowedProtocols.includes(parsedUrl.protocol)) {
+      return new Response(
+        JSON.stringify({ error: 'Invalid URL protocol' }),
+        { status: 400, headers: { 'Content-Type': 'application/json' } }
+      )
+    }
+
+    // Build headers for the proxied request
+    const proxyHeaders: Record<string, string> = {}
+    for (const [key, value] of Object.entries(headers || {})) {
+      if (!EXCLUDED_REQUEST_HEADERS.includes(key.toLowerCase())) {
+        proxyHeaders[key] = value
+      }
+    }
+
+    // Make the proxied request
+    const response = await fetch(url, {
+      method: method || 'GET',
+      headers: proxyHeaders,
+      body: requestBody || undefined,
+    })
+
+    const contentType = response.headers.get('content-type') || ''
+    
+    // Check if this is a streaming response (SSE or similar)
+    const isStreaming = 
+      contentType.includes('text/event-stream') ||
+      contentType.includes('application/x-ndjson') ||
+      contentType.includes('application/stream+json')
+    
+    if (isStreaming && response.body) {
+      // For streaming responses, wrap in our SSE format
+      const encoder = new TextEncoder()
+      
+      // Send metadata first, then stream chunks
+      const stream = new ReadableStream({
+        async start(controller) {
+          // Send metadata
+          const metadata = {
+            type: 'metadata',
+            status: response.status,
+            statusText: response.statusText,
+            headers: Object.fromEntries(response.headers.entries()),
+            contentType,
+          }
+          controller.enqueue(encoder.encode(`data: ${JSON.stringify(metadata)}\n\n`))
+          
+          const reader = response.body!.getReader()
+          const decoder = new TextDecoder()
+          let totalSize = 0
+          
+          try {
+            while (true) {
+              const { done, value } = await reader.read()
+              
+              if (done) {
+                controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'done', totalSize })}\n\n`))
+                controller.close()
+                break
+              }
+              
+              const chunk = decoder.decode(value, { stream: true })
+              totalSize += value.length
+              
+              // Send chunk
+              const chunkEvent = {
+                type: 'chunk',
+                data: chunk,
+                size: value.length,
+              }
+              controller.enqueue(encoder.encode(`data: ${JSON.stringify(chunkEvent)}\n\n`))
+            }
+          } catch (error) {
+            const errorEvent = {
+              type: 'error',
+              error: error instanceof Error ? error.message : 'Stream error',
+            }
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify(errorEvent)}\n\n`))
+            controller.close()
+          }
+        },
+      })
+
+      return new Response(stream, {
+        headers: {
+          'Content-Type': 'text/event-stream',
+          'Cache-Control': 'no-cache',
+          'Connection': 'keep-alive',
+        },
+      })
+    }
+
+    // For non-streaming responses, return as JSON
+    const responseBody = await response.text()
+    const responseHeaders: Record<string, string> = {}
+    response.headers.forEach((value, key) => {
+      responseHeaders[key] = value
+    })
+
+    return new Response(
+      JSON.stringify({
+        status: response.status,
+        statusText: response.statusText,
+        headers: responseHeaders,
+        body: responseBody,
+        size: new Blob([responseBody]).size,
+        responseTime: Date.now() - startTime,
+        isStreaming: false,
+      }),
+      {
+        headers: { 'Content-Type': 'application/json' },
+      }
+    )
+  } catch (error) {
+    return new Response(
+      JSON.stringify({
+        status: 0,
+        statusText: 'Proxy Error',
+        error: error instanceof Error ? error.message : 'Proxy request failed',
+      }),
+      { status: 500, headers: { 'Content-Type': 'application/json' } }
+    )
+  }
+}

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

@@ -0,0 +1,47 @@
+import { NextResponse } from 'next/server'
+import { readFileSync, existsSync } from 'fs'
+import { join, isAbsolute } from 'path'
+
+// Configuration
+const STARTER_PATH = process.env.STARTER_PATH || 'devdoc-docs'
+
+// Helper to resolve paths - supports both relative and absolute STARTER_PATH
+function resolvePath(...paths: string[]): string {
+  if (isAbsolute(STARTER_PATH)) {
+    return join(STARTER_PATH, ...paths)
+  }
+  return join(process.cwd(), STARTER_PATH, ...paths)
+}
+
+interface RedirectConfig {
+  source: string
+  destination: string
+}
+
+interface DocsConfig {
+  redirects?: RedirectConfig[]
+}
+
+/**
+ * GET /api/redirects
+ * Returns the redirect configuration from docs.json
+ */
+export async function GET() {
+  try {
+    const docsJsonPath = resolvePath('docs.json')
+    
+    if (!existsSync(docsJsonPath)) {
+      return NextResponse.json({ redirects: [] })
+    }
+    
+    const docsJsonContent = readFileSync(docsJsonPath, 'utf-8')
+    const docsConfig: DocsConfig = JSON.parse(docsJsonContent)
+    
+    return NextResponse.json({
+      redirects: docsConfig.redirects || []
+    })
+  } catch (error) {
+    console.error('[Redirects API] Error:', error)
+    return NextResponse.json({ redirects: [] })
+  }
+}

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

@@ -0,0 +1,65 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { readFileSync, existsSync } from 'fs'
+import { join } from 'path'
+import { getProjectContent } from '@/lib/storage/blob'
+
+// Get the docs directory
+function getDocsDir(): string {
+  const projectSlug = process.env.BRAINFISH_PROJECT_SLUG
+  if (projectSlug) {
+    return join(process.cwd(), '.devdoc', projectSlug)
+  }
+  return join(process.cwd(), 'devdoc-docs')
+}
+
+export async function GET(request: NextRequest) {
+  const searchParams = request.nextUrl.searchParams
+  const path = searchParams.get('path')
+  
+  if (!path) {
+    return NextResponse.json({ error: 'Missing path parameter' }, { status: 400 })
+  }
+  
+  // Security: Only allow .graphql, .gql files
+  if (!path.endsWith('.graphql') && !path.endsWith('.gql')) {
+    return NextResponse.json({ error: 'Invalid file type' }, { status: 400 })
+  }
+  
+  // Security: Prevent path traversal
+  if (path.includes('..')) {
+    return NextResponse.json({ error: 'Invalid path' }, { status: 400 })
+  }
+  
+  try {
+    // Try blob storage first (for deployed projects)
+    const projectSlug = process.env.BRAINFISH_PROJECT_SLUG
+    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, {
+            headers: { 'Content-Type': 'text/plain' }
+          })
+        }
+      }
+    }
+    
+    // Try local filesystem
+    const docsDir = getDocsDir()
+    const fullPath = join(docsDir, path)
+    
+    if (!existsSync(fullPath)) {
+      return NextResponse.json({ error: 'Schema file not found' }, { status: 404 })
+    }
+    
+    const content = readFileSync(fullPath, 'utf-8')
+    
+    return new NextResponse(content, {
+      headers: { 'Content-Type': 'text/plain' }
+    })
+  } catch (error) {
+    console.error('[Schema API] Error:', error)
+    return NextResponse.json({ error: 'Failed to read schema' }, { status: 500 })
+  }
+}

package/renderer/app/api/subdomains/check/route.ts

@@ -0,0 +1,172 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { isSubdomainRegistered } from '@/lib/storage/blob'
+
+// Reserved/blacklisted subdomains
+const BLACKLISTED_SUBDOMAINS = new Set([
+  // Generic reserved
+  'www',
+  'api',
+  'app',
+  'admin',
+  'dashboard',
+  'console',
+  'panel',
+  'manage',
+  'login',
+  'signin',
+  'signup',
+  'register',
+  'auth',
+  'oauth',
+  'sso',
+  // Brand/product
+  'devdoc',
+  'brainfish',
+  'docs',
+  'documentation',
+  'help',
+  'support',
+  'status',
+  'blog',
+  'news',
+  // Infrastructure
+  'mail',
+  'email',
+  'smtp',
+  'ftp',
+  'cdn',
+  'static',
+  'assets',
+  'images',
+  'files',
+  'media',
+  'download',
+  'downloads',
+  // Common
+  'test',
+  'testing',
+  'dev',
+  'development',
+  'staging',
+  'prod',
+  'production',
+  'demo',
+  'example',
+  'sandbox',
+  'preview',
+  // Security
+  'secure',
+  'ssl',
+  'security',
+  'abuse',
+  'spam',
+  'postmaster',
+  'hostmaster',
+  'webmaster',
+  // Misc
+  'null',
+  'undefined',
+  'true',
+  'false',
+  'root',
+  'system',
+  'localhost',
+])
+
+interface CheckRequest {
+  subdomain: string
+}
+
+/**
+ * POST /api/subdomains/check
+ * Check if a subdomain is available
+ * 
+ * Body:
+ *   subdomain: string - The subdomain to check
+ * 
+ * Returns:
+ *   available: boolean
+ *   error?: string - If not available, why
+ *   suggestion?: string - Alternative suggestion
+ */
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json() as CheckRequest
+    const { subdomain } = body
+    
+    if (!subdomain) {
+      return NextResponse.json(
+        { available: false, error: 'Subdomain is required' },
+        { status: 400 }
+      )
+    }
+    
+    // Normalize subdomain
+    const normalized = subdomain.toLowerCase().trim()
+    
+    // Format validation
+    if (normalized.length < 3) {
+      return NextResponse.json({
+        available: false,
+        error: 'Subdomain must be at least 3 characters',
+      })
+    }
+    
+    if (normalized.length > 63) {
+      return NextResponse.json({
+        available: false,
+        error: 'Subdomain must be 63 characters or less',
+      })
+    }
+    
+    if (!/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/.test(normalized)) {
+      return NextResponse.json({
+        available: false,
+        error: 'Subdomain must start and end with alphanumeric characters, and can only contain lowercase letters, numbers, and hyphens',
+      })
+    }
+    
+    if (/--/.test(normalized)) {
+      return NextResponse.json({
+        available: false,
+        error: 'Subdomain cannot contain consecutive hyphens',
+      })
+    }
+    
+    // Check blacklist
+    if (BLACKLISTED_SUBDOMAINS.has(normalized)) {
+      // Generate suggestion
+      const suggestion = `${normalized}-docs`
+      return NextResponse.json({
+        available: false,
+        error: `"${normalized}" is a reserved subdomain`,
+        suggestion,
+      })
+    }
+    
+    // Check if subdomain is already registered (O(1) lookup from registry)
+    const exists = await isSubdomainRegistered(normalized)
+    
+    if (exists) {
+      // Generate suggestion with random suffix
+      const suffix = Math.random().toString(36).substring(2, 6)
+      const suggestion = `${normalized}-${suffix}`
+      return NextResponse.json({
+        available: false,
+        error: `"${normalized}" is already taken`,
+        suggestion,
+      })
+    }
+    
+    return NextResponse.json({
+      available: true,
+    })
+    
+  } catch (error) {
+    console.error('[Subdomains API] Check Error:', error)
+    return NextResponse.json(
+      { available: false, error: 'Internal server error' },
+      { status: 500 }
+    )
+  }
+}

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

@@ -0,0 +1,144 @@
+import { generateObject } from 'ai'
+import { anthropic } from '@ai-sdk/anthropic'
+import { z } from 'zod'
+import type { EndpointIndex } from '@/lib/api-docs/agent/types'
+
+export const runtime = 'nodejs'
+
+// In-memory cache for suggestions (persists across requests in the same server instance)
+const suggestionsCache = new Map<string, { suggestions: Suggestion[]; timestamp: number }>()
+const CACHE_TTL = 1000 * 60 * 60 // 1 hour
+
+interface Suggestion {
+  title: string
+  label: string
+  prompt: string
+}
+
+const SuggestionsSchema = z.object({
+  suggestions: z.array(z.object({
+    title: z.string().describe('Short action phrase (2-4 words) like "Find endpoints" or "How do I"'),
+    label: z.string().describe('Completion of the title (2-5 words) like "for user management" or "authenticate?"'),
+    prompt: z.string().describe('Full question the user would ask'),
+  })).length(4),
+})
+
+function buildSuggestionPrompt(endpoints: EndpointIndex[], currentEndpointId?: string): string {
+  const currentEndpoint = currentEndpointId 
+    ? endpoints.find(e => e.id === currentEndpointId)
+    : null
+
+  if (currentEndpoint) {
+    return `You are helping users explore an API. Generate 4 helpful question suggestions for the "${currentEndpoint.name}" endpoint.
+
+Endpoint details:
+- Name: ${currentEndpoint.name}
+- Method: ${currentEndpoint.method}
+- Path: ${currentEndpoint.path}
+- Description: ${currentEndpoint.description || 'No description'}
+- Parameters: ${currentEndpoint.parameters.join(', ') || 'None'}
+- Has request body: ${currentEndpoint.hasBody}
+
+Generate questions that help users:
+1. Understand what this endpoint does
+2. Know what parameters/data to send
+3. See example requests or responses
+4. Understand error handling or edge cases
+
+Make questions specific to this endpoint, not generic.`
+  }
+
+  // General suggestions based on the API
+  const methodCounts = endpoints.reduce((acc, e) => {
+    acc[e.method] = (acc[e.method] || 0) + 1
+    return acc
+  }, {} as Record<string, number>)
+
+  const categories = [...new Set(endpoints.flatMap(e => e.tags))].slice(0, 5)
+  
+  return `You are helping users explore an API documentation. Generate 4 helpful starter question suggestions.
+
+API Overview:
+- Total endpoints: ${endpoints.length}
+- Methods: ${Object.entries(methodCounts).map(([m, c]) => `${m}: ${c}`).join(', ')}
+- Categories: ${categories.join(', ') || 'General'}
+
+Sample endpoints:
+${endpoints.slice(0, 8).map(e => `- ${e.method} ${e.name}: ${e.description || 'No description'}`).join('\n')}
+
+Generate questions that help users:
+1. Find the right endpoint for their use case
+2. Understand authentication/authorization
+3. Explore common operations (create, read, update, delete)
+4. Get started quickly with the API
+
+Make questions specific to this API's capabilities.`
+}
+
+export async function POST(req: Request) {
+  try {
+    const body = await req.json()
+    const { endpointIndex, currentEndpointId } = body as {
+      endpointIndex: EndpointIndex[]
+      currentEndpointId?: string
+    }
+
+    // Create cache key based on endpoint context
+    const cacheKey = currentEndpointId 
+      ? `endpoint:${currentEndpointId}`
+      : `general:${endpointIndex.length}`
+
+    // Check cache
+    const cached = suggestionsCache.get(cacheKey)
+    if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
+      return Response.json({ suggestions: cached.suggestions, cached: true })
+    }
+
+    const apiKey = process.env.ANTHROPIC_API_KEY
+    if (!apiKey) {
+      // Return fallback suggestions if no API key
+      const fallback = currentEndpointId
+        ? [
+            { title: 'What does this', label: 'endpoint do?', prompt: 'What does this endpoint do?' },
+            { title: 'What parameters', label: 'are required?', prompt: 'What parameters are required?' },
+            { title: 'Show me an', label: 'example request', prompt: 'Show me an example request' },
+            { title: 'What are the', label: 'possible responses?', prompt: 'What are the possible responses?' },
+          ]
+        : [
+            { title: 'Find endpoints', label: 'for creating resources', prompt: 'Find endpoints for creating resources' },
+            { title: 'How do I', label: 'authenticate?', prompt: 'How do I authenticate?' },
+            { title: 'What APIs are', label: 'available?', prompt: 'What APIs are available?' },
+            { title: 'Show me', label: 'GET endpoints', prompt: 'Show me all GET endpoints' },
+          ]
+      return Response.json({ suggestions: fallback, cached: false, fallback: true })
+    }
+
+    const prompt = buildSuggestionPrompt(endpointIndex, currentEndpointId)
+
+    const { object } = await generateObject({
+      model: anthropic('claude-sonnet-4-20250514'),
+      schema: SuggestionsSchema,
+      prompt,
+    })
+
+    // Cache the result
+    suggestionsCache.set(cacheKey, {
+      suggestions: object.suggestions,
+      timestamp: Date.now(),
+    })
+
+    return Response.json({ suggestions: object.suggestions, cached: false })
+  } catch (error) {
+    console.error('[Suggestions API] Error:', error)
+    
+    // Return fallback on error
+    const fallback = [
+      { title: 'What APIs are', label: 'available?', prompt: 'What APIs are available?' },
+      { title: 'How do I', label: 'authenticate?', prompt: 'How do I authenticate?' },
+      { title: 'Find endpoints', label: 'for my use case', prompt: 'Help me find the right endpoint' },
+      { title: 'Show me', label: 'examples', prompt: 'Show me some example requests' },
+    ]
+    
+    return Response.json({ suggestions: fallback, cached: false, error: true })
+  }
+}