@brainfish-ai/devdoc 0.1.21

package/dist/config/index.d.ts

@@ -0,0 +1,80 @@
+export interface DocsConfig {
+    name?: string;
+    logo?: string | {
+        light?: string;
+        dark?: string;
+    };
+    favicon?: string;
+    colors?: {
+        primary?: string;
+        accent?: string;
+    };
+    navigation?: Navigation | NavigationGroup[];
+    tabs?: Tab[];
+    footer?: {
+        links?: Array<{
+            name: string;
+            url: string;
+        }>;
+    };
+    notice?: {
+        content?: string;
+        dismissible?: boolean;
+        background?: string;
+    };
+    redirects?: Array<{
+        source: string;
+        destination: string;
+    }>;
+}
+export interface Navigation {
+    tabs?: NavigationTab[];
+    global?: {
+        anchors?: Array<{
+            anchor: string;
+            href: string;
+            icon?: string;
+        }>;
+    };
+}
+export interface NavigationTab {
+    tab: string;
+    type: 'docs' | 'openapi' | 'changelog';
+    path?: string;
+    groups?: NavigationGroup[];
+    versions?: Array<{
+        version: string;
+        spec: string;
+        default?: boolean;
+    }>;
+}
+export interface NavigationGroup {
+    group: string;
+    icon?: string;
+    pages: Array<string | {
+        page?: string;
+        group?: string;
+        pages?: string[];
+        title?: string;
+    }>;
+}
+export interface Tab {
+    name: string;
+    url: string;
+    openapi?: string;
+}
+/**
+ * Load docs.json configuration from project root
+ */
+export declare function loadConfig(projectRoot: string): Promise<DocsConfig>;
+/**
+ * Validate docs.json configuration
+ */
+export declare function validateConfig(config: DocsConfig): {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Get the content directory from config or default
+ */
+export declare function getContentDir(config: DocsConfig, projectRoot: string): string;

package/dist/config/index.js

@@ -0,0 +1,133 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = loadConfig;
+exports.validateConfig = validateConfig;
+exports.getContentDir = getContentDir;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+/**
+ * Load docs.json configuration from project root
+ */
+async function loadConfig(projectRoot) {
+    const configPath = path_1.default.join(projectRoot, 'docs.json');
+    if (!fs_extra_1.default.existsSync(configPath)) {
+        throw new Error(`docs.json not found at ${configPath}`);
+    }
+    const content = await fs_extra_1.default.readFile(configPath, 'utf-8');
+    try {
+        return JSON.parse(content);
+    }
+    catch (error) {
+        throw new Error(`Invalid JSON in docs.json: ${error.message}`);
+    }
+}
+/**
+ * Validate docs.json configuration
+ */
+function validateConfig(config) {
+    const errors = [];
+    // Check required fields
+    if (!config.name) {
+        errors.push('Missing required field: name');
+    }
+    // Validate navigation - support both old array format and new object format
+    if (config.navigation) {
+        if (Array.isArray(config.navigation)) {
+            // Old format: navigation is an array of groups
+            config.navigation.forEach((group, index) => {
+                if (!group.group) {
+                    errors.push(`navigation[${index}]: missing group name`);
+                }
+                if (!group.pages || !Array.isArray(group.pages)) {
+                    errors.push(`navigation[${index}]: pages must be an array`);
+                }
+            });
+        }
+        else if (typeof config.navigation === 'object') {
+            // New format: navigation is an object with tabs
+            const nav = config.navigation;
+            if (nav.tabs) {
+                if (!Array.isArray(nav.tabs)) {
+                    errors.push('navigation.tabs must be an array');
+                }
+                else {
+                    nav.tabs.forEach((tab, index) => {
+                        if (!tab.tab) {
+                            errors.push(`navigation.tabs[${index}]: missing tab name`);
+                        }
+                        if (!tab.type) {
+                            errors.push(`navigation.tabs[${index}]: missing type`);
+                        }
+                    });
+                }
+            }
+        }
+    }
+    // Validate tabs (legacy format)
+    if (config.tabs) {
+        if (!Array.isArray(config.tabs)) {
+            errors.push('tabs must be an array');
+        }
+        else {
+            config.tabs.forEach((tab, index) => {
+                if (!tab.name) {
+                    errors.push(`tabs[${index}]: missing name`);
+                }
+                if (!tab.url) {
+                    errors.push(`tabs[${index}]: missing url`);
+                }
+            });
+        }
+    }
+    // Validate colors
+    if (config.colors) {
+        if (config.colors.primary && !isValidColor(config.colors.primary)) {
+            errors.push('colors.primary must be a valid color (hex, rgb, or named color)');
+        }
+        if (config.colors.accent && !isValidColor(config.colors.accent)) {
+            errors.push('colors.accent must be a valid color (hex, rgb, or named color)');
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+    };
+}
+/**
+ * Check if a string is a valid color
+ */
+function isValidColor(color) {
+    // Hex colors
+    if (/^#([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$/.test(color)) {
+        return true;
+    }
+    // RGB/RGBA
+    if (/^rgba?\(.+\)$/.test(color)) {
+        return true;
+    }
+    // HSL/HSLA
+    if (/^hsla?\(.+\)$/.test(color)) {
+        return true;
+    }
+    // Named colors (basic check)
+    const namedColors = [
+        'black', 'white', 'red', 'green', 'blue', 'yellow', 'cyan', 'magenta',
+        'gray', 'grey', 'orange', 'purple', 'pink', 'brown',
+    ];
+    if (namedColors.includes(color.toLowerCase())) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Get the content directory from config or default
+ */
+function getContentDir(config, projectRoot) {
+    // For now, content is at the project root
+    // Could be made configurable in the future
+    return projectRoot;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/config/index.ts"],"names":[],"mappings":"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","sourcesContent":["import path from 'path';\nimport fs from 'fs-extra';\n\nexport interface DocsConfig {\n  name?: string;\n  logo?: string | { light?: string; dark?: string };\n  favicon?: string;\n  colors?: {\n    primary?: string;\n    accent?: string;\n  };\n  navigation?: Navigation | NavigationGroup[];\n  tabs?: Tab[];\n  footer?: {\n    links?: Array<{ name: string; url: string }>;\n  };\n  notice?: {\n    content?: string;\n    dismissible?: boolean;\n    background?: string;\n  };\n  redirects?: Array<{\n    source: string;\n    destination: string;\n  }>;\n}\n\n// New navigation structure with tabs\nexport interface Navigation {\n  tabs?: NavigationTab[];\n  global?: {\n    anchors?: Array<{ anchor: string; href: string; icon?: string }>;\n  };\n}\n\nexport interface NavigationTab {\n  tab: string;\n  type: 'docs' | 'openapi' | 'changelog';\n  path?: string;\n  groups?: NavigationGroup[];\n  versions?: Array<{ version: string; spec: string; default?: boolean }>;\n}\n\nexport interface NavigationGroup {\n  group: string;\n  icon?: string;\n  pages: Array<string | { page?: string; group?: string; pages?: string[]; title?: string }>;\n}\n\nexport interface Tab {\n  name: string;\n  url: string;\n  openapi?: string;\n}\n\n/**\n * Load docs.json configuration from project root\n */\nexport async function loadConfig(projectRoot: string): Promise<DocsConfig> {\n  const configPath = path.join(projectRoot, 'docs.json');\n  \n  if (!fs.existsSync(configPath)) {\n    throw new Error(`docs.json not found at ${configPath}`);\n  }\n  \n  const content = await fs.readFile(configPath, 'utf-8');\n  \n  try {\n    return JSON.parse(content);\n  } catch (error: any) {\n    throw new Error(`Invalid JSON in docs.json: ${error.message}`);\n  }\n}\n\n/**\n * Validate docs.json configuration\n */\nexport function validateConfig(config: DocsConfig): { valid: boolean; errors: string[] } {\n  const errors: string[] = [];\n  \n  // Check required fields\n  if (!config.name) {\n    errors.push('Missing required field: name');\n  }\n  \n  // Validate navigation - support both old array format and new object format\n  if (config.navigation) {\n    if (Array.isArray(config.navigation)) {\n      // Old format: navigation is an array of groups\n      config.navigation.forEach((group, index) => {\n        if (!group.group) {\n          errors.push(`navigation[${index}]: missing group name`);\n        }\n        if (!group.pages || !Array.isArray(group.pages)) {\n          errors.push(`navigation[${index}]: pages must be an array`);\n        }\n      });\n    } else if (typeof config.navigation === 'object') {\n      // New format: navigation is an object with tabs\n      const nav = config.navigation as Navigation;\n      if (nav.tabs) {\n        if (!Array.isArray(nav.tabs)) {\n          errors.push('navigation.tabs must be an array');\n        } else {\n          nav.tabs.forEach((tab, index) => {\n            if (!tab.tab) {\n              errors.push(`navigation.tabs[${index}]: missing tab name`);\n            }\n            if (!tab.type) {\n              errors.push(`navigation.tabs[${index}]: missing type`);\n            }\n          });\n        }\n      }\n    }\n  }\n  \n  // Validate tabs (legacy format)\n  if (config.tabs) {\n    if (!Array.isArray(config.tabs)) {\n      errors.push('tabs must be an array');\n    } else {\n      config.tabs.forEach((tab, index) => {\n        if (!tab.name) {\n          errors.push(`tabs[${index}]: missing name`);\n        }\n        if (!tab.url) {\n          errors.push(`tabs[${index}]: missing url`);\n        }\n      });\n    }\n  }\n  \n  // Validate colors\n  if (config.colors) {\n    if (config.colors.primary && !isValidColor(config.colors.primary)) {\n      errors.push('colors.primary must be a valid color (hex, rgb, or named color)');\n    }\n    if (config.colors.accent && !isValidColor(config.colors.accent)) {\n      errors.push('colors.accent must be a valid color (hex, rgb, or named color)');\n    }\n  }\n  \n  return {\n    valid: errors.length === 0,\n    errors,\n  };\n}\n\n/**\n * Check if a string is a valid color\n */\nfunction isValidColor(color: string): boolean {\n  // Hex colors\n  if (/^#([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$/.test(color)) {\n    return true;\n  }\n  \n  // RGB/RGBA\n  if (/^rgba?\\(.+\\)$/.test(color)) {\n    return true;\n  }\n  \n  // HSL/HSLA\n  if (/^hsla?\\(.+\\)$/.test(color)) {\n    return true;\n  }\n  \n  // Named colors (basic check)\n  const namedColors = [\n    'black', 'white', 'red', 'green', 'blue', 'yellow', 'cyan', 'magenta',\n    'gray', 'grey', 'orange', 'purple', 'pink', 'brown',\n  ];\n  if (namedColors.includes(color.toLowerCase())) {\n    return true;\n  }\n  \n  return false;\n}\n\n/**\n * Get the content directory from config or default\n */\nexport function getContentDir(config: DocsConfig, projectRoot: string): string {\n  // For now, content is at the project root\n  // Could be made configurable in the future\n  return projectRoot;\n}\n"]}

package/dist/constants.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Default API URL for DevDoc services
+ * Used for subdomain checks, project registration, deployment, etc.
+ */
+export declare const DEFAULT_API_URL = "https://api.devdoc.sh";
+/**
+ * Default domain suffix for deployed documentation sites
+ */
+export declare const DOCS_DOMAIN_SUFFIX = ".devdoc.sh";

package/dist/constants.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DOCS_DOMAIN_SUFFIX = exports.DEFAULT_API_URL = void 0;
+/**
+ * Default API URL for DevDoc services
+ * Used for subdomain checks, project registration, deployment, etc.
+ */
+exports.DEFAULT_API_URL = 'https://api.devdoc.sh';
+/**
+ * Default domain suffix for deployed documentation sites
+ */
+exports.DOCS_DOMAIN_SUFFIX = '.devdoc.sh';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2NvbnN0YW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQTs7O0dBR0c7QUFDVSxRQUFBLGVBQWUsR0FBRyx1QkFBdUIsQ0FBQTtBQUV0RDs7R0FFRztBQUNVLFFBQUEsa0JBQWtCLEdBQUcsWUFBWSxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBEZWZhdWx0IEFQSSBVUkwgZm9yIERldkRvYyBzZXJ2aWNlc1xuICogVXNlZCBmb3Igc3ViZG9tYWluIGNoZWNrcywgcHJvamVjdCByZWdpc3RyYXRpb24sIGRlcGxveW1lbnQsIGV0Yy5cbiAqL1xuZXhwb3J0IGNvbnN0IERFRkFVTFRfQVBJX1VSTCA9ICdodHRwczovL2FwaS5kZXZkb2Muc2gnXG5cbi8qKlxuICogRGVmYXVsdCBkb21haW4gc3VmZml4IGZvciBkZXBsb3llZCBkb2N1bWVudGF0aW9uIHNpdGVzXG4gKi9cbmV4cG9ydCBjb25zdCBET0NTX0RPTUFJTl9TVUZGSVggPSAnLmRldmRvYy5zaCdcbiJdfQ==

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @brainfish/devdoc
+ *
+ * Documentation framework for developers
+ */
+export { loadConfig, validateConfig } from './config';
+export type { DocsConfig, NavigationGroup, Tab } from './config';

package/dist/index.js

@@ -0,0 +1,12 @@
+"use strict";
+/**
+ * @brainfish/devdoc
+ *
+ * Documentation framework for developers
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateConfig = exports.loadConfig = void 0;
+var config_1 = require("./config");
+Object.defineProperty(exports, "loadConfig", { enumerable: true, get: function () { return config_1.loadConfig; } });
+Object.defineProperty(exports, "validateConfig", { enumerable: true, get: function () { return config_1.validateConfig; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7O0dBSUc7OztBQUVILG1DQUFzRDtBQUE3QyxvR0FBQSxVQUFVLE9BQUE7QUFBRSx3R0FBQSxjQUFjLE9BQUEiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBicmFpbmZpc2gvZGV2ZG9jXG4gKiBcbiAqIERvY3VtZW50YXRpb24gZnJhbWV3b3JrIGZvciBkZXZlbG9wZXJzXG4gKi9cblxuZXhwb3J0IHsgbG9hZENvbmZpZywgdmFsaWRhdGVDb25maWcgfSBmcm9tICcuL2NvbmZpZyc7XG5leHBvcnQgdHlwZSB7IERvY3NDb25maWcsIE5hdmlnYXRpb25Hcm91cCwgVGFiIH0gZnJvbSAnLi9jb25maWcnO1xuIl19

package/dist/utils/logger.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Simple logger utility for CLI output
+ */
+export declare const logger: {
+    info(message: string): void;
+    success(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+    debug(message: string): void;
+    log(message: string): void;
+    newline(): void;
+    cyan(text: string): string;
+    green(text: string): string;
+    yellow(text: string): string;
+    red(text: string): string;
+};

package/dist/utils/logger.js

@@ -0,0 +1,61 @@
+"use strict";
+/**
+ * Simple logger utility for CLI output
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+const colors = {
+    reset: '\x1b[0m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    magenta: '\x1b[35m',
+    cyan: '\x1b[36m',
+    white: '\x1b[37m',
+    gray: '\x1b[90m',
+};
+function formatMessage(color, prefix, message) {
+    return `${color}${prefix}${colors.reset} ${message}`;
+}
+exports.logger = {
+    info(message) {
+        console.log(formatMessage(colors.blue, '○', message));
+    },
+    success(message) {
+        console.log(formatMessage(colors.green, '✓', message));
+    },
+    warn(message) {
+        console.log(formatMessage(colors.yellow, '⚠', message));
+    },
+    error(message) {
+        console.error(formatMessage(colors.red, '✗', message));
+    },
+    debug(message) {
+        if (process.env.DEBUG || process.env.DEVDOC_DEBUG) {
+            console.log(formatMessage(colors.gray, '⋯', message));
+        }
+    },
+    // Plain log without prefix
+    log(message) {
+        console.log(message);
+    },
+    // Empty line
+    newline() {
+        console.log('');
+    },
+    // Color helpers for inline formatting
+    cyan(text) {
+        return `${colors.cyan}${text}${colors.reset}`;
+    },
+    green(text) {
+        return `${colors.green}${text}${colors.reset}`;
+    },
+    yellow(text) {
+        return `${colors.yellow}${text}${colors.reset}`;
+    },
+    red(text) {
+        return `${colors.red}${text}${colors.reset}`;
+    },
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/utils/paths.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Get the renderer directory
+ *
+ * The renderer is bundled with the package at:
+ * - Development: packages/devdoc/renderer (built by scripts/build.js)
+ * - Published: node_modules/@brainfish/devdoc/renderer
+ */
+export declare function getRendererDir(): string | null;
+/**
+ * Check if we're running in development mode (from source)
+ */
+export declare function isDevelopment(): boolean;
+/**
+ * Get the package root directory
+ */
+export declare function getPackageRoot(): string;

package/dist/utils/paths.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRendererDir = getRendererDir;
+exports.isDevelopment = isDevelopment;
+exports.getPackageRoot = getPackageRoot;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+/**
+ * Get the renderer directory
+ *
+ * The renderer is bundled with the package at:
+ * - Development: packages/devdoc/renderer (built by scripts/build.js)
+ * - Published: node_modules/@brainfish/devdoc/renderer
+ */
+function getRendererDir() {
+    // __dirname is dist/utils when compiled
+    const distDir = __dirname;
+    const packageRoot = path_1.default.resolve(distDir, '../..');
+    // Check for bundled renderer
+    const rendererDir = path_1.default.join(packageRoot, 'renderer');
+    if (fs_extra_1.default.existsSync(rendererDir) && fs_extra_1.default.existsSync(path_1.default.join(rendererDir, 'package.json'))) {
+        return rendererDir;
+    }
+    // Development fallback: look for the main app
+    // When developing locally, the renderer might not be built yet
+    const devAppDir = path_1.default.resolve(packageRoot, '../..');
+    if (fs_extra_1.default.existsSync(path_1.default.join(devAppDir, 'app')) && fs_extra_1.default.existsSync(path_1.default.join(devAppDir, 'package.json'))) {
+        return devAppDir;
+    }
+    return null;
+}
+/**
+ * Check if we're running in development mode (from source)
+ */
+function isDevelopment() {
+    const packageRoot = path_1.default.resolve(__dirname, '../..');
+    const rendererDir = path_1.default.join(packageRoot, 'renderer');
+    // If bundled renderer doesn't exist, we're in dev mode
+    return !fs_extra_1.default.existsSync(rendererDir);
+}
+/**
+ * Get the package root directory
+ */
+function getPackageRoot() {
+    return path_1.default.resolve(__dirname, '../..');
+}
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@brainfish-ai/devdoc",
+  "version": "0.1.21",
+  "description": "Documentation framework for developers. Write docs in MDX, preview locally, deploy to Brainfish.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "devdoc": "./bin/devdoc.js"
+  },
+  "scripts": {
+    "build:cli": "tsc",
+    "build:bundle": "node scripts/build.js",
+    "build": "npm run build:cli",
+    "dev": "tsc --watch",
+    "test:dev": "npm run build:cli && cd ../../devdoc-docs && node ../../packages/devdoc/bin/devdoc.js dev",
+    "test:check": "npm run build:cli && cd ../../devdoc-docs && node ../../packages/devdoc/bin/devdoc.js check",
+    "prepublishOnly": "npm run build:bundle"
+  },
+  "keywords": [
+    "documentation",
+    "docs",
+    "mdx",
+    "api-docs",
+    "developer-docs",
+    "cli"
+  ],
+  "author": "Brainfish",
+  "license": "AGPL-3.0",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "commander": "^12.0.0",
+    "fs-extra": "^11.2.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@types/fs-extra": "^11.0.4",
+    "typescript": "^5.0.0"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "renderer",
+    "templates"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/brainfish/devdoc"
+  }
+}

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

@@ -0,0 +1,123 @@
+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'
+}