primo-cli 0.1.0

package/dist/commands/publish.js

@@ -0,0 +1,239 @@
+import fs from 'fs/promises';
+import path from 'path';
+import chalk from 'chalk';
+import ora from 'ora';
+import inquirer from 'inquirer';
+import { execSync, spawn } from 'child_process';
+export async function publish(options) {
+    const spinner = ora('Preparing deployment...').start();
+    try {
+        const site_dir = path.resolve(options.dir);
+        // Read primo.json
+        const config_path = path.join(site_dir, 'primo.json');
+        let config;
+        try {
+            const config_data = await fs.readFile(config_path, 'utf-8');
+            config = JSON.parse(config_data);
+        }
+        catch {
+            spinner.fail('No primo.json found. Run `primo new` first.');
+            process.exit(1);
+        }
+        spinner.stop();
+        // Determine provider
+        let provider = options.provider;
+        if (!provider) {
+            const { selected_provider } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'selected_provider',
+                    message: 'Where do you want to deploy?',
+                    choices: [
+                        { name: 'Railway', value: 'railway' },
+                        { name: 'Fly.io', value: 'fly' }
+                    ]
+                }]);
+            provider = selected_provider;
+        }
+        // Check if provider CLI is installed
+        const cli_installed = await check_provider_cli(provider);
+        if (!cli_installed) {
+            console.log('');
+            console.log(chalk.yellow(`${provider} CLI not found. Install it first:`));
+            if (provider === 'railway') {
+                console.log(chalk.dim('  npm install -g @railway/cli'));
+                console.log(chalk.dim('  railway login'));
+            }
+            else {
+                console.log(chalk.dim('  curl -L https://fly.io/install.sh | sh'));
+                console.log(chalk.dim('  fly auth login'));
+            }
+            process.exit(1);
+        }
+        // Generate deployment files
+        spinner.start('Generating deployment files...');
+        await generate_dockerfile(site_dir, config);
+        if (provider === 'fly') {
+            await generate_fly_toml(site_dir, config);
+        }
+        spinner.succeed('Deployment files generated');
+        // Deploy
+        if (provider === 'railway') {
+            await deploy_to_railway(site_dir, config);
+        }
+        else {
+            await deploy_to_fly(site_dir, config);
+        }
+    }
+    catch (error) {
+        spinner.fail(`Deployment failed: ${error instanceof Error ? error.message : error}`);
+        process.exit(1);
+    }
+}
+async function check_provider_cli(provider) {
+    try {
+        if (provider === 'railway') {
+            execSync('railway --version', { stdio: 'ignore' });
+        }
+        else {
+            execSync('fly version', { stdio: 'ignore' });
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function generate_dockerfile(site_dir, config) {
+    const dockerfile = `# Pala CMS Deployment
+FROM golang:1.22-alpine AS builder
+
+RUN apk add --no-cache git
+
+WORKDIR /build
+RUN git clone https://github.com/palacms/palacms.git . && \\
+    go build -o palacms .
+
+FROM alpine:3.19
+
+RUN apk add --no-cache ca-certificates
+
+WORKDIR /app
+
+COPY --from=builder /build/palacms /app/palacms
+
+COPY blocks/ /app/pb_data/blocks/
+COPY pages/ /app/pb_data/pages/
+COPY page-types/ /app/pb_data/page-types/
+COPY site/ /app/pb_data/site/
+COPY uploads/ /app/pb_data/uploads/ 2>/dev/null || true
+COPY primo.json /app/pb_data/
+
+RUN chmod +x /app/palacms
+
+ENV PB_DATA_DIR=/app/pb_data
+
+EXPOSE 8080
+
+CMD ["/app/palacms", "serve", "--http", "0.0.0.0:8080"]
+`;
+    await fs.writeFile(path.join(site_dir, 'Dockerfile'), dockerfile);
+    const dockerignore = `node_modules/
+.git/
+.primo/
+*.log
+.DS_Store
+`;
+    await fs.writeFile(path.join(site_dir, '.dockerignore'), dockerignore);
+}
+async function generate_fly_toml(site_dir, config) {
+    const app_name = config.name.toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/-+/g, '-');
+    const fly_toml = `app = "${app_name}"
+primary_region = "sjc"
+
+[build]
+
+[env]
+  PB_DATA_DIR = "/app/pb_data"
+
+[http_service]
+  internal_port = 8080
+  force_https = true
+  auto_stop_machines = true
+  auto_start_machines = true
+  min_machines_running = 0
+
+[[vm]]
+  memory = "512mb"
+  cpu_kind = "shared"
+  cpus = 1
+
+[mounts]
+  source = "pb_data"
+  destination = "/app/pb_data"
+`;
+    await fs.writeFile(path.join(site_dir, 'fly.toml'), fly_toml);
+}
+async function deploy_to_railway(site_dir, config) {
+    console.log('');
+    console.log(chalk.cyan('Deploying to Railway...'));
+    const spinner = ora('Setting up Railway project...').start();
+    try {
+        try {
+            execSync('railway status', { cwd: site_dir, stdio: 'ignore' });
+            spinner.succeed('Linked to existing Railway project');
+        }
+        catch {
+            spinner.text = 'Creating new Railway project...';
+            execSync(`railway init --name "${config.name}"`, { cwd: site_dir, stdio: 'inherit' });
+            spinner.succeed('Created new Railway project');
+        }
+    }
+    catch (error) {
+        spinner.fail('Failed to set up Railway project');
+        throw error;
+    }
+    console.log('');
+    console.log(chalk.dim('Building and deploying...'));
+    console.log('');
+    const deploy_process = spawn('railway', ['up', '--detach'], {
+        cwd: site_dir,
+        stdio: 'inherit'
+    });
+    return new Promise((resolve, reject) => {
+        deploy_process.on('close', (code) => {
+            if (code === 0) {
+                console.log('');
+                console.log(chalk.green('✓ Deployment started'));
+                console.log('');
+                console.log(chalk.dim('  railway open    - view deployment'));
+                console.log(chalk.dim('  railway logs    - view logs'));
+                resolve();
+            }
+            else {
+                reject(new Error(`Railway deployment failed with code ${code}`));
+            }
+        });
+    });
+}
+async function deploy_to_fly(site_dir, config) {
+    console.log('');
+    console.log(chalk.cyan('Deploying to Fly.io...'));
+    const app_name = config.name.toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/-+/g, '-');
+    const spinner = ora('Checking Fly.io app...').start();
+    try {
+        execSync(`fly status --app ${app_name}`, { cwd: site_dir, stdio: 'ignore' });
+        spinner.succeed(`Found existing app: ${app_name}`);
+    }
+    catch {
+        spinner.text = 'Creating Fly.io app...';
+        execSync(`fly apps create ${app_name}`, { cwd: site_dir, stdio: 'inherit' });
+        spinner.text = 'Creating persistent volume...';
+        execSync(`fly volumes create pb_data --size 1 --region sjc --app ${app_name}`, {
+            cwd: site_dir,
+            stdio: 'inherit'
+        });
+        spinner.succeed(`Created app: ${app_name}`);
+    }
+    console.log('');
+    console.log(chalk.dim('Building and deploying...'));
+    console.log('');
+    const deploy_process = spawn('fly', ['deploy'], {
+        cwd: site_dir,
+        stdio: 'inherit'
+    });
+    return new Promise((resolve, reject) => {
+        deploy_process.on('close', (code) => {
+            if (code === 0) {
+                console.log('');
+                console.log(chalk.green('✓ Deployed'));
+                console.log('');
+                console.log(chalk.cyan(`  https://${app_name}.fly.dev`));
+                console.log(chalk.cyan(`  https://${app_name}.fly.dev/_/  (admin)`));
+                resolve();
+            }
+            else {
+                reject(new Error(`Fly deployment failed with code ${code}`));
+            }
+        });
+    });
+}

package/dist/commands/pull.d.ts

@@ -0,0 +1,8 @@
+interface PullOptions {
+    server?: string;
+    site?: string;
+    output: string;
+    token?: string;
+}
+export declare function pull_site(options: PullOptions): Promise<void>;
+export {};

package/dist/commands/pull.js

@@ -0,0 +1,243 @@
+import fs from 'fs/promises';
+import path from 'path';
+import chalk from 'chalk';
+import ora from 'ora';
+import extract from 'extract-zip';
+import inquirer from 'inquirer';
+import { get_auth_token } from '../utils/auth.js';
+async function detect_server() {
+    // Check common local ports
+    const ports = [3000, 8080, 5173];
+    for (const port of ports) {
+        try {
+            const url = `http://127.0.0.1:${port}`;
+            const response = await fetch(`${url}/api/health`, {
+                signal: AbortSignal.timeout(500)
+            });
+            if (response.ok) {
+                return url;
+            }
+        }
+        catch {
+            // Not running on this port
+        }
+    }
+    return null;
+}
+export async function pull_site(options) {
+    const spinner = ora('Connecting...').start();
+    try {
+        // Detect or use provided server
+        let server;
+        if (options.server) {
+            server = options.server;
+        }
+        else {
+            spinner.text = 'Looking for local server...';
+            const detected = await detect_server();
+            // Default to localhost:3000 if no server detected
+            server = detected || 'http://localhost:3000';
+            spinner.text = `Using ${server}`;
+        }
+        // Get auth token (may not be needed for local)
+        const token = options.token || await get_auth_token(server);
+        // Local servers may not require auth
+        const headers = {};
+        if (token) {
+            headers['Authorization'] = `Bearer ${token}`;
+        }
+        let site_id = options.site;
+        let site_host;
+        // If no site specified, show interactive selection
+        if (!site_id) {
+            spinner.text = 'Fetching sites...';
+            const sites_response = await fetch(`${server}/api/collections/sites/records`, {
+                headers
+            });
+            if (!sites_response.ok) {
+                spinner.fail('Failed to fetch sites');
+                process.exit(1);
+            }
+            const sites_data = await sites_response.json();
+            const sites = sites_data.items || [];
+            if (sites.length === 0) {
+                spinner.fail('No sites found on this server');
+                process.exit(1);
+            }
+            spinner.stop();
+            const { selected_site } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'selected_site',
+                    message: 'Select a site to pull:',
+                    choices: sites.map(site => ({
+                        name: `${site.name} ${chalk.dim(`(${site.host})`)}`,
+                        value: site
+                    }))
+                }]);
+            site_id = selected_site.id;
+            site_host = selected_site.host;
+            spinner.start('Exporting site...');
+        }
+        else {
+            // Fetch site info to get hostname for folder name
+            spinner.text = 'Fetching site info...';
+            const site_response = await fetch(`${server}/api/collections/sites/records/${site_id}`, {
+                headers
+            });
+            if (site_response.ok) {
+                const site_data = await site_response.json();
+                site_host = site_data.host;
+            }
+        }
+        let output_dir = path.resolve(options.output);
+        // If output is default (.), use hostname as folder name
+        if (options.output === '.' && site_host) {
+            const hostname = site_host.split(':')[0];
+            if (hostname && hostname !== 'localhost') {
+                output_dir = path.resolve(hostname);
+            }
+        }
+        await fs.mkdir(output_dir, { recursive: true });
+        // Fetch the export
+        spinner.text = 'Exporting site...';
+        const response = await fetch(`${server}/api/palacms/export/${site_id}`, {
+            headers
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            spinner.fail(`Export failed: ${error}`);
+            process.exit(1);
+        }
+        // Save ZIP temporarily
+        const zip_data = await response.arrayBuffer();
+        const temp_zip = path.join(output_dir, '.primo-export.zip');
+        await fs.writeFile(temp_zip, Buffer.from(zip_data));
+        // Extract ZIP
+        spinner.text = 'Extracting files...';
+        await extract(temp_zip, { dir: output_dir });
+        // Clean up temp ZIP
+        await fs.unlink(temp_zip);
+        // Copy JSON schemas
+        spinner.text = 'Adding JSON schemas...';
+        await copy_schemas(output_dir);
+        // Add $schema references
+        await add_schema_references(output_dir);
+        spinner.succeed(`Site exported to ${chalk.cyan(output_dir)}`);
+        // Show summary
+        const files = await count_files(output_dir);
+        console.log('');
+        console.log(chalk.dim('  Files exported:'));
+        console.log(chalk.dim(`    blocks/     ${files.blocks} blocks`));
+        console.log(chalk.dim(`    page-types/ ${files.page_types} page types`));
+        console.log(chalk.dim(`    pages/      ${files.pages} pages`));
+        console.log('');
+        console.log(chalk.green('  Ready for local development!'));
+        console.log(chalk.dim('  Run `primo dev` to start the local server'));
+    }
+    catch (error) {
+        spinner.fail(`Export failed: ${error instanceof Error ? error.message : error}`);
+        process.exit(1);
+    }
+}
+async function count_files(dir) {
+    const counts = { blocks: 0, page_types: 0, pages: 0 };
+    try {
+        const blocks_dir = path.join(dir, 'blocks');
+        const entries = await fs.readdir(blocks_dir, { withFileTypes: true });
+        counts.blocks = entries.filter(e => e.isDirectory()).length;
+    }
+    catch { }
+    try {
+        const pt_dir = path.join(dir, 'page-types');
+        const entries = await fs.readdir(pt_dir, { withFileTypes: true });
+        counts.page_types = entries.filter(e => e.isDirectory()).length;
+    }
+    catch { }
+    try {
+        const pages_dir = path.join(dir, 'pages');
+        counts.pages = await count_json_files(pages_dir);
+    }
+    catch { }
+    return counts;
+}
+async function count_json_files(dir) {
+    let count = 0;
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (entry.isDirectory()) {
+            count += await count_json_files(path.join(dir, entry.name));
+        }
+        else if (entry.name.endsWith('.json')) {
+            count++;
+        }
+    }
+    return count;
+}
+async function copy_schemas(output_dir) {
+    // Get path to schemas directory relative to compiled dist file
+    const current_file = new URL(import.meta.url).pathname;
+    const dist_dir = path.dirname(path.dirname(current_file)); // dist/
+    const project_root = path.dirname(dist_dir); // project root
+    const schemas_src = path.join(project_root, 'schemas');
+    const schemas_dest = path.join(output_dir, '.schemas');
+    await fs.mkdir(schemas_dest, { recursive: true });
+    const schema_files = await fs.readdir(schemas_src);
+    for (const file of schema_files) {
+        if (file.endsWith('.json')) {
+            await fs.copyFile(path.join(schemas_src, file), path.join(schemas_dest, file));
+        }
+    }
+}
+async function add_schema_references(output_dir) {
+    // Add $schema to block fields.json
+    const blocks_dir = path.join(output_dir, 'blocks');
+    try {
+        const blocks = await fs.readdir(blocks_dir, { withFileTypes: true });
+        for (const block of blocks) {
+            if (block.isDirectory()) {
+                const fields_path = path.join(blocks_dir, block.name, 'fields.json');
+                try {
+                    const fields = JSON.parse(await fs.readFile(fields_path, 'utf-8'));
+                    // Create new object with $schema first
+                    const with_schema = {
+                        $schema: '../../.schemas/fields.schema.json',
+                        ...fields
+                    };
+                    await fs.writeFile(fields_path, JSON.stringify(with_schema, null, 2) + '\n');
+                }
+                catch { }
+            }
+        }
+    }
+    catch { }
+    // Add $schema to page-type config.json
+    const page_types_dir = path.join(output_dir, 'page-types');
+    try {
+        const page_types = await fs.readdir(page_types_dir, { withFileTypes: true });
+        for (const page_type of page_types) {
+            if (page_type.isDirectory()) {
+                const config_path = path.join(page_types_dir, page_type.name, 'config.json');
+                try {
+                    const config = JSON.parse(await fs.readFile(config_path, 'utf-8'));
+                    // Create new object with $schema first
+                    const with_schema = {
+                        $schema: '../../.schemas/page-type-config.schema.json',
+                        ...config
+                    };
+                    await fs.writeFile(config_path, JSON.stringify(with_schema, null, 2) + '\n');
+                }
+                catch { }
+            }
+        }
+    }
+    catch { }
+    // Add $schema to site fields.json
+    const site_fields_path = path.join(output_dir, 'site/fields.json');
+    try {
+        const site_fields = JSON.parse(await fs.readFile(site_fields_path, 'utf-8'));
+        // Site fields is an array, so we need to add $schema differently
+        // Since JSON Schema doesn't support $schema in arrays, we'll skip this for now
+        // IDEs can still use the schema if users manually add it via settings
+    }
+    catch { }
+}

package/dist/commands/push.d.ts

@@ -0,0 +1,9 @@
+interface PushOptions {
+    server?: string;
+    site?: string;
+    dir: string;
+    token?: string;
+    preview?: boolean;
+}
+export declare function push_site(options: PushOptions): Promise<void>;
+export {};

package/dist/commands/push.js

@@ -0,0 +1,118 @@
+import fs from 'fs/promises';
+import path from 'path';
+import chalk from 'chalk';
+import ora from 'ora';
+import archiver from 'archiver';
+import { get_auth_token } from '../utils/auth.js';
+export async function push_site(options) {
+    const spinner = ora('Reading local files...').start();
+    try {
+        const site_dir = path.resolve(options.dir);
+        // Read primo.json for server/site info
+        const config_path = path.join(site_dir, 'primo.json');
+        let config = null;
+        try {
+            const config_data = await fs.readFile(config_path, 'utf-8');
+            config = JSON.parse(config_data);
+        }
+        catch {
+            // No config file, must provide options
+        }
+        const server = options.server || config?.server;
+        const site_id = options.site || config?.site_id;
+        if (!server) {
+            spinner.fail('Server URL required. Use --server or add server field to primo.json.');
+            process.exit(1);
+        }
+        if (!site_id) {
+            spinner.fail('Site ID required. Use --site or add site_id field to primo.json.');
+            process.exit(1);
+        }
+        // Get auth token
+        const token = options.token || await get_auth_token(server);
+        if (!token) {
+            spinner.fail('Authentication required. Use --token or run `primo login` first.');
+            process.exit(1);
+        }
+        // Create ZIP of the site directory
+        spinner.text = 'Packaging files...';
+        const zip_buffer = await create_zip(site_dir);
+        // Send to server
+        const endpoint = options.preview
+            ? `${server}/api/palacms/import/${site_id}/preview`
+            : `${server}/api/palacms/import/${site_id}`;
+        spinner.text = options.preview ? 'Previewing changes...' : 'Pushing changes...';
+        const form_data = new FormData();
+        form_data.append('file', new Blob([zip_buffer]), 'site.zip');
+        const response = await fetch(endpoint, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${token}`
+            },
+            body: form_data
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            spinner.fail(`Push failed: ${error}`);
+            process.exit(1);
+        }
+        const result = await response.json();
+        if (options.preview) {
+            spinner.succeed('Preview complete');
+            console.log('');
+            print_diff(result.diff);
+            console.log('');
+            console.log(chalk.dim('  Run without --preview to apply these changes'));
+        }
+        else {
+            spinner.succeed('Push complete');
+            console.log('');
+            print_diff(result.diff);
+        }
+    }
+    catch (error) {
+        spinner.fail(`Push failed: ${error instanceof Error ? error.message : error}`);
+        process.exit(1);
+    }
+}
+async function create_zip(dir) {
+    return new Promise((resolve, reject) => {
+        const archive = archiver('zip', { zlib: { level: 9 } });
+        const chunks = [];
+        archive.on('data', chunk => chunks.push(chunk));
+        archive.on('end', () => resolve(Buffer.concat(chunks)));
+        archive.on('error', reject);
+        // Add directories
+        const dirs_to_include = ['blocks', 'page-types', 'pages', 'site', 'uploads'];
+        for (const subdir of dirs_to_include) {
+            const full_path = path.join(dir, subdir);
+            archive.directory(full_path, subdir);
+        }
+        // Add primo.json
+        archive.file(path.join(dir, 'primo.json'), { name: 'primo.json' });
+        archive.finalize();
+    });
+}
+function print_diff(diff) {
+    let has_changes = false;
+    for (const [section, changes] of Object.entries(diff)) {
+        const { added, modified, deleted } = changes;
+        if (added.length === 0 && modified.length === 0 && deleted.length === 0) {
+            continue;
+        }
+        has_changes = true;
+        console.log(chalk.bold(`  ${section}:`));
+        for (const item of added) {
+            console.log(chalk.green(`    + ${item}`));
+        }
+        for (const item of modified) {
+            console.log(chalk.yellow(`    ~ ${item}`));
+        }
+        for (const item of deleted) {
+            console.log(chalk.red(`    - ${item}`));
+        }
+    }
+    if (!has_changes) {
+        console.log(chalk.dim('  No changes detected'));
+    }
+}

package/dist/commands/validate.d.ts

@@ -0,0 +1,7 @@
+export declare function normalize_site(site_dir: string): Promise<void>;
+interface ValidateOptions {
+    dir: string;
+    strict?: boolean;
+}
+export declare function validate_site(options: ValidateOptions): Promise<void>;
+export {};