primo-cli 0.1.0

package/dist/commands/validate.js

@@ -0,0 +1,514 @@
+import fs from 'fs/promises';
+import path from 'path';
+import chalk from 'chalk';
+// Auto-fix common issues without full validation output
+export async function normalize_site(site_dir) {
+    const pages_dir = path.join(site_dir, 'pages');
+    const index_path = path.join(pages_dir, 'index.yaml');
+    try {
+        let content = await fs.readFile(index_path, 'utf-8');
+        const slug_index_pattern = /^slug:\s*index\s*$/m;
+        if (slug_index_pattern.test(content)) {
+            content = content.replace(slug_index_pattern, "slug: ''");
+            await fs.writeFile(index_path, content, 'utf-8');
+        }
+    }
+    catch {
+        // File doesn't exist, skip
+    }
+}
+const VALID_FIELD_TYPES = [
+    'text',
+    'rich-text',
+    'markdown',
+    'image',
+    'link',
+    'url',
+    'icon',
+    'number',
+    'switch',
+    'select',
+    'repeater',
+    'group',
+    'page',
+    'page-list',
+    'page-field',
+    'site-field',
+    'slider',
+    'date',
+    'info'
+];
+export async function validate_site(options) {
+    const errors = [];
+    const warnings = [];
+    const site_dir = path.resolve(options.dir);
+    console.log(chalk.bold('\n🔍 Validating site structure...\n'));
+    try {
+        // Check if directory exists
+        await fs.access(site_dir);
+    }
+    catch {
+        console.log(chalk.red(`✖ Directory not found: ${site_dir}`));
+        process.exit(1);
+    }
+    // Validate blocks
+    const blocks_errors = await validate_blocks(site_dir);
+    errors.push(...blocks_errors.filter(e => e.severity === 'error'));
+    warnings.push(...blocks_errors.filter(e => e.severity === 'warning'));
+    // Validate page types
+    const page_types_errors = await validate_page_types(site_dir);
+    errors.push(...page_types_errors.filter(e => e.severity === 'error'));
+    warnings.push(...page_types_errors.filter(e => e.severity === 'warning'));
+    // Validate site fields
+    const site_errors = await validate_site_fields(site_dir);
+    errors.push(...site_errors.filter(e => e.severity === 'error'));
+    warnings.push(...site_errors.filter(e => e.severity === 'warning'));
+    // Validate pages
+    const pages_errors = await validate_pages(site_dir);
+    errors.push(...pages_errors.filter(e => e.severity === 'error'));
+    warnings.push(...pages_errors.filter(e => e.severity === 'warning'));
+    // Print results
+    if (errors.length === 0 && warnings.length === 0) {
+        console.log(chalk.green('✓ All validations passed!\n'));
+        return;
+    }
+    if (warnings.length > 0) {
+        console.log(chalk.yellow(`⚠ ${warnings.length} warning${warnings.length > 1 ? 's' : ''}:\n`));
+        for (const warning of warnings) {
+            print_error(warning);
+        }
+        console.log('');
+    }
+    if (errors.length > 0) {
+        console.log(chalk.red(`✖ ${errors.length} error${errors.length > 1 ? 's' : ''}:\n`));
+        for (const error of errors) {
+            print_error(error);
+        }
+        console.log('');
+        process.exit(1);
+    }
+}
+async function validate_blocks(site_dir) {
+    const errors = [];
+    const blocks_dir = path.join(site_dir, 'blocks');
+    try {
+        await fs.access(blocks_dir);
+    }
+    catch {
+        return [{
+                file: 'blocks/',
+                message: 'Blocks directory not found',
+                severity: 'error'
+            }];
+    }
+    const block_names = await fs.readdir(blocks_dir);
+    for (const block_name of block_names) {
+        if (block_name.startsWith('.'))
+            continue;
+        const block_dir = path.join(blocks_dir, block_name);
+        const stat = await fs.stat(block_dir);
+        if (!stat.isDirectory())
+            continue;
+        // Check for required files - read actual directory listing to handle case-insensitive filesystems
+        const fields_path = path.join(block_dir, 'fields.json');
+        const block_files = await fs.readdir(block_dir);
+        // Check for component.svelte with correct casing
+        const component_file = block_files.find(f => f.toLowerCase() === 'component.svelte');
+        if (!component_file) {
+            errors.push({
+                file: `blocks/${block_name}/`,
+                message: 'Missing component.svelte file',
+                severity: 'error'
+            });
+        }
+        else if (component_file !== 'component.svelte') {
+            errors.push({
+                file: `blocks/${block_name}/${component_file}`,
+                message: `Filename must be lowercase: "component.svelte", not "${component_file}". The import will silently skip this block.`,
+                severity: 'error'
+            });
+        }
+        try {
+            const fields_data = await fs.readFile(fields_path, 'utf-8');
+            let fields_json;
+            try {
+                fields_json = JSON.parse(fields_data);
+            }
+            catch {
+                errors.push({
+                    file: `blocks/${block_name}/fields.json`,
+                    message: 'Invalid JSON syntax',
+                    severity: 'error'
+                });
+                continue;
+            }
+            // Validate fields structure
+            const field_errors = validate_fields(fields_json, `blocks/${block_name}/fields.json`);
+            errors.push(...field_errors);
+        }
+        catch {
+            errors.push({
+                file: `blocks/${block_name}/`,
+                message: 'Missing fields.json file',
+                severity: 'error'
+            });
+        }
+    }
+    return errors;
+}
+async function validate_page_types(site_dir) {
+    const errors = [];
+    const page_types_dir = path.join(site_dir, 'page-types');
+    try {
+        await fs.access(page_types_dir);
+    }
+    catch {
+        return [{
+                file: 'page-types/',
+                message: 'Page types directory not found',
+                severity: 'warning'
+            }];
+    }
+    const page_type_names = await fs.readdir(page_types_dir);
+    for (const page_type_name of page_type_names) {
+        if (page_type_name.startsWith('.'))
+            continue;
+        const page_type_dir = path.join(page_types_dir, page_type_name);
+        const stat = await fs.stat(page_type_dir);
+        if (!stat.isDirectory())
+            continue;
+        const config_path = path.join(page_type_dir, 'config.json');
+        try {
+            const config_data = await fs.readFile(config_path, 'utf-8');
+            let config;
+            try {
+                config = JSON.parse(config_data);
+            }
+            catch {
+                errors.push({
+                    file: `page-types/${page_type_name}/config.json`,
+                    message: 'Invalid JSON syntax',
+                    severity: 'error'
+                });
+                continue;
+            }
+            // Validate config has required fields
+            if (!config.name) {
+                errors.push({
+                    file: `page-types/${page_type_name}/config.json`,
+                    message: 'Missing "name" field',
+                    severity: 'error'
+                });
+            }
+            // Validate page type fields if they exist
+            if (config.fields) {
+                const field_errors = validate_fields({ fields: config.fields }, `page-types/${page_type_name}/config.json`);
+                errors.push(...field_errors);
+            }
+        }
+        catch {
+            errors.push({
+                file: `page-types/${page_type_name}/`,
+                message: 'Missing config.json file',
+                severity: 'error'
+            });
+        }
+    }
+    return errors;
+}
+async function validate_site_fields(site_dir) {
+    const errors = [];
+    const site_fields_path = path.join(site_dir, 'site/fields.json');
+    try {
+        const fields_data = await fs.readFile(site_fields_path, 'utf-8');
+        let fields_json;
+        try {
+            fields_json = JSON.parse(fields_data);
+        }
+        catch {
+            errors.push({
+                file: 'site/fields.json',
+                message: 'Invalid JSON syntax',
+                severity: 'error'
+            });
+            return errors;
+        }
+        // site/fields.json must be a plain array, not wrapped in an object
+        if (!Array.isArray(fields_json)) {
+            errors.push({
+                file: 'site/fields.json',
+                message: 'Must be a plain array (e.g., []) not wrapped in an object. The import will fail.',
+                severity: 'error'
+            });
+            return errors;
+        }
+        // Validate as array of fields
+        if (fields_json.length > 0) {
+            const field_errors = validate_fields({ fields: fields_json }, 'site/fields.json');
+            errors.push(...field_errors);
+        }
+    }
+    catch {
+        errors.push({
+            file: 'site/',
+            message: 'Missing fields.json file',
+            severity: 'warning'
+        });
+    }
+    return errors;
+}
+function validate_fields(fields_json, file_path) {
+    const errors = [];
+    if (!fields_json.fields || !Array.isArray(fields_json.fields)) {
+        errors.push({
+            file: file_path,
+            message: 'Missing or invalid "fields" array',
+            severity: 'error'
+        });
+        return errors;
+    }
+    const field_ids = new Set();
+    const field_names = new Set();
+    const parent_names = new Set();
+    // Collect all field names for parent validation
+    for (const field of fields_json.fields) {
+        if (field.name) {
+            field_names.add(field.name);
+        }
+    }
+    for (const field of fields_json.fields) {
+        const field_name = field.name || field.id || '(unnamed)';
+        // Check required properties
+        if (!field.id) {
+            errors.push({
+                file: file_path,
+                field: field_name,
+                message: 'Missing required "id" field',
+                severity: 'error'
+            });
+        }
+        else {
+            // Check for duplicate IDs
+            if (field_ids.has(field.id)) {
+                errors.push({
+                    file: file_path,
+                    field: field_name,
+                    message: `Duplicate field ID: "${field.id}"`,
+                    severity: 'error'
+                });
+            }
+            field_ids.add(field.id);
+        }
+        if (!field.name) {
+            errors.push({
+                file: file_path,
+                field: field_name,
+                message: 'Missing required "name" field',
+                severity: 'error'
+            });
+        }
+        if (!field.label && field.type !== 'info') {
+            errors.push({
+                file: file_path,
+                field: field_name,
+                message: 'Missing "label" field',
+                severity: 'warning'
+            });
+        }
+        if (!field.type) {
+            errors.push({
+                file: file_path,
+                field: field_name,
+                message: 'Missing required "type" field',
+                severity: 'error'
+            });
+        }
+        else {
+            // Check valid field type
+            if (!VALID_FIELD_TYPES.includes(field.type)) {
+                errors.push({
+                    file: file_path,
+                    field: field_name,
+                    message: `Invalid field type: "${field.type}". Valid types: ${VALID_FIELD_TYPES.join(', ')}`,
+                    severity: 'error'
+                });
+            }
+            // Type-specific validation
+            if (field.type === 'select') {
+                const select_errors = validate_select_field(field, field_name, file_path);
+                errors.push(...select_errors);
+            }
+            if (field.type === 'repeater' || field.type === 'group') {
+                parent_names.add(field.name);
+            }
+        }
+        // Validate parent reference
+        if (field.parent) {
+            if (!field_names.has(field.parent)) {
+                errors.push({
+                    file: file_path,
+                    field: field_name,
+                    message: `Parent field "${field.parent}" not found`,
+                    severity: 'error'
+                });
+            }
+        }
+    }
+    return errors;
+}
+function validate_select_field(field, field_name, file_path) {
+    const errors = [];
+    if (!field.options || !field.options.options) {
+        errors.push({
+            file: file_path,
+            field: field_name,
+            message: 'Select field missing "options.options" array',
+            severity: 'error'
+        });
+        return errors;
+    }
+    if (!Array.isArray(field.options.options)) {
+        errors.push({
+            file: file_path,
+            field: field_name,
+            message: 'Select field "options.options" must be an array',
+            severity: 'error'
+        });
+        return errors;
+    }
+    for (let i = 0; i < field.options.options.length; i++) {
+        const option = field.options.options[i];
+        if (!option.label) {
+            errors.push({
+                file: file_path,
+                field: field_name,
+                message: `Option ${i + 1} missing "label" property`,
+                severity: 'error'
+            });
+        }
+        if (!option.value) {
+            errors.push({
+                file: file_path,
+                field: field_name,
+                message: `Option ${i + 1} missing "value" property`,
+                severity: 'error'
+            });
+        }
+        if (!('icon' in option)) {
+            errors.push({
+                file: file_path,
+                field: field_name,
+                message: `Option ${i + 1} missing "icon" property (can be empty string)`,
+                severity: 'error'
+            });
+        }
+    }
+    return errors;
+}
+async function validate_pages(site_dir) {
+    const errors = [];
+    const pages_dir = path.join(site_dir, 'pages');
+    try {
+        await fs.access(pages_dir);
+    }
+    catch {
+        return [{
+                file: 'pages/',
+                message: 'Pages directory not found',
+                severity: 'warning'
+            }];
+    }
+    // Recursively find all YAML files in pages directory
+    const yaml_files = await find_yaml_files(pages_dir, 'pages');
+    for (const yaml_file of yaml_files) {
+        const file_path = path.join(site_dir, yaml_file);
+        try {
+            let content = await fs.readFile(file_path, 'utf-8');
+            // Auto-fix: normalize homepage slug from "index" to ""
+            if (yaml_file === 'pages/index.yaml' || yaml_file === 'pages\\index.yaml') {
+                const slug_index_pattern = /^slug:\s*index\s*$/m;
+                if (slug_index_pattern.test(content)) {
+                    content = content.replace(slug_index_pattern, "slug: ''");
+                    await fs.writeFile(file_path, content, 'utf-8');
+                }
+            }
+            // Check for common mistakes
+            if (content.includes('\nblocks:') || content.match(/^blocks:/m)) {
+                errors.push({
+                    file: yaml_file,
+                    message: 'Page uses "blocks:" but should use "sections:" with nested "content" objects. The import will fail.',
+                    severity: 'error'
+                });
+            }
+            // Check that sections have the correct structure
+            if (content.includes('\nsections:') || content.match(/^sections:/m)) {
+                // Basic check: sections should have "block:" and "content:" keys
+                const lines = content.split('\n');
+                let in_sections = false;
+                let found_block = false;
+                let found_content = false;
+                for (const line of lines) {
+                    if (line.match(/^sections:/)) {
+                        in_sections = true;
+                    }
+                    else if (in_sections && line.match(/^\s+- block:/)) {
+                        found_block = true;
+                    }
+                    else if (in_sections && line.match(/^\s+content:/)) {
+                        found_content = true;
+                    }
+                    else if (in_sections && line.match(/^[a-z]/)) {
+                        // New top-level key, end of sections
+                        in_sections = false;
+                    }
+                }
+                if (found_block && !found_content) {
+                    errors.push({
+                        file: yaml_file,
+                        message: 'Sections missing "content:" key. Each section should have "block:" and "content:" keys.',
+                        severity: 'warning'
+                    });
+                }
+            }
+        }
+        catch (err) {
+            errors.push({
+                file: yaml_file,
+                message: `Failed to read file: ${err}`,
+                severity: 'error'
+            });
+        }
+    }
+    return errors;
+}
+async function find_yaml_files(dir, relative_path) {
+    const files = [];
+    try {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.name.startsWith('.'))
+                continue;
+            const full_path = path.join(dir, entry.name);
+            const rel_path = path.join(relative_path, entry.name);
+            if (entry.isDirectory()) {
+                const nested = await find_yaml_files(full_path, rel_path);
+                files.push(...nested);
+            }
+            else if (entry.name.endsWith('.yaml') || entry.name.endsWith('.yml')) {
+                files.push(rel_path);
+            }
+        }
+    }
+    catch {
+        // Directory doesn't exist or not readable
+    }
+    return files;
+}
+function print_error(error) {
+    const icon = error.severity === 'error' ? chalk.red('✖') : chalk.yellow('⚠');
+    const location = error.field
+        ? `${error.file} → ${chalk.bold(error.field)}`
+        : error.file;
+    console.log(`  ${icon} ${chalk.dim(location)}`);
+    console.log(`    ${error.message}`);
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { new_site } from './commands/new.js';
+import { pull_site } from './commands/pull.js';
+import { push_site } from './commands/push.js';
+import { dev_server } from './commands/dev.js';
+import { login } from './commands/login.js';
+import { validate_site } from './commands/validate.js';
+import { publish } from './commands/publish.js';
+import { build_site } from './commands/build.js';
+const program = new Command();
+program
+    .name('primo')
+    .description('Build sites visually, edit them anywhere')
+    .version('0.1.0');
+program
+    .command('new [name]')
+    .description('Create a new site and start local CMS')
+    .option('-t, --template <template>', 'Starter template')
+    .option('--skip-dev', 'Create files only, don\'t start CMS')
+    .action((name, options) => new_site({ name, ...options }));
+program
+    .command('dev')
+    .description('Start local CMS')
+    .option('-d, --dir <dir>', 'Site directory', '.')
+    .option('-p, --port <port>', 'Port', '3000')
+    .action(dev_server);
+program
+    .command('publish')
+    .description('Deploy site with CMS')
+    .option('-d, --dir <dir>', 'Site directory', '.')
+    .option('-p, --provider <provider>', 'Provider (railway, fly)')
+    .action(publish);
+program
+    .command('push')
+    .description('Push local files to hosted CMS')
+    .option('-s, --server <url>', 'Server URL')
+    .option('--site <id>', 'Site ID')
+    .option('-d, --dir <dir>', 'Directory', '.')
+    .option('-t, --token <token>', 'Auth token')
+    .option('--preview', 'Preview only')
+    .action(push_site);
+program
+    .command('pull')
+    .description('Pull from hosted CMS to local files')
+    .option('-s, --server <url>', 'Server URL (auto-detects local)')
+    .option('--site <id>', 'Site ID (interactive if not provided)')
+    .option('-o, --output <dir>', 'Output directory', '.')
+    .option('-t, --token <token>', 'Auth token')
+    .action(pull_site);
+program
+    .command('login')
+    .description('Login to hosted CMS')
+    .argument('<server>', 'Server URL')
+    .option('-e, --email <email>', 'Email')
+    .option('-p, --password <password>', 'Password')
+    .action((server, options) => login({ server, ...options }));
+program
+    .command('validate')
+    .description('Validate site structure')
+    .option('-d, --dir <dir>', 'Directory', '.')
+    .option('--strict', 'Strict mode')
+    .action(validate_site);
+program
+    .command('build')
+    .description('Build static site')
+    .option('-d, --dir <dir>', 'Site directory', '.')
+    .option('-o, --output <dir>', 'Output directory', 'dist')
+    .action(build_site);
+program.parse();

package/dist/utils/auth.d.ts

@@ -0,0 +1,2 @@
+export declare function get_auth_token(server: string): Promise<string | null>;
+export declare function save_auth_token(server: string, token: string): Promise<void>;

package/dist/utils/auth.js

@@ -0,0 +1,29 @@
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+const CONFIG_DIR = path.join(os.homedir(), '.primo');
+const TOKEN_FILE = path.join(CONFIG_DIR, 'tokens.json');
+export async function get_auth_token(server) {
+    try {
+        const data = await fs.readFile(TOKEN_FILE, 'utf-8');
+        const tokens = JSON.parse(data);
+        return tokens[normalize_server(server)] || null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function save_auth_token(server, token) {
+    await fs.mkdir(CONFIG_DIR, { recursive: true });
+    let tokens = {};
+    try {
+        const data = await fs.readFile(TOKEN_FILE, 'utf-8');
+        tokens = JSON.parse(data);
+    }
+    catch { }
+    tokens[normalize_server(server)] = token;
+    await fs.writeFile(TOKEN_FILE, JSON.stringify(tokens, null, 2));
+}
+function normalize_server(server) {
+    return server.replace(/\/+$/, '').toLowerCase();
+}

package/dist/utils/binary.d.ts

@@ -0,0 +1,5 @@
+export declare function get_binary_path(): Promise<string>;
+export declare function ensure_data_dir(base_dir: string): Promise<string>;
+export declare function is_binary_installed(): Promise<boolean>;
+export declare function ensure_binary(): Promise<string>;
+export declare function get_binary_version(): Promise<string | null>;