primo-cli 0.1.2 → 0.1.4

package/dist/commands/push.js

@@ -4,75 +4,382 @@ import chalk from 'chalk';
 import ora from 'ora';
 import archiver from 'archiver';
 import { get_auth_token } from '../utils/auth.js';
+import { read_site_config, get_site_config_path, SITE_CONFIG_FILE } from '../utils/site-config.js';
+import { get_server_config_path, read_server_config } from '../utils/server-config.js';
+async function path_exists(p) {
+    try {
+        await fs.access(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 export async function push_site(options) {
+    const root_dir = path.resolve(options.dir);
+    const has_site_yaml = await path_exists(get_site_config_path(root_dir));
+    const has_server_yaml = await path_exists(get_server_config_path(root_dir));
+    // Resolve a workspace-level default server URL (server.yaml). Used as the
+    // fallback for sites that don't declare their own `server` in site.yaml,
+    // and for the library push.
+    let workspace_server;
+    if (has_server_yaml) {
+        try {
+            const server_config = await read_server_config(root_dir);
+            workspace_server = server_config.server;
+        }
+        catch {
+            // fall through — bad server.yaml will surface elsewhere
+        }
+    }
+    const effective_options = workspace_server && !options.server
+        ? { ...options, server: workspace_server }
+        : options;
+    if (options.dryRun) {
+        await print_push_dry_run(root_dir, has_site_yaml, has_server_yaml, effective_options);
+        return;
+    }
+    // Server-folder mode: walk site subfolders + push library
+    if (!has_site_yaml && has_server_yaml) {
+        await push_server(root_dir, effective_options);
+        return;
+    }
+    // Single-site mode (cwd is a site folder, or --dir points at one)
     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;
+        await push_single_site(root_dir, effective_options, spinner);
+    }
+    catch (error) {
+        spinner.fail(`Push failed: ${error instanceof Error ? error.message : error}`);
+        if (is_auth_error(error))
+            print_auth_hint();
+        process.exit(1);
+    }
+}
+function is_auth_error(error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return /Authentication required/i.test(msg) || /\b401\b/.test(msg) || /unauthorized/i.test(msg);
+}
+function print_auth_hint() {
+    console.log('');
+    console.log(chalk.dim('  Run `primo login -s <server-url>` to authenticate, then retry.'));
+    console.log('');
+}
+async function print_push_dry_run(root_dir, has_site_yaml, has_server_yaml, options) {
+    console.log('');
+    console.log(chalk.bold('Push preview (dry-run)'));
+    console.log('');
+    if (!has_site_yaml && !has_server_yaml) {
+        console.log(chalk.red(`  No ${SITE_CONFIG_FILE} or ${path.basename(get_server_config_path(root_dir))} found in ${root_dir}.`));
+        console.log('');
+        return;
+    }
+    const sites = [];
+    let library_present = false;
+    let inferred_server;
+    if (has_site_yaml) {
         try {
-            const config_data = await fs.readFile(config_path, 'utf-8');
-            config = JSON.parse(config_data);
+            const config = await read_site_config(root_dir);
+            sites.push({ dir: root_dir, config: config, label: config.name || path.basename(root_dir) });
+            inferred_server = config.server;
         }
         catch {
-            // No config file, must provide options
+            // fall through
         }
-        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);
+    }
+    else if (has_server_yaml) {
+        const sites_root = path.join(root_dir, 'sites');
+        if (await path_exists(sites_root)) {
+            const entries = await fs.readdir(sites_root, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory() || entry.name.startsWith('.'))
+                    continue;
+                const candidate = path.join(sites_root, entry.name);
+                if (!await path_exists(get_site_config_path(candidate)))
+                    continue;
+                try {
+                    const config = await read_site_config(candidate);
+                    sites.push({ dir: candidate, config: config, label: config.name || entry.name });
+                    inferred_server = inferred_server || config.server;
+                }
+                catch {
+                    // skip
+                }
+            }
         }
-        if (!site_id) {
-            spinner.fail('Site ID required. Use --site or add site_id field to primo.json.');
-            process.exit(1);
+        library_present = await path_exists(path.join(root_dir, 'library'));
+    }
+    const server = (options.server || inferred_server)?.replace(/\/+$/, '');
+    console.log(`  Target server: ${chalk.cyan(server || '(not set — pass --server or set in site.yaml)')}`);
+    console.log('');
+    console.log(chalk.bold('  Will sync:'));
+    if (sites.length === 0) {
+        console.log(chalk.yellow('    (no sites found)'));
+    }
+    else {
+        for (const site of sites) {
+            console.log(`    ${chalk.green('+')} site: ${site.label}  ${chalk.dim(`(${path.basename(site.dir)})`)}`);
         }
-        // Get auth token
+    }
+    if (library_present) {
+        console.log(`    ${chalk.green('+')} library/`);
+    }
+    console.log('');
+    if (server) {
         const token = options.token || await get_auth_token(server);
-        if (!token) {
-            spinner.fail('Authentication required. Use --token or run `primo login` first.');
+        if (token) {
+            console.log(chalk.dim(`  Auth: token found for ${server}.`));
+        }
+        else {
+            console.log(chalk.yellow(`  Auth: not logged in to ${server}. Run \`primo login -s ${server}\`.`));
+        }
+    }
+    if (options.preview) {
+        console.log(chalk.dim('  --preview flag set: real push would request a server-side preview only.'));
+    }
+    console.log('');
+    console.log(chalk.dim('  No requests sent. Run without --dry-run to push.'));
+    console.log('');
+}
+async function push_server(root_dir, options) {
+    // Sites live under sites/<slug>/
+    const sites_root = path.join(root_dir, 'sites');
+    const site_dirs = [];
+    if (await path_exists(sites_root)) {
+        const entries = await fs.readdir(sites_root, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory() || entry.name.startsWith('.'))
+                continue;
+            const candidate = path.join(sites_root, entry.name);
+            if (await path_exists(get_site_config_path(candidate))) {
+                site_dirs.push(candidate);
+            }
+        }
+    }
+    if (site_dirs.length === 0) {
+        console.log(chalk.yellow('  No site folders found in this server directory.'));
+        process.exit(1);
+    }
+    // --only <slug>: push just one site folder, skip the library
+    if (options.only) {
+        const match = site_dirs.find((d) => path.basename(d) === options.only);
+        if (!match) {
+            const available = site_dirs.map((d) => path.basename(d)).join(', ');
+            console.log(chalk.red(`  No site folder named "${options.only}" under sites/.`));
+            console.log(chalk.dim(`  Available: ${available}`));
             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}`);
+        const spinner = ora(`Pushing ${chalk.cyan(path.basename(match))}...`).start();
+        try {
+            await push_single_site(match, { ...options, dir: match }, spinner);
+        }
+        catch (error) {
+            spinner.fail(`${path.basename(match)}: ${error instanceof Error ? error.message : error}`);
+            if (is_auth_error(error))
+                print_auth_hint();
             process.exit(1);
         }
-        const result = await response.json();
+        return;
+    }
+    let saw_auth_error = false;
+    // Push each site
+    for (const site_dir of site_dirs) {
+        const spinner = ora(`Pushing ${chalk.cyan(path.basename(site_dir))}...`).start();
+        try {
+            await push_single_site(site_dir, { ...options, dir: site_dir }, spinner);
+        }
+        catch (error) {
+            spinner.fail(`${path.basename(site_dir)}: ${error instanceof Error ? error.message : error}`);
+            if (is_auth_error(error))
+                saw_auth_error = true;
+            // Continue to remaining sites rather than abort the whole push
+        }
+    }
+    // Push library if present
+    const library_dir = path.join(root_dir, 'library');
+    if (await path_exists(library_dir)) {
+        const spinner = ora('Pushing library...').start();
+        try {
+            await push_library_dir(root_dir, options, spinner);
+        }
+        catch (error) {
+            spinner.fail(`library: ${error instanceof Error ? error.message : error}`);
+            if (is_auth_error(error))
+                saw_auth_error = true;
+        }
+    }
+    if (saw_auth_error)
+        print_auth_hint();
+}
+async function push_single_site(site_dir, options, spinner) {
+    let config = null;
+    try {
+        config = await read_site_config(site_dir);
+    }
+    catch {
+        // No config file, must provide options
+    }
+    const server = (options.server || config?.server)?.replace(/\/+$/, '');
+    const site_id = options.site || config?.site_id;
+    if (!server) {
+        throw new Error(`Server URL required. Use --server or add server field to ${SITE_CONFIG_FILE}.`);
+    }
+    if (!site_id) {
+        throw new Error(`Site ID required. Use --site or add site_id field to ${SITE_CONFIG_FILE}.`);
+    }
+    const token = options.token || await get_auth_token(server);
+    spinner.text = 'Packaging files...';
+    const zip_buffer = await create_zip(site_dir);
+    // If the user isn't logged in yet, skip the import attempt and try
+    // bootstrap directly. Bootstrap doesn't require auth (only allowed when
+    // the server has zero sites), so it's the right path for first-time
+    // setup against a fresh deployment.
+    if (!token) {
         if (options.preview) {
-            spinner.succeed('Preview complete');
-            console.log('');
-            print_diff(result.diff);
+            throw new Error('Authentication required for --preview. Run `primo login` first.');
+        }
+        spinner.text = 'No auth token — attempting bootstrap...';
+        const bootstrap_result = await try_bootstrap_site(server, undefined, zip_buffer, config, site_id);
+        if (bootstrap_result.ok) {
+            spinner.succeed(`Bootstrapped ${config?.name || path.basename(site_dir)}`);
             console.log('');
-            console.log(chalk.dim('  Run without --preview to apply these changes'));
+            console.log(chalk.dim('  Site created on server and content uploaded.'));
+            console.log(chalk.dim('  Run `primo login` and re-push to update content later.'));
+            return;
         }
-        else {
-            spinner.succeed('Push complete');
+        throw new Error(bootstrap_result.error);
+    }
+    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
+    });
+    // 404 from import means the site doesn't exist on the server yet. On a
+    // freshly-deployed server we can fall back to /api/palacms/bootstrap,
+    // which creates the site and ingests the zip in one shot. Bootstrap is
+    // only available when the server has zero sites — past the first site,
+    // new sites must be created via the dashboard UI.
+    if (response.status === 404 && !options.preview) {
+        spinner.text = 'Site not found on server — bootstrapping...';
+        const bootstrap_result = await try_bootstrap_site(server, token, zip_buffer, config, site_id);
+        if (bootstrap_result.ok) {
+            spinner.succeed(`Bootstrapped ${config?.name || path.basename(site_dir)}`);
             console.log('');
-            print_diff(result.diff);
+            console.log(chalk.dim('  Site created on server and content uploaded.'));
+            console.log(chalk.dim('  Subsequent pushes will use the import endpoint.'));
+            return;
         }
+        throw new Error(bootstrap_result.error);
     }
-    catch (error) {
-        spinner.fail(`Push failed: ${error instanceof Error ? error.message : error}`);
-        process.exit(1);
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    const result = await response.json();
+    const label = config?.name || path.basename(site_dir);
+    if (options.preview) {
+        spinner.succeed(`Preview: ${label}`);
+        console.log('');
+        print_diff(result.diff);
+        console.log('');
+        console.log(chalk.dim('  Run without --preview to apply these changes'));
+    }
+    else {
+        spinner.succeed(`Pushed ${label}`);
+        console.log('');
+        print_diff(result.diff);
+    }
+}
+async function try_bootstrap_site(server, token, zip_buffer, config, site_id) {
+    const form = new FormData();
+    form.append('site_id', site_id);
+    if (config?.name)
+        form.append('name', config.name);
+    if (config?.host)
+        form.append('host', config.host);
+    if (config?.group)
+        form.append('group', config.group);
+    form.append('file', new Blob([zip_buffer]), 'site.zip');
+    const headers = {};
+    if (token)
+        headers['Authorization'] = `Bearer ${token}`;
+    const response = await fetch(`${server}/api/palacms/bootstrap`, {
+        method: 'POST',
+        headers,
+        body: form
+    });
+    if (response.ok)
+        return { ok: true };
+    if (response.status === 403) {
+        return {
+            ok: false,
+            error: `Site '${site_id}' not found on server, and bootstrap is locked ` +
+                `(server already has other sites). Create the site in the dashboard first, ` +
+                `then update site_id in site.yaml to match.`
+        };
+    }
+    return { ok: false, error: await response.text() };
+}
+async function push_library_dir(root_dir, options, spinner) {
+    // Resolve server: --server > any site.yaml's server (they all point at the same server)
+    let server = options.server?.replace(/\/+$/, '');
+    if (!server) {
+        const sites_root = path.join(root_dir, 'sites');
+        if (await path_exists(sites_root)) {
+            const entries = await fs.readdir(sites_root, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                try {
+                    const config = await read_site_config(path.join(sites_root, entry.name));
+                    if (config.server) {
+                        server = config.server.replace(/\/+$/, '');
+                        break;
+                    }
+                }
+                catch { }
+            }
+        }
+    }
+    if (!server)
+        throw new Error('Server URL required for library push.');
+    const token = options.token || await get_auth_token(server);
+    if (!token)
+        throw new Error('Authentication required. Run `primo login` first.');
+    spinner.text = 'Packaging library...';
+    const archive = archiver('zip', { zlib: { level: 9 } });
+    const chunks = [];
+    const zip_buffer = await new Promise((resolve, reject) => {
+        archive.on('data', (chunk) => chunks.push(chunk));
+        archive.on('end', () => resolve(Buffer.concat(chunks)));
+        archive.on('error', reject);
+        archive.directory(path.join(root_dir, 'library'), 'library');
+        archive.finalize();
+    });
+    spinner.text = 'Pushing library...';
+    const form_data = new FormData();
+    form_data.append('file', new Blob([zip_buffer]), 'library.zip');
+    const response = await fetch(`${server}/api/palacms/import-library`, {
+        method: 'POST',
+        headers: { 'Authorization': `Bearer ${token}` },
+        body: form_data
+    });
+    if (response.status === 404) {
+        spinner.warn('Library push not supported by this server — skipping');
+        return;
+    }
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    const result = await response.json();
+    spinner.succeed('Pushed library');
+    if (result.summary) {
+        console.log(chalk.dim(`    groups/ ${result.summary.groups}, blocks/ ${result.summary.blocks}`));
     }
 }
 async function create_zip(dir) {
@@ -88,8 +395,8 @@ async function create_zip(dir) {
             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' });
+        // Add site config
+        archive.file(path.join(dir, SITE_CONFIG_FILE), { name: SITE_CONFIG_FILE });
         archive.finalize();
     });
 }

package/dist/commands/validate.d.ts

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