blok0 0.1.0 → 0.1.2

package/dist/blocks/index.d.ts

@@ -0,0 +1,56 @@
+import { BlockEntry } from '../registry';
+import { CodeFile } from '../api';
+/**
+ * Convert slug to PascalCase identifier
+ */
+export declare function slugToIdentifier(slug: string): string;
+/**
+ * Convert slug to folder name (direct mapping)
+ */
+export declare function slugToFolderName(slug: string): string;
+/**
+ * Validate that a directory contains a valid block
+ */
+export declare function validateBlockDirectory(dirPath: string): {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Create block directory structure and write files
+ */
+export declare function createBlockDirectory(baseDir: string, slug: string, files: CodeFile[]): {
+    dir: string;
+    configPath: string;
+    componentPath: string;
+};
+/**
+ * Remove block directory
+ */
+export declare function removeBlockDirectory(dirPath: string): void;
+/**
+ * Create block entry from metadata and file paths
+ */
+export declare function createBlockEntry(metadata: {
+    id: number;
+    name: string;
+    slug: string;
+    sourceUrl: string;
+}, dir: string, configPath: string, componentPath: string, checksums: {
+    [filename: string]: string;
+}): BlockEntry;
+/**
+ * Get all block directories in src/blocks
+ */
+export declare function getBlockDirectories(blocksDir?: string): string[];
+/**
+ * Find blocks by scanning filesystem (fallback when registry is unavailable)
+ */
+export declare function discoverBlocksFromFilesystem(): Array<{
+    slug: string;
+    dir: string;
+    hasConfig: boolean;
+}>;
+/**
+ * Ensure src/blocks directory exists
+ */
+export declare function ensureBlocksDirectory(): string;

package/dist/blocks/index.js

@@ -0,0 +1,189 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.slugToIdentifier = slugToIdentifier;
+exports.slugToFolderName = slugToFolderName;
+exports.validateBlockDirectory = validateBlockDirectory;
+exports.createBlockDirectory = createBlockDirectory;
+exports.removeBlockDirectory = removeBlockDirectory;
+exports.createBlockEntry = createBlockEntry;
+exports.getBlockDirectories = getBlockDirectories;
+exports.discoverBlocksFromFilesystem = discoverBlocksFromFilesystem;
+exports.ensureBlocksDirectory = ensureBlocksDirectory;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Convert slug to PascalCase identifier
+ */
+function slugToIdentifier(slug) {
+    return slug
+        .split('-')
+        .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+        .join('');
+}
+/**
+ * Convert slug to folder name (direct mapping)
+ */
+function slugToFolderName(slug) {
+    return slug;
+}
+/**
+ * Validate that a directory contains a valid block
+ */
+function validateBlockDirectory(dirPath) {
+    const errors = [];
+    if (!fs.existsSync(dirPath)) {
+        errors.push('Block directory does not exist');
+        return { valid: false, errors };
+    }
+    const configPath = path.join(dirPath, 'config.ts');
+    if (!fs.existsSync(configPath)) {
+        errors.push('config.ts file is missing');
+    }
+    // Check if config.ts exports a valid block configuration
+    if (fs.existsSync(configPath)) {
+        try {
+            const configContent = fs.readFileSync(configPath, 'utf-8');
+            // Basic validation - check for required exports
+            if (!configContent.includes('export') || !configContent.includes('Block')) {
+                errors.push('config.ts does not appear to export a valid block configuration');
+            }
+        }
+        catch (error) {
+            errors.push(`Failed to read config.ts: ${error.message}`);
+        }
+    }
+    return { valid: errors.length === 0, errors };
+}
+/**
+ * Create block directory structure and write files
+ */
+function createBlockDirectory(baseDir, slug, files) {
+    const blockDir = path.join(baseDir, slugToFolderName(slug));
+    // Check if directory already exists
+    if (fs.existsSync(blockDir)) {
+        throw new Error(`Block directory already exists: ${blockDir}`);
+    }
+    // Create directory
+    fs.mkdirSync(blockDir, { recursive: true });
+    let configPath = '';
+    let componentPath = '';
+    // Write files
+    for (const file of files) {
+        const filePath = path.join(blockDir, file.name);
+        fs.writeFileSync(filePath, file.content);
+        if (file.name === 'config.ts') {
+            configPath = filePath;
+        }
+        else if (file.name === 'Component.tsx') {
+            componentPath = filePath;
+        }
+    }
+    if (!configPath) {
+        throw new Error('config.ts file was not found in downloaded files');
+    }
+    if (!componentPath) {
+        throw new Error('Component.tsx file was not found in downloaded files');
+    }
+    return { dir: blockDir, configPath, componentPath };
+}
+/**
+ * Remove block directory
+ */
+function removeBlockDirectory(dirPath) {
+    if (fs.existsSync(dirPath)) {
+        fs.rmSync(dirPath, { recursive: true, force: true });
+    }
+}
+/**
+ * Create block entry from metadata and file paths
+ */
+function createBlockEntry(metadata, dir, configPath, componentPath, checksums) {
+    return {
+        id: metadata.id,
+        name: metadata.name,
+        slug: metadata.slug,
+        dir,
+        configPath,
+        componentPath,
+        source: {
+            url: metadata.sourceUrl,
+            id: metadata.id,
+            fetchedAt: new Date().toISOString()
+        },
+        checksums
+    };
+}
+/**
+ * Get all block directories in src/blocks
+ */
+function getBlockDirectories(blocksDir = 'src/blocks') {
+    const fullBlocksDir = path.join(process.cwd(), blocksDir);
+    if (!fs.existsSync(fullBlocksDir)) {
+        return [];
+    }
+    const entries = fs.readdirSync(fullBlocksDir, { withFileTypes: true });
+    return entries
+        .filter(entry => entry.isDirectory())
+        .map(entry => path.join(fullBlocksDir, entry.name));
+}
+/**
+ * Find blocks by scanning filesystem (fallback when registry is unavailable)
+ */
+function discoverBlocksFromFilesystem() {
+    const blocksDir = path.join(process.cwd(), 'src/blocks');
+    if (!fs.existsSync(blocksDir)) {
+        return [];
+    }
+    const blockDirs = getBlockDirectories();
+    const blocks = [];
+    for (const dir of blockDirs) {
+        const slug = path.basename(dir);
+        const configPath = path.join(dir, 'config.ts');
+        const hasConfig = fs.existsSync(configPath);
+        blocks.push({ slug, dir, hasConfig });
+    }
+    return blocks;
+}
+/**
+ * Ensure src/blocks directory exists
+ */
+function ensureBlocksDirectory() {
+    const blocksDir = path.join(process.cwd(), 'src/blocks');
+    if (!fs.existsSync(blocksDir)) {
+        fs.mkdirSync(blocksDir, { recursive: true });
+    }
+    return blocksDir;
+}

package/dist/handlers/add-block.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Handle add block command
+ */
+export declare function handleAddBlock(blockUrl: string, options?: {
+    force?: boolean;
+    dryRun?: boolean;
+}): Promise<void>;

package/dist/handlers/add-block.js

@@ -0,0 +1,142 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleAddBlock = handleAddBlock;
+const path = __importStar(require("path"));
+const auth_1 = require("../auth");
+const api_1 = require("../api");
+const registry_1 = require("../registry");
+const blocks_1 = require("../blocks");
+const ast_1 = require("../ast");
+/**
+ * Handle add block command
+ */
+async function handleAddBlock(blockUrl, options = {}) {
+    console.log('📦 Adding Blok0 Block');
+    console.log('====================');
+    console.log('');
+    try {
+        // Step 1: Authentication check
+        console.log('🔐 Checking authentication...');
+        const authenticated = await (0, auth_1.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 api_1.apiClient.fetchBlockData(blockUrl);
+        console.log(`✅ Found block: "${metadata.name}" (${metadata.slug})`);
+        // Step 3: Check if block is already registered
+        if ((0, registry_1.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 = (0, blocks_1.ensureBlocksDirectory)();
+        // Step 5: Create block directory and files
+        console.log('📁 Creating block directory and files...');
+        const { dir, configPath, componentPath } = (0, blocks_1.createBlockDirectory)(blocksDir, metadata.slug, files);
+        console.log(`✅ Created block directory: ${path.relative(process.cwd(), dir)}`);
+        // Step 6: Validate created block
+        const validation = (0, blocks_1.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 = (0, registry_1.calculateDirectoryChecksums)(dir);
+        // Step 8: Create registry entry
+        const blockEntry = (0, blocks_1.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 = (0, ast_1.findPagesCollection)();
+        if (pagesCollectionPath) {
+            console.log('🔧 Updating Pages collection...');
+            const blockIdentifier = (0, blocks_1.slugToIdentifier)(metadata.slug);
+            const relativeConfigPath = `@/blocks/${metadata.slug}/config`;
+            (0, ast_1.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 = (0, ast_1.findRenderBlocksComponent)();
+        if (renderBlocksPath) {
+            console.log('🔧 Updating RenderBlocks component...');
+            const relativeComponentPath = `./${metadata.slug}/Component`;
+            (0, ast_1.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...');
+        (0, registry_1.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.message);
+        process.exit(1);
+    }
+}

package/dist/handlers/login.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Handle login command
+ */
+export declare function handleLogin(token?: string, manual?: boolean): Promise<void>;
+/**
+ * Handle logout command
+ */
+export declare function handleLogout(): Promise<void>;

package/dist/handlers/login.js

@@ -0,0 +1,124 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleLogin = handleLogin;
+exports.handleLogout = handleLogout;
+const auth_1 = require("../auth");
+const server_1 = require("../auth/server");
+const open_1 = __importDefault(require("open"));
+// Add SIGINT handler for graceful cleanup
+process.on('SIGINT', () => {
+    console.log('\n\n⚠️  Authentication cancelled by user.');
+    process.exit(0);
+});
+/**
+ * Handle login command
+ */
+async function handleLogin(token, manual) {
+    // Direct token authentication (CI/CD)
+    if (token) {
+        try {
+            console.log('🔐 Saving authentication token...');
+            await (0, auth_1.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.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.message);
+        console.log('');
+        console.log('💡 Try manual authentication:');
+        console.log('   blok0 login --manual');
+        process.exit(1);
+    }
+}
+/**
+ * Handle browser-based authentication flow
+ */
+async function handleBrowserLogin() {
+    console.log('🔐 Blok0 Authentication');
+    console.log('======================');
+    console.log('');
+    // Create authentication server
+    const authServer = new server_1.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 (0, open_1.default)(authUrl);
+        console.log('📱 Please complete authentication in your browser.');
+        console.log('⏳ Waiting for authentication to complete...');
+        // Start server and wait for callback
+        const authCallback = await authServer.start();
+        // Store the token
+        console.log('🔐 Saving authentication token...');
+        await (0, auth_1.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() {
+    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
+ */
+async function handleLogout() {
+    try {
+        const wasAuthenticated = await (0, auth_1.isAuthenticated)();
+        if (!wasAuthenticated) {
+            console.log('You are not currently logged in.');
+            return;
+        }
+        await (0, auth_1.clearCredentials)();
+        console.log('✅ Successfully logged out and cleared stored credentials.');
+    }
+    catch (error) {
+        console.error('❌ Failed to logout:', error.message);
+        process.exit(1);
+    }
+}

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-#!/usr/bin/env bun
+#!/usr/bin/env node
 export {};