blok0 0.1.0 → 0.1.2

package/dist/index.js

@@ -1,10 +1,46 @@
-#!/usr/bin/env bun
+#!/usr/bin/env node
 "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 });
 const fs_1 = require("fs");
 const readline_1 = require("readline");
 const detectors_1 = require("./detectors");
 const generate_1 = require("./handlers/generate");
+const login_1 = require("./handlers/login");
+const add_block_1 = require("./handlers/add-block");
+const registry_1 = require("./registry");
 function prompt(question) {
     return new Promise((resolve) => {
         const rl = (0, readline_1.createInterface)({
@@ -17,13 +53,119 @@ function prompt(question) {
         });
     });
 }
+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 < 2 || args[0] !== 'generate' || args[1] !== 'starter') {
-        console.error('Error: Invalid command. Supported: generate starter [folder]');
+    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 (0, login_1.handleLogin)(token);
+                }
+                else if (manualIndex !== -1) {
+                    await (0, login_1.handleLogin)(undefined, true);
+                }
+                else {
+                    await (0, login_1.handleLogin)();
+                }
+                break;
+            case 'logout':
+                await (0, login_1.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 (0, add_block_1.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.message}`);
         process.exit(1);
     }
-    let targetFolder = args[2];
+}
+async function handleGenerateStarter(args) {
+    let targetFolder = args[0];
     if (!targetFolder) {
         targetFolder = await prompt('Enter project folder name: ');
     }
@@ -34,12 +176,50 @@ async function main() {
     if (!(0, detectors_1.checkEmptyDirectory)()) {
         process.exit(1);
     }
+    await (0, generate_1.generateStarter)();
+    // Initialize empty registry for the new project
     try {
-        await (0, generate_1.generateStarter)();
+        (0, registry_1.createEmptyRegistry)();
+        console.log('📝 Initialized blok0-registry.json');
     }
     catch (error) {
-        console.error(`Error: ${error.message}`);
-        process.exit(1);
+        console.warn('⚠️  Failed to initialize registry:', error.message);
+    }
+}
+async function handleDebug() {
+    console.log('🔍 Blok0 CLI Debug Information');
+    console.log('==============================');
+    console.log('');
+    // Check stored token
+    const { getAccessToken, isAuthenticated } = await Promise.resolve().then(() => __importStar(require('./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 Promise.resolve().then(() => __importStar(require('./api')));
+    try {
+        const connectionTest = await apiClient.testConnection();
+        console.log(`  Connection Test: ${connectionTest ? '✅ Passed' : '❌ Failed'}`);
+    }
+    catch (error) {
+        console.log(`  Connection Test: ❌ Failed - ${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/dist/registry/index.d.ts

@@ -0,0 +1,75 @@
+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;
+    };
+}
+/**
+ * Load registry from file
+ */
+export declare function loadRegistry(): RegistryData;
+/**
+ * Save registry to file
+ */
+export declare function saveRegistry(registry: RegistryData): void;
+/**
+ * Check if block slug already exists in registry
+ */
+export declare function isBlockRegistered(slug: string): boolean;
+/**
+ * Get block entry by slug
+ */
+export declare function getBlockEntry(slug: string): BlockEntry | null;
+/**
+ * Add block to registry
+ */
+export declare function addBlockToRegistry(entry: BlockEntry): void;
+/**
+ * Remove block from registry
+ */
+export declare function removeBlockFromRegistry(slug: string): void;
+/**
+ * Update block checksums
+ */
+export declare function updateBlockChecksums(slug: string, checksums: {
+    [filename: string]: string;
+}): void;
+/**
+ * Calculate file checksum
+ */
+export declare function calculateChecksum(filePath: string): string;
+/**
+ * Calculate checksums for all files in a directory
+ */
+export declare function calculateDirectoryChecksums(dirPath: string): {
+    [filename: string]: string;
+};
+/**
+ * Validate registry integrity
+ */
+export declare function validateRegistry(): {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Create empty registry for new projects
+ */
+export declare function createEmptyRegistry(): void;

package/dist/registry/index.js

@@ -0,0 +1,231 @@
+"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.loadRegistry = loadRegistry;
+exports.saveRegistry = saveRegistry;
+exports.isBlockRegistered = isBlockRegistered;
+exports.getBlockEntry = getBlockEntry;
+exports.addBlockToRegistry = addBlockToRegistry;
+exports.removeBlockFromRegistry = removeBlockFromRegistry;
+exports.updateBlockChecksums = updateBlockChecksums;
+exports.calculateChecksum = calculateChecksum;
+exports.calculateDirectoryChecksums = calculateDirectoryChecksums;
+exports.validateRegistry = validateRegistry;
+exports.createEmptyRegistry = createEmptyRegistry;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+const REGISTRY_FILE = 'blok0-registry.json';
+const REGISTRY_VERSION = '1.0';
+/**
+ * Get registry file path
+ */
+function getRegistryPath() {
+    return path.join(process.cwd(), REGISTRY_FILE);
+}
+/**
+ * Load registry from file
+ */
+function loadRegistry() {
+    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.message}`);
+    }
+}
+/**
+ * Save registry to file
+ */
+function saveRegistry(registry) {
+    const registryPath = getRegistryPath();
+    try {
+        fs.writeFileSync(registryPath, JSON.stringify(registry, null, 2));
+    }
+    catch (error) {
+        throw new Error(`Failed to save registry: ${error.message}`);
+    }
+}
+/**
+ * Check if block slug already exists in registry
+ */
+function isBlockRegistered(slug) {
+    const registry = loadRegistry();
+    return slug in registry.blocks;
+}
+/**
+ * Get block entry by slug
+ */
+function getBlockEntry(slug) {
+    const registry = loadRegistry();
+    return registry.blocks[slug] || null;
+}
+/**
+ * Add block to registry
+ */
+function addBlockToRegistry(entry) {
+    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
+ */
+function removeBlockFromRegistry(slug) {
+    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
+ */
+function updateBlockChecksums(slug, checksums) {
+    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
+ */
+function calculateChecksum(filePath) {
+    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
+ */
+function calculateDirectoryChecksums(dirPath) {
+    const checksums = {};
+    function walkDirectory(dir) {
+        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
+ */
+function validateRegistry() {
+    const errors = [];
+    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.message}`);
+    }
+    return {
+        valid: errors.length === 0,
+        errors
+    };
+}
+/**
+ * Create empty registry for new projects
+ */
+function createEmptyRegistry() {
+    const registryPath = getRegistryPath();
+    if (fs.existsSync(registryPath)) {
+        throw new Error('Registry already exists');
+    }
+    const emptyRegistry = {
+        version: REGISTRY_VERSION,
+        blocks: {}
+    };
+    saveRegistry(emptyRegistry);
+}

package/package.json

@@ -1,25 +1,33 @@
-{
-  "name": "blok0",
-  "version": "0.1.0",
-  "description": "CLI tool for Payload CMS scaffolding",
-  "main": "dist/index.js",
-  "bin": {
-    "blok0": "./dist/index.js"
-  },
-  "scripts": {
-    "build": "bun run tsc",
-    "dev": "bun run tsx src/index.ts"
-  },
-  "keywords": ["cli", "payload", "cms"],
-  "author": "Your Name",
-  "license": "MIT",
-  "dependencies": {
-    "payload": "^2.0.0"
-  },
-  "devDependencies": {
-    "@types/node": "^20.0.0",
-    "bun-types": "^1.0.0",
-    "tsx": "^4.0.0",
-    "typescript": "^5.0.0"
-  }
-}
+{
+  "name": "blok0",
+  "version": "0.1.2",
+  "description": "CLI tool for Payload CMS scaffolding",
+  "main": "dist/index.js",
+  "bin": {
+    "blok0": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "bun run tsc",
+    "dev": "bun run tsx src/index.ts"
+  },
+  "keywords": [
+    "cli",
+    "payload",
+    "cms"
+  ],
+  "author": "Your Name",
+  "license": "MIT",
+  "dependencies": {
+    "axios": "^1.13.2",
+    "keytar": "^7.9.0",
+    "open": "^11.0.0",
+    "payload": "^2.0.0",
+    "ts-morph": "^27.0.2"
+  },
+  "devDependencies": {
+    "@types/node": "^20.19.27",
+    "bun-types": "^1.0.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.0.0"
+  }
+}