primo-cli 0.1.10 → 0.1.12

package/dist/commands/deploy.d.ts

@@ -1,6 +1,7 @@
 interface DeployOptions {
     provider?: string;
     dryRun?: boolean;
+    push?: boolean;
 }
 export declare function deploy(options: DeployOptions): Promise<void>;
 export {};

package/dist/commands/deploy.js

@@ -2,10 +2,11 @@ import fs from 'fs/promises';
 import path from 'path';
 import chalk from 'chalk';
 import ora from 'ora';
-import { select } from '@inquirer/prompts';
+import { select, confirm } from '@inquirer/prompts';
 import { execSync, spawn } from 'child_process';
 import { read_server_config, write_server_config, get_server_config_path, SERVER_CONFIG_FILE } from '../utils/server-config.js';
 import { read_site_config, get_site_config_path } from '../utils/site-config.js';
+import { push_site } from './push.js';
 async function path_exists(p) {
     try {
         await fs.access(p);
@@ -135,11 +136,13 @@ export async function deploy(options) {
             await generate_fly_toml(inventory);
         }
         spinner.succeed('Deployment files generated');
+        // commander's --no-push sets push:false; treat anything else as opt-in.
+        const auto_push = options.push !== false;
         if (provider === 'railway') {
-            await deploy_to_railway(inventory);
+            await deploy_to_railway(inventory, auto_push);
         }
         else {
-            await deploy_to_fly(inventory);
+            await deploy_to_fly(inventory, auto_push);
         }
     }
     catch (error) {
@@ -163,7 +166,7 @@ function print_dry_run(inventory, provider) {
     }
     console.log(`    ${chalk.green('+')} Dockerfile in this workspace`);
     console.log('');
-    console.log(chalk.bold('  Will be uploaded after first boot via primo push:'));
+    console.log(chalk.bold('  Will be uploaded automatically once the server is online:'));
     console.log(`    ${chalk.dim('—')} ${SERVER_CONFIG_FILE}`);
     if (inventory.has_library) {
         console.log(`    ${chalk.dim('—')} library/`);
@@ -227,10 +230,10 @@ async function check_provider_auth(provider) {
 // Bump to a release tag (:v3.0.0) when primocms cuts a stable release.
 const PRIMO_SERVER_IMAGE = 'ghcr.io/primocms/primo:main';
 async function generate_dockerfile(inventory) {
-    // One-line Dockerfile: pull the published palacms image and run it
+    // One-line Dockerfile: pull the published primo image and run it
     // unchanged. Workspace data (server.yaml, sites/, library/) is uploaded
-    // after deploy via `primo push`, which calls /api/palacms/bootstrap on
-    // first push (server with no sites) and /api/palacms/import/<id> on
+    // after deploy via `primo push`, which calls /api/primo/bootstrap on
+    // first push (server with no sites) and /api/primo/import/<id> on
     // subsequent pushes. The volume mounted at /app/pb_data persists the
     // SQLite database between restarts.
     void inventory;
@@ -252,7 +255,7 @@ EXPOSE 8080
 }
 async function generate_fly_toml(inventory) {
     const app_name = workspace_app_name(inventory.root_dir);
-    // palacms binds 0.0.0.0:8080 in its CMD; mount /app/pb_data on a persistent
+    // primo binds 0.0.0.0:8080 in its CMD; mount /app/pb_data on a persistent
     // volume so the SQLite db + uploads survive restarts. Auto-start/stop keeps
     // the small instance free-tier-friendly.
     const fly_toml = `app = "${app_name}"
@@ -278,7 +281,7 @@ primary_region = "sjc"
 `;
     await fs.writeFile(path.join(inventory.root_dir, 'fly.toml'), fly_toml);
 }
-async function deploy_to_railway(inventory) {
+async function deploy_to_railway(inventory, auto_push) {
     console.log('');
     console.log(chalk.cyan('Deploying to Railway...'));
     const spinner = ora('Setting up Railway project...').start();
@@ -320,11 +323,44 @@ async function deploy_to_railway(inventory) {
             if (url) {
                 await record_workspace_server(inventory.root_dir, url);
             }
-            print_post_deploy_next_steps('railway', url);
+            // Railway needs a manual volume mount before the server can persist
+            // /app/pb_data. Print the instructions, wait for the user, then poll
+            // readiness and push. If anything in that chain fails we fall back
+            // to the old "next steps" message so the user can finish by hand.
+            const pushed = url
+                ? await finish_railway_deploy(inventory, url, auto_push)
+                : false;
+            print_post_deploy_next_steps('railway', url, { auto_push, pushed });
             resolve();
         });
     });
 }
+async function finish_railway_deploy(inventory, url, auto_push) {
+    console.log('');
+    console.log(chalk.bold('  One manual step on Railway'));
+    console.log(chalk.dim('    Open the project in the Railway dashboard, then:'));
+    console.log(chalk.dim('      Settings → Volumes → mount on /app/pb_data (size 1GB+)'));
+    console.log('');
+    if (!auto_push)
+        return false;
+    let confirmed = false;
+    try {
+        confirmed = await confirm({
+            message: 'Mounted the volume? (press enter to upload your workspace)',
+            default: true
+        });
+    }
+    catch {
+        // Ctrl+C / non-interactive — bail out, user can run primo push later.
+        return false;
+    }
+    if (!confirmed)
+        return false;
+    const ready = await wait_for_ready(url);
+    if (!ready)
+        return false;
+    return await run_auto_push(inventory);
+}
 async function try_railway_domain(cwd) {
     try {
         const out = execSync('railway domain --json', { cwd, stdio: ['ignore', 'pipe', 'ignore'] }).toString();
@@ -351,28 +387,93 @@ async function record_workspace_server(root_dir, url) {
         // the server URL manually.
     }
 }
-function print_post_deploy_next_steps(provider, url) {
+function print_post_deploy_next_steps(provider, url, ctx) {
     console.log('');
-    console.log(chalk.green('✓ Deployment started'));
+    if (ctx.pushed) {
+        console.log(chalk.green('✓ Deployment complete — your workspace is live'));
+    }
+    else {
+        console.log(chalk.green('✓ Server provisioned'));
+    }
     console.log('');
     if (url) {
         console.log(chalk.bold('  URL: ') + chalk.cyan(url));
         console.log(chalk.dim('  (saved as `server:` in server.yaml — primo push/login pick it up automatically)'));
         console.log('');
     }
+    if (ctx.pushed) {
+        console.log(chalk.bold('Next steps'));
+        console.log('');
+        console.log(chalk.dim('  Open the URL above and create your editor account.'));
+        console.log(chalk.dim('  Future edits: `primo push` to upload, `primo pull` to fetch.'));
+        console.log('');
+        return;
+    }
     console.log(chalk.bold('Next steps'));
     console.log('');
-    if (provider === 'railway') {
+    if (provider === 'railway' && !ctx.auto_push) {
+        // User passed --no-push; remind them about the volume since we
+        // skipped the prompt that would normally cover it.
         console.log(chalk.dim('  Railway needs one manual setting the CLI can\'t set for you:'));
         console.log(chalk.dim('    Settings → Volumes → mount on /app/pb_data (size 1GB+)'));
         console.log('');
     }
-    console.log(chalk.dim('  Then upload your workspace into the deployed server:'));
+    console.log(chalk.dim('  Upload your workspace into the deployed server:'));
     console.log(chalk.dim(`    primo push${url ? '' : ' -s <url>'}`));
     console.log(chalk.dim('  (first push bootstraps the sites; later pushes update them incrementally)'));
     console.log('');
 }
-async function deploy_to_fly(inventory) {
+// Poll the deployed server until it answers /api/health with HTTP 200. The
+// timeout is generous because Railway's first build can be slow and the user
+// may have just mounted the volume which forces a restart.
+async function wait_for_ready(url) {
+    const health_url = `${url.replace(/\/+$/, '')}/api/health`;
+    const deadline = Date.now() + 5 * 60 * 1000;
+    const spinner = ora(`Waiting for ${url} to come online...`).start();
+    let attempt = 0;
+    while (Date.now() < deadline) {
+        attempt += 1;
+        try {
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), 5000);
+            const response = await fetch(health_url, { signal: controller.signal });
+            clearTimeout(timer);
+            if (response.ok) {
+                spinner.succeed('Server is online');
+                return true;
+            }
+        }
+        catch {
+            // not ready yet — keep polling
+        }
+        spinner.text = `Waiting for ${url} to come online... (attempt ${attempt})`;
+        await new Promise((r) => setTimeout(r, 3000));
+    }
+    spinner.fail(`Server did not respond at ${health_url} within 5 minutes`);
+    console.log('');
+    console.log(chalk.dim('  The server may still be starting (or the volume is not mounted yet).'));
+    console.log(chalk.dim('  Once the URL above loads in a browser, run `primo push` to upload.'));
+    return false;
+}
+// Run the equivalent of `primo push` against the local workspace. push_site
+// resolves the server URL from server.yaml (which we just wrote), so no extra
+// flags are needed. We surface failures but don't re-throw — the deploy already
+// succeeded and the user can rerun push manually.
+async function run_auto_push(inventory) {
+    console.log('');
+    console.log(chalk.cyan('Uploading your workspace...'));
+    try {
+        await push_site({ dir: inventory.root_dir });
+        return true;
+    }
+    catch (error) {
+        console.log('');
+        console.log(chalk.yellow(`Auto-push failed: ${error instanceof Error ? error.message : error}`));
+        console.log(chalk.dim('  Your server is live — rerun `primo push` once the issue is sorted.'));
+        return false;
+    }
+}
+async function deploy_to_fly(inventory, auto_push) {
     console.log('');
     console.log(chalk.cyan('Deploying to Fly.io...'));
     const app_name = workspace_app_name(inventory.root_dir);
@@ -406,7 +507,15 @@ async function deploy_to_fly(inventory) {
             }
             const url = `https://${app_name}.fly.dev`;
             await record_workspace_server(inventory.root_dir, url);
-            print_post_deploy_next_steps('fly', url);
+            // Fly's CLI provisions the volume for us, so we can go straight to
+            // readiness + push. No interactive prompt required.
+            let pushed = false;
+            if (auto_push) {
+                const ready = await wait_for_ready(url);
+                if (ready)
+                    pushed = await run_auto_push(inventory);
+            }
+            print_post_deploy_next_steps('fly', url, { auto_push, pushed });
             resolve();
         });
     });

package/dist/commands/dev.js

@@ -33,7 +33,7 @@ let is_importing_library = false;
 let has_pending_library_local_changes = false;
 let site_sync_baselines = new Map();
 // Tracks the last set of conflict paths logged per site so we don't reprint
-// the same conflict block every pull cycle when palacms's serialization
+// the same conflict block every pull cycle when primo's serialization
 // keeps producing the same divergence (e.g. data-key mangling, key reorder).
 const last_logged_conflicts = new Map();
 // Track files written by sync to prevent watcher from re-pushing them.
@@ -254,7 +254,7 @@ function hash_snapshot_content(contents) {
 function snapshot_value(snapshot, file_path) {
     return snapshot.has(file_path) ? snapshot.get(file_path) : null;
 }
-// Reads a file but treats ENOENT as a soft miss — palacms' export step can
+// Reads a file but treats ENOENT as a soft miss — primo' export step can
 // reshape the on-disk layout (e.g. promoting pages/foo.yaml to
 // pages/foo/index.yaml when a child route is added) between when a directory
 // listing is captured and when each file is read. The vanished file isn't an
@@ -273,7 +273,7 @@ async function read_file_or_vanish(full_path, label) {
 }
 // A path is "in conflict" when local has content that differs from CMS AND
 // the local content represents a real user change — not just CMS-side
-// serialization noise (palacms re-emits YAML with normalized key order,
+// serialization noise (primo re-emits YAML with normalized key order,
 // ISO-coerced dates, etc., so the CMS export legitimately differs from a
 // freshly-scaffolded file forever, and we don't want to scream about that
 // every pull cycle).
@@ -369,7 +369,7 @@ async function collect_directory_snapshot(current_dir, relative_dir, snapshot, o
     }
 }
 async function fetch_cms_site_snapshot(site_dir, api_url, config, server_config, workspace_dir, temp_name) {
-    const response = await fetch_with_timeout(`${api_url}/api/palacms/export/${config.site_id}`, {}, 15000);
+    const response = await fetch_with_timeout(`${api_url}/api/primo/export/${config.site_id}`, {}, 15000);
     if (!response.ok)
         return null;
     const temp_dir = path.join(site_dir, '.primo', temp_name);
@@ -572,19 +572,19 @@ export async function dev_server(options) {
             }
         }
         // Ensure binary is installed
-        spinner.text = 'Checking palacms...';
+        spinner.text = 'Checking primo...';
         const binary_path = await ensure_binary();
         // Create data directory in project folder
         const data_dir = await ensure_data_dir(base_dir);
         spinner.text = 'Starting CMS...';
         // Start the CMS binary with dev mode enabled. PRIMO_AUTHOR_MODE
-        // tells palacms which sync mode the CLI is running in so the CMS
+        // tells primo which sync mode the CLI is running in so the CMS
         // UI can gate its editable surfaces accordingly (read-only when
         // the CLI is in --author files, since CMS edits would be discarded
         // before they ever round-trip to disk).
         cms_process = spawn(binary_path, ['serve', '--http', `127.0.0.1:${port}`, '--dir', data_dir], {
             stdio: ['pipe', 'pipe', 'pipe'],
-            env: { ...process.env, PALA_DEV_MODE: '1', PRIMO_AUTHOR_MODE: sync_policy.mode }
+            env: { ...process.env, PRIMO_DEV_MODE: '1', PRIMO_AUTHOR_MODE: sync_policy.mode }
         });
         // Capture stderr for errors
         let stderr_output = '';
@@ -1119,11 +1119,11 @@ async function register_primo_mcp_server(base_dir) {
     if (mcp_servers.primo !== undefined) {
         return null;
     }
-    const local_mcp = process.env.PRIMO_MCP_LOCAL
-        ?? '/Users/mateo/Desktop/primo/primo-mcp/dist/index.js';
+    // Default to the published package; PRIMO_MCP_LOCAL opts into a local dist build.
+    const local_mcp = process.env.PRIMO_MCP_LOCAL;
     mcp_servers.primo = local_mcp
         ? { command: 'node', args: [local_mcp] }
-        : { command: 'npx', args: ['-y', '@primo/mcp'] };
+        : { command: 'npx', args: ['-y', 'primo-mcp'] };
     config.mcpServers = mcp_servers;
     // Claude Code reads project-root .mcp.json. .primo/ is gitignored local
     // state, so the discoverable root file is the right registration target.
@@ -1251,7 +1251,7 @@ function change_requires_reload(_dir, _filename) {
     return true;
 }
 async function request_browser_reload(api_url) {
-    await fetch_with_timeout(`${api_url}/api/palacms/dev/reload`, {
+    await fetch_with_timeout(`${api_url}/api/primo/dev/reload`, {
         method: 'POST'
     }, 5000);
 }
@@ -1870,7 +1870,7 @@ async function import_site_files(site_dir, api_url, config, port, server_config,
         const import_form = new FormData();
         import_form.append('file', new Blob([zip_buffer]), 'site.zip');
         const request_started = Date.now();
-        const import_response = await fetch_with_timeout(`${api_url}/api/palacms/import/${site_id}`, {
+        const import_response = await fetch_with_timeout(`${api_url}/api/primo/import/${site_id}`, {
             method: 'POST',
             body: import_form
         }, 300000);
@@ -1912,7 +1912,7 @@ async function import_site_files(site_dir, api_url, config, port, server_config,
         form_data.append('file', new Blob([zip_buffer]), 'site.zip');
         try {
             const bootstrap_started = Date.now();
-            const bootstrap_response = await fetch_with_timeout(`${api_url}/api/palacms/bootstrap`, {
+            const bootstrap_response = await fetch_with_timeout(`${api_url}/api/primo/bootstrap`, {
                 method: 'POST',
                 body: form_data
             }, 300000); // 300s timeout for imports
@@ -1944,7 +1944,7 @@ async function import_site_files(site_dir, api_url, config, port, server_config,
             const import_form = new FormData();
             import_form.append('file', new Blob([zip_buffer]), 'site.zip');
             const import_started = Date.now();
-            const import_response = await fetch_with_timeout(`${api_url}/api/palacms/import/${site_id}`, {
+            const import_response = await fetch_with_timeout(`${api_url}/api/primo/import/${site_id}`, {
                 method: 'POST',
                 body: import_form
             }, 300000); // 300s timeout for imports
@@ -2016,13 +2016,13 @@ async function import_library_files(base_dir, api_url, delete_group_ids = [], de
         }));
     }
     const request_started = Date.now();
-    const response = await fetch_with_timeout(`${api_url}/api/palacms/import-library`, {
+    const response = await fetch_with_timeout(`${api_url}/api/primo/import-library`, {
         method: 'POST',
         body: form_data
     }, 120000);
     const request_ms = Date.now() - request_started;
     if (response.status === 404) {
-        throw new Error('Shared library sync is not supported by the current palacms binary/server. Rebuild or update palacms to use library sync.');
+        throw new Error('Shared library sync is not supported by the current primo binary/server. Rebuild or update primo to use library sync.');
     }
     if (!response.ok) {
         const error_text = await response.text();
@@ -2146,7 +2146,7 @@ async function create_site_zip(dir, excluded_paths = new Set()) {
     });
 }
 async function sync_from_cms(site_dir, api_url, config, server_config, workspace_dir, sync_policy = { mode: 'both' }) {
-    const response = await fetch_with_timeout(`${api_url}/api/palacms/export/${config.site_id}`, {}, 15000);
+    const response = await fetch_with_timeout(`${api_url}/api/primo/export/${config.site_id}`, {}, 15000);
     if (!response.ok)
         return;
     const zip_data = await response.arrayBuffer();
@@ -2240,9 +2240,9 @@ async function sync_from_cms(site_dir, api_url, config, server_config, workspace
     }
 }
 async function sync_library_from_cms(base_dir, api_url) {
-    const response = await fetch_with_timeout(`${api_url}/api/palacms/export-library`, {}, 15000);
+    const response = await fetch_with_timeout(`${api_url}/api/primo/export-library`, {}, 15000);
     if (response.status === 404) {
-        throw new Error('Shared library sync is not supported by the current palacms binary/server. Rebuild or update palacms to use library sync.');
+        throw new Error('Shared library sync is not supported by the current primo binary/server. Rebuild or update primo to use library sync.');
     }
     if (!response.ok)
         return;

package/dist/commands/new.js

@@ -107,10 +107,14 @@ allowed_blocks:
 `);
         await fs.writeFile(path.join(site_dir, 'page-types', 'default', 'fields.yaml'), '[]\n');
         await fs.writeFile(path.join(site_dir, 'page-types', 'default', 'layout.yaml'), `# Sections shared by every page of this type. Add blocks here to render
-# the same header/footer across all pages of this type.
+# the same header/footer across all pages of this type. Body sections are
+# seeded onto each newly created page of this type (and locked when the type
+# has no allowed_blocks).
 #
 # header:
 #   - block: site-header
+# body:
+#   - block: hero
 # footer:
 #   - block: site-footer
 `);

package/dist/commands/pull-library.js

@@ -43,11 +43,11 @@ export async function pull_library(options) {
         const output_dir = path.resolve(options.output || '.');
         await fs.mkdir(output_dir, { recursive: true });
         spinner.text = 'Exporting library...';
-        const response = await fetch(`${server}/api/palacms/export-library`, {
+        const response = await fetch(`${server}/api/primo/export-library`, {
             headers
         });
         if (response.status === 404) {
-            spinner.fail('Shared library sync is not supported by this palacms server. Update the server before using `primo library pull`.');
+            spinner.fail('Shared library sync is not supported by this primo server. Update the server before using `primo library pull`.');
             process.exit(1);
         }
         if (!response.ok) {

package/dist/commands/pull.js

@@ -183,7 +183,7 @@ export async function pull_site(options) {
 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 });
+    const response = await fetch(`${server}/api/primo/export/${site.id}`, { headers });
     if (!response.ok) {
         const error = await response.text();
         throw new Error(`Export failed for ${site.name}: ${error}`);
@@ -205,7 +205,7 @@ async function pull_one_site(server, headers, site, site_dir, spinner) {
 }
 async function pull_library_into(server, headers, root_dir, spinner) {
     spinner.start('Pulling library...');
-    const response = await fetch(`${server}/api/palacms/export-library`, { headers });
+    const response = await fetch(`${server}/api/primo/export-library`, { headers });
     if (response.status === 404) {
         spinner.warn('Library export not supported by this server — skipping');
         return false;

package/dist/commands/push-library.js

@@ -47,13 +47,13 @@ export async function push_library(options) {
         if (token) {
             headers.Authorization = `Bearer ${token}`;
         }
-        const response = await fetch(`${server}/api/palacms/import-library`, {
+        const response = await fetch(`${server}/api/primo/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`.');
+            spinner.fail('Shared library sync is not supported by this primo server. Update the server before using `primo library push`.');
             process.exit(1);
         }
         if (!response.ok) {

package/dist/commands/push.js

@@ -15,6 +15,30 @@ async function path_exists(p) {
         return false;
     }
 }
+// Look up the display name for a group ID by walking up from the site dir
+// to find a workspace server.yaml. site.yaml only stores the group ID, so
+// without this the server has nothing to label the group with on first push
+// and falls back to humanizing the random ID ("8Y17hao5jt2xmd8").
+async function resolve_group_name(site_dir, group_id) {
+    if (!group_id)
+        return undefined;
+    // Typical layout: <workspace>/sites/<slug>/site.yaml — server.yaml lives two levels up.
+    const candidates = [path.dirname(path.dirname(site_dir)), path.dirname(site_dir), site_dir];
+    for (const dir of candidates) {
+        if (!(await path_exists(get_server_config_path(dir))))
+            continue;
+        try {
+            const cfg = await read_server_config(dir);
+            const match = cfg.site_groups?.find((g) => g.id === group_id);
+            if (match?.name)
+                return match.name;
+        }
+        catch {
+            // ignore — bad server.yaml shouldn't block the push
+        }
+    }
+    return undefined;
+}
 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));
@@ -230,6 +254,7 @@ async function push_single_site(site_dir, options, spinner) {
     const token = options.token || await get_auth_token(server);
     spinner.text = 'Packaging files...';
     const zip_buffer = await create_zip(site_dir);
+    const group_name = await resolve_group_name(site_dir, config?.group);
     // 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
@@ -239,7 +264,7 @@ async function push_single_site(site_dir, options, spinner) {
             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);
+        const bootstrap_result = await try_bootstrap_site(server, undefined, zip_buffer, config, site_id, group_name);
         if (bootstrap_result.ok) {
             spinner.succeed(`Bootstrapped ${config?.name || path.basename(site_dir)}`);
             console.log('');
@@ -250,24 +275,26 @@ async function push_single_site(site_dir, options, spinner) {
         throw new Error(bootstrap_result.error);
     }
     const endpoint = options.preview
-        ? `${server}/api/palacms/import/${site_id}/preview`
-        : `${server}/api/palacms/import/${site_id}`;
+        ? `${server}/api/primo/import/${site_id}/preview`
+        : `${server}/api/primo/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');
+    if (group_name)
+        form_data.append('group_name', group_name);
     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,
+    // freshly-deployed server we can fall back to /api/primo/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);
+        const bootstrap_result = await try_bootstrap_site(server, token, zip_buffer, config, site_id, group_name);
         if (bootstrap_result.ok) {
             spinner.succeed(`Bootstrapped ${config?.name || path.basename(site_dir)}`);
             console.log('');
@@ -295,13 +322,15 @@ async function push_single_site(site_dir, options, spinner) {
         print_diff(result.diff);
     }
 }
-async function try_bootstrap_site(server, token, zip_buffer, config, site_id) {
+async function try_bootstrap_site(server, token, zip_buffer, config, site_id, group_name) {
     const form = new FormData();
     form.append('site_id', site_id);
     if (config?.name)
         form.append('name', config.name);
     if (config?.group)
         form.append('group', config.group);
+    if (group_name)
+        form.append('group_name', group_name);
     // Register the site against the deploy URL's host so the first visit to
     // that domain finds a matching site instead of dropping into CreateSite.
     try {
@@ -314,7 +343,7 @@ async function try_bootstrap_site(server, token, zip_buffer, config, site_id) {
     const headers = {};
     if (token)
         headers['Authorization'] = `Bearer ${token}`;
-    const response = await fetch(`${server}/api/palacms/bootstrap`, {
+    const response = await fetch(`${server}/api/primo/bootstrap`, {
         method: 'POST',
         headers,
         body: form
@@ -370,7 +399,7 @@ async function push_library_dir(root_dir, options, spinner) {
     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`, {
+    const response = await fetch(`${server}/api/primo/import-library`, {
         method: 'POST',
         headers: { 'Authorization': `Bearer ${token}` },
         body: form_data

package/dist/commands/validate.js

@@ -456,7 +456,7 @@ async function validate_page_types(site_dir) {
             }
         }
         // layout.yaml is required — comment-only stub is fine, but the file
-        // must exist so the page type's shared header/footer slots are
+        // must exist so the page type's header/body/footer slots are
         // discoverable.
         try {
             await fs.access(layout_path);
@@ -464,7 +464,7 @@ async function validate_page_types(site_dir) {
         catch {
             errors.push({
                 file: `page-types/${page_type_name}/layout.yaml`,
-                message: 'Missing layout.yaml. Each page type needs one (use the comment-only stub if there are no shared header/footer sections yet).',
+                message: 'Missing layout.yaml. Each page type needs one (use the comment-only stub if there are no shared header/body/footer sections yet).',
                 severity: 'error'
             });
         }

package/dist/index.js

@@ -56,6 +56,7 @@ program
     .command('deploy')
     .description('Deploy this workspace (all sites) with editable CMS (Railway, Fly)')
     .option('-p, --provider <provider>', 'Provider: railway | fly')
+    .option('--no-push', 'Skip uploading the workspace after provisioning (you can run `primo push` later)')
     .option('--dry-run', 'Show what would be deployed without doing anything')
     .addHelpText('after', `
 ${chalk.bold('Supported providers')}

package/dist/utils/binary.js

@@ -9,11 +9,10 @@ import ora from 'ora';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const PRIMO_HOME = path.join(os.homedir(), '.primo');
 const BIN_DIR = path.join(PRIMO_HOME, 'bin');
-const DATA_DIR = path.join(PRIMO_HOME, 'data');
-const VERSION = '3.1.0'; // matches palacms releases
+const VERSION = '3.2.0'; // matches primo releases
 // Path to locally built binary (for development)
-// The binary is at palacms/palacms (inside the palacms repo directory)
-const LOCAL_BINARY = path.resolve(__dirname, '..', '..', '..', 'palacms', 'palacms');
+// The binary is at primo/primo (inside the primo repo directory)
+const LOCAL_BINARY = path.resolve(__dirname, '..', '..', '..', 'primo', 'primo');
 function get_platform() {
     const platform = os.platform();
     const arch = os.arch();
@@ -47,13 +46,25 @@ function get_platform() {
     return { os: osName, arch: archName, ext };
 }
 function get_download_url(platform) {
-    // TODO: Update to actual GitHub releases URL
-    const base = 'https://github.com/palacms/palacms/releases/download';
-    const filename = `palacms_${platform.os}_${platform.arch}${platform.ext}`;
+    const base = 'https://github.com/primocms/primo/releases/download';
+    const filename = `primo_${platform.os}_${platform.arch}${platform.ext}`;
     return `${base}/v${VERSION}/${filename}`;
 }
 export async function get_binary_path() {
-    // Check for locally built binary first (development)
+    // Explicit override wins — layout-independent, the way to point at a
+    // local server build regardless of where this CLI lives on disk.
+    const override = process.env.PRIMO_BINARY;
+    if (override) {
+        try {
+            await fs.access(override, fs.constants.X_OK);
+            return override;
+        }
+        catch {
+            throw new Error(`PRIMO_BINARY is set to "${override}" but it is not an executable file`);
+        }
+    }
+    // Otherwise prefer a sibling dev build (only resolves when running from
+    // source next to a `primo` checkout), then fall back to the download.
     try {
         await fs.access(LOCAL_BINARY, fs.constants.X_OK);
         return LOCAL_BINARY;
@@ -61,7 +72,7 @@ export async function get_binary_path() {
     catch { }
     // Fall back to downloaded binary
     const platform = get_platform();
-    return path.join(BIN_DIR, `palacms${platform.ext}`);
+    return path.join(BIN_DIR, `primo${platform.ext}`);
 }
 export async function ensure_data_dir(base_dir) {
     const data_dir = path.join(base_dir, '.primo');
@@ -79,18 +90,23 @@ export async function is_binary_installed() {
     }
 }
 export async function ensure_binary() {
+    // If PRIMO_BINARY is set, honor it exclusively — surface a bad override
+    // rather than silently downloading a release binary behind the user's back.
+    if (process.env.PRIMO_BINARY) {
+        return await get_binary_path();
+    }
     if (await is_binary_installed()) {
         return await get_binary_path();
     }
     // Need to download - get the target path
     const platform = get_platform();
-    const binary_path = path.join(BIN_DIR, `palacms${platform.ext}`);
-    const spinner = ora('Setting up Pala...').start();
+    const binary_path = path.join(BIN_DIR, `primo${platform.ext}`);
+    const spinner = ora('Setting up Primo...').start();
     try {
         // Create directories
         await fs.mkdir(BIN_DIR, { recursive: true });
         const url = get_download_url(platform);
-        spinner.text = `Downloading palacms for ${platform.os}/${platform.arch}...`;
+        spinner.text = `Downloading primo for ${platform.os}/${platform.arch}...`;
         // Download binary
         const response = await fetch(url);
         if (!response.ok) {
@@ -101,7 +117,7 @@ export async function ensure_binary() {
         await pipeline(response.body, file_stream);
         // Make executable
         await fs.chmod(binary_path, 0o755);
-        spinner.succeed('Pala setup complete');
+        spinner.succeed('Primo setup complete');
         return binary_path;
     }
     catch (error) {
@@ -109,16 +125,16 @@ export async function ensure_binary() {
         // Provide manual instructions
         console.log('');
         console.log(chalk.yellow('To install manually:'));
-        console.log(chalk.dim('  1. Download palacms from https://github.com/palacms/palacms/releases'));
+        console.log(chalk.dim('  1. Download primo from https://github.com/primocms/primo/releases'));
         console.log(chalk.dim(`  2. Place it in ${BIN_DIR}`));
-        console.log(chalk.dim('  3. Make it executable: chmod +x palacms'));
+        console.log(chalk.dim('  3. Make it executable: chmod +x primo'));
         console.log('');
         throw error;
     }
 }
 export async function get_binary_version() {
     try {
-        const binary_path = get_binary_path();
+        const binary_path = await get_binary_path();
         const { execSync } = await import('child_process');
         const output = execSync(`"${binary_path}" --version`, { encoding: 'utf-8' });
         return output.trim();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primo-cli",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "Local development CLI for Primo",
   "type": "module",
   "bin": {