@brainfish-ai/devdoc 0.1.41 → 0.1.43

package/renderer/app/api/debug/route.js

@@ -0,0 +1,47 @@
+import { NextResponse } from 'next/server';
+import { headers } from 'next/headers';
+import { getProjectContent, projectExists } from '@/lib/storage/blob';
+/**
+ * Debug endpoint to check multi-tenant routing
+ * 
+ * GET /api/debug?slug=acme-api-docs-i2rjwv
+ */ export async function GET(request) {
+    const headersList = await headers();
+    const { searchParams } = new URL(request.url);
+    const testSlug = searchParams.get('slug');
+    // Collect all headers
+    const allHeaders = {};
+    headersList.forEach((value, key)=>{
+        allHeaders[key] = value;
+    });
+    // Check for project header
+    const projectSlug = headersList.get('x-devdoc-project');
+    // Test Blob storage if slug provided
+    let blobTest = null;
+    if (testSlug) {
+        try {
+            const exists = await projectExists(testSlug);
+            const content = exists ? await getProjectContent(testSlug) : null;
+            blobTest = {
+                slug: testSlug,
+                exists,
+                hasContent: !!content,
+                filesCount: content?.files?.length || 0,
+                projectName: content?.name || null
+            };
+        } catch (error) {
+            blobTest = {
+                slug: testSlug,
+                error: String(error)
+            };
+        }
+    }
+    return NextResponse.json({
+        timestamp: new Date().toISOString(),
+        host: headersList.get('host'),
+        projectSlug,
+        hasBlobToken: !!process.env.BLOB_READ_WRITE_TOKEN,
+        blobTest,
+        headers: allHeaders
+    });
+}

package/renderer/app/api/deploy/route.js

@@ -0,0 +1,199 @@
+import { NextResponse } from 'next/server';
+import { storeProjectContent, updateProjectContent, projectExists, generateProjectSlug, generateApiKey, storeProjectApiKey, validateApiKey } from '@/lib/storage/blob';
+import { getProjectUrl, isValidSlug } from '@/lib/multi-tenant/context';
+/**
+ * Deploy API - receives content from CLI and stores in Vercel Blob
+ * 
+ * POST /api/deploy
+ * Headers:
+ *   Authorization: Bearer <api_key>  // Required for updates
+ * Body: {
+ *   name: string,           // Project name from docs.json
+ *   slug?: string,          // Optional: existing slug for updates
+ *   docsJson: object,       // The docs.json configuration
+ *   files: Array<{          // MDX and other content files
+ *     path: string,
+ *     content: string
+ *   }>
+ * }
+ */ export async function POST(request) {
+    try {
+        const body = await request.json();
+        // Validate request body
+        const { name, slug: existingSlug, docsJson, files } = body;
+        if (!name || typeof name !== 'string') {
+            return NextResponse.json({
+                error: 'Missing or invalid project name'
+            }, {
+                status: 400
+            });
+        }
+        if (!docsJson || typeof docsJson !== 'object') {
+            return NextResponse.json({
+                error: 'Missing or invalid docs.json configuration'
+            }, {
+                status: 400
+            });
+        }
+        if (!files || !Array.isArray(files)) {
+            return NextResponse.json({
+                error: 'Missing or invalid files array'
+            }, {
+                status: 400
+            });
+        }
+        // Validate files structure
+        const validFiles = [];
+        for (const file of files){
+            if (!file.path || typeof file.path !== 'string') {
+                return NextResponse.json({
+                    error: `Invalid file entry: missing path`
+                }, {
+                    status: 400
+                });
+            }
+            if (typeof file.content !== 'string') {
+                return NextResponse.json({
+                    error: `Invalid file entry for ${file.path}: content must be a string`
+                }, {
+                    status: 400
+                });
+            }
+            validFiles.push({
+                path: file.path,
+                content: file.content
+            });
+        }
+        let slug;
+        let isUpdate = false;
+        let apiKey = null;
+        // Check if this is an update to an existing project
+        if (existingSlug) {
+            if (!isValidSlug(existingSlug)) {
+                return NextResponse.json({
+                    error: 'Invalid project slug format'
+                }, {
+                    status: 400
+                });
+            }
+            const exists = await projectExists(existingSlug);
+            if (!exists) {
+                return NextResponse.json({
+                    error: `Project with slug "${existingSlug}" not found`
+                }, {
+                    status: 404
+                });
+            }
+            // For updates, validate API key
+            const authHeader = request.headers.get('Authorization');
+            const providedKey = authHeader?.replace('Bearer ', '') || body.apiKey;
+            if (!providedKey) {
+                return NextResponse.json({
+                    error: 'API key required for project updates. Provide via Authorization header or apiKey field.'
+                }, {
+                    status: 401
+                });
+            }
+            const validatedSlug = await validateApiKey(providedKey);
+            if (validatedSlug !== existingSlug) {
+                return NextResponse.json({
+                    error: 'Invalid API key for this project'
+                }, {
+                    status: 403
+                });
+            }
+            slug = existingSlug;
+            isUpdate = true;
+        } else {
+            // Generate a new unique slug
+            slug = generateProjectSlug(name);
+            // Ensure it doesn't already exist (very unlikely but possible)
+            let attempts = 0;
+            while(await projectExists(slug) && attempts < 5){
+                slug = generateProjectSlug(name);
+                attempts++;
+            }
+            if (attempts >= 5) {
+                return NextResponse.json({
+                    error: 'Failed to generate unique project slug'
+                }, {
+                    status: 500
+                });
+            }
+            // Generate API key for new project
+            apiKey = generateApiKey();
+        }
+        // Store or update content
+        let result;
+        if (isUpdate) {
+            result = await updateProjectContent(slug, docsJson, validFiles);
+        } else {
+            result = await storeProjectContent(slug, name, docsJson, validFiles);
+            // Store the API key for new projects
+            if (apiKey) {
+                await storeProjectApiKey(slug, apiKey);
+            }
+        }
+        // Build response
+        const projectUrl = getProjectUrl(slug);
+        // For new projects, include the API key in response
+        const response = {
+            success: true,
+            slug,
+            url: projectUrl,
+            blobUrl: result.url,
+            isUpdate,
+            filesCount: validFiles.length
+        };
+        if (apiKey) {
+            response.apiKey = apiKey;
+        }
+        return NextResponse.json(response);
+    } catch (error) {
+        console.error('[Deploy API] Error:', error);
+        const message = error instanceof Error ? error.message : String(error);
+        // Provide clearer error messages for common issues
+        let userMessage = 'Deployment failed';
+        if (message.includes('blob already exists')) {
+            userMessage = 'Storage conflict - please try again';
+        } else if (message.includes('network') || message.includes('fetch')) {
+            userMessage = 'Network error connecting to storage';
+        } else if (message.includes('unauthorized') || message.includes('401')) {
+            userMessage = 'Authentication failed';
+        }
+        return NextResponse.json({
+            error: userMessage,
+            details: message
+        }, {
+            status: 500
+        });
+    }
+}
+/**
+ * GET /api/deploy - Check deployment status or get project info
+ */ export async function GET(request) {
+    const { searchParams } = new URL(request.url);
+    const slug = searchParams.get('slug');
+    if (!slug) {
+        return NextResponse.json({
+            error: 'Missing slug parameter'
+        }, {
+            status: 400
+        });
+    }
+    const exists = await projectExists(slug);
+    if (!exists) {
+        return NextResponse.json({
+            exists: false,
+            slug
+        }, {
+            status: 404
+        });
+    }
+    const projectUrl = getProjectUrl(slug);
+    return NextResponse.json({
+        exists: true,
+        slug,
+        url: projectUrl
+    });
+}

package/renderer/app/api/device/route.js

@@ -0,0 +1,36 @@
+import { NextResponse } from 'next/server';
+import { cookies } from 'next/headers';
+const DEVICE_COOKIE_NAME = 'bf_device_id';
+const COOKIE_MAX_AGE = 60 * 60 * 24 * 365 // 1 year
+;
+/**
+ * Generate a unique device ID
+ * Uses crypto.randomUUID for secure random generation
+ */ function generateDeviceId() {
+    return crypto.randomUUID();
+}
+/**
+ * GET /api/device
+ * Returns or creates a unique device ID for the client
+ * The device ID is stored in an httpOnly cookie for security
+ */ export async function GET() {
+    const cookieStore = await cookies();
+    let deviceId = cookieStore.get(DEVICE_COOKIE_NAME)?.value;
+    // Generate new device ID if not exists
+    if (!deviceId) {
+        deviceId = generateDeviceId();
+    }
+    // Create response with device ID
+    const response = NextResponse.json({
+        deviceId
+    });
+    // Set/refresh the httpOnly cookie
+    response.cookies.set(DEVICE_COOKIE_NAME, deviceId, {
+        httpOnly: true,
+        secure: process.env.NODE_ENV === 'production',
+        sameSite: 'strict',
+        maxAge: COOKIE_MAX_AGE,
+        path: '/'
+    });
+    return response;
+}

package/renderer/app/api/docs/route.js

@@ -0,0 +1,205 @@
+import { NextResponse } from 'next/server';
+import { readFileSync, existsSync } from 'fs';
+import { join, isAbsolute } from 'path';
+import matter from 'gray-matter';
+import { serialize } from 'next-mdx-remote/serialize';
+import remarkGfm from 'remark-gfm';
+import rehypeSlug from 'rehype-slug';
+// Note: rehype-pretty-code is dynamically imported to handle serverless environments
+// where shiki may not be fully available
+import { getProjectFile } from '@/lib/storage/blob';
+const STARTER_PATH = process.env.STARTER_PATH || 'devdoc-docs';
+// Helper to get content root - supports both relative and absolute paths
+function getContentRoot() {
+    if (isAbsolute(STARTER_PATH)) {
+        return STARTER_PATH;
+    }
+    return join(process.cwd(), STARTER_PATH);
+}
+// Shiki theme options for syntax highlighting
+const prettyCodeOptions = {
+    theme: 'github-dark',
+    keepBackground: true,
+    defaultLang: 'plaintext'
+};
+export async function GET(request) {
+    const searchParams = request.nextUrl.searchParams;
+    const slug = searchParams.get('slug');
+    const is404Request = searchParams.get('is404') === 'true';
+    if (!slug) {
+        return NextResponse.json({
+            error: 'Missing slug parameter'
+        }, {
+            status: 400
+        });
+    }
+    // Check for multi-tenant mode (project slug from middleware)
+    const projectSlug = request.headers.get('x-devdoc-project');
+    // If multi-tenant, fetch from Blob Storage
+    if (projectSlug && !projectSlug.startsWith('custom:')) {
+        return handleMultiTenantDocs(projectSlug, slug, is404Request);
+    }
+    try {
+        const starterDir = getContentRoot();
+        // Try .mdx then .md
+        let fullPath = join(starterDir, `${slug}.mdx`);
+        if (!existsSync(fullPath)) {
+            fullPath = join(starterDir, `${slug}.md`);
+        }
+        if (!existsSync(fullPath)) {
+            // For 404 page requests, return 404 status (not a server error)
+            // The client will handle showing the default 404 if custom doesn't exist
+            return NextResponse.json({
+                error: 'Page not found'
+            }, {
+                status: 404
+            });
+        }
+        const fileContent = readFileSync(fullPath, 'utf-8');
+        const { data: frontmatter, content } = matter(fileContent);
+        // Serialize MDX for client-side rendering
+        // Note: rehype-pretty-code is dynamically imported to handle cases where shiki
+        // may not be available in serverless environments
+        let mdxSource;
+        try {
+            // Try with syntax highlighting first
+            const rehypePrettyCodeModule = await import('rehype-pretty-code');
+            const rehypePrettyCode = rehypePrettyCodeModule.default;
+            mdxSource = await serialize(content, {
+                mdxOptions: {
+                    remarkPlugins: [
+                        remarkGfm
+                    ],
+                    rehypePlugins: [
+                        rehypeSlug,
+                        [
+                            rehypePrettyCode,
+                            prettyCodeOptions
+                        ]
+                    ]
+                },
+                parseFrontmatter: false
+            });
+        } catch (syntaxError) {
+            // Fallback: serialize without syntax highlighting if shiki is unavailable
+            console.warn('[Docs API] Syntax highlighting unavailable, using fallback:', syntaxError);
+            mdxSource = await serialize(content, {
+                mdxOptions: {
+                    remarkPlugins: [
+                        remarkGfm
+                    ],
+                    rehypePlugins: [
+                        rehypeSlug
+                    ]
+                },
+                parseFrontmatter: false
+            });
+        }
+        return NextResponse.json({
+            slug,
+            frontmatter: {
+                title: frontmatter.title || slug,
+                description: frontmatter.description,
+                icon: frontmatter.icon,
+                // Page mode and layout options
+                mode: frontmatter.mode || 'default',
+                hideHeader: frontmatter.hideHeader || false,
+                fullWidth: frontmatter.fullWidth || false,
+                background: frontmatter.background
+            },
+            mdxSource,
+            rawContent: content
+        });
+    } catch (error) {
+        console.error('[Docs API] Error loading page:', error);
+        return NextResponse.json({
+            error: 'Failed to load page',
+            details: error instanceof Error ? error.message : String(error)
+        }, {
+            status: 500
+        });
+    }
+}
+/**
+ * Handle multi-tenant docs request - fetch from Blob Storage
+ */ async function handleMultiTenantDocs(projectSlug, slug, is404Request = false) {
+    try {
+        // Try .mdx then .md
+        let fileContent = await getProjectFile(projectSlug, `${slug}.mdx`);
+        if (!fileContent) {
+            fileContent = await getProjectFile(projectSlug, `${slug}.md`);
+        }
+        if (!fileContent) {
+            // For 404 page requests, return 404 status
+            return NextResponse.json({
+                error: 'Page not found'
+            }, {
+                status: 404
+            });
+        }
+        const { data: frontmatter, content } = matter(fileContent);
+        // Serialize MDX for client-side rendering
+        // Note: rehype-pretty-code is dynamically imported to handle cases where shiki
+        // may not be available in serverless environments
+        let mdxSource;
+        try {
+            // Try with syntax highlighting first
+            const rehypePrettyCodeModule = await import('rehype-pretty-code');
+            const rehypePrettyCode = rehypePrettyCodeModule.default;
+            mdxSource = await serialize(content, {
+                mdxOptions: {
+                    remarkPlugins: [
+                        remarkGfm
+                    ],
+                    rehypePlugins: [
+                        rehypeSlug,
+                        [
+                            rehypePrettyCode,
+                            prettyCodeOptions
+                        ]
+                    ]
+                },
+                parseFrontmatter: false
+            });
+        } catch (syntaxError) {
+            // Fallback: serialize without syntax highlighting if shiki is unavailable
+            console.warn('[Docs API] Multi-tenant syntax highlighting unavailable:', syntaxError);
+            mdxSource = await serialize(content, {
+                mdxOptions: {
+                    remarkPlugins: [
+                        remarkGfm
+                    ],
+                    rehypePlugins: [
+                        rehypeSlug
+                    ]
+                },
+                parseFrontmatter: false
+            });
+        }
+        return NextResponse.json({
+            slug,
+            frontmatter: {
+                title: frontmatter.title || slug,
+                description: frontmatter.description,
+                icon: frontmatter.icon,
+                // Page mode and layout options
+                mode: frontmatter.mode || 'default',
+                hideHeader: frontmatter.hideHeader || false,
+                fullWidth: frontmatter.fullWidth || false,
+                background: frontmatter.background
+            },
+            mdxSource,
+            rawContent: content,
+            isMultiTenant: true,
+            projectSlug
+        });
+    } catch (error) {
+        console.error('[Docs API] Multi-tenant error:', error);
+        return NextResponse.json({
+            error: 'Failed to load page',
+            details: error instanceof Error ? error.message : String(error)
+        }, {
+            status: 500
+        });
+    }
+}

package/renderer/app/api/domains/add/route.js

@@ -0,0 +1,121 @@
+import { NextResponse } from 'next/server';
+import { validateApiKey, addCustomDomain, isCustomDomainRegistered } from '@/lib/storage/blob';
+import { isValidDomain, normalizeDomain, getDnsInstructions } from '@/lib/docs/config';
+/**
+ * POST /api/domains/add
+ * 
+ * Add a custom domain to a project.
+ * Each project can have ONE custom domain (free).
+ * 
+ * Headers:
+ *   Authorization: Bearer <api_key>
+ * 
+ * Body:
+ *   { customDomain: "docs.example.com" }
+ * 
+ * Response:
+ *   {
+ *     success: true,
+ *     domain: "docs.example.com",
+ *     status: "pending",
+ *     verification: {
+ *       cname: { name: "docs", value: "cname.devdoc-dns.com" },
+ *       txt: { name: "_devdoc-verify.docs.example.com", value: "devdoc-verify=xxx" }
+ *     }
+ *   }
+ */ 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 projectSlug = await validateApiKey(apiKey);
+        if (!projectSlug) {
+            return NextResponse.json({
+                error: 'Invalid API key'
+            }, {
+                status: 403
+            });
+        }
+        // Parse request body
+        const body = await request.json();
+        const { customDomain: rawDomain } = body;
+        if (!rawDomain || typeof rawDomain !== 'string') {
+            return NextResponse.json({
+                error: 'Missing customDomain in request body'
+            }, {
+                status: 400
+            });
+        }
+        // Normalize and validate domain
+        const customDomain = normalizeDomain(rawDomain);
+        const validation = isValidDomain(customDomain);
+        if (!validation.valid) {
+            return NextResponse.json({
+                error: validation.error
+            }, {
+                status: 400
+            });
+        }
+        // Check if domain is already registered
+        const isRegistered = await isCustomDomainRegistered(customDomain);
+        if (isRegistered) {
+            return NextResponse.json({
+                error: `Domain ${customDomain} is already registered to another project.`
+            }, {
+                status: 409
+            });
+        }
+        // Add the custom domain
+        const result = await addCustomDomain(projectSlug, customDomain);
+        if (!result.success) {
+            return NextResponse.json({
+                error: result.error
+            }, {
+                status: 400
+            });
+        }
+        // Get DNS instructions
+        const dnsInstructions = getDnsInstructions(customDomain);
+        // Add verification token to TXT record
+        dnsInstructions.txt.value = result.entry.verificationToken || '';
+        return NextResponse.json({
+            success: true,
+            domain: customDomain,
+            projectSlug,
+            status: result.entry.status,
+            verification: {
+                cname: dnsInstructions.cname,
+                txt: dnsInstructions.txt
+            },
+            instructions: [
+                'Add the following DNS records to your domain:',
+                '',
+                `1. CNAME Record:`,
+                `   Name: ${dnsInstructions.cname.name}`,
+                `   Value: ${dnsInstructions.cname.value}`,
+                '',
+                `2. TXT Record (for verification):`,
+                `   Name: ${dnsInstructions.txt.name}`,
+                `   Value: ${dnsInstructions.txt.value}`,
+                '',
+                'After adding DNS records, run "devdoc domain verify" to verify.'
+            ]
+        });
+    } catch (error) {
+        console.error('[Domains API] Error adding domain:', error);
+        const message = error instanceof Error ? error.message : String(error);
+        return NextResponse.json({
+            error: 'Failed to add domain',
+            details: message
+        }, {
+            status: 500
+        });
+    }
+}

package/renderer/app/api/domains/lookup/route.js

@@ -0,0 +1,43 @@
+import { NextResponse } from 'next/server';
+import { lookupCustomDomain } from '@/lib/storage/blob';
+/**
+ * GET /api/domains/lookup
+ * 
+ * Internal API for middleware to look up custom domains.
+ * Returns the project slug for an active custom domain.
+ * 
+ * Query:
+ *   ?domain=docs.example.com
+ * 
+ * Response:
+ *   { found: true, projectSlug: "my-project" }
+ *   or
+ *   { found: false }
+ */ export async function GET(request) {
+    try {
+        const { searchParams } = new URL(request.url);
+        const domain = searchParams.get('domain');
+        if (!domain) {
+            return NextResponse.json({
+                found: false,
+                error: 'Missing domain parameter'
+            });
+        }
+        const entry = await lookupCustomDomain(domain);
+        if (entry) {
+            return NextResponse.json({
+                found: true,
+                projectSlug: entry.projectSlug,
+                status: entry.status
+            });
+        }
+        return NextResponse.json({
+            found: false
+        });
+    } catch (error) {
+        console.error('[Domains Lookup] Error:', error);
+        return NextResponse.json({
+            found: false
+        });
+    }
+}