@brainfish-ai/devdoc 0.1.41 → 0.1.43

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

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

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

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

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

@@ -1,149 +0,0 @@
-/**
- * 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 })
-  }
-}