blok0 0.1.0 → 0.1.1

package/src/handlers/add-block.ts

@@ -0,0 +1,132 @@
+import * as path from 'path';
+import { isAuthenticated } from '../auth';
+import { apiClient } from '../api';
+import { isBlockRegistered, addBlockToRegistry, calculateDirectoryChecksums } from '../registry';
+import {
+  ensureBlocksDirectory,
+  createBlockDirectory,
+  createBlockEntry,
+  slugToIdentifier,
+  validateBlockDirectory
+} from '../blocks';
+import { updatePageCollectionConfig, updateRenderBlocksComponent, findPagesCollection, findRenderBlocksComponent } from '../ast';
+
+/**
+ * Handle add block command
+ */
+export async function handleAddBlock(blockUrl: string, options: { force?: boolean; dryRun?: boolean } = {}): Promise<void> {
+  console.log('📦 Adding Blok0 Block');
+  console.log('====================');
+  console.log('');
+
+  try {
+    // Step 1: Authentication check
+    console.log('🔐 Checking authentication...');
+    const authenticated = await isAuthenticated();
+    if (!authenticated) {
+      console.error('❌ You are not logged in. Please run `blok0 login` first.');
+      process.exit(1);
+    }
+
+    // Step 2: Fetch block data from API
+    console.log(`📡 Fetching block from: ${blockUrl}`);
+    const { metadata, files } = await apiClient.fetchBlockData(blockUrl);
+    console.log(`✅ Found block: "${metadata.name}" (${metadata.slug})`);
+
+    // Step 3: Check if block is already registered
+    if (isBlockRegistered(metadata.slug)) {
+      if (!options.force) {
+        console.error(`❌ Block "${metadata.slug}" is already installed. Use --force to reinstall.`);
+        process.exit(1);
+      }
+      console.log('⚠️  Block already exists, reinstalling...');
+    }
+
+    if (options.dryRun) {
+      console.log('🔍 Dry run mode - would perform the following actions:');
+      console.log(`  - Create directory: src/blocks/${metadata.slug}`);
+      console.log(`  - Download ${files.length} files`);
+      console.log('  - Update Payload config');
+      console.log('  - Update RenderBlocks component');
+      console.log('  - Register block in blok0-registry.json');
+      return;
+    }
+
+    // Step 4: Ensure blocks directory exists
+    const blocksDir = ensureBlocksDirectory();
+
+    // Step 5: Create block directory and files
+    console.log('📁 Creating block directory and files...');
+    const { dir, configPath, componentPath } = createBlockDirectory(blocksDir, metadata.slug, files);
+    console.log(`✅ Created block directory: ${path.relative(process.cwd(), dir)}`);
+
+    // Step 6: Validate created block
+    const validation = validateBlockDirectory(dir);
+    if (!validation.valid) {
+      console.error('❌ Block validation failed:');
+      validation.errors.forEach(error => console.error(`  - ${error}`));
+      // Cleanup on failure
+      require('fs').rmSync(dir, { recursive: true, force: true });
+      process.exit(1);
+    }
+
+    // Step 7: Calculate checksums
+    const checksums = calculateDirectoryChecksums(dir);
+
+    // Step 8: Create registry entry
+    const blockEntry = createBlockEntry(
+      {
+        id: metadata.id,
+        name: metadata.name,
+        slug: metadata.slug,
+        sourceUrl: blockUrl
+      },
+      dir,
+      configPath,
+      componentPath,
+      checksums
+    );
+
+    // Step 9: Update Pages collection (AST manipulation)
+    const pagesCollectionPath = findPagesCollection();
+    if (pagesCollectionPath) {
+      console.log('🔧 Updating Pages collection...');
+      const blockIdentifier = slugToIdentifier(metadata.slug);
+      const relativeConfigPath = `@/blocks/${metadata.slug}/config`;
+
+      updatePageCollectionConfig(pagesCollectionPath, relativeConfigPath, blockIdentifier);
+      console.log(`✅ Added ${blockIdentifier} to Pages collection`);
+    } else {
+      console.warn('⚠️  Could not find Pages collection file. You may need to manually add the block to your collections.');
+    }
+
+    // Step 10: Update RenderBlocks component (AST manipulation)
+    const renderBlocksPath = findRenderBlocksComponent();
+    if (renderBlocksPath) {
+      console.log('🔧 Updating RenderBlocks component...');
+      const relativeComponentPath = `./${metadata.slug}/Component`;
+
+      updateRenderBlocksComponent(renderBlocksPath, metadata.slug, relativeComponentPath);
+      console.log(`✅ Added ${metadata.slug} component to RenderBlocks`);
+    } else {
+      console.warn('⚠️  Could not find RenderBlocks component. You may need to manually add the block component.');
+    }
+
+    // Step 11: Register block in registry
+    console.log('📝 Registering block...');
+    addBlockToRegistry(blockEntry);
+    console.log('✅ Block registered successfully');
+
+    console.log('');
+    console.log('🎉 Block installation complete!');
+    console.log('');
+    console.log('Next steps:');
+    console.log('1. Review the installed files in src/blocks/' + metadata.slug);
+    console.log('2. Test your application to ensure the block works correctly');
+    console.log('3. Commit the changes to your repository');
+
+  } catch (error) {
+    console.error('❌ Failed to add block:', (error as Error).message);
+    process.exit(1);
+  }
+}

package/src/handlers/generate.ts

@@ -1,62 +1,62 @@
-import { createInterface } from 'readline';
-import { exec, spawn } from 'child_process';
-import { promisify } from 'util';
-
-const execAsync = promisify(exec);
-
-const repoUrl = 'https://github.com/blok0-payload/starter.git';
-
-function prompt(question: string): Promise<boolean> {
-  return new Promise((resolve) => {
-    const rl = createInterface({
-      input: process.stdin,
-      output: process.stdout,
-    });
-    rl.question(question, (answer) => {
-      rl.close();
-      resolve(answer.toLowerCase().startsWith('y'));
-    });
-  });
-}
-
-export async function generateStarter(): Promise<void> {
-  console.log('Cloning starter repository...');
-  try {
-    await execAsync(`git clone --depth 1 ${repoUrl} .`);
-    console.log('Repository cloned successfully.');
-  } catch (error) {
-    throw new Error(`Failed to clone repository: ${error}`);
-  }
-
-  // Prompt for bun install
-  const installDeps = await prompt('Run \'bun install\' to install dependencies? (y/n): ');
-  if (installDeps) {
-    console.log('Installing dependencies...');
-    try {
-      await new Promise<void>((resolve, reject) => {
-        const child = spawn('bun', ['install'], { stdio: 'inherit' });
-        child.on('close', (code) => {
-          if (code === 0) resolve();
-          else reject(new Error('Failed to install dependencies'));
-        });
-        child.on('error', reject);
-      });
-    } catch (error) {
-      console.error('Failed to install dependencies:', error);
-    }
-  }
-
-  // Prompt for git init
-  const initGit = await prompt('Initialize git repository? (y/n): ');
-  if (initGit) {
-    console.log('Initializing git repository...');
-    try {
-      await execAsync('git init');
-      console.log('Git repository initialized.');
-    } catch (error) {
-      console.error('Failed to initialize git:', error);
-    }
-  }
-
-  console.log('Blok0 starter project created successfully!');
-}
+import { createInterface } from 'readline';
+import { exec, spawn } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+
+const repoUrl = 'https://github.com/blok0-payload/starter.git';
+
+function prompt(question: string): Promise<boolean> {
+  return new Promise((resolve) => {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase().startsWith('y'));
+    });
+  });
+}
+
+export async function generateStarter(): Promise<void> {
+  console.log('Cloning starter repository...');
+  try {
+    await execAsync(`git clone --depth 1 ${repoUrl} .`);
+    console.log('Repository cloned successfully.');
+  } catch (error) {
+    throw new Error(`Failed to clone repository: ${error}`);
+  }
+
+  // Prompt for bun install
+  const installDeps = await prompt('Run \'bun install\' to install dependencies? (y/n): ');
+  if (installDeps) {
+    console.log('Installing dependencies...');
+    try {
+      await new Promise<void>((resolve, reject) => {
+        const child = spawn('bun', ['install'], { stdio: 'inherit' });
+        child.on('close', (code) => {
+          if (code === 0) resolve();
+          else reject(new Error('Failed to install dependencies'));
+        });
+        child.on('error', reject);
+      });
+    } catch (error) {
+      console.error('Failed to install dependencies:', error);
+    }
+  }
+
+  // Prompt for git init
+  const initGit = await prompt('Initialize git repository? (y/n): ');
+  if (initGit) {
+    console.log('Initializing git repository...');
+    try {
+      await execAsync('git init');
+      console.log('Git repository initialized.');
+    } catch (error) {
+      console.error('Failed to initialize git:', error);
+    }
+  }
+
+  console.log('Blok0 starter project created successfully!');
+}

package/src/handlers/login.ts

@@ -0,0 +1,130 @@
+import { isAuthenticated, clearCredentials, storeAccessToken, AuthCallback } from '../auth';
+import { AuthServer } from '../auth/server';
+import open from 'open';
+
+// Add SIGINT handler for graceful cleanup
+process.on('SIGINT', () => {
+  console.log('\n\n⚠️  Authentication cancelled by user.');
+  process.exit(0);
+});
+
+/**
+ * Handle login command
+ */
+export async function handleLogin(token?: string, manual?: boolean): Promise<void> {
+  // Direct token authentication (CI/CD)
+  if (token) {
+    try {
+      console.log('🔐 Saving authentication token...');
+      await storeAccessToken(token);
+      console.log('✅ Successfully authenticated!');
+      console.log('');
+      console.log('You can now use blok0 commands that require authentication.');
+    } catch (error) {
+      console.error('❌ Failed to save authentication token:', (error as Error).message);
+      process.exit(1);
+    }
+    return;
+  }
+
+  // Manual authentication instructions
+  if (manual) {
+    showManualInstructions();
+    return;
+  }
+
+  // Default: Browser-based authentication
+  try {
+    await handleBrowserLogin();
+  } catch (error) {
+    console.error('❌ Browser authentication failed:', (error as Error).message);
+    console.log('');
+    console.log('💡 Try manual authentication:');
+    console.log('   blok0 login --manual');
+    process.exit(1);
+  }
+}
+
+/**
+ * Handle browser-based authentication flow
+ */
+async function handleBrowserLogin(): Promise<void> {
+  console.log('🔐 Blok0 Authentication');
+  console.log('======================');
+  console.log('');
+
+  // Create authentication server
+  const authServer = new AuthServer();
+
+  try {
+    // Initialize server (find available port)
+    console.log('🚀 Starting authentication server...');
+    await authServer.initialize();
+
+    // Get the authorization URL (now port is available)
+    const authUrl = authServer.getAuthorizationUrl();
+
+    console.log('🌐 Opening browser for authentication...');
+    await open(authUrl);
+
+    console.log('📱 Please complete authentication in your browser.');
+    console.log('⏳ Waiting for authentication to complete...');
+
+    // Start server and wait for callback
+    const authCallback: AuthCallback = await authServer.start();
+
+    // Store the token
+    console.log('🔐 Saving authentication token...');
+    await storeAccessToken(authCallback.token);
+    console.log('✅ Successfully authenticated!');
+    console.log('');
+    console.log('You can now use blok0 commands that require authentication.');
+
+  } catch (error) {
+    authServer.stop();
+    throw error;
+  }
+}
+
+/**
+ * Show manual authentication instructions
+ */
+function showManualInstructions(): void {
+  console.log('🔐 Blok0 Manual Authentication');
+  console.log('==============================');
+  console.log('');
+  console.log('To authenticate with the Blok0 API, make a POST request to:');
+  console.log('https://www.blok0.xyz/api/customers/login');
+  console.log('');
+  console.log('Example using curl:');
+  console.log('curl -X POST https://www.blok0.xyz/api/customers/login \\');
+  console.log('  -H "Content-Type: application/json" \\');
+  console.log('  -d \'{"email": "your-email@example.com", "password": "your-password"}\'');
+  console.log('');
+  console.log('Then copy the access token and run:');
+  console.log('blok0 login --token <your-token>');
+  console.log('');
+  console.log('For CI/CD environments, set the BLOK0_TOKEN environment variable.');
+  console.log('');
+  console.log('💡 For browser-based login, run: blok0 login');
+}
+
+/**
+ * Handle logout command
+ */
+export async function handleLogout(): Promise<void> {
+  try {
+    const wasAuthenticated = await isAuthenticated();
+
+    if (!wasAuthenticated) {
+      console.log('You are not currently logged in.');
+      return;
+    }
+
+    await clearCredentials();
+    console.log('✅ Successfully logged out and cleared stored credentials.');
+  } catch (error) {
+    console.error('❌ Failed to logout:', (error as Error).message);
+    process.exit(1);
+  }
+}

package/src/index.ts

@@ -1,51 +1,212 @@
-#!/usr/bin/env bun
-
-import { mkdirSync } from 'fs';
-import { createInterface } from 'readline';
-import { checkEmptyDirectory } from './detectors';
-import { generateStarter } from './handlers/generate';
-
-function prompt(question: string): Promise<string> {
-  return new Promise((resolve) => {
-    const rl = createInterface({
-      input: process.stdin,
-      output: process.stdout,
-    });
-    rl.question(question, (answer) => {
-      rl.close();
-      resolve(answer.trim());
-    });
-  });
-}
-
-async function main() {
-  const args = process.argv.slice(2);
-
-  if (args.length < 2 || args[0] !== 'generate' || args[1] !== 'starter') {
-    console.error('Error: Invalid command. Supported: generate starter [folder]');
-    process.exit(1);
-  }
-
-  let targetFolder = args[2];
-  if (!targetFolder) {
-    targetFolder = await prompt('Enter project folder name: ');
-  }
-
-  if (targetFolder !== '.') {
-    mkdirSync(targetFolder, { recursive: true });
-    process.chdir(targetFolder);
-  }
-
-  if (!checkEmptyDirectory()) {
-    process.exit(1);
-  }
-
-  try {
-    await generateStarter();
-  } catch (error) {
-    console.error(`Error: ${(error as Error).message}`);
-    process.exit(1);
-  }
-}
-
-main();
+#!/usr/bin/env node
+
+import { mkdirSync } from 'fs';
+import { createInterface } from 'readline';
+import { checkEmptyDirectory } from './detectors';
+import { generateStarter } from './handlers/generate';
+import { handleLogin, handleLogout } from './handlers/login';
+import { handleAddBlock } from './handlers/add-block';
+import { createEmptyRegistry } from './registry';
+
+function prompt(question: string): Promise<string> {
+  return new Promise((resolve) => {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+async function showHelp() {
+  console.log(`
+Blok0 - PayloadCMS Block Management CLI
+
+USAGE:
+  blok0 <command> [subcommand] [options]
+
+COMMANDS:
+  login                    Authenticate via browser or token
+  logout                   Remove stored credentials
+  debug                    Show authentication debug info
+  generate starter [folder] Generate PayloadCMS starter project
+  add block <url>          Add a block from remote API
+  update block <id>        Update existing block (future)
+  remove block <id>        Remove block and clean up (future)
+  registry validate        Validate registry integrity (future)
+
+OPTIONS:
+  --help, -h               Show this help message
+  --version, -v            Show version information
+  --verbose                Enable verbose logging
+  --dry-run                Preview changes without applying them
+
+EXAMPLES:
+  blok0 login
+  blok0 generate starter my-project
+  blok0 add block https://api.example.com/blocks/123
+
+For more information, visit: https://github.com/blok0-payload/cli
+`);
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
+    showHelp();
+    process.exit(0);
+  }
+
+  if (args.includes('--version') || args.includes('-v')) {
+    const pkg = require('../package.json');
+    console.log(`blok0 v${pkg.version}`);
+    process.exit(0);
+  }
+
+  const [command, ...restArgs] = args;
+
+  try {
+    switch (command) {
+      case 'generate':
+        const [genSubcommand, ...genRestArgs] = restArgs;
+        if (genSubcommand === 'starter') {
+          await handleGenerateStarter(genRestArgs);
+        } else {
+          console.error('Error: Invalid subcommand. Use: blok0 generate starter [folder]');
+          process.exit(1);
+        }
+        break;
+
+      case 'login':
+        // Check for flags
+        const tokenIndex = restArgs.indexOf('--token');
+        const manualIndex = restArgs.indexOf('--manual');
+
+        if (tokenIndex !== -1 && tokenIndex + 1 < restArgs.length) {
+          const token = restArgs[tokenIndex + 1];
+          await handleLogin(token);
+        } else if (manualIndex !== -1) {
+          await handleLogin(undefined, true);
+        } else {
+          await handleLogin();
+        }
+        break;
+
+      case 'logout':
+        await handleLogout();
+        break;
+
+      case 'debug':
+        await handleDebug();
+        break;
+
+      case 'add':
+        const [addSubcommand, ...addRestArgs] = restArgs;
+        if (addSubcommand === 'block') {
+          const blockUrl = addRestArgs[0];
+          if (!blockUrl) {
+            console.error('Error: Block URL is required. Use: blok0 add block <url>');
+            process.exit(1);
+          }
+          const options = {
+            force: addRestArgs.includes('--force'),
+            dryRun: addRestArgs.includes('--dry-run')
+          };
+          await handleAddBlock(blockUrl, options);
+        } else {
+          console.error('Error: Invalid subcommand. Use: blok0 add block <url>');
+          process.exit(1);
+        }
+        break;
+
+      case 'update':
+      case 'remove':
+      case 'registry':
+        console.log(`${command} functionality coming soon...`);
+        break;
+
+      default:
+        console.error(`Error: Unknown command '${command}'`);
+        showHelp();
+        process.exit(1);
+    }
+  } catch (error) {
+    console.error(`Error: ${(error as Error).message}`);
+    process.exit(1);
+  }
+}
+
+async function handleGenerateStarter(args: string[]) {
+  let targetFolder = args[0];
+  if (!targetFolder) {
+    targetFolder = await prompt('Enter project folder name: ');
+  }
+
+  if (targetFolder !== '.') {
+    mkdirSync(targetFolder, { recursive: true });
+    process.chdir(targetFolder);
+  }
+
+  if (!checkEmptyDirectory()) {
+    process.exit(1);
+  }
+
+  await generateStarter();
+
+  // Initialize empty registry for the new project
+  try {
+    createEmptyRegistry();
+    console.log('📝 Initialized blok0-registry.json');
+  } catch (error) {
+    console.warn('⚠️  Failed to initialize registry:', (error as Error).message);
+  }
+}
+
+async function handleDebug() {
+  console.log('🔍 Blok0 CLI Debug Information');
+  console.log('==============================');
+  console.log('');
+
+  // Check stored token
+  const { getAccessToken, isAuthenticated } = await import('./auth');
+  const token = await getAccessToken();
+  const isAuth = await isAuthenticated();
+
+  console.log('🔐 Authentication Status:');
+  console.log(`  Authenticated: ${isAuth ? '✅ Yes' : '❌ No'}`);
+  console.log(`  Token Stored: ${token ? '✅ Yes' : '❌ No'}`);
+
+  if (token) {
+    console.log(`  Token Preview: ${token.substring(0, 20)}...`);
+    console.log(`  Authorization Header: Bearer ${token}`);
+  }
+
+  console.log('');
+  console.log('🌐 API Configuration:');
+  console.log('  Base URL: https://www.blok0.xyz');
+  console.log('  User Agent: blok0-cli/1.0.0');
+
+  console.log('');
+  console.log('🧪 Test API Connection:');
+
+  // Test API connection
+  const { apiClient } = await import('./api');
+  try {
+    const connectionTest = await apiClient.testConnection();
+    console.log(`  Connection Test: ${connectionTest ? '✅ Passed' : '❌ Failed'}`);
+  } catch (error) {
+    console.log(`  Connection Test: ❌ Failed - ${(error as Error).message}`);
+  }
+
+  console.log('');
+  console.log('💡 Next Steps:');
+  console.log('  1. If no token, run: blok0 login');
+  console.log('  2. Test API with: blok0 add block <url>');
+  console.log('  3. Check server logs for detailed request info');
+}
+
+main();