@brainfish-ai/devdoc 0.1.21

package/renderer/app/api/openapi-spec/route.ts

@@ -0,0 +1,151 @@
+import { NextResponse } from 'next/server'
+import { CacheUtils } from '@/lib/cache'
+
+// Configuration - you can set these as environment variables
+const BRAINFISH_API_BASE_URL = process.env.BRAINFISH_API_BASE_URL || 'https://api.brainfish.ai/api'
+const BRAINFISH_CATALOG_ID = process.env.BRAINFISH_CATALOG_ID || 'your_catalog_id_here'
+const BRAINFISH_JWT_TOKEN = process.env.BRAINFISH_JWT_TOKEN || 'your_jwt_token_here'
+
+// Cache configuration
+const CACHE_KEY = `openapi-spec-${BRAINFISH_CATALOG_ID}`
+const CACHE_TTL = 60 * 5 // 5 minutes
+const FALLBACK_CACHE_KEY = `${CACHE_KEY}-fallback`
+
+interface OpenApiSpec {
+  openapi: string;
+  info: {
+    title: string;
+    version: string;
+    description: string;
+  };
+  paths: Record<string, unknown>;
+  servers: Array<{
+    url: string;
+    description: string;
+  }>;
+}
+
+async function fetchOpenApiSpec(): Promise<OpenApiSpec> {
+  // First, try to get from cache
+  const cachedSpec = await CacheUtils.get<OpenApiSpec>(CACHE_KEY)
+  if (cachedSpec) {
+    return cachedSpec
+  }
+
+  // If not in cache, try to fetch from API
+  try {
+    // IMPORTANT: Use dots (.) not slashes (/) - e.g., catalogs.openapi-spec NOT catalogs/openapi-spec
+    const url = `${BRAINFISH_API_BASE_URL}/catalogs.openapi-spec`
+    
+    console.log('[OpenAPI] Fetching from:', url)
+    console.log('[OpenAPI] Request body:', { catalogId: BRAINFISH_CATALOG_ID })
+    
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${BRAINFISH_JWT_TOKEN}`,
+        'Accept': 'application/json',
+        'Content-Type': 'application/json',
+        'User-Agent': 'Brainfish-API-Docs/1.0',
+      },
+      body: JSON.stringify({
+        catalogId: BRAINFISH_CATALOG_ID
+      }),
+      // Ensure fetch doesn't cache
+      cache: 'no-store',
+    })
+
+    console.log('[OpenAPI] Response status:', response.status, response.statusText)
+    console.log('[OpenAPI] Response headers:', Object.fromEntries(response.headers.entries()))
+
+    if (!response.ok) {
+      // Try to get error details from response body
+      let errorBody = ''
+      try {
+        errorBody = await response.text()
+        console.log('[OpenAPI] Error response body:', errorBody)
+      } catch {
+        console.log('[OpenAPI] Could not read error response body')
+      }
+      
+      throw new Error(`Failed to fetch OpenAPI spec: ${response.status} ${response.statusText}${errorBody ? ` - ${errorBody}` : ''}`)
+    }
+
+    const spec = await response.json() as OpenApiSpec
+    
+    // Cache the successful response
+    await CacheUtils.set(CACHE_KEY, spec, CACHE_TTL)
+    // Also store as fallback (with longer TTL)
+    await CacheUtils.set(FALLBACK_CACHE_KEY, spec, 60 * 60 * 24 * 365)
+    return spec
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : 'Unknown error'
+    console.error('[OpenAPI] Error fetching spec:', errorMessage)
+    
+    // Try to get fallback from cache
+    const fallbackSpec = await CacheUtils.get<OpenApiSpec>(FALLBACK_CACHE_KEY)
+    if (fallbackSpec) {
+      console.warn('[OpenAPI] Using fallback cache due to API error')
+      return fallbackSpec
+    }
+    
+    // If no fallback available, return basic spec
+    console.warn('[OpenAPI] No fallback available, using basic spec')
+    return {
+      openapi: '3.0.0',
+      info: {
+        title: 'Brainfish API',
+        version: '1.0.0',
+        description: 'API temporarily unavailable. Please try again later.',
+      },
+      paths: {},
+      servers: [
+        {
+          url: BRAINFISH_API_BASE_URL.replace('/api', ''),
+          description: 'Brainfish API'
+        }
+      ]
+    }
+  }
+}
+
+export async function GET() {
+  try {
+    const spec = await fetchOpenApiSpec()
+    
+    return NextResponse.json(spec, {
+      headers: {
+        'Content-Type': 'application/json',
+        'Cache-Control': 'no-cache, no-store, must-revalidate', // Disable browser caching
+      },
+    })
+  } catch (error) {
+    console.error('[OpenAPI] Unexpected error in endpoint:', error)
+    
+    // As a last resort, try the fallback cache
+    const fallbackSpec = await CacheUtils.get<OpenApiSpec>(FALLBACK_CACHE_KEY)
+    if (fallbackSpec) {
+      console.warn('[OpenAPI] Using fallback cache in error handler')
+      return NextResponse.json(fallbackSpec, {
+        headers: {
+          'Content-Type': 'application/json',
+          'Cache-Control': 'no-cache, no-store, must-revalidate',
+        },
+      })
+    }
+    
+    return NextResponse.json(
+      { 
+        error: 'OpenAPI specification temporarily unavailable',
+        openapi: '3.0.0',
+        info: {
+          title: 'Brainfish API',
+          version: '1.0.0',
+          description: 'Service temporarily unavailable. Please try again later.',
+        },
+        paths: {},
+      },
+      { status: 503 } // Service Unavailable
+    )
+  }
+}

package/renderer/app/api/projects/[slug]/route.ts

@@ -0,0 +1,153 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { 
+  validateApiKey, 
+  getProjectContent, 
+  getProjectApiKey,
+  deleteProject,
+  projectExists 
+} from '@/lib/storage/blob'
+
+interface RouteParams {
+  params: Promise<{ slug: string }>
+}
+
+/**
+ * GET /api/projects/[slug]
+ * Get detailed project information
+ * 
+ * Headers:
+ *   Authorization: Bearer <api_key>
+ */
+export async function GET(request: NextRequest, { params }: RouteParams) {
+  try {
+    const { slug } = await params
+    
+    // Validate API key
+    const authHeader = request.headers.get('Authorization')
+    const apiKey = authHeader?.replace('Bearer ', '')
+    
+    if (!apiKey) {
+      return NextResponse.json(
+        { error: 'API key required' },
+        { status: 401 }
+      )
+    }
+    
+    // Validate the API key belongs to this project
+    const validatedSlug = await validateApiKey(apiKey)
+    
+    if (validatedSlug !== slug) {
+      return NextResponse.json(
+        { error: 'API key does not match this project' },
+        { status: 403 }
+      )
+    }
+    
+    // Get project details
+    const content = await getProjectContent(slug)
+    const keyData = await getProjectApiKey(slug)
+    
+    if (!content) {
+      return NextResponse.json(
+        { error: 'Project not found' },
+        { status: 404 }
+      )
+    }
+    
+    // Parse docs.json
+    let docsConfig: Record<string, unknown> = {}
+    try {
+      docsConfig = JSON.parse(content.docsJson)
+    } catch {
+      // Ignore parse errors
+    }
+    
+    // Build file list (without content for security/size)
+    const files = content.files.map(f => ({
+      path: f.path,
+      size: f.content.length,
+    }))
+    
+    return NextResponse.json({
+      slug: content.slug,
+      name: content.name,
+      url: `https://${slug}.devdoc.sh`,
+      createdAt: content.createdAt,
+      updatedAt: content.updatedAt,
+      lastDeployedAt: keyData?.lastUsedAt || content.updatedAt,
+      filesCount: content.files.length,
+      totalSize: content.files.reduce((sum, f) => sum + f.content.length, 0),
+      files,
+      config: {
+        name: docsConfig.name,
+        favicon: docsConfig.favicon,
+        navigation: docsConfig.navigation ? 'configured' : 'default',
+      },
+    })
+    
+  } catch (error) {
+    console.error('[Projects API] GET Error:', error)
+    return NextResponse.json(
+      { error: 'Internal server error' },
+      { status: 500 }
+    )
+  }
+}
+
+/**
+ * DELETE /api/projects/[slug]
+ * Delete a project and all its content
+ * 
+ * Headers:
+ *   Authorization: Bearer <api_key>
+ */
+export async function DELETE(request: NextRequest, { params }: RouteParams) {
+  try {
+    const { slug } = await params
+    
+    // Validate API key
+    const authHeader = request.headers.get('Authorization')
+    const apiKey = authHeader?.replace('Bearer ', '')
+    
+    if (!apiKey) {
+      return NextResponse.json(
+        { error: 'API key required' },
+        { status: 401 }
+      )
+    }
+    
+    // Validate the API key belongs to this project
+    const validatedSlug = await validateApiKey(apiKey)
+    
+    if (validatedSlug !== slug) {
+      return NextResponse.json(
+        { error: 'API key does not match this project' },
+        { status: 403 }
+      )
+    }
+    
+    // Check project exists
+    const exists = await projectExists(slug)
+    if (!exists) {
+      return NextResponse.json(
+        { error: 'Project not found' },
+        { status: 404 }
+      )
+    }
+    
+    // Delete the project
+    await deleteProject(slug)
+    
+    return NextResponse.json({
+      success: true,
+      message: `Project ${slug} has been deleted`,
+    })
+    
+  } catch (error) {
+    console.error('[Projects API] DELETE Error:', error)
+    return NextResponse.json(
+      { error: 'Internal server error' },
+      { status: 500 }
+    )
+  }
+}

package/renderer/app/api/projects/[slug]/stats/route.ts

@@ -0,0 +1,96 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { 
+  validateApiKey, 
+  getProjectContent,
+  getProjectApiKey,
+} from '@/lib/storage/blob'
+
+interface RouteParams {
+  params: Promise<{ slug: string }>
+}
+
+/**
+ * GET /api/projects/[slug]/stats
+ * Get project statistics
+ * 
+ * Headers:
+ *   Authorization: Bearer <api_key>
+ */
+export async function GET(request: NextRequest, { params }: RouteParams) {
+  try {
+    const { slug } = await params
+    
+    // Validate API key
+    const authHeader = request.headers.get('Authorization')
+    const apiKey = authHeader?.replace('Bearer ', '')
+    
+    if (!apiKey) {
+      return NextResponse.json(
+        { error: 'API key required' },
+        { status: 401 }
+      )
+    }
+    
+    // Validate the API key belongs to this project
+    const validatedSlug = await validateApiKey(apiKey)
+    
+    if (validatedSlug !== slug) {
+      return NextResponse.json(
+        { error: 'API key does not match this project' },
+        { status: 403 }
+      )
+    }
+    
+    // Get project details
+    const content = await getProjectContent(slug)
+    const keyData = await getProjectApiKey(slug)
+    
+    if (!content) {
+      return NextResponse.json(
+        { error: 'Project not found' },
+        { status: 404 }
+      )
+    }
+    
+    // Calculate stats
+    const totalSize = content.files.reduce((sum, f) => sum + f.content.length, 0)
+    const mdxFiles = content.files.filter(f => f.path.endsWith('.mdx') || f.path.endsWith('.md'))
+    const jsonFiles = content.files.filter(f => f.path.endsWith('.json'))
+    const otherFiles = content.files.filter(f => !f.path.endsWith('.mdx') && !f.path.endsWith('.md') && !f.path.endsWith('.json'))
+    
+    // Calculate days since creation
+    const createdDate = new Date(content.createdAt)
+    const now = new Date()
+    const daysSinceCreation = Math.floor((now.getTime() - createdDate.getTime()) / (1000 * 60 * 60 * 24))
+    
+    return NextResponse.json({
+      slug,
+      stats: {
+        totalFiles: content.files.length,
+        mdxPages: mdxFiles.length,
+        configFiles: jsonFiles.length,
+        otherFiles: otherFiles.length,
+        totalSizeBytes: totalSize,
+        totalSizeKB: Math.round(totalSize / 1024 * 10) / 10,
+      },
+      deployment: {
+        createdAt: content.createdAt,
+        updatedAt: content.updatedAt,
+        lastDeployedAt: keyData?.lastUsedAt || content.updatedAt,
+        daysSinceCreation,
+      },
+      // Placeholder for future analytics
+      analytics: {
+        pageViews: 'coming soon',
+        uniqueVisitors: 'coming soon',
+      },
+    })
+    
+  } catch (error) {
+    console.error('[Projects Stats API] Error:', error)
+    return NextResponse.json(
+      { error: 'Internal server error' },
+      { status: 500 }
+    )
+  }
+}

package/renderer/app/api/projects/register/route.ts

@@ -0,0 +1,152 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { 
+  isSubdomainRegistered,
+  registerSubdomain,
+  generateApiKey,
+  storeProjectApiKey,
+} from '@/lib/storage/blob'
+
+// Reserved/blacklisted subdomains (same as in subdomains/check)
+const BLACKLISTED_SUBDOMAINS = new Set([
+  'www', 'api', 'app', 'admin', 'dashboard', 'console', 'panel', 'manage',
+  'login', 'signin', 'signup', 'register', 'auth', 'oauth', 'sso',
+  'devdoc', 'brainfish', 'docs', 'documentation', 'help', 'support', 'status', 'blog', 'news',
+  'mail', 'email', 'smtp', 'ftp', 'cdn', 'static', 'assets', 'images', 'files', 'media', 'download', 'downloads',
+  'test', 'testing', 'dev', 'development', 'staging', 'prod', 'production', 'demo', 'example', 'sandbox', 'preview',
+  'secure', 'ssl', 'security', 'abuse', 'spam', 'postmaster', 'hostmaster', 'webmaster',
+  'null', 'undefined', 'true', 'false', 'root', 'system', 'localhost',
+])
+
+interface RegisterRequest {
+  name: string
+  slug: string
+  subdomain: string
+}
+
+interface RegisterResponse {
+  success: boolean
+  projectId: string
+  slug: string
+  subdomain: string
+  apiKey: string
+  url: string
+}
+
+/**
+ * POST /api/projects/register
+ * Register a new project and generate an API key
+ * 
+ * Body:
+ *   name: string - Project display name
+ *   slug: string - Project slug (URL-safe identifier)
+ *   subdomain: string - Desired subdomain for <subdomain>.devdoc.sh
+ * 
+ * Returns:
+ *   success: boolean
+ *   projectId: string
+ *   slug: string
+ *   subdomain: string
+ *   apiKey: string
+ *   url: string
+ */
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json() as RegisterRequest
+    const { name, slug, subdomain } = body
+    
+    // Validate required fields
+    if (!name || !slug || !subdomain) {
+      return NextResponse.json(
+        { error: 'name, slug, and subdomain are required' },
+        { status: 400 }
+      )
+    }
+    
+    // Normalize subdomain
+    const normalizedSubdomain = subdomain.toLowerCase().trim()
+    
+    // Validate subdomain format
+    if (normalizedSubdomain.length < 3) {
+      return NextResponse.json(
+        { error: 'Subdomain must be at least 3 characters' },
+        { status: 400 }
+      )
+    }
+    
+    if (normalizedSubdomain.length > 63) {
+      return NextResponse.json(
+        { error: 'Subdomain must be 63 characters or less' },
+        { status: 400 }
+      )
+    }
+    
+    if (!/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/.test(normalizedSubdomain)) {
+      return NextResponse.json(
+        { error: 'Subdomain must start and end with alphanumeric characters' },
+        { status: 400 }
+      )
+    }
+    
+    // Check blacklist
+    if (BLACKLISTED_SUBDOMAINS.has(normalizedSubdomain)) {
+      return NextResponse.json(
+        { error: `"${normalizedSubdomain}" is a reserved subdomain` },
+        { status: 400 }
+      )
+    }
+    
+    // Use subdomain as the project identifier (slug)
+    // This ensures subdomain uniqueness = project uniqueness
+    const projectSlug = normalizedSubdomain
+    
+    // Check if subdomain already registered (O(1) lookup from registry)
+    const exists = await isSubdomainRegistered(projectSlug)
+    
+    if (exists) {
+      return NextResponse.json(
+        { error: `Project with subdomain "${normalizedSubdomain}" already exists` },
+        { status: 409 }
+      )
+    }
+    
+    // Generate API key and project ID
+    const apiKey = generateApiKey()
+    const projectId = `proj_${projectSlug}_${Math.random().toString(36).substring(2, 8)}`
+    
+    // Register in domain registry (O(1) lookup for future checks)
+    await registerSubdomain(projectSlug, projectId, name, apiKey)
+    
+    // Also store API key in project folder (for backwards compatibility)
+    await storeProjectApiKey(projectSlug, apiKey)
+    
+    const response: RegisterResponse = {
+      success: true,
+      projectId,
+      slug: projectSlug,
+      subdomain: normalizedSubdomain,
+      apiKey,
+      url: `https://${normalizedSubdomain}.devdoc.sh`,
+    }
+    
+    console.log(`[Projects API] Registered new project: ${projectSlug}`)
+    
+    return NextResponse.json(response, { status: 201 })
+    
+  } catch (error) {
+    console.error('[Projects API] Register Error:', error)
+    const message = error instanceof Error ? error.message : String(error)
+    
+    // Provide clearer error messages for common issues
+    let userMessage = 'Failed to register project'
+    if (message.includes('blob already exists')) {
+      userMessage = 'Project storage conflict. Please try again or use a different subdomain.'
+    } else if (message.includes('network') || message.includes('fetch')) {
+      userMessage = 'Network error connecting to storage service'
+    }
+    
+    return NextResponse.json(
+      { error: userMessage, details: message },
+      { status: 500 }
+    )
+  }
+}

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

@@ -0,0 +1,149 @@
+/**
+ * API Proxy Route
+ * 
+ * Forwards requests to external APIs to bypass CORS restrictions
+ * and ensure auth headers are sent properly.
+ */
+
+import { NextRequest, NextResponse } 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',
+]
+
+const EXCLUDED_RESPONSE_HEADERS = [
+  'transfer-encoding',
+  'connection',
+  'keep-alive',
+  'content-encoding',
+]
+
+export async function POST(request: NextRequest) {
+  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 NextResponse.json(
+        { error: 'URL is required' },
+        { status: 400 }
+      )
+    }
+
+    // Validate URL to prevent SSRF attacks
+    const parsedUrl = new URL(url)
+    const allowedProtocols = ['http:', 'https:']
+    if (!allowedProtocols.includes(parsedUrl.protocol)) {
+      return NextResponse.json(
+        { error: 'Invalid URL protocol' },
+        { status: 400 }
+      )
+    }
+
+    // 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 startTime = Date.now()
+    const response = await fetch(url, {
+      method: method || 'GET',
+      headers: proxyHeaders,
+      body: requestBody || undefined,
+    })
+    const responseTime = Date.now() - startTime
+
+    // Read response body
+    const contentType = response.headers.get('content-type') || ''
+    let responseBody: string | null = null
+    
+    if (contentType.includes('application/json') || contentType.includes('text/')) {
+      responseBody = await response.text()
+    } else {
+      // For binary content, convert to base64
+      const buffer = await response.arrayBuffer()
+      responseBody = Buffer.from(buffer).toString('base64')
+    }
+
+    // Build response headers
+    const responseHeaders: Record<string, string> = {}
+    response.headers.forEach((value, key) => {
+      if (!EXCLUDED_RESPONSE_HEADERS.includes(key.toLowerCase())) {
+        responseHeaders[key] = value
+      }
+    })
+
+    return NextResponse.json({
+      status: response.status,
+      statusText: response.statusText,
+      headers: responseHeaders,
+      body: responseBody,
+      responseTime,
+      size: responseBody ? new Blob([responseBody]).size : 0,
+    })
+  } catch (error) {
+    return NextResponse.json({
+      status: 0,
+      statusText: 'Proxy Error',
+      headers: {},
+      body: null,
+      responseTime: 0,
+      size: 0,
+      error: error instanceof Error ? error.message : 'Proxy request failed',
+    })
+  }
+}
+
+// Also support GET for simple requests
+export async function GET(request: NextRequest) {
+  const url = request.nextUrl.searchParams.get('url')
+  
+  if (!url) {
+    return NextResponse.json(
+      { error: 'URL query parameter is required' },
+      { status: 400 }
+    )
+  }
+
+  try {
+    const parsedUrl = new URL(url)
+    const allowedProtocols = ['http:', 'https:']
+    if (!allowedProtocols.includes(parsedUrl.protocol)) {
+      return NextResponse.json(
+        { error: 'Invalid URL protocol' },
+        { status: 400 }
+      )
+    }
+
+    const response = await fetch(url)
+    const body = await response.text()
+
+    return NextResponse.json({
+      status: response.status,
+      statusText: response.statusText,
+      body,
+    })
+  } catch (error) {
+    return NextResponse.json({
+      error: error instanceof Error ? error.message : 'Request failed',
+    }, { status: 500 })
+  }
+}