blok0 0.1.0 → 0.1.2

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://www.blok0.com/api/cli/sections/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 = `https://www.blok0.com/api/cli/sections/${addRestArgs[0]}`;
+          if (!blockUrl) {
+            console.error('Error: Block Slug is required. Use: blok0 add block <slug>');
+            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();

package/src/registry/index.ts

@@ -0,0 +1,244 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as crypto from 'crypto';
+
+export interface BlockSource {
+  url: string;
+  id: number;
+}
+
+export interface BlockEntry {
+  id: number;
+  name: string;
+  slug: string;
+  dir: string;
+  configPath: string;
+  componentPath: string;
+  source: BlockSource & {
+    fetchedAt: string;
+  };
+  checksums: {
+    [filename: string]: string;
+  };
+}
+
+export interface RegistryData {
+  version: string;
+  blocks: {
+    [slug: string]: BlockEntry;
+  };
+}
+
+const REGISTRY_FILE = 'blok0-registry.json';
+const REGISTRY_VERSION = '1.0';
+
+/**
+ * Get registry file path
+ */
+function getRegistryPath(): string {
+  return path.join(process.cwd(), REGISTRY_FILE);
+}
+
+/**
+ * Load registry from file
+ */
+export function loadRegistry(): RegistryData {
+  const registryPath = getRegistryPath();
+
+  if (!fs.existsSync(registryPath)) {
+    return {
+      version: REGISTRY_VERSION,
+      blocks: {}
+    };
+  }
+
+  try {
+    const data = fs.readFileSync(registryPath, 'utf-8');
+    const registry = JSON.parse(data);
+
+    // Validate registry structure
+    if (!registry.version || !registry.blocks) {
+      throw new Error('Invalid registry structure');
+    }
+
+    return registry;
+  } catch (error) {
+    throw new Error(`Failed to load registry: ${(error as Error).message}`);
+  }
+}
+
+/**
+ * Save registry to file
+ */
+export function saveRegistry(registry: RegistryData): void {
+  const registryPath = getRegistryPath();
+
+  try {
+    fs.writeFileSync(registryPath, JSON.stringify(registry, null, 2));
+  } catch (error) {
+    throw new Error(`Failed to save registry: ${(error as Error).message}`);
+  }
+}
+
+/**
+ * Check if block slug already exists in registry
+ */
+export function isBlockRegistered(slug: string): boolean {
+  const registry = loadRegistry();
+  return slug in registry.blocks;
+}
+
+/**
+ * Get block entry by slug
+ */
+export function getBlockEntry(slug: string): BlockEntry | null {
+  const registry = loadRegistry();
+  return registry.blocks[slug] || null;
+}
+
+/**
+ * Add block to registry
+ */
+export function addBlockToRegistry(entry: BlockEntry): void {
+  const registry = loadRegistry();
+
+  if (entry.slug in registry.blocks) {
+    throw new Error(`Block with slug '${entry.slug}' is already registered`);
+  }
+
+  registry.blocks[entry.slug] = entry;
+  saveRegistry(registry);
+}
+
+/**
+ * Remove block from registry
+ */
+export function removeBlockFromRegistry(slug: string): void {
+  const registry = loadRegistry();
+
+  if (!(slug in registry.blocks)) {
+    throw new Error(`Block with slug '${slug}' is not registered`);
+  }
+
+  delete registry.blocks[slug];
+  saveRegistry(registry);
+}
+
+/**
+ * Update block checksums
+ */
+export function updateBlockChecksums(slug: string, checksums: { [filename: string]: string }): void {
+  const registry = loadRegistry();
+
+  if (!(slug in registry.blocks)) {
+    throw new Error(`Block with slug '${slug}' is not registered`);
+  }
+
+  registry.blocks[slug].checksums = checksums;
+  saveRegistry(registry);
+}
+
+/**
+ * Calculate file checksum
+ */
+export function calculateChecksum(filePath: string): string {
+  const fileBuffer = fs.readFileSync(filePath);
+  const hashSum = crypto.createHash('sha256');
+  hashSum.update(fileBuffer);
+  return hashSum.digest('hex');
+}
+
+/**
+ * Calculate checksums for all files in a directory
+ */
+export function calculateDirectoryChecksums(dirPath: string): { [filename: string]: string } {
+  const checksums: { [filename: string]: string } = {};
+
+  function walkDirectory(dir: string): void {
+    const files = fs.readdirSync(dir);
+
+    for (const file of files) {
+      const filePath = path.join(dir, file);
+      const stat = fs.statSync(filePath);
+
+      if (stat.isDirectory()) {
+        walkDirectory(filePath);
+      } else {
+        const relativePath = path.relative(dirPath, filePath);
+        checksums[relativePath] = calculateChecksum(filePath);
+      }
+    }
+  }
+
+  walkDirectory(dirPath);
+  return checksums;
+}
+
+/**
+ * Validate registry integrity
+ */
+export function validateRegistry(): { valid: boolean; errors: string[] } {
+  const errors: string[] = [];
+
+  try {
+    const registry = loadRegistry();
+
+    for (const [slug, entry] of Object.entries(registry.blocks)) {
+      // Check if block directory exists
+      if (!fs.existsSync(entry.dir)) {
+        errors.push(`Block '${slug}': directory '${entry.dir}' does not exist`);
+        continue;
+      }
+
+      // Check if config file exists
+      if (!fs.existsSync(entry.configPath)) {
+        errors.push(`Block '${slug}': config file '${entry.configPath}' does not exist`);
+      }
+
+      // Check if component file exists
+      if (!fs.existsSync(entry.componentPath)) {
+        errors.push(`Block '${slug}': component file '${entry.componentPath}' does not exist`);
+      }
+
+      // Validate checksums if they exist
+      if (entry.checksums) {
+        for (const [file, expectedChecksum] of Object.entries(entry.checksums)) {
+          const filePath = path.join(entry.dir, file);
+          if (fs.existsSync(filePath)) {
+            const actualChecksum = calculateChecksum(filePath);
+            if (actualChecksum !== expectedChecksum) {
+              errors.push(`Block '${slug}': checksum mismatch for '${file}'`);
+            }
+          } else {
+            errors.push(`Block '${slug}': file '${file}' referenced in checksums does not exist`);
+          }
+        }
+      }
+    }
+  } catch (error) {
+    errors.push(`Registry validation failed: ${(error as Error).message}`);
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+/**
+ * Create empty registry for new projects
+ */
+export function createEmptyRegistry(): void {
+  const registryPath = getRegistryPath();
+
+  if (fs.existsSync(registryPath)) {
+    throw new Error('Registry already exists');
+  }
+
+  const emptyRegistry: RegistryData = {
+    version: REGISTRY_VERSION,
+    blocks: {}
+  };
+
+  saveRegistry(emptyRegistry);
+}