primo-cli 0.1.19 → 0.1.21

package/dist/commands/build.js

@@ -48,6 +48,18 @@ export async function build_site(options) {
             }
             // No head.svelte, that's fine
         }
+        // site/foot.html is verbatim HTML appended before </body> on every page —
+        // no templating, matching server publish. page-types/*/foot.html is
+        // intentionally not included (it isn't in server publish either).
+        let foot_content = '';
+        try {
+            foot_content = await fs.readFile(path.join(site_dir, 'site', 'foot.html'), 'utf-8');
+        }
+        catch (error) {
+            if (error?.code !== 'ENOENT') {
+                throw error;
+            }
+        }
         // Find all pages
         const pages_dir = path.join(site_dir, 'pages');
         const page_files = await find_pages(pages_dir);
@@ -78,6 +90,7 @@ export async function build_site(options) {
                 site_dir,
                 temp_dir,
                 head_content,
+                foot_content,
                 site_name: config.name,
                 block_cache,
                 layout_cache,
@@ -125,6 +138,23 @@ export async function build_site(options) {
         process.exit(1);
     }
 }
+// Field keys exposed to head fragments as bare identifiers. Anything that
+// can't be a `let` binding (or would collide with the page component's own
+// props) is skipped — the field just isn't available in head scope.
+const RESERVED_HEAD_KEYS = new Set([
+    'arguments', 'eval', 'implements', 'interface', 'package', 'private', 'protected', 'public',
+    'break', 'case', 'catch', 'class', 'const', 'continue', 'debugger', 'default',
+    'delete', 'do', 'else', 'enum', 'export', 'extends', 'false', 'finally', 'for',
+    'function', 'if', 'import', 'in', 'instanceof', 'let', 'new', 'null', 'return',
+    'static', 'super', 'switch', 'this', 'throw', 'true', 'try', 'typeof', 'var',
+    'void', 'while', 'with', 'yield', 'await', 'head_props'
+]);
+function head_identifier_keys(keys) {
+    return [...new Set(keys)].filter((key) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) &&
+        !RESERVED_HEAD_KEYS.has(key) &&
+        !/^section_\d+_props$/.test(key) &&
+        !/^Section_\d+/.test(key));
+}
 // Lazily load and validate a page type's head.svelte. Cached value is the raw
 // fragment (may include <style>); empty string means "no head file present".
 async function load_page_type_head(site_dir, page_type, cache) {
@@ -146,7 +176,7 @@ async function load_page_type_head(site_dir, page_type, cache) {
     return content;
 }
 async function build_page(options) {
-    const { page, page_path, site_dir, temp_dir, head_content, site_name, block_cache, layout_cache, page_type_head_cache, site_data, page_url_map } = options;
+    const { page, page_path, site_dir, temp_dir, head_content, foot_content, site_name, block_cache, layout_cache, page_type_head_cache, site_data, page_url_map } = options;
     try {
         const page_build_id = safe_temp_id(page._id || page.id || page_path || page.name || 'page');
         // Load layout for this page type
@@ -164,11 +194,19 @@ async function build_page(options) {
         const header_sections = await resolve_layout_sections(layout.header || [], site_dir, site_data, page_url_map);
         const footer_sections = await resolve_layout_sections(layout.footer || [], site_dir, site_data, page_url_map);
         const page_sections = await resolve_page_sections(page.sections || [], site_dir, site_data, page_url_map);
-        const all_sections = [...header_sections, ...page_sections, ...footer_sections];
-        if (all_sections.length === 0) {
-            return { html: generate_empty_page(site_name, page.name, combined_head_content) };
-        }
-        const sections = all_sections;
+        const sections = [...header_sections, ...page_sections, ...footer_sections];
+        // Head fragments see site fields merged with the page's own fields (page
+        // wins), each pre-declared as a bare identifier — same scope as server
+        // publish. Every DEFINED field key is declared even when no value is set
+        // (binding to undefined), so `{seo_title || fallback}` works on pages
+        // that leave the field empty instead of throwing ReferenceError.
+        const head_data = { ...site_data.content, ...(page.fields || {}) };
+        const page_type_fields = await load_page_type_fields(site_dir, page_type);
+        const head_keys = head_identifier_keys([
+            ...site_data.fields.map((field) => field.name),
+            ...page_type_fields.map((field) => field.name),
+            ...Object.keys(head_data)
+        ]);
         // Compile each block and collect CSS
         const all_css = [];
         const section_components = [];
@@ -192,8 +230,11 @@ async function build_page(options) {
                 props: section.content || {}
             });
         }
-        // Create a page component that renders all sections
-        const page_component = generate_page_component(section_components, sections);
+        // Create a page component that renders all sections and the head. The
+        // head rides through <svelte:head> so its Svelte syntax ({expression},
+        // {@html}, {#if}) is actually evaluated — pasting the fragment into the
+        // output verbatim leaked raw template syntax into deployed pages.
+        const page_component = generate_page_component(section_components, sections, combined_head_content, head_keys);
         const page_component_path = path.join(temp_dir, `page_${page_build_id}.svelte`);
         await fs.writeFile(page_component_path, page_component);
         // Compile the page component
@@ -244,43 +285,36 @@ async function build_page(options) {
         const { default: PageComponent } = await import(bundle_url);
         // Import render from svelte/server
         const { render } = await import('svelte/server');
-        // Build props for all sections
+        // Build props for all sections + the head fragment's field data
         const props = {};
         sections.forEach((section, i) => {
             props[`section_${i}_props`] = section.content || {};
         });
+        props.head_props = head_data;
         const rendered = render(PageComponent, { props });
-        // Extract CSS from combined head fragments (site + page-type).
-        let head_css = '';
-        let head_html = combined_head_content;
-        const style_matches = combined_head_content.matchAll(/<style[^>]*>([\s\S]*?)<\/style>/gi);
-        const head_css_parts = [];
-        for (const m of style_matches) {
-            head_css_parts.push(m[1]);
-        }
-        if (head_css_parts.length > 0) {
-            head_css = head_css_parts.join('\n');
-            head_html = combined_head_content.replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '');
+        // No automatic <title> — server publish emits none, and an injected
+        // title would suppress any title a page-type head renders (Svelte keeps
+        // the first <title> it encounters). Warn so the omission is visible.
+        if (!/<title[\s>]/i.test(rendered.head || '')) {
+            console.log(chalk.yellow(`  Warning: ${page.name || page_path || 'home'}: no <title> — render one from a head fragment (see the head-and-seo doc)`));
         }
-        // Combine all CSS (reset first, then head, then blocks)
-        const combined_css = [CSS_RESET, head_css, ...all_css].filter(Boolean).join('\n');
-        // Generate final HTML
-        const title = page.name === 'Home' ? site_name : `${page.name} | ${site_name}`;
+        // Head <style> tags flow through rendered.head as real global style
+        // elements (matching server publish). Reset first so head styles can
+        // override it; block CSS last, as component styles land during render.
+        const block_css = all_css.filter(Boolean).join('\n');
         const html = `<!DOCTYPE html>
 <html lang="en">
 <head>
 	<meta charset="UTF-8">
 	<meta name="viewport" content="width=device-width, initial-scale=1.0">
-	<title>${escape_html(title)}</title>
-${head_html}
 	<style>
-${combined_css}
+${CSS_RESET}
 	</style>
 	${rendered.head || ''}
-</head>
+${block_css ? `	<style>\n${block_css}\n	</style>\n` : ''}</head>
 <body>
 ${rendered.body || ''}
-</body>
+${foot_content}</body>
 </html>`;
         return { html };
     }
@@ -315,14 +349,18 @@ async function compile_block(site_dir, block_name, temp_dir) {
         return { js: '', css: '' };
     }
 }
-function generate_page_component(components, sections) {
+function generate_page_component(components, sections, head_content, head_keys) {
     const imports = sections.map((section, i) => {
         const safe_name = section.block.replace(/-/g, '_');
         return `import Section_${i} from './${section.block}.compiled.js'`;
     }).join('\n');
-    const props_declarations = sections.map((_, i) => {
-        return `section_${i}_props = {}`;
-    }).join(',\n\t');
+    const props_declarations = [
+        ...sections.map((_, i) => `section_${i}_props = {}`),
+        'head_props = {}'
+    ].join(',\n\t');
+    // Bare identifiers for head scope; keys are pre-filtered to valid, safe
+    // binding names by head_identifier_keys.
+    const head_declarations = head_keys.map((key) => `let ${key} = head_props['${key}']`).join('\n');
     const section_renders = sections.map((_, i) => {
         return `<Section_${i} {...section_${i}_props} />`;
     }).join('\n\t\t');
@@ -334,27 +372,17 @@ ${imports}
 let {
 	${props_declarations}
 } = $props()
+${head_declarations}
 </script>
 
+<svelte:head>
+${head_content}
+</svelte:head>
+
 <main>
 	${section_renders}
 </main>`;
 }
-function generate_empty_page(site_name, page_name, head_content) {
-    const title = page_name === 'Home' ? site_name : `${page_name} | ${site_name}`;
-    return `<!DOCTYPE html>
-<html lang="en">
-<head>
-	<meta charset="UTF-8">
-	<meta name="viewport" content="width=device-width, initial-scale=1.0">
-	<title>${escape_html(title)}</title>
-	<style>${CSS_RESET}</style>
-${head_content}
-</head>
-<body>
-</body>
-</html>`;
-}
 function generate_error_page(site_name, page_name, error, head_content) {
     const title = page_name === 'Home' ? site_name : `${page_name} | ${site_name}`;
     // Extract just the CSS from head_content
@@ -590,6 +618,22 @@ async function load_block_fields(site_dir, block_name) {
         return [];
     }
 }
+const page_type_fields_cache = new Map();
+async function load_page_type_fields(site_dir, page_type) {
+    const cache_key = `${site_dir}:${page_type}`;
+    const cached = page_type_fields_cache.get(cache_key);
+    if (cached !== undefined)
+        return cached;
+    let fields = [];
+    try {
+        fields = extract_fields_array(await load_fields_file(path.join(site_dir, 'page-types', page_type, 'fields.yaml')));
+    }
+    catch {
+        // No fields file for this page type
+    }
+    page_type_fields_cache.set(cache_key, fields);
+    return fields;
+}
 async function resolve_site_fields(site_dir, block_name, content, site_data) {
     // Load block field definitions to check for site-field types
     const block_fields = await load_block_fields(site_dir, block_name);

package/dist/commands/deploy.js

@@ -479,18 +479,26 @@ async function wait_for_ready(url) {
 // 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.
+// succeeded and the user can rerun push manually. Only a fully clean push
+// counts as success: a partial upload must not be reported as "complete".
 async function run_auto_push(inventory) {
     console.log('');
     console.log(chalk.cyan('Uploading your workspace...'));
     try {
-        await push_site({ dir: inventory.root_dir });
+        const failed = await push_site({ dir: inventory.root_dir });
+        if (failed.length > 0) {
+            // push_site already printed the per-item errors, the summary, and
+            // set the exit code. The server itself is fine, so finish the
+            // deploy flow — just not as "complete".
+            return false;
+        }
         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.'));
+        process.exitCode = 1;
         return false;
     }
 }

package/dist/commands/push.d.ts

@@ -7,5 +7,5 @@ interface PushOptions {
     preview?: boolean;
     dryRun?: boolean;
 }
-export declare function push_site(options: PushOptions): Promise<void>;
+export declare function push_site(options: PushOptions): Promise<string[]>;
 export {};

package/dist/commands/push.js

@@ -39,6 +39,8 @@ async function resolve_group_name(site_dir, group_id) {
     }
     return undefined;
 }
+// Returns the labels (site slugs / 'library') that failed to push so callers
+// like `primo deploy` can tell a clean run from a partial one. Empty = success.
 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));
@@ -61,17 +63,27 @@ export async function push_site(options) {
         : options;
     if (options.dryRun) {
         await print_push_dry_run(root_dir, has_site_yaml, has_server_yaml, effective_options);
-        return;
+        return [];
     }
     // Server-folder mode: walk site subfolders + push library
     if (!has_site_yaml && has_server_yaml) {
-        await push_server(root_dir, effective_options);
-        return;
+        const failed = await push_server(root_dir, effective_options);
+        if (failed.length > 0) {
+            console.log('');
+            console.log(chalk.red(`Push incomplete — failed: ${failed.join(', ')}`));
+            console.log(chalk.dim('  Fix the errors above and rerun `primo push` (completed pushes are safe to repeat).'));
+            console.log('');
+            // exitCode (not process.exit) so an in-process caller like `primo
+            // deploy` can still finish its own reporting before the process ends.
+            process.exitCode = 1;
+        }
+        return failed;
     }
     // Single-site mode (cwd is a site folder, or --dir points at one)
     const spinner = ora('Reading local files...').start();
     try {
         await push_single_site(root_dir, effective_options, spinner);
+        return [];
     }
     catch (error) {
         spinner.fail(`Push failed: ${error instanceof Error ? error.message : error}`);
@@ -166,6 +178,9 @@ async function print_push_dry_run(root_dir, has_site_yaml, has_server_yaml, opti
     console.log(chalk.dim('  No requests sent. Run without --dry-run to push.'));
     console.log('');
 }
+// Pushes every site folder plus the library, continuing past individual
+// failures. Returns the labels that failed — the caller decides how loudly a
+// partial push should fail.
 async function push_server(root_dir, options) {
     // Sites live under sites/<slug>/
     const sites_root = path.join(root_dir, 'sites');
@@ -204,9 +219,10 @@ async function push_server(root_dir, options) {
                 print_auth_hint();
             process.exit(1);
         }
-        return;
+        return [];
     }
     let saw_auth_error = false;
+    const failed = [];
     // Push each site
     for (const site_dir of site_dirs) {
         const spinner = ora(`Pushing ${chalk.cyan(path.basename(site_dir))}...`).start();
@@ -217,6 +233,7 @@ async function push_server(root_dir, options) {
             spinner.fail(`${path.basename(site_dir)}: ${error instanceof Error ? error.message : error}`);
             if (is_auth_error(error))
                 saw_auth_error = true;
+            failed.push(path.basename(site_dir));
             // Continue to remaining sites rather than abort the whole push
         }
     }
@@ -231,10 +248,12 @@ async function push_server(root_dir, options) {
             spinner.fail(`library: ${error instanceof Error ? error.message : error}`);
             if (is_auth_error(error))
                 saw_auth_error = true;
+            failed.push('library');
         }
     }
     if (saw_auth_error)
         print_auth_hint();
+    return failed;
 }
 async function push_single_site(site_dir, options, spinner) {
     let config = null;

package/dist/index.js

@@ -95,7 +95,7 @@ ${chalk.bold('See also')}
   primo deploy  Stand up a new hosted Primo server
   primo login   Authenticate with a hosted Primo server
 `)
-    .action((server, options) => push_site({ ...options, server: server || options.server }));
+    .action(async (server, options) => { await push_site({ ...options, server: server || options.server }); });
 program
     .command('pull [server] [dir]')
     .description('Pull entire server (all sites + library) to local files (defaults to ./<server-hostname>)')
@@ -169,4 +169,13 @@ program.on('command:*', (operands) => {
     console.error('');
     process.exit(1);
 });
-program.parse();
+// parseAsync so async action handlers are awaited inside commander's
+// lifecycle — with plain parse() a rejected handler becomes an unhandled
+// rejection (ugly stack, engine-dependent exit) instead of the clean
+// message + exit(1) below.
+program.parseAsync().catch((error) => {
+    console.error('');
+    console.error(chalk.red(error instanceof Error ? error.message : String(error)));
+    console.error('');
+    process.exit(1);
+});

package/package.json

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