@brainfish-ai/devdoc 0.1.41 → 0.1.43

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

@@ -0,0 +1,108 @@
+import { 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, { params }) {
+    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) {
+    const ext = fileName.split('.').pop()?.toLowerCase();
+    const types = {
+        '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.js

@@ -0,0 +1,114 @@
+import { 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) {
+    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) {
+    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.js

@@ -0,0 +1,163 @@
+import { 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) {
+    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');
+        const slug = formData.get('slug');
+        const assetPath = formData.get('path');
+        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;
+        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.js

@@ -0,0 +1,58 @@
+/**
+ * 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 { readFileSync, existsSync } from 'fs';
+import { join, isAbsolute } from 'path';
+import { extractSecuritySchemes, getDefaultAuth } from '@/lib/api-docs/parsers/openapi/extractors/auth';
+const STARTER_PATH = process.env.STARTER_PATH || 'devdoc-docs';
+const LOCAL_SPEC_PATH = process.env.LOCAL_SPEC_PATH || `${STARTER_PATH}/api-reference/openapi.json`;
+// Helper to resolve paths
+function resolvePath(...paths) {
+    if (isAbsolute(STARTER_PATH)) {
+        return join(STARTER_PATH, ...paths);
+    }
+    return join(process.cwd(), STARTER_PATH, ...paths);
+}
+// Load OpenAPI spec from local file
+function loadLocalSpec() {
+    try {
+        const relativePath = LOCAL_SPEC_PATH;
+        const fullPath = relativePath.startsWith(STARTER_PATH) || isAbsolute(relativePath) ? isAbsolute(relativePath) ? relativePath : resolvePath(relativePath.replace(STARTER_PATH + '/', '')) : resolvePath(relativePath);
+        if (!existsSync(fullPath)) {
+            return null;
+        }
+        const content = readFileSync(fullPath, 'utf-8');
+        return JSON.parse(content);
+    } catch (error) {
+        console.error('[Auth Schemes] Error loading local spec:', error);
+        return null;
+    }
+}
+export async function GET() {
+    try {
+        const spec = loadLocalSpec();
+        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
+        });
+    }
+}