@brainfish-ai/devdoc 0.1.41 → 0.1.43

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

@@ -0,0 +1,129 @@
+import { NextResponse } from 'next/server';
+import { validateApiKey, getProjectContent, getProjectApiKey, deleteProject, projectExists } from '@/lib/storage/blob';
+/**
+ * GET /api/projects/[slug]
+ * Get detailed project information
+ * 
+ * Headers:
+ *   Authorization: Bearer <api_key>
+ */ export async function GET(request, { params }) {
+    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 = {};
+        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, { params }) {
+    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.js

@@ -0,0 +1,80 @@
+import { NextResponse } from 'next/server';
+import { validateApiKey, getProjectContent, getProjectApiKey } from '@/lib/storage/blob';
+/**
+ * GET /api/projects/[slug]/stats
+ * Get project statistics
+ * 
+ * Headers:
+ *   Authorization: Bearer <api_key>
+ */ export async function GET(request, { params }) {
+    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.js

@@ -0,0 +1,176 @@
+import { 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'
+]);
+/**
+ * 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) {
+    try {
+        const body = await request.json();
+        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 = {
+            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.js

@@ -0,0 +1,139 @@
+/**
+ * API Proxy Route
+ * 
+ * Forwards requests to external APIs to bypass CORS restrictions
+ * and ensure auth headers are sent properly.
+ */ import { 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) {
+    try {
+        const body = await request.json();
+        const { url, method, headers, requestBody } = body;
+        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 = {};
+        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 = 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 = {};
+        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) {
+    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
+        });
+    }
+}

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

@@ -0,0 +1,156 @@
+/**
+ * Streaming Proxy Route
+ * 
+ * Forwards requests and streams responses back for SSE endpoints.
+ * Auto-detects SSE based on response content-type.
+ */ // 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) {
+    const startTime = Date.now();
+    try {
+        const body = await request.json();
+        const { url, method, headers, requestBody } = body;
+        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 = {};
+        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 = {};
+        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'
+            }
+        });
+    }
+}