@husar.ai/cli 0.4.0 → 0.4.2

package/src/cli.ts

@@ -7,7 +7,10 @@ import { ConfigMaker } from 'config-maker';
 import { parser } from './functions/parser.js';
 import { generateCms } from './functions/generate.js';
 import { startMcpServer } from './mcp.js';
-import { HusarConfigType } from '@/types/config.js';
+import { HusarConfigType, getAdminToken } from '@/types/config.js';
+import { startLoginFlow } from './auth/login.js';
+import { clearAuth, getCurrentUser, getConfigPath, isLoggedIn, readAuthConfig } from './auth/config.js';
+import { runCreateCommand } from './functions/create.js';
 
 const config = new ConfigMaker<HusarConfigType>('husar', { decoders: {} });
 
@@ -40,13 +43,14 @@ program
     if (!conf.host) {
       throw new Error('Host is not configured. Please run "husar generate" first.');
     }
-    if (!conf.adminToken) {
-      throw new Error('Admin token is not configured. Please set it in the config or use environment variable.');
+    const adminToken = getAdminToken(conf);
+    if (!adminToken) {
+      throw new Error('Admin token not configured. Set HUSAR_ADMIN_TOKEN env var, or adminTokenEnv in husar.json');
     }
     const result = await parser({
       inputFile,
       opts: { name, type: opts?.type },
-      authentication: { HUSAR_MCP_HOST: conf.host, HUSAR_MCP_ADMIN_TOKEN: conf.adminToken },
+      authentication: { HUSAR_MCP_HOST: conf.host, HUSAR_MCP_ADMIN_TOKEN: adminToken },
     });
     console.log(result ? 'File parsed and upserted successfully.' : 'Failed to parse and upsert file.');
   });
@@ -61,4 +65,92 @@ program
     await new Promise<void>(() => {});
   });
 
+// ============ Auth Commands ============
+
+program
+  .command('login')
+  .description('Log in to Husar.ai via browser authentication')
+  .action(async () => {
+    const loggedIn = await isLoggedIn();
+    if (loggedIn) {
+      const user = await getCurrentUser();
+      console.log(`Already logged in as ${user?.email}`);
+      console.log('Run "husar logout" to switch accounts.');
+      return;
+    }
+
+    console.log('Starting Husar.ai authentication...');
+    const result = await startLoginFlow();
+
+    if (result.success) {
+      console.log(`\n✅ Successfully logged in as ${result.email}`);
+      if (result.project) {
+        console.log(`   Connected to project: ${result.project.projectName}`);
+        console.log(`   Host: ${result.project.host}`);
+      }
+    } else {
+      console.error(`\n❌ Login failed: ${result.error}`);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('logout')
+  .description('Log out and clear stored credentials')
+  .action(async () => {
+    const loggedIn = await isLoggedIn();
+    if (!loggedIn) {
+      console.log('Not logged in.');
+      return;
+    }
+
+    const user = await getCurrentUser();
+    await clearAuth();
+    console.log(`✅ Logged out${user?.email ? ` (was: ${user.email})` : ''}`);
+    console.log(`   Cleared credentials from ${getConfigPath()}`);
+  });
+
+program
+  .command('whoami')
+  .description('Display current logged-in user and projects')
+  .action(async () => {
+    const loggedIn = await isLoggedIn();
+    if (!loggedIn) {
+      console.log('Not logged in. Run "husar login" to authenticate.');
+      return;
+    }
+
+    const user = await getCurrentUser();
+    const authConfig = await readAuthConfig();
+
+    console.log(`\n👤 Logged in as: ${user?.email}`);
+
+    if (authConfig.projects && Object.keys(authConfig.projects).length > 0) {
+      console.log('\n📦 Connected projects:');
+      for (const [name, project] of Object.entries(authConfig.projects)) {
+        console.log(`   • ${name}`);
+        console.log(`     Host: ${project.host}`);
+      }
+    } else {
+      console.log('\nNo projects connected. Run "husar create" to set up a new project.');
+    }
+
+    console.log(`\n📁 Config: ${getConfigPath()}`);
+  });
+
+// ============ Create Command ============
+
+program
+  .command('create [projectName]')
+  .description('Create a new project with Husar CMS integration')
+  .option('-f, --framework <framework>', 'Framework to use: nextjs or vite', 'nextjs')
+  .option('--skip-install', 'Skip package installation after scaffolding')
+  .action(async (projectName: string | undefined, opts: { framework: string; skipInstall?: boolean }) => {
+    await runCreateCommand({
+      projectName,
+      framework: opts.framework as 'nextjs' | 'vite',
+      skipInstall: opts.skipInstall,
+    });
+  });
+
 program.parse(process.argv);

package/src/functions/create.ts

@@ -0,0 +1,489 @@
+/**
+ * Create command for Husar CLI
+ *
+ * Onboarding flow for new users:
+ * 1. Choose connection method (manual URL or cloud login)
+ * 2. If cloud login: Get JWT → List projects → Select one
+ * 3. Panel CMS login: Get adminToken via browser auth
+ * 4. Delegate to framework CLI (create-next-app / create-vite)
+ * 5. Add Husar configuration and install packages
+ */
+
+import { spawn } from 'node:child_process';
+import { promises as fs } from 'node:fs';
+import { join, resolve } from 'node:path';
+import * as readline from 'node:readline';
+
+import { getCloudAuth, ProjectAuth } from '../auth/config.js';
+import { startCloudLoginFlow, startPanelLoginFlow } from '../auth/login.js';
+import { getProjects, CloudProject, verifyAccessToken } from '../auth/api.js';
+
+export interface CreateOptions {
+  /** Project directory name */
+  projectName?: string;
+  /** Framework to use: nextjs or vite */
+  framework: 'nextjs' | 'vite';
+  /** Skip npm install after scaffolding */
+  skipInstall?: boolean;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// MAIN CREATE COMMAND
+// ═══════════════════════════════════════════════════════════════════════════
+
+/**
+ * Run the create command
+ */
+export async function runCreateCommand(options: CreateOptions): Promise<void> {
+  console.log('\n🚀 Husar.ai Project Creator\n');
+
+  // ═══════════════════════════════════════════════════════════════════════
+  // STEP 1: How to connect to CMS?
+  // ═══════════════════════════════════════════════════════════════════════
+
+  const connectionMethod = await promptConnectionMethod();
+  let panelHost: string;
+
+  if (connectionMethod === 'manual') {
+    // User enters URL manually
+    panelHost = await promptManualUrl();
+  } else {
+    // Cloud login flow → select project
+    const cloudAuth = await ensureCloudLogin();
+    if (!cloudAuth) {
+      console.error('\n❌ Cloud authentication failed. Please try again.');
+      process.exit(1);
+    }
+
+    // Fetch user's projects
+    console.log('\n📦 Fetching your projects...\n');
+    const projects = await getProjects(cloudAuth.accessToken);
+
+    if (projects.length === 0) {
+      console.log('❌ No projects found in your account.');
+      console.log('   Create a project at https://admin.husar.ai first.\n');
+      process.exit(1);
+    }
+
+    // Let user select a project
+    const selectedProject = await promptSelectProject(projects);
+    panelHost = selectedProject.adminURL;
+    console.log(`\n📌 Selected: ${selectedProject.name}`);
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════
+  // STEP 2: Panel CMS login (get adminToken)
+  // ═══════════════════════════════════════════════════════════════════════
+
+  console.log('\n🔐 Opening browser for CMS authentication...');
+  console.log("   You'll need your SUPERADMIN credentials (from the welcome email)\n");
+
+  const panelAuth = await startPanelLoginFlow(panelHost);
+
+  if (!panelAuth.success || !panelAuth.project) {
+    console.error('\n❌ CMS authentication failed:', panelAuth.error ?? 'Unknown error');
+    process.exit(1);
+  }
+
+  const project = panelAuth.project;
+  console.log(`\n✅ Connected to: ${project.projectName}`);
+  console.log(`   Host: ${project.host}\n`);
+
+  // ═══════════════════════════════════════════════════════════════════════
+  // STEP 3: Get project name (directory)
+  // ═══════════════════════════════════════════════════════════════════════
+
+  const projectName = options.projectName || (await promptProjectName(project.projectName));
+  if (!projectName) {
+    console.error('❌ Project name is required.');
+    process.exit(1);
+  }
+
+  const projectPath = resolve(process.cwd(), projectName);
+
+  // ═══════════════════════════════════════════════════════════════════════
+  // STEP 4: Run framework CLI
+  // ═══════════════════════════════════════════════════════════════════════
+
+  console.log(`\n📦 Creating ${options.framework === 'nextjs' ? 'Next.js' : 'Vite + React'} project...\n`);
+
+  const frameworkSuccess = await runFrameworkCli(options.framework, projectName);
+  if (!frameworkSuccess) {
+    console.error('\n❌ Framework CLI failed. Please check the output above.');
+    process.exit(1);
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════
+  // STEP 5: Add Husar configuration (with hybrid storage)
+  // ═══════════════════════════════════════════════════════════════════════
+
+  console.log('\n⚙️  Adding Husar configuration...\n');
+  await addHusarConfig(projectPath, project, options.framework);
+
+  // ═══════════════════════════════════════════════════════════════════════
+  // STEP 6: Install Husar packages
+  // ═══════════════════════════════════════════════════════════════════════
+
+  if (!options.skipInstall) {
+    console.log('\n📥 Installing Husar packages...\n');
+    await installHusarPackages(projectPath);
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════
+  // STEP 7: Generate CMS files
+  // ═══════════════════════════════════════════════════════════════════════
+
+  console.log('\n🔧 Generating CMS client...\n');
+  await generateCmsClient(projectPath, options.framework);
+
+  // ═══════════════════════════════════════════════════════════════════════
+  // SUCCESS!
+  // ═══════════════════════════════════════════════════════════════════════
+
+  console.log('\n' + '═'.repeat(50));
+  console.log('✨ Project created successfully!');
+  console.log('═'.repeat(50));
+  console.log(`\n📁 Project location: ${projectPath}`);
+  console.log('\n🎯 Next steps:');
+  console.log(`   cd ${projectName}`);
+  console.log('   npm run dev\n');
+  console.log('📚 Documentation: https://docs.husar.ai');
+  console.log('💬 Need help? Join our Discord: https://discord.gg/husar\n');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// PROMPTS
+// ═══════════════════════════════════════════════════════════════════════════
+
+/**
+ * Prompt for connection method
+ */
+async function promptConnectionMethod(): Promise<'manual' | 'cloud'> {
+  console.log('How do you want to connect to your CMS?\n');
+  console.log('  1. Enter project URL manually');
+  console.log('  2. Login to husar.ai and select from list\n');
+
+  const choice = await promptChoice(2);
+  return choice === 1 ? 'manual' : 'cloud';
+}
+
+/**
+ * Prompt for manual URL entry
+ */
+async function promptManualUrl(): Promise<string> {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    const ask = () => {
+      rl.question('\n🌐 Enter your CMS panel URL: ', (answer) => {
+        const url = answer.trim();
+
+        // Basic validation
+        if (!url) {
+          console.log('   URL is required.');
+          ask();
+          return;
+        }
+
+        if (!url.startsWith('http://') && !url.startsWith('https://')) {
+          console.log('   URL must start with http:// or https://');
+          ask();
+          return;
+        }
+
+        rl.close();
+        resolve(url);
+      });
+    };
+
+    ask();
+  });
+}
+
+/**
+ * Prompt for project selection from list
+ */
+async function promptSelectProject(projects: CloudProject[]): Promise<CloudProject> {
+  console.log('Select a project:\n');
+  projects.forEach((p, i) => {
+    console.log(`  ${i + 1}. ${p.name}`);
+    console.log(`     ${p.adminURL}\n`);
+  });
+
+  const choice = await promptChoice(projects.length);
+  return projects[choice - 1]!;
+}
+
+/**
+ * Prompt for project directory name
+ */
+async function promptProjectName(suggestedName?: string): Promise<string> {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    const defaultName = suggestedName ? suggestedName.replace(/[^a-zA-Z0-9-_]/g, '-') : '';
+    const prompt = defaultName
+      ? `📝 Enter project directory name [${defaultName}]: `
+      : '📝 Enter project directory name: ';
+
+    rl.question(prompt, (answer) => {
+      rl.close();
+      const name = answer.trim() || defaultName;
+      resolve(name);
+    });
+  });
+}
+
+/**
+ * Prompt for numeric choice
+ */
+async function promptChoice(max: number): Promise<number> {
+  return new Promise((resolvePrompt) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    const ask = () => {
+      rl.question(`Enter choice (1-${max}): `, (answer) => {
+        const num = parseInt(answer, 10);
+        if (num >= 1 && num <= max) {
+          rl.close();
+          resolvePrompt(num);
+        } else {
+          console.log(`Please enter a number between 1 and ${max}`);
+          ask();
+        }
+      });
+    };
+    ask();
+  });
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// CLOUD LOGIN
+// ═══════════════════════════════════════════════════════════════════════════
+
+/**
+ * Ensure user has valid cloud login (JWT)
+ */
+async function ensureCloudLogin(): Promise<{ accessToken: string; email?: string } | null> {
+  // Check if we already have a valid cloud auth
+  const existingAuth = await getCloudAuth();
+
+  if (existingAuth) {
+    // Verify the token is still valid
+    console.log('🔍 Checking existing cloud session...');
+    const isValid = await verifyAccessToken(existingAuth.accessToken);
+
+    if (isValid) {
+      console.log(`✅ Logged in as: ${existingAuth.email ?? 'user'}`);
+      return existingAuth;
+    }
+
+    console.log('⚠️  Session expired, need to re-authenticate...');
+  }
+
+  // Need to login
+  console.log('\n🔐 Please log in to Husar.ai...\n');
+  const result = await startCloudLoginFlow();
+
+  if (result.success && result.accessToken) {
+    console.log(`\n✅ Logged in as: ${result.email ?? 'user'}`);
+    return {
+      accessToken: result.accessToken,
+      email: result.email,
+    };
+  }
+
+  return null;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// FRAMEWORK CLI
+// ═══════════════════════════════════════════════════════════════════════════
+
+/**
+ * Run the framework-specific CLI
+ */
+async function runFrameworkCli(framework: 'nextjs' | 'vite', projectName: string): Promise<boolean> {
+  return new Promise((resolve) => {
+    let command: string;
+    let args: string[];
+
+    if (framework === 'nextjs') {
+      // Using npx create-next-app with recommended options
+      command = 'npx';
+      args = [
+        'create-next-app@latest',
+        projectName,
+        '--typescript',
+        '--tailwind',
+        '--eslint',
+        '--app',
+        '--src-dir',
+        '--import-alias',
+        '@/*',
+      ];
+    } else {
+      // Using npm create vite with React + TypeScript
+      command = 'npm';
+      args = ['create', 'vite@latest', projectName, '--', '--template', 'react-ts'];
+    }
+
+    console.log(`Running: ${command} ${args.join(' ')}\n`);
+
+    const child = spawn(command, args, {
+      stdio: 'inherit',
+      shell: true,
+    });
+
+    child.on('close', (code) => {
+      resolve(code === 0);
+    });
+
+    child.on('error', (err) => {
+      console.error('Failed to start framework CLI:', err.message);
+      resolve(false);
+    });
+  });
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// CONFIGURATION
+// ═══════════════════════════════════════════════════════════════════════════
+
+/**
+ * Add Husar configuration files to the project
+ * Uses HYBRID storage: husar.json (committal) + .env.local (secrets)
+ */
+async function addHusarConfig(projectPath: string, project: ProjectAuth, framework: 'nextjs' | 'vite'): Promise<void> {
+  const hostEnvVar = framework === 'nextjs' ? 'NEXT_PUBLIC_HUSAR_HOST' : 'VITE_HUSAR_HOST';
+
+  // 1. Create husar.json (committal - NO adminToken!)
+  const husarConfig = {
+    host: project.host,
+    hostEnvironmentVariable: hostEnvVar,
+    authenticationEnvironmentVariable: 'HUSAR_API_KEY',
+    adminTokenEnv: 'HUSAR_ADMIN_TOKEN', // Points to env var, not actual token
+    overrideHost: false,
+  };
+  await fs.writeFile(join(projectPath, 'husar.json'), JSON.stringify(husarConfig, null, 2));
+  console.log('   ✓ Created husar.json');
+
+  // 2. Create .env.local (secrets - NOT committed)
+  const envContent = `# Husar CMS Configuration
+# This file contains secrets - DO NOT commit to version control!
+
+# CMS Host URL
+${hostEnvVar}=${project.host}
+
+# Content API Key (for public content queries)
+HUSAR_API_KEY=
+
+# Admin Token (for CLI/MCP operations)
+HUSAR_ADMIN_TOKEN=${project.adminToken}
+`;
+  await fs.writeFile(join(projectPath, '.env.local'), envContent);
+  console.log('   ✓ Created .env.local (contains admin credentials)');
+
+  // 3. Create opencode.jsonc for MCP integration
+  const opencodeConfig = {
+    $schema: 'https://opencode.ai/schemas/opencode.json',
+    mcpServers: {
+      husar: {
+        command: 'npx',
+        args: ['@husar.ai/cli', 'mcp'],
+        cwd: '.',
+      },
+    },
+  };
+  await fs.writeFile(join(projectPath, 'opencode.jsonc'), JSON.stringify(opencodeConfig, null, 2));
+  console.log('   ✓ Created opencode.jsonc (MCP configuration)');
+
+  // 4. Update .gitignore
+  const gitignorePath = join(projectPath, '.gitignore');
+  try {
+    let gitignore = await fs.readFile(gitignorePath, 'utf-8');
+    const additions: string[] = [];
+
+    if (!gitignore.includes('.env.local')) {
+      additions.push('.env.local');
+    }
+    if (!gitignore.includes('.env*.local')) {
+      additions.push('.env*.local');
+    }
+
+    if (additions.length > 0) {
+      gitignore += '\n# Local environment files (contain secrets)\n' + additions.join('\n') + '\n';
+      await fs.writeFile(gitignorePath, gitignore);
+      console.log('   ✓ Updated .gitignore');
+    }
+  } catch {
+    // .gitignore doesn't exist, create it
+    await fs.writeFile(gitignorePath, '# Local environment files (contain secrets)\n.env.local\n.env*.local\n');
+    console.log('   ✓ Created .gitignore');
+  }
+}
+
+/**
+ * Install Husar packages
+ */
+async function installHusarPackages(projectPath: string): Promise<void> {
+  return new Promise((resolve) => {
+    const packages = ['@husar.ai/ssr', '@husar.ai/render'];
+
+    const child = spawn('npm', ['install', ...packages], {
+      cwd: projectPath,
+      stdio: 'inherit',
+      shell: true,
+    });
+
+    child.on('close', () => {
+      console.log('   ✓ Installed @husar.ai/ssr and @husar.ai/render');
+      resolve();
+    });
+
+    child.on('error', (err) => {
+      console.error('Warning: Failed to install packages:', err.message);
+      console.log('   Run manually: npm install @husar.ai/ssr @husar.ai/render');
+      resolve();
+    });
+  });
+}
+
+/**
+ * Generate CMS client files using husar generate
+ */
+async function generateCmsClient(projectPath: string, framework: 'nextjs' | 'vite'): Promise<void> {
+  // Determine src folder based on framework
+  const srcFolder = framework === 'nextjs' ? './src' : './src';
+
+  return new Promise((resolve) => {
+    const child = spawn('npx', ['@husar.ai/cli', 'generate', srcFolder], {
+      cwd: projectPath,
+      stdio: 'inherit',
+      shell: true,
+    });
+
+    child.on('close', (code) => {
+      if (code === 0) {
+        console.log('   ✓ Generated cms/ folder with Zeus client');
+      } else {
+        console.log('   ⚠ CMS generation may have failed - you can run "husar generate" later');
+      }
+      resolve();
+    });
+
+    child.on('error', () => {
+      console.log('   ⚠ Could not generate CMS client - run "husar generate" manually');
+      resolve();
+    });
+  });
+}