@brainfish-ai/devdoc 0.1.21

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

@@ -0,0 +1,5 @@
+interface StartOptions {
+    port: string;
+}
+export declare function start(options: StartOptions): Promise<void>;
+export {};

package/dist/cli/commands/start.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.start = start;
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const logger_1 = require("../../utils/logger");
+const paths_1 = require("../../utils/paths");
+async function start(options) {
+    const projectRoot = process.cwd();
+    logger_1.logger.info('Starting production server...');
+    // Check for build output
+    const buildDir = path_1.default.join(projectRoot, 'dist', '.next');
+    if (!fs_extra_1.default.existsSync(buildDir)) {
+        logger_1.logger.error('No build found. Run "devdoc build" first.');
+        process.exit(1);
+    }
+    // Get the renderer directory
+    const rendererDir = (0, paths_1.getRendererDir)();
+    if (!rendererDir || !fs_extra_1.default.existsSync(rendererDir)) {
+        logger_1.logger.error('Renderer not found. Package may be corrupted.');
+        process.exit(1);
+    }
+    // Set environment variables
+    const env = {
+        ...process.env,
+        STARTER_PATH: projectRoot,
+        PORT: options.port,
+    };
+    logger_1.logger.info(`Starting server at http://localhost:${options.port}`);
+    // Start Next.js production server
+    const child = (0, child_process_1.spawn)('npx', ['next', 'start', '-p', options.port], {
+        cwd: rendererDir,
+        env,
+        stdio: 'inherit',
+        shell: true,
+    });
+    child.on('error', (error) => {
+        logger_1.logger.error(`Failed to start server: ${error.message}`);
+        process.exit(1);
+    });
+    child.on('exit', (code) => {
+        process.exit(code || 0);
+    });
+    // Handle termination
+    process.on('SIGINT', () => {
+        child.kill('SIGINT');
+    });
+    process.on('SIGTERM', () => {
+        child.kill('SIGTERM');
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,13 @@
+interface UploadOptions {
+    url?: string;
+    apiKey?: string;
+}
+/**
+ * Upload assets to DevDoc storage
+ */
+export declare function upload(files: string[], options: UploadOptions): Promise<void>;
+/**
+ * List uploaded assets
+ */
+export declare function listAssets(options: UploadOptions): Promise<void>;
+export {};

package/dist/cli/commands/upload.js

@@ -0,0 +1,238 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.upload = upload;
+exports.listAssets = listAssets;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const logger_1 = require("../../utils/logger");
+const constants_1 = require("../../constants");
+// Max file size: 25MB
+const MAX_FILE_SIZE = 25 * 1024 * 1024;
+/**
+ * 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}%`;
+}
+/**
+ * Upload a file with progress tracking using XMLHttpRequest-like approach
+ */
+async function uploadFileWithProgress(file, apiUrl, slug, apiKey, onProgress) {
+    const filePath = path_1.default.resolve(file);
+    if (!fs_extra_1.default.existsSync(filePath)) {
+        throw new Error(`File not found: ${filePath}`);
+    }
+    const stats = fs_extra_1.default.statSync(filePath);
+    const fileSize = stats.size;
+    const fileName = path_1.default.basename(filePath);
+    // Check file size
+    if (fileSize > MAX_FILE_SIZE) {
+        throw new Error(`File size (${formatSize(fileSize)}) exceeds maximum allowed size of 25MB`);
+    }
+    // Read file
+    const fileBuffer = fs_extra_1.default.readFileSync(filePath);
+    // Create form data manually for Node.js
+    const boundary = `----DevDocUpload${Date.now()}`;
+    const CRLF = '\r\n';
+    // Build multipart form data
+    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 footer = `${CRLF}--${boundary}--${CRLF}`;
+    const headerBuffer = Buffer.from(header);
+    const slugBuffer = Buffer.from(slugPart);
+    const footerBuffer = Buffer.from(footer);
+    const totalSize = headerBuffer.length + fileBuffer.length + slugBuffer.length + footerBuffer.length;
+    // Combine all parts
+    const body = Buffer.concat([headerBuffer, fileBuffer, slugBuffer, footerBuffer]);
+    // Simulate progress for better UX (since fetch doesn't support upload progress natively)
+    let uploaded = 0;
+    const chunkSize = Math.ceil(totalSize / 20); // Simulate 20 progress updates
+    const progressInterval = setInterval(() => {
+        if (uploaded < totalSize * 0.9) { // Only go to 90% until response
+            uploaded = Math.min(uploaded + chunkSize, totalSize * 0.9);
+            onProgress(uploaded / totalSize, uploaded, totalSize);
+        }
+    }, 100);
+    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);
+        // Complete progress
+        onProgress(1, totalSize, totalSize);
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ error: 'Upload failed' }));
+            throw new Error(error.error || `HTTP ${response.status}`);
+        }
+        return await response.json();
+    }
+    catch (error) {
+        clearInterval(progressInterval);
+        throw error;
+    }
+}
+/**
+ * Upload assets to DevDoc storage
+ */
+async function upload(files, options) {
+    const projectRoot = process.cwd();
+    const apiUrl = options.url || process.env.DEVDOC_API_URL || constants_1.DEFAULT_API_URL;
+    if (files.length === 0) {
+        logger_1.logger.error('No files specified');
+        logger_1.logger.info('Usage: devdoc upload <file1> [file2] ...');
+        process.exit(1);
+    }
+    // Load .devdoc.json to get project info
+    const devdocConfigPath = path_1.default.join(projectRoot, '.devdoc.json');
+    if (!fs_extra_1.default.existsSync(devdocConfigPath)) {
+        logger_1.logger.error('.devdoc.json not found');
+        logger_1.logger.info('Run "devdoc init" or "devdoc deploy" first to initialize your project');
+        process.exit(1);
+    }
+    let devdocConfig;
+    try {
+        devdocConfig = fs_extra_1.default.readJsonSync(devdocConfigPath);
+    }
+    catch {
+        logger_1.logger.error('Failed to read .devdoc.json');
+        process.exit(1);
+    }
+    const slug = devdocConfig.slug;
+    const apiKey = options.apiKey || process.env.DEVDOC_API_KEY || devdocConfig.apiKey;
+    if (!slug) {
+        logger_1.logger.error('Project slug not found in .devdoc.json');
+        process.exit(1);
+    }
+    if (!apiKey) {
+        logger_1.logger.error('API key not found');
+        logger_1.logger.info('Provide via --api-key, DEVDOC_API_KEY env var, or in .devdoc.json');
+        process.exit(1);
+    }
+    logger_1.logger.info(`Uploading ${files.length} file(s) to ${slug}...\n`);
+    const results = [];
+    for (const file of files) {
+        const fileName = path_1.default.basename(file);
+        process.stdout.write(`  ${fileName}: `);
+        try {
+            const result = await uploadFileWithProgress(file, apiUrl, slug, apiKey, (progress, loaded, total) => {
+                // Clear line and rewrite progress
+                process.stdout.clearLine(0);
+                process.stdout.cursorTo(0);
+                process.stdout.write(`  ${fileName}: ${createProgressBar(progress)} ${formatSize(loaded)}/${formatSize(total)}`);
+            });
+            // Clear line and show success
+            process.stdout.clearLine(0);
+            process.stdout.cursorTo(0);
+            console.log(`  ${logger_1.logger.green('✓')} ${fileName} (${formatSize(result.size)})`);
+            console.log(`    ${logger_1.logger.cyan(result.url)}`);
+            results.push({ file: fileName, success: true, url: result.url });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            // Clear line and show 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 });
+        }
+    }
+    // Summary
+    console.log('');
+    const successful = results.filter(r => r.success).length;
+    const failed = results.filter(r => !r.success).length;
+    if (failed === 0) {
+        logger_1.logger.success(`All ${successful} file(s) uploaded successfully!`);
+    }
+    else if (successful === 0) {
+        logger_1.logger.error(`All ${failed} file(s) failed to upload`);
+        process.exit(1);
+    }
+    else {
+        logger_1.logger.warn(`${successful} file(s) uploaded, ${failed} failed`);
+    }
+}
+/**
+ * List uploaded assets
+ */
+async function listAssets(options) {
+    const projectRoot = process.cwd();
+    const apiUrl = options.url || process.env.DEVDOC_API_URL || constants_1.DEFAULT_API_URL;
+    // Load .devdoc.json
+    const devdocConfigPath = path_1.default.join(projectRoot, '.devdoc.json');
+    if (!fs_extra_1.default.existsSync(devdocConfigPath)) {
+        logger_1.logger.error('.devdoc.json not found');
+        process.exit(1);
+    }
+    const devdocConfig = fs_extra_1.default.readJsonSync(devdocConfigPath);
+    const slug = devdocConfig.slug;
+    const apiKey = options.apiKey || process.env.DEVDOC_API_KEY || devdocConfig.apiKey;
+    if (!slug || !apiKey) {
+        logger_1.logger.error('Project slug or API key not found');
+        process.exit(1);
+    }
+    logger_1.logger.info(`Fetching assets for ${slug}...`);
+    try {
+        const response = await fetch(`${apiUrl}/api/assets?slug=${slug}`, {
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}`);
+        }
+        const data = await response.json();
+        if (data.assets.length === 0) {
+            logger_1.logger.info('No assets found');
+            return;
+        }
+        console.log('');
+        console.log('Assets:');
+        for (const asset of data.assets) {
+            console.log(`  ${asset.fileName} (${formatSize(asset.size)})`);
+            console.log(`    ${logger_1.logger.cyan(asset.url)}`);
+        }
+        console.log('');
+        logger_1.logger.info(`Total: ${data.assets.length} asset(s)`);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger_1.logger.error(`Failed to list assets: ${message}`);
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"upload.js","sourceRoot":"","sources":["../../../src/cli/commands/upload.ts"],"names":[],"mappings":"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","sourcesContent":["import path from 'path'\nimport fs from 'fs-extra'\nimport { logger } from '../../utils/logger'\nimport { DEFAULT_API_URL } from '../../constants'\n\n// Max file size: 25MB\nconst MAX_FILE_SIZE = 25 * 1024 * 1024\n\ninterface DevDocConfig {\n  slug: string\n  apiKey?: string\n  url?: string\n}\n\ninterface UploadOptions {\n  url?: string\n  apiKey?: string\n}\n\ninterface UploadResponse {\n  success: boolean\n  url: string\n  path: string\n  fileName: string\n  size: number\n  contentType: string\n  error?: string\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\n/**\n * Upload a file with progress tracking using XMLHttpRequest-like approach\n */\nasync function uploadFileWithProgress(\n  file: string,\n  apiUrl: string,\n  slug: string,\n  apiKey: string,\n  onProgress: (progress: number, loaded: number, total: number) => void\n): Promise<UploadResponse> {\n  const filePath = path.resolve(file)\n  \n  if (!fs.existsSync(filePath)) {\n    throw new Error(`File not found: ${filePath}`)\n  }\n  \n  const stats = fs.statSync(filePath)\n  const fileSize = stats.size\n  const fileName = path.basename(filePath)\n  \n  // Check file size\n  if (fileSize > MAX_FILE_SIZE) {\n    throw new Error(`File size (${formatSize(fileSize)}) exceeds maximum allowed size of 25MB`)\n  }\n  \n  // Read file\n  const fileBuffer = fs.readFileSync(filePath)\n  \n  // Create form data manually for Node.js\n  const boundary = `----DevDocUpload${Date.now()}`\n  const CRLF = '\\r\\n'\n  \n  // Build multipart form data\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 footer = `${CRLF}--${boundary}--${CRLF}`\n  \n  const headerBuffer = Buffer.from(header)\n  const slugBuffer = Buffer.from(slugPart)\n  const footerBuffer = Buffer.from(footer)\n  \n  const totalSize = headerBuffer.length + fileBuffer.length + slugBuffer.length + footerBuffer.length\n  \n  // Combine all parts\n  const body = Buffer.concat([headerBuffer, fileBuffer, slugBuffer, footerBuffer])\n  \n  // Simulate progress for better UX (since fetch doesn't support upload progress natively)\n  let uploaded = 0\n  const chunkSize = Math.ceil(totalSize / 20) // Simulate 20 progress updates\n  \n  const progressInterval = setInterval(() => {\n    if (uploaded < totalSize * 0.9) { // Only go to 90% until response\n      uploaded = Math.min(uploaded + chunkSize, totalSize * 0.9)\n      onProgress(uploaded / totalSize, uploaded, totalSize)\n    }\n  }, 100)\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    \n    // Complete progress\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    return await response.json() as UploadResponse\n  } catch (error) {\n    clearInterval(progressInterval)\n    throw error\n  }\n}\n\n/**\n * Upload assets to DevDoc storage\n */\nexport async function upload(files: string[], options: UploadOptions): Promise<void> {\n  const projectRoot = process.cwd()\n  const apiUrl = options.url || process.env.DEVDOC_API_URL || DEFAULT_API_URL\n  \n  if (files.length === 0) {\n    logger.error('No files specified')\n    logger.info('Usage: devdoc upload <file1> [file2] ...')\n    process.exit(1)\n  }\n  \n  // Load .devdoc.json to get project info\n  const devdocConfigPath = path.join(projectRoot, '.devdoc.json')\n  \n  if (!fs.existsSync(devdocConfigPath)) {\n    logger.error('.devdoc.json not found')\n    logger.info('Run \"devdoc init\" or \"devdoc deploy\" first to initialize your project')\n    process.exit(1)\n  }\n  \n  let devdocConfig: DevDocConfig\n  try {\n    devdocConfig = fs.readJsonSync(devdocConfigPath) as DevDocConfig\n  } catch {\n    logger.error('Failed to read .devdoc.json')\n    process.exit(1)\n  }\n  \n  const slug = devdocConfig.slug\n  const apiKey = options.apiKey || process.env.DEVDOC_API_KEY || devdocConfig.apiKey\n  \n  if (!slug) {\n    logger.error('Project slug not found in .devdoc.json')\n    process.exit(1)\n  }\n  \n  if (!apiKey) {\n    logger.error('API key not found')\n    logger.info('Provide via --api-key, DEVDOC_API_KEY env var, or in .devdoc.json')\n    process.exit(1)\n  }\n  \n  logger.info(`Uploading ${files.length} file(s) to ${slug}...\\n`)\n  \n  const results: { file: string; success: boolean; url?: string; error?: string }[] = []\n  \n  for (const file of files) {\n    const fileName = path.basename(file)\n    \n    process.stdout.write(`  ${fileName}: `)\n    \n    try {\n      const result = await uploadFileWithProgress(\n        file,\n        apiUrl,\n        slug,\n        apiKey,\n        (progress, loaded, total) => {\n          // Clear line and rewrite progress\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      // Clear line and show success\n      process.stdout.clearLine(0)\n      process.stdout.cursorTo(0)\n      console.log(`  ${logger.green('✓')} ${fileName} (${formatSize(result.size)})`)\n      console.log(`    ${logger.cyan(result.url)}`)\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      // Clear line and show error\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  // Summary\n  console.log('')\n  const successful = results.filter(r => r.success).length\n  const failed = results.filter(r => !r.success).length\n  \n  if (failed === 0) {\n    logger.success(`All ${successful} file(s) uploaded successfully!`)\n  } else if (successful === 0) {\n    logger.error(`All ${failed} file(s) failed to upload`)\n    process.exit(1)\n  } else {\n    logger.warn(`${successful} file(s) uploaded, ${failed} failed`)\n  }\n}\n\n/**\n * List uploaded assets\n */\nexport async function listAssets(options: UploadOptions): Promise<void> {\n  const projectRoot = process.cwd()\n  const apiUrl = options.url || process.env.DEVDOC_API_URL || DEFAULT_API_URL\n  \n  // Load .devdoc.json\n  const devdocConfigPath = path.join(projectRoot, '.devdoc.json')\n  \n  if (!fs.existsSync(devdocConfigPath)) {\n    logger.error('.devdoc.json not found')\n    process.exit(1)\n  }\n  \n  const devdocConfig = fs.readJsonSync(devdocConfigPath) as DevDocConfig\n  const slug = devdocConfig.slug\n  const apiKey = options.apiKey || process.env.DEVDOC_API_KEY || devdocConfig.apiKey\n  \n  if (!slug || !apiKey) {\n    logger.error('Project slug or API key not found')\n    process.exit(1)\n  }\n  \n  logger.info(`Fetching assets for ${slug}...`)\n  \n  try {\n    const response = await fetch(`${apiUrl}/api/assets?slug=${slug}`, {\n      headers: {\n        'Authorization': `Bearer ${apiKey}`,\n      },\n    })\n    \n    if (!response.ok) {\n      throw new Error(`HTTP ${response.status}`)\n    }\n    \n    const data = await response.json() as { assets: Array<{ fileName: string; size: number; url: string; uploadedAt: string }> }\n    \n    if (data.assets.length === 0) {\n      logger.info('No assets found')\n      return\n    }\n    \n    console.log('')\n    console.log('Assets:')\n    for (const asset of data.assets) {\n      console.log(`  ${asset.fileName} (${formatSize(asset.size)})`)\n      console.log(`    ${logger.cyan(asset.url)}`)\n    }\n    console.log('')\n    logger.info(`Total: ${data.assets.length} asset(s)`)\n  } catch (error) {\n    const message = error instanceof Error ? error.message : String(error)\n    logger.error(`Failed to list assets: ${message}`)\n    process.exit(1)\n  }\n}\n"]}

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

@@ -0,0 +1,8 @@
+interface WhoamiOptions {
+    url?: string;
+}
+/**
+ * Show current project information
+ */
+export declare function whoami(options: WhoamiOptions): Promise<void>;
+export {};

package/dist/cli/commands/whoami.js

@@ -0,0 +1,91 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.whoami = whoami;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const logger_1 = require("../../utils/logger");
+const constants_1 = require("../../constants");
+/**
+ * Show current project information
+ */
+async function whoami(options) {
+    const projectRoot = process.cwd();
+    const apiUrl = options.url || process.env.DEVDOC_API_URL || constants_1.DEFAULT_API_URL;
+    const devdocConfigPath = path_1.default.join(projectRoot, '.devdoc.json');
+    const docsConfigPath = path_1.default.join(projectRoot, 'docs.json');
+    console.log('');
+    console.log('DevDoc Project Information');
+    console.log('========================');
+    console.log('');
+    // Check for docs.json
+    if (fs_extra_1.default.existsSync(docsConfigPath)) {
+        try {
+            const docsConfig = fs_extra_1.default.readJsonSync(docsConfigPath);
+            console.log(`  Project Name: ${logger_1.logger.cyan(docsConfig.name || 'Untitled')}`);
+        }
+        catch {
+            console.log(`  Project Name: ${logger_1.logger.yellow('Unable to read docs.json')}`);
+        }
+    }
+    else {
+        console.log(`  ${logger_1.logger.yellow('No docs.json found in current directory')}`);
+        console.log('');
+        process.exit(0);
+    }
+    // Check for .devdoc.json
+    if (!fs_extra_1.default.existsSync(devdocConfigPath)) {
+        console.log(`  Status:       ${logger_1.logger.yellow('Not deployed')}`);
+        console.log('');
+        logger_1.logger.info('Run "devdoc deploy" to deploy your documentation.');
+        console.log('');
+        process.exit(0);
+    }
+    try {
+        const config = fs_extra_1.default.readJsonSync(devdocConfigPath);
+        console.log(`  Project Slug: ${config.slug || logger_1.logger.yellow('Unknown')}`);
+        console.log(`  Status:       ${logger_1.logger.green('Deployed')}`);
+        if (config.url) {
+            console.log(`  URL:          ${logger_1.logger.cyan(config.url)}`);
+        }
+        if (config.apiKey) {
+            const maskedKey = config.apiKey.substring(0, 12) + '...' + config.apiKey.substring(config.apiKey.length - 4);
+            console.log(`  API Key:      ${maskedKey}`);
+        }
+        if (config.lastDeployed) {
+            const date = new Date(config.lastDeployed);
+            console.log(`  Last Deploy:  ${date.toLocaleString()}`);
+        }
+        console.log('');
+        console.log(`  Platform:     ${apiUrl}`);
+        console.log('');
+        // Optional: verify with server
+        if (config.slug && config.apiKey) {
+            try {
+                const response = await fetch(`${apiUrl}/api/deploy?slug=${config.slug}`, {
+                    method: 'GET',
+                    headers: {
+                        'Authorization': `Bearer ${config.apiKey}`,
+                    },
+                });
+                if (response.ok) {
+                    const data = await response.json();
+                    if (data.exists) {
+                        logger_1.logger.success('✓ Project verified on server');
+                    }
+                }
+            }
+            catch {
+                // Silent fail - server verification is optional
+            }
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger_1.logger.error(`Failed to read project config: ${message}`);
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"whoami.js","sourceRoot":"","sources":["../../../src/cli/commands/whoami.ts"],"names":[],"mappings":"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","sourcesContent":["import path from 'path'\nimport fs from 'fs-extra'\nimport { logger } from '../../utils/logger'\nimport { DEFAULT_API_URL } from '../../constants'\n\ninterface WhoamiOptions {\n  url?: string\n}\n\ninterface DevDocConfig {\n  slug?: string\n  apiKey?: string\n  url?: string\n  lastDeployed?: string\n}\n\n/**\n * Show current project information\n */\nexport async function whoami(options: WhoamiOptions): Promise<void> {\n  const projectRoot = process.cwd()\n  const apiUrl = options.url || process.env.DEVDOC_API_URL || DEFAULT_API_URL\n  const devdocConfigPath = path.join(projectRoot, '.devdoc.json')\n  const docsConfigPath = path.join(projectRoot, 'docs.json')\n  \n  console.log('')\n  console.log('DevDoc Project Information')\n  console.log('========================')\n  console.log('')\n  \n  // Check for docs.json\n  if (fs.existsSync(docsConfigPath)) {\n    try {\n      const docsConfig = fs.readJsonSync(docsConfigPath)\n      console.log(`  Project Name: ${logger.cyan(docsConfig.name || 'Untitled')}`)\n    } catch {\n      console.log(`  Project Name: ${logger.yellow('Unable to read docs.json')}`)\n    }\n  } else {\n    console.log(`  ${logger.yellow('No docs.json found in current directory')}`)\n    console.log('')\n    process.exit(0)\n  }\n  \n  // Check for .devdoc.json\n  if (!fs.existsSync(devdocConfigPath)) {\n    console.log(`  Status:       ${logger.yellow('Not deployed')}`)\n    console.log('')\n    logger.info('Run \"devdoc deploy\" to deploy your documentation.')\n    console.log('')\n    process.exit(0)\n  }\n  \n  try {\n    const config = fs.readJsonSync(devdocConfigPath) as DevDocConfig\n    \n    console.log(`  Project Slug: ${config.slug || logger.yellow('Unknown')}`)\n    console.log(`  Status:       ${logger.green('Deployed')}`)\n    \n    if (config.url) {\n      console.log(`  URL:          ${logger.cyan(config.url)}`)\n    }\n    \n    if (config.apiKey) {\n      const maskedKey = config.apiKey.substring(0, 12) + '...' + config.apiKey.substring(config.apiKey.length - 4)\n      console.log(`  API Key:      ${maskedKey}`)\n    }\n    \n    if (config.lastDeployed) {\n      const date = new Date(config.lastDeployed)\n      console.log(`  Last Deploy:  ${date.toLocaleString()}`)\n    }\n    \n    console.log('')\n    console.log(`  Platform:     ${apiUrl}`)\n    console.log('')\n    \n    // Optional: verify with server\n    if (config.slug && config.apiKey) {\n      try {\n        const response = await fetch(`${apiUrl}/api/deploy?slug=${config.slug}`, {\n          method: 'GET',\n          headers: {\n            'Authorization': `Bearer ${config.apiKey}`,\n          },\n        })\n        \n        if (response.ok) {\n          const data = await response.json() as { exists?: boolean }\n          if (data.exists) {\n            logger.success('✓ Project verified on server')\n          }\n        }\n      } catch {\n        // Silent fail - server verification is optional\n      }\n    }\n    \n  } catch (error: unknown) {\n    const message = error instanceof Error ? error.message : String(error)\n    logger.error(`Failed to read project config: ${message}`)\n    process.exit(1)\n  }\n}\n"]}

package/dist/cli/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/index.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const create_1 = require("./commands/create");
+const init_1 = require("./commands/init");
+const dev_1 = require("./commands/dev");
+const build_1 = require("./commands/build");
+const start_1 = require("./commands/start");
+const check_1 = require("./commands/check");
+const deploy_1 = require("./commands/deploy");
+const keys_1 = require("./commands/keys");
+const whoami_1 = require("./commands/whoami");
+const upload_1 = require("./commands/upload");
+const packageJson = require('../../package.json');
+const program = new commander_1.Command();
+program
+    .name('devdoc')
+    .description('Documentation framework for developers')
+    .version(packageJson.version);
+program
+    .command('create [project-directory]')
+    .description('Create a new DevDoc documentation site')
+    .option('-t, --template <type>', 'Template to use (basic, openapi, graphql)')
+    .option('-s, --subdomain <subdomain>', 'Subdomain for your docs (e.g., my-docs.devdoc.sh)')
+    .option('--no-git', 'Skip git initialization')
+    .option('--no-install', 'Skip installing dependencies')
+    .option('-u, --url <url>', 'API URL (default: https://devdoc.sh)')
+    .action(create_1.create);
+program
+    .command('init')
+    .description('Initialize/register project with Brainfish')
+    .option('-s, --slug <slug>', 'Project slug')
+    .option('--subdomain <subdomain>', 'Subdomain for your docs (e.g., my-docs.devdoc.sh)')
+    .option('-f, --force', 'Overwrite existing .devdoc.json')
+    .option('-u, --url <url>', 'API URL (default: https://devdoc.sh)')
+    .action(init_1.init);
+program
+    .command('dev')
+    .description('Start development server with hot reload')
+    .option('-p, --port <port>', 'Port to run the server on', '3333')
+    .option('-H, --host <host>', 'Host to bind the server to', 'localhost')
+    .action(dev_1.dev);
+program
+    .command('build')
+    .description('Build documentation for production')
+    .option('-o, --output <dir>', 'Output directory', 'dist')
+    .action(build_1.build);
+program
+    .command('start')
+    .description('Start production server')
+    .option('-p, --port <port>', 'Port to run the server on', '3000')
+    .action(start_1.start);
+program
+    .command('check')
+    .description('Validate docs.json and MDX files')
+    .action(check_1.check);
+program
+    .command('deploy')
+    .description('Deploy documentation to DevDoc platform')
+    .option('-u, --url <url>', 'API URL (default: https://devdoc.sh)')
+    .option('-k, --api-key <key>', 'API key for authentication')
+    .action(deploy_1.deploy);
+// Keys management
+const keysCmd = program
+    .command('keys')
+    .description('Manage API keys for your project');
+keysCmd
+    .command('list')
+    .description('Show current API key info')
+    .option('-u, --url <url>', 'API URL')
+    .action(keys_1.listKeys);
+keysCmd
+    .command('regenerate')
+    .description('Generate a new API key (invalidates the old one)')
+    .option('-u, --url <url>', 'API URL')
+    .action(keys_1.regenerateKey);
+program
+    .command('whoami')
+    .description('Show current project information')
+    .option('-u, --url <url>', 'API URL')
+    .action(whoami_1.whoami);
+// Assets management
+const assetsCmd = program
+    .command('assets')
+    .description('Manage project assets (images, files)');
+assetsCmd
+    .command('upload <files...>')
+    .description('Upload assets to storage (max 25MB per file)')
+    .option('-u, --url <url>', 'API URL')
+    .option('-k, --api-key <key>', 'API key for authentication')
+    .action(upload_1.upload);
+assetsCmd
+    .command('list')
+    .description('List uploaded assets')
+    .option('-u, --url <url>', 'API URL')
+    .option('-k, --api-key <key>', 'API key for authentication')
+    .action(upload_1.listAssets);
+// Shortcut for upload
+program
+    .command('upload <files...>')
+    .description('Upload assets to storage (shortcut for "devdoc assets upload")')
+    .option('-u, --url <url>', 'API URL')
+    .option('-k, --api-key <key>', 'API key for authentication')
+    .action(upload_1.upload);
+program.parse(process.argv);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/cli/index.ts"],"names":[],"mappings":"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","sourcesContent":["import { Command } from 'commander';\nimport { create } from './commands/create';\nimport { init } from './commands/init';\nimport { dev } from './commands/dev';\nimport { build } from './commands/build';\nimport { start } from './commands/start';\nimport { check } from './commands/check';\nimport { deploy } from './commands/deploy';\nimport { listKeys, regenerateKey } from './commands/keys';\nimport { whoami } from './commands/whoami';\nimport { upload, listAssets } from './commands/upload';\n\nconst packageJson = require('../../package.json');\n\nconst program = new Command();\n\nprogram\n  .name('devdoc')\n  .description('Documentation framework for developers')\n  .version(packageJson.version);\n\nprogram\n  .command('create [project-directory]')\n  .description('Create a new DevDoc documentation site')\n  .option('-t, --template <type>', 'Template to use (basic, openapi, graphql)')\n  .option('-s, --subdomain <subdomain>', 'Subdomain for your docs (e.g., my-docs.devdoc.sh)')\n  .option('--no-git', 'Skip git initialization')\n  .option('--no-install', 'Skip installing dependencies')\n  .option('-u, --url <url>', 'API URL (default: https://devdoc.sh)')\n  .action(create);\n\nprogram\n  .command('init')\n  .description('Initialize/register project with Brainfish')\n  .option('-s, --slug <slug>', 'Project slug')\n  .option('--subdomain <subdomain>', 'Subdomain for your docs (e.g., my-docs.devdoc.sh)')\n  .option('-f, --force', 'Overwrite existing .devdoc.json')\n  .option('-u, --url <url>', 'API URL (default: https://devdoc.sh)')\n  .action(init);\n\nprogram\n  .command('dev')\n  .description('Start development server with hot reload')\n  .option('-p, --port <port>', 'Port to run the server on', '3333')\n  .option('-H, --host <host>', 'Host to bind the server to', 'localhost')\n  .action(dev);\n\nprogram\n  .command('build')\n  .description('Build documentation for production')\n  .option('-o, --output <dir>', 'Output directory', 'dist')\n  .action(build);\n\nprogram\n  .command('start')\n  .description('Start production server')\n  .option('-p, --port <port>', 'Port to run the server on', '3000')\n  .action(start);\n\nprogram\n  .command('check')\n  .description('Validate docs.json and MDX files')\n  .action(check);\n\nprogram\n  .command('deploy')\n  .description('Deploy documentation to DevDoc platform')\n  .option('-u, --url <url>', 'API URL (default: https://devdoc.sh)')\n  .option('-k, --api-key <key>', 'API key for authentication')\n  .action(deploy);\n\n// Keys management\nconst keysCmd = program\n  .command('keys')\n  .description('Manage API keys for your project');\n\nkeysCmd\n  .command('list')\n  .description('Show current API key info')\n  .option('-u, --url <url>', 'API URL')\n  .action(listKeys);\n\nkeysCmd\n  .command('regenerate')\n  .description('Generate a new API key (invalidates the old one)')\n  .option('-u, --url <url>', 'API URL')\n  .action(regenerateKey);\n\nprogram\n  .command('whoami')\n  .description('Show current project information')\n  .option('-u, --url <url>', 'API URL')\n  .action(whoami);\n\n// Assets management\nconst assetsCmd = program\n  .command('assets')\n  .description('Manage project assets (images, files)');\n\nassetsCmd\n  .command('upload <files...>')\n  .description('Upload assets to storage (max 25MB per file)')\n  .option('-u, --url <url>', 'API URL')\n  .option('-k, --api-key <key>', 'API key for authentication')\n  .action(upload);\n\nassetsCmd\n  .command('list')\n  .description('List uploaded assets')\n  .option('-u, --url <url>', 'API URL')\n  .option('-k, --api-key <key>', 'API key for authentication')\n  .action(listAssets);\n\n// Shortcut for upload\nprogram\n  .command('upload <files...>')\n  .description('Upload assets to storage (shortcut for \"devdoc assets upload\")')\n  .option('-u, --url <url>', 'API URL')\n  .option('-k, --api-key <key>', 'API key for authentication')\n  .action(upload);\n\nprogram.parse(process.argv);\n"]}