@brainfish-ai/devdoc 0.1.41 → 0.1.43

package/renderer/lib/utils/icons.js

@@ -0,0 +1,30 @@
+import * as PhosphorIcons from '@phosphor-icons/react';
+/**
+ * Get a Phosphor icon component by its kebab-case name
+ * 
+ * @param iconName - The icon name in kebab-case (e.g., "arrow-right", "github-logo")
+ * @returns The Phosphor icon component or null if not found
+ * 
+ * @example
+ * const Icon = getPhosphorIcon('arrow-right')
+ * if (Icon) {
+ *   return <Icon className="h-5 w-5" weight="bold" />
+ * }
+ */ export function getPhosphorIcon(iconName) {
+    if (!iconName) return null;
+    // Convert kebab-case to PascalCase for Phosphor icons
+    const pascalCase = iconName.split('-').map((part)=>part.charAt(0).toUpperCase() + part.slice(1)).join('');
+    const IconComponent = PhosphorIcons[pascalCase];
+    if (typeof IconComponent === 'function') {
+        return IconComponent;
+    }
+    return null;
+}
+/**
+ * Check if a Phosphor icon exists by name
+ * 
+ * @param iconName - The icon name in kebab-case
+ * @returns true if the icon exists
+ */ export function hasPhosphorIcon(iconName) {
+    return getPhosphorIcon(iconName) !== null;
+}

package/renderer/lib/utils.js

@@ -0,0 +1,5 @@
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+export function cn(...inputs) {
+    return twMerge(clsx(inputs));
+}

package/renderer/next.config.js

@@ -0,0 +1,62 @@
+const nextConfig = {
+    /* config options here */ turbopack: {
+        root: __dirname,
+        resolveAlias: {
+            '@': __dirname
+        }
+    },
+    // Disable compression to allow SSE streaming to work properly
+    // Without this, Next.js buffers responses and sends them all at once
+    compress: false,
+    // Optimize package imports for better tree shaking
+    // Note: modularizeImports for @phosphor-icons/react was removed because
+    // it conflicts with optimizePackageImports and the SSR files use named exports
+    experimental: {
+        optimizePackageImports: [
+            '@phosphor-icons/react',
+            '@radix-ui/react-dialog',
+            '@radix-ui/react-dropdown-menu',
+            '@radix-ui/react-select',
+            '@radix-ui/react-tabs',
+            '@radix-ui/react-tooltip',
+            'motion',
+            'ai',
+            '@ai-sdk/react'
+        ]
+    },
+    // Externalize heavy packages to reduce serverless function size
+    // These packages won't be bundled into each function, reducing the ~250MB limit issue
+    serverExternalPackages: [
+        // Syntax highlighting - shiki bundles ALL language grammars (~30MB+)
+        'shiki',
+        'rehype-pretty-code',
+        // Monaco editor - heavy code editor
+        'monaco-editor',
+        '@monaco-editor/react',
+        // Mermaid - diagram generation library
+        'mermaid',
+        // HTTP snippet generation
+        '@hoppscotch/httpsnippet'
+    ],
+    // Exclude cache and large directories from output file tracing
+    // This prevents webpack cache and other large files from being included in serverless functions
+    outputFileTracingExcludes: {
+        '*': [
+            // Next.js cache directories
+            '.next/cache/**',
+            '.next/cache/webpack/**',
+            // Large node_modules that shouldn't be traced
+            'node_modules/@swc/**',
+            'node_modules/esbuild/**',
+            'node_modules/terser/**',
+            'node_modules/webpack/**',
+            // Note: shiki is NOT excluded because it's needed by /api/docs for syntax highlighting
+            // The dynamic import with fallback in route.ts handles cases where it may be unavailable
+            // Monaco editor assets
+            'node_modules/monaco-editor/**',
+            // TypeScript compiler (not needed at runtime)
+            'node_modules/typescript/**'
+        ]
+    }
+};
+module.exports = nextConfig;

package/renderer/tsconfig.json

@@ -1,7 +1,11 @@
 {
   "compilerOptions": {
     "target": "ES2017",
-    "lib": ["dom", "dom.iterable", "esnext"],
+    "lib": [
+      "dom",
+      "dom.iterable",
+      "esnext"
+    ],
     "allowJs": true,
     "skipLibCheck": true,
     "strict": true,
@@ -20,9 +24,23 @@
     ],
     "baseUrl": ".",
     "paths": {
-      "@/*": ["./*"]
-    }
+      "@/*": [
+        "./*"
+      ]
+    },
+    "checkJs": false
   },
-  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
-  "exclude": ["node_modules", "hoppscotch", "scalar", "assistant-ui", "packages"]
+  "include": [
+    "next-env.d.ts",
+    "**/*.ts",
+    "**/*.tsx",
+    ".next/types/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules",
+    "hoppscotch",
+    "scalar",
+    "assistant-ui",
+    "packages"
+  ]
 }

package/renderer/app/api/assets/[...path]/route.ts

@@ -1,123 +0,0 @@
-import { NextRequest, NextResponse } from 'next/server'
-import { head } from '@vercel/blob'
-import path from 'path'
-import fs from 'fs'
-
-// Check if we're in local development mode
-const IS_LOCAL_DEV = !process.env.BLOB_READ_WRITE_TOKEN
-const LOCAL_STORAGE_DIR = path.join(process.cwd(), '.devdoc-storage')
-
-/**
- * Asset proxy - serves uploaded assets for multi-tenant docs
- * 
- * GET /api/assets/[slug]/[...path]
- * 
- * This allows MDX files to reference assets as:
- *   ![logo](/api/assets/my-project/logo.png)
- * 
- * Or with the middleware rewrite, simply:
- *   ![logo](/logo.png)  -> rewrites to /api/assets/[slug]/logo.png
- */
-export async function GET(
-  request: NextRequest,
-  { params }: { params: Promise<{ path: string[] }> }
-) {
-  try {
-    const { path: pathSegments } = await params
-    
-    if (!pathSegments || pathSegments.length < 2) {
-      return NextResponse.json(
-        { error: 'Invalid asset path' },
-        { status: 400 }
-      )
-    }
-    
-    // First segment is the project slug, rest is the asset path
-    const [slug, ...assetPath] = pathSegments
-    const fileName = assetPath.join('/')
-    
-    if (!slug || !fileName) {
-      return NextResponse.json(
-        { error: 'Missing slug or file path' },
-        { status: 400 }
-      )
-    }
-    
-    // Build blob path
-    const blobPath = `projects/${slug}/assets/${fileName}`
-    
-    if (IS_LOCAL_DEV) {
-      // Local development - serve from filesystem
-      const filePath = path.join(LOCAL_STORAGE_DIR, 'projects', slug, 'assets', fileName)
-      
-      if (!fs.existsSync(filePath)) {
-        return NextResponse.json(
-          { error: 'Asset not found' },
-          { status: 404 }
-        )
-      }
-      
-      const fileBuffer = fs.readFileSync(filePath)
-      const contentType = getContentType(fileName)
-      
-      return new NextResponse(fileBuffer, {
-        status: 200,
-        headers: {
-          'Content-Type': contentType,
-          'Cache-Control': 'public, max-age=31536000, immutable',
-        },
-      })
-    }
-    
-    // Production - fetch from Vercel Blob
-    const blobInfo = await head(blobPath).catch(() => null)
-    
-    if (!blobInfo) {
-      return NextResponse.json(
-        { error: 'Asset not found' },
-        { status: 404 }
-      )
-    }
-    
-    // Redirect to the blob URL (more efficient than proxying)
-    return NextResponse.redirect(blobInfo.url, {
-      status: 302,
-      headers: {
-        'Cache-Control': 'public, max-age=31536000, immutable',
-      },
-    })
-    
-  } catch (error) {
-    console.error('[Asset Proxy] Error:', error)
-    return NextResponse.json(
-      { error: 'Failed to serve asset' },
-      { status: 500 }
-    )
-  }
-}
-
-/**
- * Get content type from file extension
- */
-function getContentType(fileName: string): string {
-  const ext = fileName.split('.').pop()?.toLowerCase()
-  const types: Record<string, string> = {
-    'jpg': 'image/jpeg',
-    'jpeg': 'image/jpeg',
-    'png': 'image/png',
-    'gif': 'image/gif',
-    'webp': 'image/webp',
-    'svg': 'image/svg+xml',
-    'ico': 'image/x-icon',
-    'pdf': 'application/pdf',
-    'mp4': 'video/mp4',
-    'webm': 'video/webm',
-    'mp3': 'audio/mpeg',
-    'wav': 'audio/wav',
-    'woff': 'font/woff',
-    'woff2': 'font/woff2',
-    'ttf': 'font/ttf',
-    'otf': 'font/otf',
-  }
-  return types[ext || ''] || 'application/octet-stream'
-}

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

@@ -1,124 +0,0 @@
-import { NextRequest, NextResponse } from 'next/server'
-import { validateApiKey, listProjectAssets, deleteProjectAsset } from '@/lib/storage/blob'
-
-/**
- * List assets API
- * 
- * GET /api/assets?slug=<project-slug>
- * Headers:
- *   Authorization: Bearer <api_key>
- */
-export async function GET(request: NextRequest) {
-  try {
-    const { searchParams } = new URL(request.url)
-    const slug = searchParams.get('slug')
-    
-    if (!slug) {
-      return NextResponse.json(
-        { error: 'Missing slug parameter' },
-        { status: 400 }
-      )
-    }
-    
-    // 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 }
-      )
-    }
-    
-    const validatedSlug = await validateApiKey(apiKey)
-    if (validatedSlug !== slug) {
-      return NextResponse.json(
-        { error: 'Invalid API key for this project' },
-        { status: 403 }
-      )
-    }
-    
-    const assets = await listProjectAssets(slug)
-    
-    return NextResponse.json({
-      success: true,
-      slug,
-      assets,
-      count: assets.length,
-    })
-    
-  } catch (error) {
-    console.error('[Assets API] Error:', error)
-    const message = error instanceof Error ? error.message : String(error)
-    
-    return NextResponse.json(
-      { error: 'Failed to list assets', details: message },
-      { status: 500 }
-    )
-  }
-}
-
-/**
- * Delete asset API
- * 
- * DELETE /api/assets?slug=<project-slug>&fileName=<file-name>
- * Headers:
- *   Authorization: Bearer <api_key>
- */
-export async function DELETE(request: NextRequest) {
-  try {
-    const { searchParams } = new URL(request.url)
-    const slug = searchParams.get('slug')
-    const fileName = searchParams.get('fileName')
-    
-    if (!slug || !fileName) {
-      return NextResponse.json(
-        { error: 'Missing slug or fileName parameter' },
-        { status: 400 }
-      )
-    }
-    
-    // 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 }
-      )
-    }
-    
-    const validatedSlug = await validateApiKey(apiKey)
-    if (validatedSlug !== slug) {
-      return NextResponse.json(
-        { error: 'Invalid API key for this project' },
-        { status: 403 }
-      )
-    }
-    
-    const deleted = await deleteProjectAsset(slug, fileName)
-    
-    if (!deleted) {
-      return NextResponse.json(
-        { error: 'Asset not found' },
-        { status: 404 }
-      )
-    }
-    
-    return NextResponse.json({
-      success: true,
-      message: `Asset ${fileName} deleted`,
-    })
-    
-  } catch (error) {
-    console.error('[Assets API] Error:', error)
-    const message = error instanceof Error ? error.message : String(error)
-    
-    return NextResponse.json(
-      { error: 'Failed to delete asset', details: message },
-      { status: 500 }
-    )
-  }
-}

package/renderer/app/api/assets/upload/route.ts

@@ -1,177 +0,0 @@
-import { NextRequest, NextResponse } from 'next/server'
-import { put } from '@vercel/blob'
-import { validateApiKey } from '@/lib/storage/blob'
-import path from 'path'
-import fs from 'fs'
-
-// Max file size: 25MB
-const MAX_FILE_SIZE = 25 * 1024 * 1024
-
-// Allowed file types for assets
-const ALLOWED_TYPES = [
-  'image/jpeg',
-  'image/png',
-  'image/gif',
-  'image/webp',
-  'image/svg+xml',
-  'image/x-icon',
-  'image/vnd.microsoft.icon',
-  'application/pdf',
-  'video/mp4',
-  'video/webm',
-  'audio/mpeg',
-  'audio/wav',
-  'font/woff',
-  'font/woff2',
-  'font/ttf',
-  'font/otf',
-  'application/font-woff',
-  'application/font-woff2',
-]
-
-// Check if we're in local development mode
-const IS_LOCAL_DEV = !process.env.BLOB_READ_WRITE_TOKEN
-const LOCAL_STORAGE_DIR = path.join(process.cwd(), '.devdoc-storage')
-
-/**
- * Upload asset API - receives files from CLI and stores in Vercel Blob
- * 
- * POST /api/assets/upload
- * Headers:
- *   Authorization: Bearer <api_key>
- *   Content-Type: multipart/form-data
- * Body: FormData with:
- *   - file: File to upload
- *   - slug: Project slug
- *   - path: Optional path/filename for the asset
- */
-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 validatedSlug = await validateApiKey(apiKey)
-    if (!validatedSlug) {
-      return NextResponse.json(
-        { error: 'Invalid API key' },
-        { status: 403 }
-      )
-    }
-    
-    // Parse multipart form data
-    const formData = await request.formData()
-    const file = formData.get('file') as File | null
-    const slug = formData.get('slug') as string | null
-    const assetPath = formData.get('path') as string | null
-    
-    if (!file) {
-      return NextResponse.json(
-        { error: 'No file provided' },
-        { status: 400 }
-      )
-    }
-    
-    if (!slug) {
-      return NextResponse.json(
-        { error: 'Project slug is required' },
-        { status: 400 }
-      )
-    }
-    
-    // Verify the API key matches the project
-    if (validatedSlug !== slug) {
-      return NextResponse.json(
-        { error: 'API key does not match project' },
-        { status: 403 }
-      )
-    }
-    
-    // Validate file size
-    if (file.size > MAX_FILE_SIZE) {
-      return NextResponse.json(
-        { error: `File size exceeds maximum allowed size of 25MB. Current size: ${(file.size / (1024 * 1024)).toFixed(2)}MB` },
-        { status: 400 }
-      )
-    }
-    
-    // Validate file type
-    const contentType = file.type
-    if (!ALLOWED_TYPES.includes(contentType) && !contentType.startsWith('image/')) {
-      return NextResponse.json(
-        { error: `File type "${contentType}" is not allowed. Allowed types: images, PDFs, videos, audio, and fonts.` },
-        { status: 400 }
-      )
-    }
-    
-    // Generate asset path
-    const fileName = assetPath || file.name
-    const sanitizedFileName = fileName.replace(/[^a-zA-Z0-9._-]/g, '_')
-    const blobPath = `projects/${slug}/assets/${sanitizedFileName}`
-    
-    // Get file buffer
-    const buffer = Buffer.from(await file.arrayBuffer())
-    
-    // Store in local filesystem or Vercel Blob
-    let url: string
-    
-    if (IS_LOCAL_DEV) {
-      // Local development - store in filesystem
-      const assetDir = path.join(LOCAL_STORAGE_DIR, 'projects', slug, 'assets')
-      fs.mkdirSync(assetDir, { recursive: true })
-      
-      const filePath = path.join(assetDir, sanitizedFileName)
-      fs.writeFileSync(filePath, buffer)
-      
-      url = `file://${filePath}`
-    } else {
-      // Production - store in Vercel Blob
-      const blob = await put(blobPath, buffer, {
-        access: 'public',
-        contentType,
-        allowOverwrite: true,
-      })
-      
-      url = blob.url
-    }
-    
-    return NextResponse.json({
-      success: true,
-      url,
-      path: blobPath,
-      fileName: sanitizedFileName,
-      size: file.size,
-      contentType,
-    })
-    
-  } catch (error) {
-    console.error('[Asset Upload API] Error:', error)
-    const message = error instanceof Error ? error.message : String(error)
-    
-    return NextResponse.json(
-      { error: 'Upload failed', details: message },
-      { status: 500 }
-    )
-  }
-}
-
-/**
- * OPTIONS for CORS preflight
- */
-export async function OPTIONS() {
-  return new NextResponse(null, {
-    status: 200,
-    headers: {
-      'Access-Control-Allow-Origin': '*',
-      'Access-Control-Allow-Methods': 'POST, OPTIONS',
-      'Access-Control-Allow-Headers': 'Content-Type, Authorization',
-    },
-  })
-}

package/renderer/app/api/auth-schemes/route.ts

@@ -1,77 +0,0 @@
-/**
- * Auth Schemes API Route
- * 
- * Returns the security schemes defined in the OpenAPI spec
- * so the frontend can suggest the correct auth type
- */
-
-import { NextResponse } from 'next/server'
-import { extractSecuritySchemes, getDefaultAuth } from '@/lib/api-docs/parsers/openapi/extractors/auth'
-import type { OpenAPI } from 'openapi-types'
-
-// Import the same fetch logic as the openapi-spec route
-import { CacheUtils } from '@/lib/cache'
-
-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'
-const CACHE_KEY = `openapi-spec-${BRAINFISH_CATALOG_ID}`
-
-// Fetch the OpenAPI spec directly (same as openapi-spec route)
-async function fetchOpenApiSpec(): Promise<OpenAPI.Document | null> {
-  try {
-    // First try cache
-    const cachedSpec = await CacheUtils.get<OpenAPI.Document>(CACHE_KEY)
-    if (cachedSpec) {
-      return cachedSpec
-    }
-
-    // Fetch from API
-    const url = `${BRAINFISH_API_BASE_URL}/catalogs.openapi-spec`
-    const response = await fetch(url, {
-      method: 'POST',
-      headers: {
-        'Authorization': `Bearer ${BRAINFISH_JWT_TOKEN}`,
-        'Accept': 'application/json',
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify({ catalogId: BRAINFISH_CATALOG_ID }),
-      cache: 'no-store',
-    })
-    
-    if (!response.ok) {
-      return null
-    }
-    
-    return await response.json()
-  } catch {
-    return null
-  }
-}
-
-export async function GET() {
-  try {
-    const spec = await fetchOpenApiSpec()
-    
-    if (!spec) {
-      return NextResponse.json({
-        schemes: [],
-        defaultAuth: null,
-      })
-    }
-
-    const schemes = extractSecuritySchemes(spec)
-    const defaultAuth = getDefaultAuth(spec)
-
-    return NextResponse.json({
-      schemes,
-      defaultAuth,
-    })
-  } catch (error) {
-    return NextResponse.json({
-      schemes: [],
-      defaultAuth: null,
-      error: error instanceof Error ? error.message : 'Unknown error',
-    }, { status: 500 })
-  }
-}