@brainfish-ai/devdoc 0.1.41 → 0.1.43

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

@@ -0,0 +1,89 @@
+import { NextResponse } from 'next/server';
+import { validateApiKey, getProjectCustomDomain, removeCustomDomain } from '@/lib/storage/blob';
+import { normalizeDomain } from '@/lib/docs/config';
+/**
+ * DELETE /api/domains/remove
+ * 
+ * Remove a custom domain from a project.
+ * 
+ * Headers:
+ *   Authorization: Bearer <api_key>
+ * 
+ * Body:
+ *   { customDomain: "docs.example.com" }  // Optional, removes project's domain if not specified
+ * 
+ * Response:
+ *   {
+ *     success: true,
+ *     message: "Domain docs.example.com removed successfully"
+ *   }
+ */ export async function DELETE(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().catch(()=>({}));
+        let customDomain = body.customDomain ? normalizeDomain(body.customDomain) : null;
+        // If no domain specified, get the project's custom domain
+        if (!customDomain) {
+            const projectDomain = await getProjectCustomDomain(projectSlug);
+            if (!projectDomain) {
+                return NextResponse.json({
+                    error: 'No custom domain configured for this project'
+                }, {
+                    status: 404
+                });
+            }
+            customDomain = projectDomain.customDomain;
+        }
+        // Remove the domain
+        const result = await removeCustomDomain(customDomain, projectSlug);
+        if (!result.success) {
+            return NextResponse.json({
+                error: result.error
+            }, {
+                status: 400
+            });
+        }
+        // TODO: In production, also remove from Vercel via API
+        // await vercelApi.removeDomain(customDomain)
+        return NextResponse.json({
+            success: true,
+            message: `Domain ${customDomain} removed successfully`,
+            domain: customDomain,
+            projectSlug
+        });
+    } catch (error) {
+        console.error('[Domains API] Error removing domain:', error);
+        const message = error instanceof Error ? error.message : String(error);
+        return NextResponse.json({
+            error: 'Failed to remove domain',
+            details: message
+        }, {
+            status: 500
+        });
+    }
+}
+/**
+ * POST /api/domains/remove
+ * 
+ * Alternative method for removing domain (some clients don't support DELETE with body)
+ */ export async function POST(request) {
+    return DELETE(request);
+}

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

@@ -0,0 +1,140 @@
+import { NextResponse } from 'next/server';
+import { validateApiKey, getProjectCustomDomain, getCustomDomainEntry } from '@/lib/storage/blob';
+import { normalizeDomain, getDnsInstructions } from '@/lib/docs/config';
+import { getProjectUrl } from '@/lib/multi-tenant/context';
+/**
+ * GET /api/domains/status
+ * 
+ * Get the status of a custom domain.
+ * 
+ * Headers:
+ *   Authorization: Bearer <api_key>
+ * 
+ * Query:
+ *   ?domain=docs.example.com  // Optional, uses project's domain if not specified
+ * 
+ * Response:
+ *   {
+ *     domain: "docs.example.com",
+ *     status: "active",
+ *     projectSlug: "my-project",
+ *     projectUrl: "https://my-project.devdoc.sh",
+ *     customUrl: "https://docs.example.com",
+ *     createdAt: "2026-01-24T...",
+ *     verifiedAt: "2026-01-24T..."
+ *   }
+ */ export async function GET(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
+            });
+        }
+        // Get domain from query or use project's domain
+        const { searchParams } = new URL(request.url);
+        let customDomain = searchParams.get('domain');
+        if (customDomain) {
+            customDomain = normalizeDomain(customDomain);
+        }
+        let domainEntry;
+        if (customDomain) {
+            // Get specific domain
+            domainEntry = await getCustomDomainEntry(customDomain);
+            if (!domainEntry) {
+                return NextResponse.json({
+                    error: `Domain ${customDomain} not found`
+                }, {
+                    status: 404
+                });
+            }
+            // Verify domain belongs to this project
+            if (domainEntry.projectSlug !== projectSlug) {
+                return NextResponse.json({
+                    error: `Domain ${customDomain} does not belong to this project`
+                }, {
+                    status: 403
+                });
+            }
+        } else {
+            // Get project's custom domain
+            domainEntry = await getProjectCustomDomain(projectSlug);
+            if (!domainEntry) {
+                return NextResponse.json({
+                    hasCustomDomain: false,
+                    projectSlug,
+                    projectUrl: getProjectUrl(projectSlug),
+                    message: 'No custom domain configured. Use /api/domains/add to add one.'
+                });
+            }
+        }
+        // Build response based on status
+        const projectUrl = getProjectUrl(projectSlug);
+        const response = {
+            hasCustomDomain: true,
+            domain: domainEntry.customDomain,
+            status: domainEntry.status,
+            projectSlug,
+            projectUrl,
+            createdAt: domainEntry.createdAt
+        };
+        // Add status-specific information
+        switch(domainEntry.status){
+            case 'pending':
+                {
+                    const dnsInstructions = getDnsInstructions(domainEntry.customDomain);
+                    dnsInstructions.txt.value = domainEntry.verificationToken || '';
+                    response.message = 'Waiting for DNS configuration';
+                    response.dnsRecords = {
+                        cname: dnsInstructions.cname,
+                        txt: dnsInstructions.txt
+                    };
+                    response.nextStep = 'Add the DNS records above, then run "devdoc domain verify"';
+                    break;
+                }
+            case 'dns_verified':
+                response.message = 'DNS verified, SSL certificate provisioning in progress';
+                response.verifiedAt = domainEntry.verifiedAt;
+                response.nextStep = 'SSL certificate should be ready within 1-24 hours';
+                break;
+            case 'ssl_provisioning':
+                response.message = 'SSL certificate being provisioned';
+                response.verifiedAt = domainEntry.verifiedAt;
+                response.nextStep = 'Almost ready! Check back in a few minutes';
+                break;
+            case 'active':
+                response.message = 'Domain is active and working';
+                response.customUrl = `https://${domainEntry.customDomain}`;
+                response.verifiedAt = domainEntry.verifiedAt;
+                break;
+            case 'error':
+                response.message = 'Domain configuration error';
+                response.error = domainEntry.errorMessage;
+                response.nextStep = 'Check DNS configuration and try verifying again';
+                break;
+        }
+        response.lastCheckedAt = domainEntry.lastCheckedAt;
+        return NextResponse.json(response);
+    } catch (error) {
+        console.error('[Domains API] Error getting status:', error);
+        const message = error instanceof Error ? error.message : String(error);
+        return NextResponse.json({
+            error: 'Failed to get domain status',
+            details: message
+        }, {
+            status: 500
+        });
+    }
+}

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

@@ -0,0 +1,168 @@
+import { NextResponse } from 'next/server';
+import { validateApiKey, getProjectCustomDomain, getCustomDomainEntry, updateCustomDomainStatus } from '@/lib/storage/blob';
+import { normalizeDomain } from '@/lib/docs/config';
+import dns from 'dns';
+import { promisify } from 'util';
+const resolveCname = promisify(dns.resolveCname);
+const resolveTxt = promisify(dns.resolveTxt);
+/**
+ * POST /api/domains/verify
+ * 
+ * Verify DNS configuration for a custom domain.
+ * Checks CNAME and TXT records, then triggers SSL provisioning.
+ * 
+ * Headers:
+ *   Authorization: Bearer <api_key>
+ * 
+ * Body:
+ *   { customDomain: "docs.example.com" }  // Optional, uses project's domain if not specified
+ * 
+ * Response:
+ *   {
+ *     success: true,
+ *     domain: "docs.example.com",
+ *     status: "dns_verified",
+ *     checks: {
+ *       cname: { found: true, value: "cname.devdoc-dns.com" },
+ *       txt: { found: true, verified: true }
+ *     }
+ *   }
+ */ 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().catch(()=>({}));
+        let customDomain = body.customDomain ? normalizeDomain(body.customDomain) : null;
+        // If no domain specified, get the project's custom domain
+        if (!customDomain) {
+            const projectDomain = await getProjectCustomDomain(projectSlug);
+            if (!projectDomain) {
+                return NextResponse.json({
+                    error: 'No custom domain configured for this project. Add one first with /api/domains/add'
+                }, {
+                    status: 404
+                });
+            }
+            customDomain = projectDomain.customDomain;
+        }
+        // Get domain entry
+        const domainEntry = await getCustomDomainEntry(customDomain);
+        if (!domainEntry) {
+            return NextResponse.json({
+                error: `Domain ${customDomain} not found`
+            }, {
+                status: 404
+            });
+        }
+        // Verify domain belongs to this project
+        if (domainEntry.projectSlug !== projectSlug) {
+            return NextResponse.json({
+                error: `Domain ${customDomain} does not belong to this project`
+            }, {
+                status: 403
+            });
+        }
+        // Check DNS records
+        const checks = {
+            cname: {
+                found: false,
+                value: null,
+                expected: 'cname.devdoc-dns.com'
+            },
+            txt: {
+                found: false,
+                verified: false,
+                expected: domainEntry.verificationToken
+            }
+        };
+        // Check CNAME record
+        try {
+            const cnameRecords = await resolveCname(customDomain);
+            if (cnameRecords && cnameRecords.length > 0) {
+                checks.cname.found = true;
+                checks.cname.value = cnameRecords[0];
+            }
+        } catch  {
+        // CNAME not found or DNS error
+        }
+        // Check TXT record for verification
+        const txtRecordName = `_devdoc-verify.${customDomain}`;
+        try {
+            const txtRecords = await resolveTxt(txtRecordName);
+            if (txtRecords && txtRecords.length > 0) {
+                checks.txt.found = true;
+                // TXT records can be arrays, flatten and check
+                const allTxtValues = txtRecords.flat();
+                checks.txt.verified = allTxtValues.some((val)=>val === domainEntry.verificationToken);
+            }
+        } catch  {
+        // TXT not found or DNS error
+        }
+        // Determine overall status
+        const cnameValid = checks.cname.found && checks.cname.value?.toLowerCase().includes('devdoc');
+        const txtValid = checks.txt.found && checks.txt.verified;
+        let newStatus = domainEntry.status;
+        let message = '';
+        if (cnameValid && txtValid) {
+            // DNS is verified, update status
+            newStatus = 'dns_verified';
+            message = 'DNS verified! SSL certificate will be provisioned automatically (1-24 hours).';
+            await updateCustomDomainStatus(customDomain, 'dns_verified');
+        // In production, this would trigger Vercel API to add domain
+        // For now, we simulate SSL provisioning by updating status
+        // TODO: Integrate with Vercel Domains API
+        } else if (cnameValid && !txtValid) {
+            message = 'CNAME record found, but TXT verification record is missing or incorrect.';
+        } else if (!cnameValid && txtValid) {
+            message = 'TXT verification found, but CNAME record is missing or incorrect.';
+        } else {
+            message = 'DNS records not found. Please add the required CNAME and TXT records.';
+        }
+        return NextResponse.json({
+            success: cnameValid && txtValid,
+            domain: customDomain,
+            projectSlug,
+            status: newStatus,
+            message,
+            checks: {
+                cname: {
+                    found: checks.cname.found,
+                    value: checks.cname.value,
+                    valid: cnameValid,
+                    expected: checks.cname.expected
+                },
+                txt: {
+                    found: checks.txt.found,
+                    verified: checks.txt.verified,
+                    expected: checks.txt.expected
+                }
+            }
+        });
+    } catch (error) {
+        console.error('[Domains API] Error verifying domain:', error);
+        const message = error instanceof Error ? error.message : String(error);
+        return NextResponse.json({
+            error: 'Failed to verify domain',
+            details: message
+        }, {
+            status: 500
+        });
+    }
+}

package/renderer/app/api/keys/regenerate/route.js

@@ -0,0 +1,71 @@
+import { NextResponse } from 'next/server';
+import { validateApiKey, regenerateApiKey, projectExists } from '@/lib/storage/blob';
+/**
+ * POST /api/keys/regenerate
+ * Regenerate API key for a project
+ * 
+ * Headers:
+ *   Authorization: Bearer <current_api_key>
+ * Body:
+ *   { slug: string }
+ */ export async function POST(request) {
+    try {
+        const body = await request.json();
+        const { slug } = body;
+        if (!slug || typeof slug !== 'string') {
+            return NextResponse.json({
+                error: 'Missing or invalid project slug'
+            }, {
+                status: 400
+            });
+        }
+        // Validate current API key
+        const authHeader = request.headers.get('Authorization');
+        const currentKey = authHeader?.replace('Bearer ', '');
+        if (!currentKey) {
+            return NextResponse.json({
+                error: 'API key required'
+            }, {
+                status: 401
+            });
+        }
+        // Check project exists
+        const exists = await projectExists(slug);
+        if (!exists) {
+            return NextResponse.json({
+                error: 'Project not found'
+            }, {
+                status: 404
+            });
+        }
+        // Validate the provided key belongs to this project
+        const validatedSlug = await validateApiKey(currentKey);
+        if (validatedSlug !== slug) {
+            return NextResponse.json({
+                error: 'Invalid API key for this project'
+            }, {
+                status: 403
+            });
+        }
+        // Regenerate the key
+        const newKey = await regenerateApiKey(slug, currentKey);
+        if (!newKey) {
+            return NextResponse.json({
+                error: 'Failed to regenerate API key'
+            }, {
+                status: 500
+            });
+        }
+        return NextResponse.json({
+            success: true,
+            apiKey: newKey
+        });
+    } catch (error) {
+        console.error('[Keys API] Error:', error);
+        return NextResponse.json({
+            error: 'Internal server error'
+        }, {
+            status: 500
+        });
+    }
+}

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

@@ -0,0 +1,108 @@
+import { NextResponse } from 'next/server';
+import path from 'path';
+import fs from 'fs';
+/**
+ * Local asset server for devdoc dev mode
+ * 
+ * Serves assets from the user's project folder (STARTER_PATH/assets/)
+ * This allows /assets/images/logo.png to work in local development
+ */ export async function GET(request, { params }) {
+    try {
+        const { path: pathSegments } = await params;
+        if (!pathSegments || pathSegments.length === 0) {
+            return NextResponse.json({
+                error: 'Invalid asset path'
+            }, {
+                status: 400
+            });
+        }
+        // Get the project path from environment
+        const projectPath = process.env.STARTER_PATH;
+        if (!projectPath) {
+            return NextResponse.json({
+                error: 'Not in local development mode'
+            }, {
+                status: 404
+            });
+        }
+        // Build file path - assets are in projectPath/assets/
+        const assetPath = pathSegments.join('/');
+        const filePath = path.join(projectPath, 'assets', assetPath);
+        // Security: ensure we're not escaping the assets directory
+        const resolvedPath = path.resolve(filePath);
+        const assetsDir = path.resolve(path.join(projectPath, 'assets'));
+        if (!resolvedPath.startsWith(assetsDir)) {
+            return NextResponse.json({
+                error: 'Invalid path'
+            }, {
+                status: 403
+            });
+        }
+        // Check if file exists
+        if (!fs.existsSync(resolvedPath)) {
+            // Also try without 'assets' prefix (for /assets/images/x.png -> images/x.png)
+            const altPath = path.join(projectPath, assetPath);
+            const resolvedAltPath = path.resolve(altPath);
+            if (resolvedAltPath.startsWith(path.resolve(projectPath)) && fs.existsSync(resolvedAltPath)) {
+                const fileBuffer = fs.readFileSync(resolvedAltPath);
+                const contentType = getContentType(assetPath);
+                return new NextResponse(fileBuffer, {
+                    status: 200,
+                    headers: {
+                        'Content-Type': contentType,
+                        'Cache-Control': 'no-cache'
+                    }
+                });
+            }
+            return NextResponse.json({
+                error: 'Asset not found',
+                path: assetPath
+            }, {
+                status: 404
+            });
+        }
+        const fileBuffer = fs.readFileSync(resolvedPath);
+        const contentType = getContentType(assetPath);
+        return new NextResponse(fileBuffer, {
+            status: 200,
+            headers: {
+                'Content-Type': contentType,
+                'Cache-Control': 'no-cache'
+            }
+        });
+    } catch (error) {
+        console.error('[Local Assets] 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',
+        'json': 'application/json',
+        'css': 'text/css',
+        'js': 'application/javascript'
+    };
+    return types[ext || ''] || 'application/octet-stream';
+}

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

@@ -0,0 +1,73 @@
+/**
+ * OpenAPI Spec API Route
+ * 
+ * Returns the OpenAPI specification from local file
+ */ import { NextResponse } from 'next/server';
+import { readFileSync, existsSync } from 'fs';
+import { join, isAbsolute } from 'path';
+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)) {
+            console.warn('[OpenAPI] Spec file not found:', fullPath);
+            return null;
+        }
+        const content = readFileSync(fullPath, 'utf-8');
+        return JSON.parse(content);
+    } catch (error) {
+        console.error('[OpenAPI] Error loading local spec:', error);
+        return null;
+    }
+}
+export async function GET() {
+    try {
+        const spec = loadLocalSpec();
+        if (!spec) {
+            return NextResponse.json({
+                openapi: '3.0.0',
+                info: {
+                    title: 'API Documentation',
+                    version: '1.0.0',
+                    description: 'OpenAPI specification not found.'
+                },
+                paths: {}
+            }, {
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Cache-Control': 'no-cache, no-store, must-revalidate'
+                }
+            });
+        }
+        return NextResponse.json(spec, {
+            headers: {
+                'Content-Type': 'application/json',
+                'Cache-Control': 'no-cache, no-store, must-revalidate'
+            }
+        });
+    } catch (error) {
+        console.error('[OpenAPI] Unexpected error:', error);
+        return NextResponse.json({
+            openapi: '3.0.0',
+            info: {
+                title: 'API Documentation',
+                version: '1.0.0',
+                description: 'Error loading specification.'
+            },
+            paths: {},
+            error: error instanceof Error ? error.message : 'Unknown error'
+        }, {
+            status: 500
+        });
+    }
+}