@brainfish-ai/devdoc 0.1.21

package/dist/cli/commands/dev.js

@@ -0,0 +1,139 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dev = dev;
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const net_1 = __importDefault(require("net"));
+const config_1 = require("../../config");
+const logger_1 = require("../../utils/logger");
+const paths_1 = require("../../utils/paths");
+/**
+ * Check if a port is available
+ */
+async function isPortAvailable(port, host) {
+    return new Promise((resolve) => {
+        const server = net_1.default.createServer();
+        server.once('error', () => resolve(false));
+        server.once('listening', () => {
+            server.close();
+            resolve(true);
+        });
+        server.listen(port, host);
+    });
+}
+/**
+ * Find an available port starting from the given port
+ */
+async function findAvailablePort(startPort, host) {
+    let port = startPort;
+    const maxAttempts = 10;
+    for (let i = 0; i < maxAttempts; i++) {
+        if (await isPortAvailable(port, host)) {
+            return port;
+        }
+        port++;
+    }
+    throw new Error(`No available port found between ${startPort} and ${startPort + maxAttempts - 1}`);
+}
+async function dev(options) {
+    const projectRoot = process.cwd();
+    logger_1.logger.info('Starting DevDoc development server...');
+    // 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('Run "devdoc init" to create a new documentation project');
+        process.exit(1);
+    }
+    // Load and validate config
+    try {
+        const 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(`Loaded configuration: ${config.name || 'Untitled'}`);
+    }
+    catch (error) {
+        logger_1.logger.error(`Failed to load docs.json: ${error.message}`);
+        process.exit(1);
+    }
+    // Get the renderer directory (bundled with this package)
+    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.');
+        logger_1.logger.debug(`Looked for renderer at: ${rendererDir}`);
+        process.exit(1);
+    }
+    // Check if renderer has node_modules
+    const nodeModulesPath = path_1.default.join(rendererDir, 'node_modules');
+    if (!fs_extra_1.default.existsSync(nodeModulesPath)) {
+        logger_1.logger.info('Installing renderer dependencies (first run)...');
+        const installChild = (0, child_process_1.spawn)('npm', ['install'], {
+            cwd: rendererDir,
+            stdio: 'inherit',
+            shell: true,
+        });
+        await new Promise((resolve, reject) => {
+            installChild.on('exit', (code) => {
+                if (code === 0)
+                    resolve();
+                else
+                    reject(new Error(`npm install failed with code ${code}`));
+            });
+            installChild.on('error', reject);
+        });
+        logger_1.logger.success('Dependencies installed');
+    }
+    // Find available port
+    const requestedPort = parseInt(options.port, 10);
+    let actualPort;
+    try {
+        actualPort = await findAvailablePort(requestedPort, options.host);
+        if (actualPort !== requestedPort) {
+            logger_1.logger.warn(`Port ${requestedPort} is in use, using ${actualPort} instead`);
+        }
+    }
+    catch (error) {
+        logger_1.logger.error(error.message);
+        process.exit(1);
+    }
+    // Set environment variables - use STARTER_PATH with absolute path
+    const env = {
+        ...process.env,
+        STARTER_PATH: projectRoot, // Absolute path to user's project
+        PORT: String(actualPort),
+        HOSTNAME: options.host,
+    };
+    logger_1.logger.info(`Content directory: ${projectRoot}`);
+    logger_1.logger.info(`Starting server at http://${options.host}:${actualPort}`);
+    logger_1.logger.info('Press Ctrl+C to stop\n');
+    // Start Next.js dev server with Turbopack for better path alias support
+    const child = (0, child_process_1.spawn)('npx', ['next', 'dev', '--turbo', '-p', String(actualPort), '-H', options.host], {
+        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,{"version":3,"file":"dev.js","sourceRoot":"","sources":["../../../src/cli/commands/dev.ts"],"names":[],"mappings":"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","sourcesContent":["import { spawn } from 'child_process';\nimport path from 'path';\nimport fs from 'fs-extra';\nimport net from 'net';\nimport { loadConfig, validateConfig } from '../../config';\nimport { logger } from '../../utils/logger';\nimport { getRendererDir } from '../../utils/paths';\n\ninterface DevOptions {\n  port: string;\n  host: string;\n}\n\n/**\n * Check if a port is available\n */\nasync function isPortAvailable(port: number, host: string): Promise<boolean> {\n  return new Promise((resolve) => {\n    const server = net.createServer();\n    server.once('error', () => resolve(false));\n    server.once('listening', () => {\n      server.close();\n      resolve(true);\n    });\n    server.listen(port, host);\n  });\n}\n\n/**\n * Find an available port starting from the given port\n */\nasync function findAvailablePort(startPort: number, host: string): Promise<number> {\n  let port = startPort;\n  const maxAttempts = 10;\n  \n  for (let i = 0; i < maxAttempts; i++) {\n    if (await isPortAvailable(port, host)) {\n      return port;\n    }\n    port++;\n  }\n  \n  throw new Error(`No available port found between ${startPort} and ${startPort + maxAttempts - 1}`);\n}\n\nexport async function dev(options: DevOptions): Promise<void> {\n  const projectRoot = process.cwd();\n  \n  logger.info('Starting DevDoc development server...');\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('Run \"devdoc init\" to create a new documentation project');\n    process.exit(1);\n  }\n  \n  // Load and validate config\n  try {\n    const 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(`Loaded configuration: ${config.name || 'Untitled'}`);\n  } catch (error: any) {\n    logger.error(`Failed to load docs.json: ${error.message}`);\n    process.exit(1);\n  }\n  \n  // Get the renderer directory (bundled with this package)\n  const rendererDir = getRendererDir();\n  \n  if (!rendererDir || !fs.existsSync(rendererDir)) {\n    logger.error('Renderer not found. Package may be corrupted.');\n    logger.debug(`Looked for renderer at: ${rendererDir}`);\n    process.exit(1);\n  }\n  \n  // Check if renderer has node_modules\n  const nodeModulesPath = path.join(rendererDir, 'node_modules');\n  if (!fs.existsSync(nodeModulesPath)) {\n    logger.info('Installing renderer dependencies (first run)...');\n    const installChild = spawn('npm', ['install'], {\n      cwd: rendererDir,\n      stdio: 'inherit',\n      shell: true,\n    });\n    \n    await new Promise<void>((resolve, reject) => {\n      installChild.on('exit', (code) => {\n        if (code === 0) resolve();\n        else reject(new Error(`npm install failed with code ${code}`));\n      });\n      installChild.on('error', reject);\n    });\n    logger.success('Dependencies installed');\n  }\n  \n  // Find available port\n  const requestedPort = parseInt(options.port, 10);\n  let actualPort: number;\n  \n  try {\n    actualPort = await findAvailablePort(requestedPort, options.host);\n    if (actualPort !== requestedPort) {\n      logger.warn(`Port ${requestedPort} is in use, using ${actualPort} instead`);\n    }\n  } catch (error: any) {\n    logger.error(error.message);\n    process.exit(1);\n  }\n  \n  // Set environment variables - use STARTER_PATH with absolute path\n  const env = {\n    ...process.env,\n    STARTER_PATH: projectRoot, // Absolute path to user's project\n    PORT: String(actualPort),\n    HOSTNAME: options.host,\n  };\n  \n  logger.info(`Content directory: ${projectRoot}`);\n  logger.info(`Starting server at http://${options.host}:${actualPort}`);\n  logger.info('Press Ctrl+C to stop\\n');\n  \n  // Start Next.js dev server with Turbopack for better path alias support\n  const child = spawn(\n    'npx',\n    ['next', 'dev', '--turbo', '-p', String(actualPort), '-H', options.host],\n    {\n      cwd: rendererDir,\n      env,\n      stdio: 'inherit',\n      shell: true,\n    }\n  );\n  \n  child.on('error', (error) => {\n    logger.error(`Failed to start server: ${error.message}`);\n    process.exit(1);\n  });\n  \n  child.on('exit', (code) => {\n    process.exit(code || 0);\n  });\n  \n  // Handle termination\n  process.on('SIGINT', () => {\n    child.kill('SIGINT');\n  });\n  \n  process.on('SIGTERM', () => {\n    child.kill('SIGTERM');\n  });\n}\n"]}

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

@@ -0,0 +1,11 @@
+interface InitOptions {
+    slug?: string;
+    subdomain?: string;
+    force?: boolean;
+    url?: string;
+}
+/**
+ * Initialize a DevDoc project with .devdoc.json and register with Brainfish
+ */
+export declare function init(options: InitOptions): Promise<void>;
+export {};

package/dist/cli/commands/init.js

@@ -0,0 +1,238 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = init;
+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");
+// Simple prompt helper using readline
+async function prompt(question, defaultValue) {
+    const readline = await Promise.resolve().then(() => __importStar(require('readline')));
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        const defaultHint = defaultValue ? ` (${defaultValue})` : '';
+        rl.question(`${question}${defaultHint}: `, (answer) => {
+            rl.close();
+            resolve(answer.trim() || defaultValue || '');
+        });
+    });
+}
+/**
+ * Basic subdomain format validation (server does full validation)
+ */
+function isValidSubdomainFormat(subdomain) {
+    if (!subdomain) {
+        return { valid: false, error: 'Subdomain is required' };
+    }
+    if (subdomain.length < 3) {
+        return { valid: false, error: 'Subdomain must be at least 3 characters' };
+    }
+    if (subdomain.length > 63) {
+        return { valid: false, error: 'Subdomain must be 63 characters or less' };
+    }
+    if (!/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/.test(subdomain)) {
+        return { valid: false, error: 'Subdomain must start and end with alphanumeric, can contain hyphens' };
+    }
+    if (/--/.test(subdomain)) {
+        return { valid: false, error: 'Subdomain cannot contain consecutive hyphens' };
+    }
+    return { valid: true };
+}
+/**
+ * Check subdomain availability via API (also validates against server blacklist)
+ */
+async function checkSubdomainAvailability(subdomain, apiUrl) {
+    try {
+        const response = await fetch(`${apiUrl}/api/subdomains/check`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ subdomain }),
+        });
+        const result = await response.json();
+        return result;
+    }
+    catch (error) {
+        // If API is unavailable, allow proceeding (will fail at registration if invalid)
+        return { available: true };
+    }
+}
+/**
+ * Initialize a DevDoc project with .devdoc.json and register with Brainfish
+ */
+async function init(options) {
+    const projectRoot = process.cwd();
+    const apiUrl = options.url || process.env.DEVDOC_API_URL || constants_1.DEFAULT_API_URL;
+    logger_1.logger.info('Initializing DevDoc project...\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);
+    }
+    // Check if .devdoc.json already exists with API key
+    const devdocConfigPath = path_1.default.join(projectRoot, '.devdoc.json');
+    if (fs_extra_1.default.existsSync(devdocConfigPath) && !options.force) {
+        const existingConfig = fs_extra_1.default.readJsonSync(devdocConfigPath);
+        if (existingConfig.apiKey) {
+            logger_1.logger.warn('.devdoc.json already exists with API key');
+            logger_1.logger.info('Use --force to overwrite and create a new project');
+            process.exit(1);
+        }
+    }
+    // Load docs.json to get project name
+    let projectName = 'My Documentation';
+    try {
+        const config = await (0, config_1.loadConfig)(projectRoot);
+        projectName = config.name || projectName;
+    }
+    catch {
+        // Use default name
+    }
+    // Generate slug from project name or use provided slug
+    const slug = options.slug || generateSlug(projectName);
+    // Get subdomain - prompt if not provided
+    let subdomain = options.subdomain;
+    if (!subdomain) {
+        const suggestedSubdomain = slug;
+        console.log('');
+        subdomain = await prompt(`Enter subdomain for ${suggestedSubdomain}.devdoc.sh`, suggestedSubdomain);
+        subdomain = subdomain.toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/^-|-$/g, '');
+    }
+    // Validate subdomain format locally
+    const formatCheck = isValidSubdomainFormat(subdomain);
+    if (!formatCheck.valid) {
+        logger_1.logger.error(formatCheck.error);
+        process.exit(1);
+    }
+    // Check subdomain availability via API (server validates blacklist)
+    logger_1.logger.info(`Checking if ${subdomain}.devdoc.sh is available...`);
+    const availability = await checkSubdomainAvailability(subdomain, apiUrl);
+    if (!availability.available) {
+        logger_1.logger.error(availability.error || `Subdomain "${subdomain}" is not available`);
+        if (availability.suggestion) {
+            logger_1.logger.info(`Suggestion: Try "${availability.suggestion}"`);
+        }
+        process.exit(1);
+    }
+    logger_1.logger.success(`✓ ${subdomain}.devdoc.sh is available!`);
+    console.log('');
+    // Register project with Brainfish API
+    logger_1.logger.info('Registering project with Brainfish...');
+    try {
+        const response = await fetch(`${apiUrl}/api/projects/register`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                name: projectName,
+                slug,
+                subdomain,
+            }),
+        });
+        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();
+        // Create .devdoc.json with API key
+        const devdocConfig = {
+            projectId: result.projectId,
+            name: projectName,
+            slug: result.slug,
+            subdomain: result.subdomain,
+            apiKey: result.apiKey,
+            createdAt: new Date().toISOString(),
+        };
+        fs_extra_1.default.writeJsonSync(devdocConfigPath, devdocConfig, { spaces: 2 });
+        logger_1.logger.success('✓ Project registered successfully');
+        console.log('');
+        console.log('  Project ID:', result.projectId);
+        console.log('  URL:', `https://${result.subdomain}.devdoc.sh`);
+        console.log('  API Key:', result.apiKey);
+        console.log('');
+        logger_1.logger.warn('⚠️  API key saved to .devdoc.json - add to .gitignore!');
+        console.log('');
+        logger_1.logger.info('Run "devdoc deploy" to deploy your documentation');
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger_1.logger.error(`Failed to register project: ${message}`);
+        // Create local .devdoc.json without API key (offline mode)
+        logger_1.logger.warn('Creating local config without API key...');
+        const projectId = `${slug}-${generateId()}`;
+        const devdocConfig = {
+            projectId,
+            name: projectName,
+            slug,
+            subdomain,
+            createdAt: new Date().toISOString(),
+        };
+        fs_extra_1.default.writeJsonSync(devdocConfigPath, devdocConfig, { spaces: 2 });
+        logger_1.logger.success('✓ Created .devdoc.json (offline mode)');
+        console.log('');
+        logger_1.logger.info('Run "devdoc init" again when online to register and get API key');
+    }
+}
+/**
+ * Generate a URL-friendly slug from a name
+ */
+function generateSlug(name) {
+    return name
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-|-$/g, '')
+        .substring(0, 50);
+}
+/**
+ * Generate a short random ID
+ */
+function generateId() {
+    return Math.random().toString(36).substring(2, 8);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"init.js","sourceRoot":"","sources":["../../../src/cli/commands/init.ts"],"names":[],"mappings":"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","sourcesContent":["import path from 'path'\nimport fs from 'fs-extra'\nimport { loadConfig } from '../../config'\nimport { logger } from '../../utils/logger'\nimport { DEFAULT_API_URL } from '../../constants'\n\ninterface InitOptions {\n  slug?: string\n  subdomain?: string\n  force?: boolean\n  url?: string\n}\n\ninterface DevDocConfig {\n  projectId: string\n  name: string\n  slug: string\n  subdomain: string\n  apiKey?: string\n  createdAt: string\n}\n\ninterface RegisterResponse {\n  success: boolean\n  projectId: string\n  slug: string\n  subdomain: string\n  apiKey: string\n  error?: string\n}\n\ninterface CheckSubdomainResponse {\n  available: boolean\n  error?: string\n  suggestion?: string\n}\n\n// Simple prompt helper using readline\nasync function prompt(question: string, defaultValue?: string): Promise<string> {\n  const readline = await import('readline')\n  const rl = readline.createInterface({\n    input: process.stdin,\n    output: process.stdout,\n  })\n\n  return new Promise((resolve) => {\n    const defaultHint = defaultValue ? ` (${defaultValue})` : ''\n    rl.question(`${question}${defaultHint}: `, (answer) => {\n      rl.close()\n      resolve(answer.trim() || defaultValue || '')\n    })\n  })\n}\n\n/**\n * Basic subdomain format validation (server does full validation)\n */\nfunction isValidSubdomainFormat(subdomain: string): { valid: boolean; error?: string } {\n  if (!subdomain) {\n    return { valid: false, error: 'Subdomain is required' }\n  }\n  \n  if (subdomain.length < 3) {\n    return { valid: false, error: 'Subdomain must be at least 3 characters' }\n  }\n  \n  if (subdomain.length > 63) {\n    return { valid: false, error: 'Subdomain must be 63 characters or less' }\n  }\n  \n  if (!/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/.test(subdomain)) {\n    return { valid: false, error: 'Subdomain must start and end with alphanumeric, can contain hyphens' }\n  }\n  \n  if (/--/.test(subdomain)) {\n    return { valid: false, error: 'Subdomain cannot contain consecutive hyphens' }\n  }\n  \n  return { valid: true }\n}\n\n/**\n * Check subdomain availability via API (also validates against server blacklist)\n */\nasync function checkSubdomainAvailability(\n  subdomain: string,\n  apiUrl: string\n): Promise<CheckSubdomainResponse> {\n  try {\n    const response = await fetch(`${apiUrl}/api/subdomains/check`, {\n      method: 'POST',\n      headers: {\n        'Content-Type': 'application/json',\n      },\n      body: JSON.stringify({ subdomain }),\n    })\n    \n    const result = await response.json() as CheckSubdomainResponse\n    return result\n  } catch (error) {\n    // If API is unavailable, allow proceeding (will fail at registration if invalid)\n    return { available: true }\n  }\n}\n\n/**\n * Initialize a DevDoc project with .devdoc.json and register with Brainfish\n */\nexport async function init(options: InitOptions): Promise<void> {\n  const projectRoot = process.cwd()\n  const apiUrl = options.url || process.env.DEVDOC_API_URL || DEFAULT_API_URL\n  \n  logger.info('Initializing DevDoc project...\\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  // Check if .devdoc.json already exists with API key\n  const devdocConfigPath = path.join(projectRoot, '.devdoc.json')\n  if (fs.existsSync(devdocConfigPath) && !options.force) {\n    const existingConfig = fs.readJsonSync(devdocConfigPath) as DevDocConfig\n    if (existingConfig.apiKey) {\n      logger.warn('.devdoc.json already exists with API key')\n      logger.info('Use --force to overwrite and create a new project')\n      process.exit(1)\n    }\n  }\n  \n  // Load docs.json to get project name\n  let projectName = 'My Documentation'\n  try {\n    const config = await loadConfig(projectRoot)\n    projectName = config.name || projectName\n  } catch {\n    // Use default name\n  }\n  \n  // Generate slug from project name or use provided slug\n  const slug = options.slug || generateSlug(projectName)\n  \n  // Get subdomain - prompt if not provided\n  let subdomain = options.subdomain\n  \n  if (!subdomain) {\n    const suggestedSubdomain = slug\n    console.log('')\n    subdomain = await prompt(`Enter subdomain for ${suggestedSubdomain}.devdoc.sh`, suggestedSubdomain)\n    subdomain = subdomain.toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/^-|-$/g, '')\n  }\n  \n  // Validate subdomain format locally\n  const formatCheck = isValidSubdomainFormat(subdomain)\n  if (!formatCheck.valid) {\n    logger.error(formatCheck.error!)\n    process.exit(1)\n  }\n  \n  // Check subdomain availability via API (server validates blacklist)\n  logger.info(`Checking if ${subdomain}.devdoc.sh is available...`)\n  const availability = await checkSubdomainAvailability(subdomain, apiUrl)\n  \n  if (!availability.available) {\n    logger.error(availability.error || `Subdomain \"${subdomain}\" is not available`)\n    if (availability.suggestion) {\n      logger.info(`Suggestion: Try \"${availability.suggestion}\"`)\n    }\n    process.exit(1)\n  }\n  \n  logger.success(`✓ ${subdomain}.devdoc.sh is available!`)\n  console.log('')\n  \n  // Register project with Brainfish API\n  logger.info('Registering project with Brainfish...')\n  \n  try {\n    const response = await fetch(`${apiUrl}/api/projects/register`, {\n      method: 'POST',\n      headers: {\n        'Content-Type': 'application/json',\n      },\n      body: JSON.stringify({\n        name: projectName,\n        slug,\n        subdomain,\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 RegisterResponse\n    \n    // Create .devdoc.json with API key\n    const devdocConfig: DevDocConfig = {\n      projectId: result.projectId,\n      name: projectName,\n      slug: result.slug,\n      subdomain: result.subdomain,\n      apiKey: result.apiKey,\n      createdAt: new Date().toISOString(),\n    }\n    \n    fs.writeJsonSync(devdocConfigPath, devdocConfig, { spaces: 2 })\n    \n    logger.success('✓ Project registered successfully')\n    console.log('')\n    console.log('  Project ID:', result.projectId)\n    console.log('  URL:', `https://${result.subdomain}.devdoc.sh`)\n    console.log('  API Key:', result.apiKey)\n    console.log('')\n    logger.warn('⚠️  API key saved to .devdoc.json - add to .gitignore!')\n    console.log('')\n    logger.info('Run \"devdoc deploy\" to deploy your documentation')\n    \n  } catch (error: unknown) {\n    const message = error instanceof Error ? error.message : String(error)\n    logger.error(`Failed to register project: ${message}`)\n    \n    // Create local .devdoc.json without API key (offline mode)\n    logger.warn('Creating local config without API key...')\n    const projectId = `${slug}-${generateId()}`\n    const devdocConfig: DevDocConfig = {\n      projectId,\n      name: projectName,\n      slug,\n      subdomain,\n      createdAt: new Date().toISOString(),\n    }\n    \n    fs.writeJsonSync(devdocConfigPath, devdocConfig, { spaces: 2 })\n    \n    logger.success('✓ Created .devdoc.json (offline mode)')\n    console.log('')\n    logger.info('Run \"devdoc init\" again when online to register and get API key')\n  }\n}\n\n/**\n * Generate a URL-friendly slug from a name\n */\nfunction generateSlug(name: string): string {\n  return name\n    .toLowerCase()\n    .replace(/[^a-z0-9]+/g, '-')\n    .replace(/^-|-$/g, '')\n    .substring(0, 50)\n}\n\n/**\n * Generate a short random ID\n */\nfunction generateId(): string {\n  return Math.random().toString(36).substring(2, 8)\n}\n"]}

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

@@ -0,0 +1,12 @@
+interface KeysOptions {
+    url?: string;
+}
+/**
+ * List API keys for the current project
+ */
+export declare function listKeys(_options: KeysOptions): Promise<void>;
+/**
+ * Regenerate API key for the current project
+ */
+export declare function regenerateKey(options: KeysOptions): Promise<void>;
+export {};

package/dist/cli/commands/keys.js

@@ -0,0 +1,165 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listKeys = listKeys;
+exports.regenerateKey = regenerateKey;
+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");
+/**
+ * List API keys for the current project
+ */
+async function listKeys(_options) {
+    const projectRoot = process.cwd();
+    const devdocConfigPath = path_1.default.join(projectRoot, '.devdoc.json');
+    if (!fs_extra_1.default.existsSync(devdocConfigPath)) {
+        logger_1.logger.error('No project found in current directory.');
+        logger_1.logger.info('Run "devdoc deploy" first to create a project.');
+        process.exit(1);
+    }
+    try {
+        const config = fs_extra_1.default.readJsonSync(devdocConfigPath);
+        if (!config.slug) {
+            logger_1.logger.error('Invalid .devdoc.json - missing project slug.');
+            process.exit(1);
+        }
+        console.log('');
+        console.log(`  Project: ${logger_1.logger.cyan(config.slug)}`);
+        if (config.apiKey) {
+            // Show masked key
+            const maskedKey = config.apiKey.substring(0, 12) + '...' + config.apiKey.substring(config.apiKey.length - 4);
+            console.log(`  API Key: ${maskedKey}`);
+        }
+        else {
+            console.log(`  API Key: ${logger_1.logger.yellow('Not found')}`);
+        }
+        if (config.url) {
+            console.log(`  URL:     ${config.url}`);
+        }
+        if (config.lastDeployed) {
+            console.log(`  Last deployed: ${new Date(config.lastDeployed).toLocaleString()}`);
+        }
+        console.log('');
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger_1.logger.error(`Failed to read project config: ${message}`);
+        process.exit(1);
+    }
+}
+/**
+ * Regenerate API key for the current project
+ */
+async function regenerateKey(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');
+    if (!fs_extra_1.default.existsSync(devdocConfigPath)) {
+        logger_1.logger.error('No project found in current directory.');
+        logger_1.logger.info('Run "devdoc deploy" first to create a project.');
+        process.exit(1);
+    }
+    let config;
+    try {
+        config = fs_extra_1.default.readJsonSync(devdocConfigPath);
+    }
+    catch {
+        logger_1.logger.error('Failed to read .devdoc.json');
+        process.exit(1);
+    }
+    if (!config.slug || !config.apiKey) {
+        logger_1.logger.error('Invalid .devdoc.json - missing project slug or API key.');
+        process.exit(1);
+    }
+    logger_1.logger.warn('⚠️  This will invalidate your current API key.');
+    logger_1.logger.warn('   Any CI/CD pipelines using the old key will fail.');
+    console.log('');
+    // Simple confirmation
+    const readline = await Promise.resolve().then(() => __importStar(require('readline')));
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const answer = await new Promise((resolve) => {
+        rl.question('Continue? (y/N) ', resolve);
+    });
+    rl.close();
+    if (answer.toLowerCase() !== 'y') {
+        logger_1.logger.info('Cancelled.');
+        process.exit(0);
+    }
+    console.log('');
+    logger_1.logger.info('Regenerating API key...');
+    try {
+        const response = await fetch(`${apiUrl}/api/keys/regenerate`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${config.apiKey}`,
+            },
+            body: JSON.stringify({
+                slug: config.slug,
+            }),
+        });
+        if (!response.ok) {
+            const errorData = await response.json().catch(() => ({ error: 'Unknown error' }));
+            throw new Error(errorData.error || `HTTP ${response.status}`);
+        }
+        const result = await response.json();
+        if (!result.apiKey) {
+            throw new Error('No API key returned');
+        }
+        // Update local config
+        config.apiKey = result.apiKey;
+        fs_extra_1.default.writeJsonSync(devdocConfigPath, config, { spaces: 2 });
+        console.log('');
+        logger_1.logger.success('✓ New API key generated!');
+        console.log('');
+        console.log(`  New key: ${result.apiKey}`);
+        console.log('');
+        logger_1.logger.info('Updated .devdoc.json with new key.');
+        logger_1.logger.warn('⚠️  Update your CI/CD secrets with this new key.');
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger_1.logger.error(`Failed to regenerate key: ${message}`);
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"keys.js","sourceRoot":"","sources":["../../../src/cli/commands/keys.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 KeysOptions {\n  url?: string\n}\n\ninterface DevDocConfig {\n  slug?: string\n  apiKey?: string\n  url?: string\n  lastDeployed?: string\n}\n\n/**\n * List API keys for the current project\n */\nexport async function listKeys(_options: KeysOptions): Promise<void> {\n  const projectRoot = process.cwd()\n  const devdocConfigPath = path.join(projectRoot, '.devdoc.json')\n  \n  if (!fs.existsSync(devdocConfigPath)) {\n    logger.error('No project found in current directory.')\n    logger.info('Run \"devdoc deploy\" first to create a project.')\n    process.exit(1)\n  }\n  \n  try {\n    const config = fs.readJsonSync(devdocConfigPath) as DevDocConfig\n    \n    if (!config.slug) {\n      logger.error('Invalid .devdoc.json - missing project slug.')\n      process.exit(1)\n    }\n    \n    console.log('')\n    console.log(`  Project: ${logger.cyan(config.slug)}`)\n    \n    if (config.apiKey) {\n      // Show masked key\n      const maskedKey = config.apiKey.substring(0, 12) + '...' + config.apiKey.substring(config.apiKey.length - 4)\n      console.log(`  API Key: ${maskedKey}`)\n    } else {\n      console.log(`  API Key: ${logger.yellow('Not found')}`)\n    }\n    \n    if (config.url) {\n      console.log(`  URL:     ${config.url}`)\n    }\n    \n    if (config.lastDeployed) {\n      console.log(`  Last deployed: ${new Date(config.lastDeployed).toLocaleString()}`)\n    }\n    \n    console.log('')\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\n/**\n * Regenerate API key for the current project\n */\nexport async function regenerateKey(options: KeysOptions): 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  \n  if (!fs.existsSync(devdocConfigPath)) {\n    logger.error('No project found in current directory.')\n    logger.info('Run \"devdoc deploy\" first to create a project.')\n    process.exit(1)\n  }\n  \n  let config: DevDocConfig\n  try {\n    config = fs.readJsonSync(devdocConfigPath) as DevDocConfig\n  } catch {\n    logger.error('Failed to read .devdoc.json')\n    process.exit(1)\n  }\n  \n  if (!config.slug || !config.apiKey) {\n    logger.error('Invalid .devdoc.json - missing project slug or API key.')\n    process.exit(1)\n  }\n  \n  logger.warn('⚠️  This will invalidate your current API key.')\n  logger.warn('   Any CI/CD pipelines using the old key will fail.')\n  console.log('')\n  \n  // Simple confirmation\n  const readline = await import('readline')\n  const rl = readline.createInterface({\n    input: process.stdin,\n    output: process.stdout,\n  })\n  \n  const answer = await new Promise<string>((resolve) => {\n    rl.question('Continue? (y/N) ', resolve)\n  })\n  rl.close()\n  \n  if (answer.toLowerCase() !== 'y') {\n    logger.info('Cancelled.')\n    process.exit(0)\n  }\n  \n  console.log('')\n  logger.info('Regenerating API key...')\n  \n  try {\n    interface RegenerateResponse {\n      success: boolean\n      apiKey?: string\n      error?: string\n    }\n    \n    const response = await fetch(`${apiUrl}/api/keys/regenerate`, {\n      method: 'POST',\n      headers: {\n        'Content-Type': 'application/json',\n        'Authorization': `Bearer ${config.apiKey}`,\n      },\n      body: JSON.stringify({\n        slug: config.slug,\n      }),\n    })\n    \n    if (!response.ok) {\n      const errorData = await response.json().catch(() => ({ error: 'Unknown error' })) as { error?: string }\n      throw new Error(errorData.error || `HTTP ${response.status}`)\n    }\n    \n    const result = await response.json() as RegenerateResponse\n    \n    if (!result.apiKey) {\n      throw new Error('No API key returned')\n    }\n    \n    // Update local config\n    config.apiKey = result.apiKey\n    fs.writeJsonSync(devdocConfigPath, config, { spaces: 2 })\n    \n    console.log('')\n    logger.success('✓ New API key generated!')\n    console.log('')\n    console.log(`  New key: ${result.apiKey}`)\n    console.log('')\n    logger.info('Updated .devdoc.json with new key.')\n    logger.warn('⚠️  Update your CI/CD secrets with this new key.')\n    \n  } catch (error: unknown) {\n    const message = error instanceof Error ? error.message : String(error)\n    logger.error(`Failed to regenerate key: ${message}`)\n    process.exit(1)\n  }\n}\n"]}