primo-cli 0.1.3 → 0.1.5

package/dist/commands/pull.js

@@ -3,10 +3,11 @@ import path from 'path';
 import chalk from 'chalk';
 import ora from 'ora';
 import extract from 'extract-zip';
-import inquirer from 'inquirer';
+import { dump as dump_yaml, load as load_yaml } from 'js-yaml';
 import { get_auth_token } from '../utils/auth.js';
+import { write_site_config } from '../utils/site-config.js';
+import { write_server_config } from '../utils/server-config.js';
 async function detect_server() {
-    // Check common local ports
     const ports = [3000, 8080, 5173];
     for (const port of ports) {
         try {
@@ -24,164 +25,185 @@ async function detect_server() {
     }
     return null;
 }
+function slugify(value) {
+    return value.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '') || 'site';
+}
+function server_folder_name(server) {
+    try {
+        return new URL(server).hostname || 'primo-server';
+    }
+    catch {
+        return 'primo-server';
+    }
+}
 export async function pull_site(options) {
     const spinner = ora('Connecting...').start();
     try {
-        // Detect or use provided server
+        // Resolve server (flag > local detect)
         let server;
         if (options.server) {
-            server = options.server;
+            server = options.server.replace(/\/+$/, '');
         }
         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';
+            server = (detected || 'http://localhost:3000').replace(/\/+$/, '');
             spinner.text = `Using ${server}`;
         }
-        // Get auth token (may not be needed for local)
+        // Auth (optional 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...');
+        // Decide root dir: if --output is default ('.'), nest under server hostname.
+        // Otherwise use --output verbatim.
+        const root_dir = options.output === '.'
+            ? path.resolve(server_folder_name(server))
+            : path.resolve(options.output);
+        await fs.mkdir(root_dir, { recursive: true });
+        // List all sites
+        spinner.text = 'Fetching sites...';
+        const sites_response = await fetch(`${server}/api/collections/sites/records?perPage=200`, {
+            headers
+        });
+        if (!sites_response.ok) {
+            spinner.fail(`Failed to fetch sites (${sites_response.status})`);
+            process.exit(1);
         }
-        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;
+        const sites_data = await sites_response.json();
+        const sites = sites_data.items || [];
+        if (sites.length === 0) {
+            if (!token) {
+                spinner.fail(`Not authenticated. Run \`primo login ${server}\` first.`);
+            }
+            else {
+                spinner.fail('No sites visible — your token may be expired. Try `primo login` again.');
             }
+            process.exit(1);
         }
-        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);
+        // Pull library (best-effort — older servers may not support it)
+        const library_pulled = await pull_library_into(server, headers, root_dir, spinner);
+        // Pull each site into sites/<slug>/
+        const sites_root = path.join(root_dir, 'sites');
+        await fs.mkdir(sites_root, { recursive: true });
+        const used_slugs = new Set();
+        const pulled_sites = [];
+        for (const site of sites) {
+            const base_slug = slugify(site.name || site.host || site.id);
+            let slug = base_slug;
+            let n = 2;
+            while (used_slugs.has(slug)) {
+                slug = `${base_slug}-${n++}`;
             }
+            used_slugs.add(slug);
+            const site_dir = path.join(sites_root, slug);
+            spinner.start(`Pulling ${chalk.cyan(site.name)}...`);
+            await pull_one_site(server, headers, site, site_dir, spinner);
+            pulled_sites.push({ slug, site });
         }
-        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
+        // Fetch site groups so server.yaml has them
+        const site_groups = await fetch_site_groups(server, headers);
+        // Write minimal server.yaml so MCP registration + dev work at the root
+        await write_server_config(root_dir, {
+            port: 3000,
+            site_groups: site_groups.length > 0 ? site_groups : undefined
         });
-        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);
+        spinner.succeed(`Server pulled to ${chalk.cyan(root_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(chalk.dim('  Sites:'));
+        for (const { slug, site } of pulled_sites) {
+            console.log(chalk.dim(`    sites/${slug}/  ${chalk.dim(`(${site.name})`)}`));
+        }
+        if (library_pulled) {
+            console.log(chalk.dim('    library/'));
+        }
+        console.log(chalk.dim(`    server.yaml`));
         console.log('');
         console.log(chalk.green('  Ready for local development!'));
-        console.log(chalk.dim('  Run `primo dev` to start the local server'));
+        console.log(chalk.dim(`  cd ${path.relative(process.cwd(), root_dir) || '.'} && primo dev`));
     }
     catch (error) {
-        spinner.fail(`Export failed: ${error instanceof Error ? error.message : error}`);
+        spinner.fail(`Pull 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;
+async function pull_one_site(server, headers, site, site_dir, spinner) {
+    await fs.mkdir(site_dir, { recursive: true });
+    spinner.text = `Exporting ${site.name}...`;
+    const response = await fetch(`${server}/api/palacms/export/${site.id}`, { headers });
+    if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`Export failed for ${site.name}: ${error}`);
     }
-    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;
+    const zip_data = await response.arrayBuffer();
+    const temp_zip = path.join(site_dir, '.primo-export.zip');
+    await fs.writeFile(temp_zip, Buffer.from(zip_data));
+    spinner.text = `Extracting ${site.name}...`;
+    await extract(temp_zip, { dir: site_dir });
+    await fs.unlink(temp_zip);
+    await write_site_config(site_dir, {
+        name: site.name || 'Imported Site',
+        host: site.host || '',
+        site_id: site.id,
+        server,
+        group: site.group
+    });
+    await copy_schemas(site_dir);
+    await add_schema_references(site_dir);
+}
+async function pull_library_into(server, headers, root_dir, spinner) {
+    spinner.start('Pulling library...');
+    const response = await fetch(`${server}/api/palacms/export-library`, { headers });
+    if (response.status === 404) {
+        spinner.warn('Library export not supported by this server — skipping');
+        return false;
     }
-    catch { }
-    try {
-        const pages_dir = path.join(dir, 'pages');
-        counts.pages = await count_json_files(pages_dir);
+    if (!response.ok) {
+        spinner.warn(`Library export failed (${response.status}) — skipping`);
+        return false;
     }
-    catch { }
-    return counts;
+    const zip_data = await response.arrayBuffer();
+    const temp_zip = path.join(root_dir, '.primo-library-export.zip');
+    await fs.writeFile(temp_zip, Buffer.from(zip_data));
+    await extract(temp_zip, { dir: root_dir });
+    await fs.unlink(temp_zip);
+    return true;
 }
-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++;
-        }
+async function fetch_site_groups(server, headers) {
+    try {
+        const response = await fetch(`${server}/api/collections/site_groups/records?perPage=200`, {
+            headers
+        });
+        if (!response.ok)
+            return [];
+        const data = await response.json();
+        const items = data.items || [];
+        return items.map((g, i) => ({
+            id: g.id,
+            name: g.name || g.id,
+            index: typeof g.index === 'number' ? g.index : i
+        }));
+    }
+    catch {
+        return [];
     }
-    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 dist_dir = path.dirname(path.dirname(current_file));
+    const project_root = path.dirname(dist_dir);
     const schemas_src = path.join(project_root, 'schemas');
     const schemas_dest = path.join(output_dir, '.schemas');
+    let schema_files;
+    try {
+        schema_files = await fs.readdir(schemas_src);
+    }
+    catch {
+        // Schemas not bundled with this CLI install — skip silently
+        return;
+    }
     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));
@@ -189,55 +211,28 @@ async function copy_schemas(output_dir) {
     }
 }
 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');
+    await stamp_schema_on_dir_configs(path.join(output_dir, 'page-types'), 'config.yaml', '../../.schemas/page-type-config.schema.json');
+    await stamp_schema_on_dir_configs(path.join(output_dir, 'blocks'), 'config.yaml', '../../.schemas/block-config.schema.json');
+}
+async function stamp_schema_on_dir_configs(parent_dir, file_name, schema_ref) {
     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 { }
+        const entries = await fs.readdir(parent_dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const config_path = path.join(parent_dir, entry.name, file_name);
+            try {
+                const config = load_yaml(await fs.readFile(config_path, 'utf-8'));
+                if (!config || typeof config !== 'object' || Array.isArray(config))
+                    continue;
+                const with_schema = {
+                    $schema: schema_ref,
+                    ...config
+                };
+                await fs.writeFile(config_path, dump_yaml(with_schema, { lineWidth: -1, noRefs: true }));
             }
+            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-library.d.ts

@@ -0,0 +1,7 @@
+interface PushLibraryOptions {
+    server?: string;
+    dir: string;
+    token?: string;
+}
+export declare function push_library(options: PushLibraryOptions): Promise<void>;
+export {};

package/dist/commands/push-library.js

@@ -0,0 +1,88 @@
+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';
+function is_local_server(server) {
+    try {
+        const url = new URL(server);
+        return url.hostname === 'localhost' || url.hostname === '127.0.0.1';
+    }
+    catch {
+        return false;
+    }
+}
+export async function push_library(options) {
+    const spinner = ora('Reading local library...').start();
+    try {
+        const workspace_dir = path.resolve(options.dir);
+        const library_dir = path.join(workspace_dir, 'library');
+        try {
+            const stat = await fs.stat(library_dir);
+            if (!stat.isDirectory()) {
+                throw new Error('not a directory');
+            }
+        }
+        catch {
+            spinner.fail(`Library directory not found at ${chalk.cyan(library_dir)}.`);
+            process.exit(1);
+        }
+        const server = options.server?.replace(/\/+$/, '');
+        if (!server) {
+            spinner.fail('Server URL required. Pass it as the first argument or use --server.');
+            process.exit(1);
+        }
+        const token = options.token || await get_auth_token(server);
+        if (!token && !is_local_server(server)) {
+            spinner.fail('Authentication required. Use --token or run `primo login` first.');
+            process.exit(1);
+        }
+        spinner.text = 'Packaging library...';
+        const zip_buffer = await create_library_zip(workspace_dir);
+        spinner.text = 'Pushing library...';
+        const form_data = new FormData();
+        form_data.append('file', new Blob([zip_buffer]), 'library.zip');
+        const headers = {};
+        if (token) {
+            headers.Authorization = `Bearer ${token}`;
+        }
+        const response = await fetch(`${server}/api/palacms/import-library`, {
+            method: 'POST',
+            headers,
+            body: form_data
+        });
+        if (response.status === 404) {
+            spinner.fail('Shared library sync is not supported by this palacms server. Update the server before using `primo library push`.');
+            process.exit(1);
+        }
+        if (!response.ok) {
+            const error = await response.text();
+            spinner.fail(`Push failed: ${error}`);
+            process.exit(1);
+        }
+        const result = await response.json();
+        spinner.succeed('Library push complete');
+        if (result.summary) {
+            console.log('');
+            console.log(chalk.dim('  Library imported:'));
+            console.log(chalk.dim(`    groups/ ${result.summary.groups}`));
+            console.log(chalk.dim(`    blocks/ ${result.summary.blocks}`));
+        }
+    }
+    catch (error) {
+        spinner.fail(`Push failed: ${error instanceof Error ? error.message : error}`);
+        process.exit(1);
+    }
+}
+async function create_library_zip(workspace_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);
+        archive.directory(path.join(workspace_dir, 'library'), 'library');
+        archive.finalize();
+    });
+}

package/dist/commands/push.d.ts

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