@brainfish-ai/devdoc 0.1.21

package/dist/cli/commands/deploy.js

@@ -0,0 +1,433 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deploy = deploy;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const config_1 = require("../../config");
+const logger_1 = require("../../utils/logger");
+const constants_1 = require("../../constants");
+// Max asset size: 25MB
+const MAX_ASSET_SIZE = 25 * 1024 * 1024;
+// Binary asset extensions to upload separately
+const BINARY_EXTENSIONS = [
+    '.png', '.jpg', '.jpeg', '.gif', '.webp', '.ico',
+    '.mp4', '.webm', '.mov',
+    '.mp3', '.wav', '.ogg',
+    '.woff', '.woff2', '.ttf', '.otf', '.eot',
+    '.pdf',
+];
+/**
+ * Deploy documentation to DevDoc platform
+ */
+async function deploy(options) {
+    const projectRoot = process.cwd();
+    const apiUrl = options.url || process.env.DEVDOC_API_URL || constants_1.DEFAULT_API_URL;
+    logger_1.logger.info('Deploying to DevDoc...\n');
+    // Check for docs.json
+    const configPath = path_1.default.join(projectRoot, 'docs.json');
+    if (!fs_extra_1.default.existsSync(configPath)) {
+        logger_1.logger.error('docs.json not found in current directory');
+        logger_1.logger.info('Make sure you are in a DevDoc documentation project directory');
+        process.exit(1);
+    }
+    // Load and validate configuration
+    let config;
+    try {
+        config = await (0, config_1.loadConfig)(projectRoot);
+        const validation = (0, config_1.validateConfig)(config);
+        if (!validation.valid) {
+            logger_1.logger.error('Invalid docs.json configuration:');
+            validation.errors.forEach(err => logger_1.logger.error(`  - ${err}`));
+            process.exit(1);
+        }
+        logger_1.logger.success(`✓ Configuration valid: ${config.name || 'Untitled'}`);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger_1.logger.error(`Failed to load configuration: ${message}`);
+        process.exit(1);
+    }
+    // Check for existing project config
+    const devdocConfigPath = path_1.default.join(projectRoot, '.devdoc.json');
+    let existingSlug = null;
+    let existingApiKey = null;
+    if (fs_extra_1.default.existsSync(devdocConfigPath)) {
+        try {
+            const devdocConfig = fs_extra_1.default.readJsonSync(devdocConfigPath);
+            existingSlug = devdocConfig.slug || null;
+            existingApiKey = devdocConfig.apiKey || null;
+            if (existingSlug) {
+                logger_1.logger.info(`Deploying project: ${existingSlug}`);
+            }
+        }
+        catch {
+            // Ignore errors reading .devdoc.json
+        }
+    }
+    // Get API key from options, env var, or .devdoc.json
+    const apiKey = options.apiKey || process.env.DEVDOC_API_KEY || existingApiKey;
+    // API key is always required for deployment
+    if (!apiKey) {
+        logger_1.logger.error('API key required for deployment.');
+        console.log('');
+        if (!existingSlug) {
+            logger_1.logger.info('Run "devdoc init" first to register your project and get an API key');
+        }
+        else {
+            logger_1.logger.info('Your project is not registered. Run "devdoc init --force" to register and get an API key');
+        }
+        logger_1.logger.info('Or provide via --api-key flag or DEVDOC_API_KEY env var');
+        process.exit(1);
+    }
+    // Collect all content files
+    logger_1.logger.info('Bundling content...');
+    const files = await collectFiles(projectRoot);
+    logger_1.logger.success(`✓ Found ${files.length} content files`);
+    // Collect binary assets
+    const assets = await collectAssets(projectRoot);
+    if (assets.length > 0) {
+        const totalAssetSize = assets.reduce((sum, a) => sum + a.size, 0);
+        logger_1.logger.success(`✓ Found ${assets.length} assets (${formatSize(totalAssetSize)})`);
+    }
+    // Calculate bundle size
+    const totalSize = files.reduce((sum, f) => sum + f.content.length, 0);
+    const sizeKB = (totalSize / 1024).toFixed(1);
+    logger_1.logger.info(`Content bundle: ${sizeKB} KB`);
+    // Upload binary assets first (with progress)
+    if (assets.length > 0 && existingSlug) {
+        console.log('');
+        logger_1.logger.info('Uploading assets...');
+        const assetResults = await uploadAssets(assets, apiUrl, existingSlug, apiKey);
+        const successCount = assetResults.filter(r => r.success).length;
+        const failCount = assetResults.filter(r => !r.success).length;
+        if (failCount > 0) {
+            logger_1.logger.warn(`${successCount} assets uploaded, ${failCount} failed`);
+        }
+        else if (successCount > 0) {
+            logger_1.logger.success(`✓ ${successCount} assets uploaded`);
+        }
+    }
+    else if (assets.length > 0 && !existingSlug) {
+        logger_1.logger.info('Assets will be uploaded on next deploy (after project registration)');
+    }
+    // Deploy content to API
+    console.log('');
+    logger_1.logger.info('Uploading content...');
+    try {
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        // Add API key header for updates
+        if (apiKey) {
+            headers['Authorization'] = `Bearer ${apiKey}`;
+        }
+        const response = await fetch(`${apiUrl}/api/deploy`, {
+            method: 'POST',
+            headers,
+            redirect: 'follow', // Follow redirects
+            body: JSON.stringify({
+                name: config.name || 'My Documentation',
+                slug: existingSlug,
+                docsJson: config,
+                files,
+                apiKey, // Also send in body as fallback
+            }),
+        });
+        if (!response.ok) {
+            const errorData = await response.json().catch(() => ({ error: 'Unknown error' }));
+            const errorMessage = errorData.error || `HTTP ${response.status}`;
+            const details = errorData.details ? `\n   Details: ${errorData.details}` : '';
+            throw new Error(`${errorMessage}${details}`);
+        }
+        const result = await response.json();
+        // Save project config for future updates
+        const newDevDocConfig = {
+            slug: result.slug,
+            url: result.url,
+            lastDeployed: new Date().toISOString(),
+        };
+        // Save API key (from response for new projects, or existing for updates)
+        if (result.apiKey) {
+            newDevDocConfig.apiKey = result.apiKey;
+        }
+        else if (apiKey) {
+            newDevDocConfig.apiKey = apiKey;
+        }
+        fs_extra_1.default.writeJsonSync(devdocConfigPath, newDevDocConfig, { spaces: 2 });
+        // Success message
+        console.log('');
+        logger_1.logger.success('Deployment successful!');
+        console.log('');
+        console.log(`  Your docs are live at:`);
+        console.log(`  ${logger_1.logger.cyan(result.url)}`);
+        console.log('');
+        if (result.isUpdate) {
+            logger_1.logger.info('Project updated with new content');
+        }
+        else {
+            logger_1.logger.info(`Project slug: ${result.slug}`);
+            logger_1.logger.info('Run "devdoc deploy" again to update');
+            // Show API key warning for new projects
+            if (result.apiKey) {
+                console.log('');
+                logger_1.logger.warn('⚠️  Save your API key for CI/CD deployments:');
+                console.log(`    ${result.apiKey}`);
+                console.log('');
+                logger_1.logger.info('API key saved to .devdoc.json (add to .gitignore!)');
+            }
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger_1.logger.error(`Deployment failed: ${message}`);
+        process.exit(1);
+    }
+}
+/**
+ * Collect all MDX and content files from the project
+ */
+async function collectFiles(projectRoot) {
+    const files = [];
+    // Directories to scan
+    const scanDirs = [
+        '', // Root directory (for index.mdx, quickstart.mdx, etc.)
+        'guides',
+        'essentials',
+        'components',
+        'api-reference',
+        'changelog',
+    ];
+    for (const dir of scanDirs) {
+        const fullDir = path_1.default.join(projectRoot, dir);
+        if (!fs_extra_1.default.existsSync(fullDir))
+            continue;
+        await scanDirectory(fullDir, projectRoot, files);
+    }
+    // Include text-based assets from assets folder (new convention)
+    const assetsDir = path_1.default.join(projectRoot, 'assets');
+    if (fs_extra_1.default.existsSync(assetsDir)) {
+        await scanPublicAssets(assetsDir, projectRoot, files);
+    }
+    // Also include public assets for backwards compatibility
+    const publicDir = path_1.default.join(projectRoot, 'public');
+    if (fs_extra_1.default.existsSync(publicDir)) {
+        await scanPublicAssets(publicDir, projectRoot, files);
+    }
+    return files;
+}
+/**
+ * Recursively scan a directory for MDX files
+ */
+async function scanDirectory(dir, projectRoot, files) {
+    const items = fs_extra_1.default.readdirSync(dir);
+    for (const item of items) {
+        // Skip common directories
+        if (['node_modules', 'dist', '.next', '.git', 'public'].includes(item)) {
+            continue;
+        }
+        const fullPath = path_1.default.join(dir, item);
+        const stat = fs_extra_1.default.statSync(fullPath);
+        if (stat.isDirectory()) {
+            await scanDirectory(fullPath, projectRoot, files);
+        }
+        else if (item.endsWith('.mdx') || item.endsWith('.md')) {
+            const relativePath = path_1.default.relative(projectRoot, fullPath);
+            const content = fs_extra_1.default.readFileSync(fullPath, 'utf-8');
+            files.push({
+                path: relativePath,
+                content,
+            });
+        }
+    }
+}
+/**
+ * Scan public assets (SVG, images) - text-based only for content bundle
+ */
+async function scanPublicAssets(dir, projectRoot, files) {
+    const items = fs_extra_1.default.readdirSync(dir);
+    for (const item of items) {
+        const fullPath = path_1.default.join(dir, item);
+        const stat = fs_extra_1.default.statSync(fullPath);
+        if (stat.isDirectory()) {
+            await scanPublicAssets(fullPath, projectRoot, files);
+        }
+        else if (item.endsWith('.svg') || item.endsWith('.json')) {
+            // Only include text-based assets in content bundle
+            const relativePath = path_1.default.relative(projectRoot, fullPath);
+            const content = fs_extra_1.default.readFileSync(fullPath, 'utf-8');
+            files.push({
+                path: relativePath,
+                content,
+            });
+        }
+    }
+}
+/**
+ * Collect binary assets from assets folder (convention: /assets)
+ */
+async function collectAssets(projectRoot) {
+    const assets = [];
+    // Check assets folder first (new convention)
+    const assetsDir = path_1.default.join(projectRoot, 'assets');
+    if (fs_extra_1.default.existsSync(assetsDir)) {
+        await scanBinaryAssets(assetsDir, projectRoot, assets);
+    }
+    // Also check public folder for backwards compatibility
+    const publicDir = path_1.default.join(projectRoot, 'public');
+    if (fs_extra_1.default.existsSync(publicDir)) {
+        await scanBinaryAssets(publicDir, projectRoot, assets);
+    }
+    return assets;
+}
+/**
+ * Recursively scan for binary assets
+ */
+async function scanBinaryAssets(dir, projectRoot, assets) {
+    const items = fs_extra_1.default.readdirSync(dir);
+    for (const item of items) {
+        const fullPath = path_1.default.join(dir, item);
+        const stat = fs_extra_1.default.statSync(fullPath);
+        if (stat.isDirectory()) {
+            await scanBinaryAssets(fullPath, projectRoot, assets);
+        }
+        else {
+            const ext = path_1.default.extname(item).toLowerCase();
+            if (BINARY_EXTENSIONS.includes(ext)) {
+                // Check size limit
+                if (stat.size > MAX_ASSET_SIZE) {
+                    logger_1.logger.warn(`Skipping ${item}: exceeds 25MB limit (${formatSize(stat.size)})`);
+                    continue;
+                }
+                const relativePath = path_1.default.relative(projectRoot, fullPath);
+                assets.push({
+                    path: relativePath,
+                    fullPath,
+                    size: stat.size,
+                });
+            }
+        }
+    }
+}
+/**
+ * Upload assets with progress tracking
+ */
+async function uploadAssets(assets, apiUrl, slug, apiKey) {
+    const results = [];
+    for (const asset of assets) {
+        const fileName = path_1.default.basename(asset.path);
+        process.stdout.write(`  ${fileName}: `);
+        try {
+            const result = await uploadAssetWithProgress(asset, apiUrl, slug, apiKey, (progress, loaded, total) => {
+                process.stdout.clearLine(0);
+                process.stdout.cursorTo(0);
+                process.stdout.write(`  ${fileName}: ${createProgressBar(progress)} ${formatSize(loaded)}/${formatSize(total)}`);
+            });
+            process.stdout.clearLine(0);
+            process.stdout.cursorTo(0);
+            console.log(`  ${logger_1.logger.green('✓')} ${fileName} (${formatSize(asset.size)})`);
+            results.push({ file: fileName, success: true, url: result.url });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            process.stdout.clearLine(0);
+            process.stdout.cursorTo(0);
+            console.log(`  ${logger_1.logger.red('✗')} ${fileName}: ${message}`);
+            results.push({ file: fileName, success: false, error: message });
+        }
+    }
+    return results;
+}
+/**
+ * Upload a single asset with progress
+ */
+async function uploadAssetWithProgress(asset, apiUrl, slug, apiKey, onProgress) {
+    const fileBuffer = fs_extra_1.default.readFileSync(asset.fullPath);
+    const fileName = path_1.default.basename(asset.path);
+    // Build multipart form data
+    const boundary = `----DevDocDeploy${Date.now()}`;
+    const CRLF = '\r\n';
+    const header = [
+        `--${boundary}`,
+        `Content-Disposition: form-data; name="file"; filename="${fileName}"`,
+        `Content-Type: application/octet-stream`,
+        '',
+        ''
+    ].join(CRLF);
+    const slugPart = [
+        '',
+        `--${boundary}`,
+        `Content-Disposition: form-data; name="slug"`,
+        '',
+        slug,
+        ''
+    ].join(CRLF);
+    const pathPart = [
+        `--${boundary}`,
+        `Content-Disposition: form-data; name="path"`,
+        '',
+        asset.path.replace(/^public\//, ''), // Remove public/ prefix
+        ''
+    ].join(CRLF);
+    const footer = `${CRLF}--${boundary}--${CRLF}`;
+    const headerBuffer = Buffer.from(header);
+    const slugBuffer = Buffer.from(slugPart);
+    const pathBuffer = Buffer.from(pathPart);
+    const footerBuffer = Buffer.from(footer);
+    const totalSize = headerBuffer.length + fileBuffer.length + slugBuffer.length + pathBuffer.length + footerBuffer.length;
+    const body = Buffer.concat([headerBuffer, fileBuffer, slugBuffer, pathBuffer, footerBuffer]);
+    // Simulate progress
+    let uploaded = 0;
+    const chunkSize = Math.ceil(totalSize / 20);
+    const progressInterval = setInterval(() => {
+        if (uploaded < totalSize * 0.9) {
+            uploaded = Math.min(uploaded + chunkSize, totalSize * 0.9);
+            onProgress(uploaded / totalSize, uploaded, totalSize);
+        }
+    }, 50);
+    try {
+        const response = await fetch(`${apiUrl}/api/assets/upload`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': `multipart/form-data; boundary=${boundary}`,
+                'Authorization': `Bearer ${apiKey}`,
+            },
+            body,
+        });
+        clearInterval(progressInterval);
+        onProgress(1, totalSize, totalSize);
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ error: 'Upload failed' }));
+            throw new Error(error.error || `HTTP ${response.status}`);
+        }
+        const result = await response.json();
+        return result;
+    }
+    catch (error) {
+        clearInterval(progressInterval);
+        throw error;
+    }
+}
+/**
+ * Format file size for display
+ */
+function formatSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+}
+/**
+ * Create a progress bar string
+ */
+function createProgressBar(progress, width = 30) {
+    const filled = Math.round(width * progress);
+    const empty = width - filled;
+    const bar = '█'.repeat(filled) + '░'.repeat(empty);
+    const percentage = Math.round(progress * 100);
+    return `[${bar}] ${percentage}%`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"deploy.js","sourceRoot":"","sources":["../../../src/cli/commands/deploy.ts"],"names":[],"mappings":"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","sourcesContent":["import path from 'path'\nimport fs from 'fs-extra'\nimport { loadConfig, validateConfig } from '../../config'\nimport { logger } from '../../utils/logger'\nimport { DEFAULT_API_URL } from '../../constants'\n\n// Max asset size: 25MB\nconst MAX_ASSET_SIZE = 25 * 1024 * 1024\n\n// Binary asset extensions to upload separately\nconst BINARY_EXTENSIONS = [\n  '.png', '.jpg', '.jpeg', '.gif', '.webp', '.ico',\n  '.mp4', '.webm', '.mov',\n  '.mp3', '.wav', '.ogg',\n  '.woff', '.woff2', '.ttf', '.otf', '.eot',\n  '.pdf',\n]\n\ninterface DeployOptions {\n  url?: string\n  apiKey?: string\n}\n\ninterface ProjectFile {\n  path: string\n  content: string\n}\n\ninterface AssetFile {\n  path: string\n  fullPath: string\n  size: number\n}\n\ninterface DevDocConfig {\n  slug?: string\n  apiKey?: string\n  url?: string\n  lastDeployed?: string\n}\n\n/**\n * Deploy documentation to DevDoc platform\n */\nexport async function deploy(options: DeployOptions): Promise<void> {\n  const projectRoot = process.cwd()\n  const apiUrl = options.url || process.env.DEVDOC_API_URL || DEFAULT_API_URL\n  \n  logger.info('Deploying to DevDoc...\\n')\n  \n  // Check for docs.json\n  const configPath = path.join(projectRoot, 'docs.json')\n  if (!fs.existsSync(configPath)) {\n    logger.error('docs.json not found in current directory')\n    logger.info('Make sure you are in a DevDoc documentation project directory')\n    process.exit(1)\n  }\n  \n  // Load and validate configuration\n  let config: ReturnType<typeof loadConfig> extends Promise<infer T> ? T : never\n  try {\n    config = await loadConfig(projectRoot)\n    const validation = validateConfig(config)\n    \n    if (!validation.valid) {\n      logger.error('Invalid docs.json configuration:')\n      validation.errors.forEach(err => logger.error(`  - ${err}`))\n      process.exit(1)\n    }\n    \n    logger.success(`✓ Configuration valid: ${config.name || 'Untitled'}`)\n  } catch (error: unknown) {\n    const message = error instanceof Error ? error.message : String(error)\n    logger.error(`Failed to load configuration: ${message}`)\n    process.exit(1)\n  }\n  \n  // Check for existing project config\n  const devdocConfigPath = path.join(projectRoot, '.devdoc.json')\n  let existingSlug: string | null = null\n  let existingApiKey: string | null = null\n  \n  if (fs.existsSync(devdocConfigPath)) {\n    try {\n      const devdocConfig = fs.readJsonSync(devdocConfigPath) as DevDocConfig\n      existingSlug = devdocConfig.slug || null\n      existingApiKey = devdocConfig.apiKey || null\n      if (existingSlug) {\n        logger.info(`Deploying project: ${existingSlug}`)\n      }\n    } catch {\n      // Ignore errors reading .devdoc.json\n    }\n  }\n  \n  // Get API key from options, env var, or .devdoc.json\n  const apiKey = options.apiKey || process.env.DEVDOC_API_KEY || existingApiKey\n  \n  // API key is always required for deployment\n  if (!apiKey) {\n    logger.error('API key required for deployment.')\n    console.log('')\n    if (!existingSlug) {\n      logger.info('Run \"devdoc init\" first to register your project and get an API key')\n    } else {\n      logger.info('Your project is not registered. Run \"devdoc init --force\" to register and get an API key')\n    }\n    logger.info('Or provide via --api-key flag or DEVDOC_API_KEY env var')\n    process.exit(1)\n  }\n  \n  // Collect all content files\n  logger.info('Bundling content...')\n  const files = await collectFiles(projectRoot)\n  logger.success(`✓ Found ${files.length} content files`)\n  \n  // Collect binary assets\n  const assets = await collectAssets(projectRoot)\n  if (assets.length > 0) {\n    const totalAssetSize = assets.reduce((sum, a) => sum + a.size, 0)\n    logger.success(`✓ Found ${assets.length} assets (${formatSize(totalAssetSize)})`)\n  }\n  \n  // Calculate bundle size\n  const totalSize = files.reduce((sum, f) => sum + f.content.length, 0)\n  const sizeKB = (totalSize / 1024).toFixed(1)\n  logger.info(`Content bundle: ${sizeKB} KB`)\n  \n  // Upload binary assets first (with progress)\n  if (assets.length > 0 && existingSlug) {\n    console.log('')\n    logger.info('Uploading assets...')\n    \n    const assetResults = await uploadAssets(assets, apiUrl, existingSlug, apiKey)\n    const successCount = assetResults.filter(r => r.success).length\n    const failCount = assetResults.filter(r => !r.success).length\n    \n    if (failCount > 0) {\n      logger.warn(`${successCount} assets uploaded, ${failCount} failed`)\n    } else if (successCount > 0) {\n      logger.success(`✓ ${successCount} assets uploaded`)\n    }\n  } else if (assets.length > 0 && !existingSlug) {\n    logger.info('Assets will be uploaded on next deploy (after project registration)')\n  }\n  \n  // Deploy content to API\n  console.log('')\n  logger.info('Uploading content...')\n  \n  try {\n    interface DeployResponse {\n      success: boolean\n      slug: string\n      url: string\n      blobUrl: string\n      isUpdate: boolean\n      filesCount: number\n      apiKey?: string\n      error?: string\n    }\n    \n    const headers: Record<string, string> = {\n      'Content-Type': 'application/json',\n    }\n    \n    // Add API key header for updates\n    if (apiKey) {\n      headers['Authorization'] = `Bearer ${apiKey}`\n    }\n    \n    const response = await fetch(`${apiUrl}/api/deploy`, {\n      method: 'POST',\n      headers,\n      redirect: 'follow', // Follow redirects\n      body: JSON.stringify({\n        name: config.name || 'My Documentation',\n        slug: existingSlug,\n        docsJson: config,\n        files,\n        apiKey, // Also send in body as fallback\n      }),\n    })\n    \n    if (!response.ok) {\n      const errorData = await response.json().catch(() => ({ error: 'Unknown error' })) as { error?: string; details?: string }\n      const errorMessage = errorData.error || `HTTP ${response.status}`\n      const details = errorData.details ? `\\n   Details: ${errorData.details}` : ''\n      throw new Error(`${errorMessage}${details}`)\n    }\n    \n    const result = await response.json() as DeployResponse\n    \n    // Save project config for future updates\n    const newDevDocConfig: DevDocConfig = {\n      slug: result.slug,\n      url: result.url,\n      lastDeployed: new Date().toISOString(),\n    }\n    \n    // Save API key (from response for new projects, or existing for updates)\n    if (result.apiKey) {\n      newDevDocConfig.apiKey = result.apiKey\n    } else if (apiKey) {\n      newDevDocConfig.apiKey = apiKey\n    }\n    \n    fs.writeJsonSync(devdocConfigPath, newDevDocConfig, { spaces: 2 })\n    \n    // Success message\n    console.log('')\n    logger.success('Deployment successful!')\n    console.log('')\n    console.log(`  Your docs are live at:`)\n    console.log(`  ${logger.cyan(result.url)}`)\n    console.log('')\n    \n    if (result.isUpdate) {\n      logger.info('Project updated with new content')\n    } else {\n      logger.info(`Project slug: ${result.slug}`)\n      logger.info('Run \"devdoc deploy\" again to update')\n      \n      // Show API key warning for new projects\n      if (result.apiKey) {\n        console.log('')\n        logger.warn('⚠️  Save your API key for CI/CD deployments:')\n        console.log(`    ${result.apiKey}`)\n        console.log('')\n        logger.info('API key saved to .devdoc.json (add to .gitignore!)')\n      }\n    }\n    \n  } catch (error: unknown) {\n    const message = error instanceof Error ? error.message : String(error)\n    logger.error(`Deployment failed: ${message}`)\n    process.exit(1)\n  }\n}\n\n/**\n * Collect all MDX and content files from the project\n */\nasync function collectFiles(projectRoot: string): Promise<ProjectFile[]> {\n  const files: ProjectFile[] = []\n  \n  // Directories to scan\n  const scanDirs = [\n    '', // Root directory (for index.mdx, quickstart.mdx, etc.)\n    'guides',\n    'essentials',\n    'components',\n    'api-reference',\n    'changelog',\n  ]\n  \n  for (const dir of scanDirs) {\n    const fullDir = path.join(projectRoot, dir)\n    if (!fs.existsSync(fullDir)) continue\n    \n    await scanDirectory(fullDir, projectRoot, files)\n  }\n  \n  // Include text-based assets from assets folder (new convention)\n  const assetsDir = path.join(projectRoot, 'assets')\n  if (fs.existsSync(assetsDir)) {\n    await scanPublicAssets(assetsDir, projectRoot, files)\n  }\n  \n  // Also include public assets for backwards compatibility\n  const publicDir = path.join(projectRoot, 'public')\n  if (fs.existsSync(publicDir)) {\n    await scanPublicAssets(publicDir, projectRoot, files)\n  }\n  \n  return files\n}\n\n/**\n * Recursively scan a directory for MDX files\n */\nasync function scanDirectory(\n  dir: string,\n  projectRoot: string,\n  files: ProjectFile[]\n): Promise<void> {\n  const items = fs.readdirSync(dir)\n  \n  for (const item of items) {\n    // Skip common directories\n    if (['node_modules', 'dist', '.next', '.git', 'public'].includes(item)) {\n      continue\n    }\n    \n    const fullPath = path.join(dir, item)\n    const stat = fs.statSync(fullPath)\n    \n    if (stat.isDirectory()) {\n      await scanDirectory(fullPath, projectRoot, files)\n    } else if (item.endsWith('.mdx') || item.endsWith('.md')) {\n      const relativePath = path.relative(projectRoot, fullPath)\n      const content = fs.readFileSync(fullPath, 'utf-8')\n      \n      files.push({\n        path: relativePath,\n        content,\n      })\n    }\n  }\n}\n\n/**\n * Scan public assets (SVG, images) - text-based only for content bundle\n */\nasync function scanPublicAssets(\n  dir: string,\n  projectRoot: string,\n  files: ProjectFile[]\n): Promise<void> {\n  const items = fs.readdirSync(dir)\n  \n  for (const item of items) {\n    const fullPath = path.join(dir, item)\n    const stat = fs.statSync(fullPath)\n    \n    if (stat.isDirectory()) {\n      await scanPublicAssets(fullPath, projectRoot, files)\n    } else if (item.endsWith('.svg') || item.endsWith('.json')) {\n      // Only include text-based assets in content bundle\n      const relativePath = path.relative(projectRoot, fullPath)\n      const content = fs.readFileSync(fullPath, 'utf-8')\n      \n      files.push({\n        path: relativePath,\n        content,\n      })\n    }\n  }\n}\n\n/**\n * Collect binary assets from assets folder (convention: /assets)\n */\nasync function collectAssets(projectRoot: string): Promise<AssetFile[]> {\n  const assets: AssetFile[] = []\n  \n  // Check assets folder first (new convention)\n  const assetsDir = path.join(projectRoot, 'assets')\n  if (fs.existsSync(assetsDir)) {\n    await scanBinaryAssets(assetsDir, projectRoot, assets)\n  }\n  \n  // Also check public folder for backwards compatibility\n  const publicDir = path.join(projectRoot, 'public')\n  if (fs.existsSync(publicDir)) {\n    await scanBinaryAssets(publicDir, projectRoot, assets)\n  }\n  \n  return assets\n}\n\n/**\n * Recursively scan for binary assets\n */\nasync function scanBinaryAssets(\n  dir: string,\n  projectRoot: string,\n  assets: AssetFile[]\n): Promise<void> {\n  const items = fs.readdirSync(dir)\n  \n  for (const item of items) {\n    const fullPath = path.join(dir, item)\n    const stat = fs.statSync(fullPath)\n    \n    if (stat.isDirectory()) {\n      await scanBinaryAssets(fullPath, projectRoot, assets)\n    } else {\n      const ext = path.extname(item).toLowerCase()\n      if (BINARY_EXTENSIONS.includes(ext)) {\n        // Check size limit\n        if (stat.size > MAX_ASSET_SIZE) {\n          logger.warn(`Skipping ${item}: exceeds 25MB limit (${formatSize(stat.size)})`)\n          continue\n        }\n        \n        const relativePath = path.relative(projectRoot, fullPath)\n        assets.push({\n          path: relativePath,\n          fullPath,\n          size: stat.size,\n        })\n      }\n    }\n  }\n}\n\n/**\n * Upload assets with progress tracking\n */\nasync function uploadAssets(\n  assets: AssetFile[],\n  apiUrl: string,\n  slug: string,\n  apiKey: string\n): Promise<Array<{ file: string; success: boolean; url?: string; error?: string }>> {\n  const results: Array<{ file: string; success: boolean; url?: string; error?: string }> = []\n  \n  for (const asset of assets) {\n    const fileName = path.basename(asset.path)\n    \n    process.stdout.write(`  ${fileName}: `)\n    \n    try {\n      const result = await uploadAssetWithProgress(\n        asset,\n        apiUrl,\n        slug,\n        apiKey,\n        (progress, loaded, total) => {\n          process.stdout.clearLine(0)\n          process.stdout.cursorTo(0)\n          process.stdout.write(`  ${fileName}: ${createProgressBar(progress)} ${formatSize(loaded)}/${formatSize(total)}`)\n        }\n      )\n      \n      process.stdout.clearLine(0)\n      process.stdout.cursorTo(0)\n      console.log(`  ${logger.green('✓')} ${fileName} (${formatSize(asset.size)})`)\n      \n      results.push({ file: fileName, success: true, url: result.url })\n    } catch (error) {\n      const message = error instanceof Error ? error.message : String(error)\n      \n      process.stdout.clearLine(0)\n      process.stdout.cursorTo(0)\n      console.log(`  ${logger.red('✗')} ${fileName}: ${message}`)\n      \n      results.push({ file: fileName, success: false, error: message })\n    }\n  }\n  \n  return results\n}\n\n/**\n * Upload a single asset with progress\n */\nasync function uploadAssetWithProgress(\n  asset: AssetFile,\n  apiUrl: string,\n  slug: string,\n  apiKey: string,\n  onProgress: (progress: number, loaded: number, total: number) => void\n): Promise<{ url: string }> {\n  const fileBuffer = fs.readFileSync(asset.fullPath)\n  const fileName = path.basename(asset.path)\n  \n  // Build multipart form data\n  const boundary = `----DevDocDeploy${Date.now()}`\n  const CRLF = '\\r\\n'\n  \n  const header = [\n    `--${boundary}`,\n    `Content-Disposition: form-data; name=\"file\"; filename=\"${fileName}\"`,\n    `Content-Type: application/octet-stream`,\n    '',\n    ''\n  ].join(CRLF)\n  \n  const slugPart = [\n    '',\n    `--${boundary}`,\n    `Content-Disposition: form-data; name=\"slug\"`,\n    '',\n    slug,\n    ''\n  ].join(CRLF)\n  \n  const pathPart = [\n    `--${boundary}`,\n    `Content-Disposition: form-data; name=\"path\"`,\n    '',\n    asset.path.replace(/^public\\//, ''), // Remove public/ prefix\n    ''\n  ].join(CRLF)\n  \n  const footer = `${CRLF}--${boundary}--${CRLF}`\n  \n  const headerBuffer = Buffer.from(header)\n  const slugBuffer = Buffer.from(slugPart)\n  const pathBuffer = Buffer.from(pathPart)\n  const footerBuffer = Buffer.from(footer)\n  \n  const totalSize = headerBuffer.length + fileBuffer.length + slugBuffer.length + pathBuffer.length + footerBuffer.length\n  const body = Buffer.concat([headerBuffer, fileBuffer, slugBuffer, pathBuffer, footerBuffer])\n  \n  // Simulate progress\n  let uploaded = 0\n  const chunkSize = Math.ceil(totalSize / 20)\n  \n  const progressInterval = setInterval(() => {\n    if (uploaded < totalSize * 0.9) {\n      uploaded = Math.min(uploaded + chunkSize, totalSize * 0.9)\n      onProgress(uploaded / totalSize, uploaded, totalSize)\n    }\n  }, 50)\n  \n  try {\n    const response = await fetch(`${apiUrl}/api/assets/upload`, {\n      method: 'POST',\n      headers: {\n        'Content-Type': `multipart/form-data; boundary=${boundary}`,\n        'Authorization': `Bearer ${apiKey}`,\n      },\n      body,\n    })\n    \n    clearInterval(progressInterval)\n    onProgress(1, totalSize, totalSize)\n    \n    if (!response.ok) {\n      const error = await response.json().catch(() => ({ error: 'Upload failed' })) as { error?: string }\n      throw new Error(error.error || `HTTP ${response.status}`)\n    }\n    \n    const result = await response.json() as { url: string }\n    return result\n  } catch (error) {\n    clearInterval(progressInterval)\n    throw error\n  }\n}\n\n/**\n * Format file size for display\n */\nfunction formatSize(bytes: number): string {\n  if (bytes < 1024) return `${bytes} B`\n  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`\n  return `${(bytes / (1024 * 1024)).toFixed(2)} MB`\n}\n\n/**\n * Create a progress bar string\n */\nfunction createProgressBar(progress: number, width: number = 30): string {\n  const filled = Math.round(width * progress)\n  const empty = width - filled\n  const bar = '█'.repeat(filled) + '░'.repeat(empty)\n  const percentage = Math.round(progress * 100)\n  return `[${bar}] ${percentage}%`\n}\n"]}

package/dist/cli/commands/dev.d.ts

@@ -0,0 +1,6 @@
+interface DevOptions {
+    port: string;
+    host: string;
+}
+export declare function dev(options: DevOptions): Promise<void>;
+export {};