primo-cli 0.1.16 → 0.1.17

package/dist/commands/build.js

@@ -51,6 +51,11 @@ export async function build_site(options) {
         // Find all pages
         const pages_dir = path.join(site_dir, 'pages');
         const page_files = await find_pages(pages_dir);
+        // Map each page's _id to its live URL so internal `page:` links resolve.
+        // The URL is derived from the page's file location (same convention the
+        // build uses to write output), not the slug, so a page-ref and a raw
+        // url pointing at the same page produce identical hrefs.
+        const page_url_map = await build_page_url_map(site_dir, page_files);
         spinner.text = `Building ${page_files.length} page${page_files.length !== 1 ? 's' : ''}...`;
         // Compile all blocks once and cache them
         const block_cache = new Map();
@@ -77,7 +82,8 @@ export async function build_site(options) {
                 block_cache,
                 layout_cache,
                 page_type_head_cache,
-                site_data
+                site_data,
+                page_url_map
             });
             if (result.error) {
                 console.log(chalk.yellow(`  Warning: ${page.name}: ${result.error}`));
@@ -140,7 +146,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 } = 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;
     try {
         const page_build_id = safe_temp_id(page._id || page.id || page_path || page.name || 'page');
         // Load layout for this page type
@@ -155,9 +161,9 @@ async function build_page(options) {
         const page_type_head = await load_page_type_head(site_dir, page_type, page_type_head_cache);
         const combined_head_content = page_type_head ? `${head_content}\n${page_type_head}` : head_content;
         // Combine header + page sections + footer
-        const header_sections = await resolve_layout_sections(layout.header || [], site_dir, site_data);
-        const footer_sections = await resolve_layout_sections(layout.footer || [], site_dir, site_data);
-        const page_sections = await resolve_page_sections(page.sections || [], site_dir, site_data);
+        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) };
@@ -448,7 +454,7 @@ async function load_layout(site_dir, page_type) {
         return {};
     }
 }
-async function resolve_layout_sections(sections, site_dir, site_data) {
+async function resolve_layout_sections(sections, site_dir, site_data, page_url_map) {
     // For layout sections without content, load from block's content.yaml
     const resolved = [];
     for (const section of sections) {
@@ -462,20 +468,73 @@ async function resolve_layout_sections(sections, site_dir, site_data) {
         }
         // Resolve any site-field references in the content
         const resolved_content = await resolve_site_fields(site_dir, section.block, content, site_data);
-        resolved.push({ ...section, content: resolved_content });
+        // Resolve internal page: links to URLs (walks nested repeaters/groups too)
+        resolved.push({ ...section, content: resolve_links(resolved_content, page_url_map) });
     }
     return resolved;
 }
-async function resolve_page_sections(sections, site_dir, site_data) {
+async function resolve_page_sections(sections, site_dir, site_data, page_url_map) {
     // Resolve site-field references in page sections
     const resolved = [];
     for (const section of sections) {
         const content = section.content || {};
         const resolved_content = await resolve_site_fields(site_dir, section.block, content, site_data);
-        resolved.push({ ...section, content: resolved_content });
+        // Resolve internal page: links to URLs (walks nested repeaters/groups too)
+        resolved.push({ ...section, content: resolve_links(resolved_content, page_url_map) });
     }
     return resolved;
 }
+// Build a map of page _id -> live URL path. The URL is derived from the page
+// file's location (the same convention used to write output HTML), so a
+// `page:` reference resolves to exactly the path that page is deployed at.
+async function build_page_url_map(site_dir, page_files) {
+    const map = new Map();
+    for (const page_file of page_files) {
+        try {
+            const page = load_yaml(await fs.readFile(page_file, 'utf-8'));
+            const id = page._id || page.id;
+            if (!id)
+                continue;
+            const page_path = get_page_path_from_file(site_dir, page_file);
+            map.set(id, page_path === '' ? '/' : `/${page_path}`);
+        }
+        catch {
+            // Skip unparseable page files; they'll surface elsewhere in the build.
+        }
+    }
+    return map;
+}
+// Recursively resolve internal `page:` links to their URL. Walks arbitrarily
+// nested content (repeaters, groups, page-lists), so links inside a
+// site-field-referenced repeater resolve the same as top-level link fields.
+//
+// A link value is any object carrying a `page` id. We look the id up in the
+// page URL map and populate `url`:
+//   - known page id      -> the page's live URL
+//   - missing/deleted id -> '' (degrades to href="#" downstream, never crashes)
+// Objects with only `url` (raw/external links) are left untouched, and every
+// other key on the link object (label, etc.) is preserved.
+function resolve_links(value, page_url_map) {
+    if (Array.isArray(value)) {
+        return value.map((item) => resolve_links(item, page_url_map));
+    }
+    if (value && typeof value === 'object') {
+        const obj = value;
+        // A link with a page reference: resolve it to a URL.
+        if (typeof obj.page === 'string' && obj.page) {
+            const url = page_url_map.get(obj.page) ?? '';
+            return { ...obj, url };
+        }
+        // Otherwise recurse into every value (covers repeater arrays, groups,
+        // and the `{ link: {...} }` wrapper repeaters produce).
+        const result = {};
+        for (const [key, child] of Object.entries(obj)) {
+            result[key] = resolve_links(child, page_url_map);
+        }
+        return result;
+    }
+    return value;
+}
 async function load_block_defaults(site_dir, block_name) {
     const content_path = path.join(site_dir, 'blocks', block_name, 'content.yaml');
     try {

package/dist/commands/login.d.ts

@@ -3,4 +3,5 @@ interface LoginOptions {
     email?: string;
 }
 export declare function login(options: LoginOptions): Promise<void>;
+export declare function authenticate_interactively(server: string, email?: string): Promise<string | null>;
 export {};

package/dist/commands/login.js

@@ -3,7 +3,7 @@ import ora from 'ora';
 import readline from 'readline';
 import fs from 'fs/promises';
 import { save_auth_token } from '../utils/auth.js';
-import { read_server_config, get_server_config_path } from '../utils/server-config.js';
+import { read_server_config, get_server_config_path, normalize_server_url } from '../utils/server-config.js';
 export async function login(options) {
     let server_url = options.server;
     if (!server_url) {
@@ -29,7 +29,19 @@ export async function login(options) {
     console.log('');
     console.log(chalk.bold(`Logging in to ${server}`));
     console.log('');
-    let email = options.email;
+    const token = await authenticate_interactively(server, options.email);
+    if (!token) {
+        process.exit(1);
+    }
+    console.log('');
+    console.log(chalk.dim('  Token saved to ~/.primo/tokens.json'));
+    console.log(chalk.dim('  You can now use `primo pull` and `primo push` without --token'));
+}
+// Prompt for credentials (email if not supplied, then password), authenticate
+// against the server, and persist the token on success. Returns the token, or
+// null if authentication failed. Shared by `login` and the auto-login prompt
+// that `pull`/`push` fall back to when no token is cached.
+export async function authenticate_interactively(server, email) {
     if (!email) {
         email = await prompt('Email: ');
     }
@@ -50,28 +62,18 @@ export async function login(options) {
         if (!response.ok) {
             const error = await response.json().catch(() => ({ message: 'Authentication failed' }));
             spinner.fail(`Login failed: ${error.message || 'Invalid credentials'}`);
-            process.exit(1);
+            return null;
         }
         const data = await response.json();
         // Save the token
         await save_auth_token(server, data.token);
         spinner.succeed(`Logged in as ${chalk.cyan(data.record.email)}`);
-        console.log('');
-        console.log(chalk.dim('  Token saved to ~/.primo/tokens.json'));
-        console.log(chalk.dim('  You can now use `primo pull` and `primo push` without --token'));
+        return data.token;
     }
     catch (error) {
         spinner.fail(`Login failed: ${error instanceof Error ? error.message : error}`);
-        process.exit(1);
-    }
-}
-function normalize_server_url(server) {
-    // Add https:// if no protocol specified
-    if (!server.startsWith('http://') && !server.startsWith('https://')) {
-        server = `https://${server}`;
+        return null;
     }
-    // Remove trailing slash
-    return server.replace(/\/+$/, '');
 }
 function prompt(question) {
     const rl = readline.createInterface({

package/dist/commands/pull-library.js

@@ -4,6 +4,7 @@ import chalk from 'chalk';
 import ora from 'ora';
 import extract from 'extract-zip';
 import { get_auth_token } from '../utils/auth.js';
+import { normalize_server_url } from '../utils/server-config.js';
 async function detect_server() {
     const ports = [3000, 8080, 5173];
     for (const port of ports) {
@@ -27,7 +28,7 @@ export async function pull_library(options) {
     try {
         let server;
         if (options.server) {
-            server = options.server.replace(/\/+$/, '');
+            server = normalize_server_url(options.server);
         }
         else {
             spinner.text = 'Looking for local server...';

package/dist/commands/pull.js

@@ -5,8 +5,9 @@ import ora from 'ora';
 import extract from 'extract-zip';
 import { dump as dump_yaml, load as load_yaml } from 'js-yaml';
 import { get_auth_token } from '../utils/auth.js';
+import { authenticate_interactively } from './login.js';
 import { write_site_config } from '../utils/site-config.js';
-import { read_server_config, write_server_config } from '../utils/server-config.js';
+import { read_server_config, write_server_config, normalize_server_url } from '../utils/server-config.js';
 async function detect_server() {
     const ports = [3000, 8080, 5173];
     for (const port of ports) {
@@ -64,12 +65,15 @@ export async function pull_site(options) {
         let server;
         let used_configured = false;
         if (options.server) {
-            server = options.server.replace(/\/+$/, '');
+            server = normalize_server_url(options.server);
         }
         else {
             const configured = await read_configured_server(process.cwd());
             if (configured) {
-                server = configured;
+                // A hand-edited server.yaml may hold a bare host; normalize it so
+                // is_remote_server() and the inline-login guard below behave the
+                // same as they do for a --server flag.
+                server = normalize_server_url(configured);
                 used_configured = true;
                 spinner.text = `Using ${server}`;
             }
@@ -80,8 +84,21 @@ export async function pull_site(options) {
                 spinner.text = `Using ${server}`;
             }
         }
-        // Auth (optional for local)
-        const token = options.token || await get_auth_token(server);
+        // Auth (optional for local). For a remote server with no cached token,
+        // prompt for login inline instead of bailing out — the user almost
+        // always wants to authenticate and continue rather than re-run.
+        let token = options.token || await get_auth_token(server);
+        if (!token && is_remote_server(server)) {
+            spinner.stop();
+            console.log('');
+            console.log(chalk.dim(`  Not logged in to ${server}. Log in to continue.`));
+            console.log('');
+            token = await authenticate_interactively(server);
+            if (!token) {
+                process.exit(1);
+            }
+            spinner.start('Fetching sites...');
+        }
         const headers = {};
         if (token) {
             headers['Authorization'] = `Bearer ${token}`;

package/dist/commands/push-library.js

@@ -4,6 +4,7 @@ import chalk from 'chalk';
 import ora from 'ora';
 import archiver from 'archiver';
 import { get_auth_token } from '../utils/auth.js';
+import { normalize_server_url } from '../utils/server-config.js';
 function is_local_server(server) {
     try {
         const url = new URL(server);
@@ -28,7 +29,7 @@ export async function push_library(options) {
             spinner.fail(`Library directory not found at ${chalk.cyan(library_dir)}.`);
             process.exit(1);
         }
-        const server = options.server?.replace(/\/+$/, '');
+        const server = options.server ? normalize_server_url(options.server) : undefined;
         if (!server) {
             spinner.fail('Server URL required. Pass it as the first argument or use --server.');
             process.exit(1);

package/dist/commands/push.js

@@ -5,7 +5,7 @@ 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';
+import { get_server_config_path, read_server_config, normalize_server_url } from '../utils/server-config.js';
 async function path_exists(p) {
     try {
         await fs.access(p);
@@ -133,7 +133,8 @@ async function print_push_dry_run(root_dir, has_site_yaml, has_server_yaml, opti
         }
         library_present = await path_exists(path.join(root_dir, 'library'));
     }
-    const server = (options.server || inferred_server)?.replace(/\/+$/, '');
+    const server_raw = options.server || inferred_server;
+    const server = server_raw ? normalize_server_url(server_raw) : undefined;
     console.log(`  Target server: ${chalk.cyan(server || '(not set — pass --server or set in site.yaml)')}`);
     console.log('');
     console.log(chalk.bold('  Will sync:'));
@@ -243,7 +244,8 @@ async function push_single_site(site_dir, options, spinner) {
     catch {
         // No config file, must provide options
     }
-    const server = (options.server || config?.server)?.replace(/\/+$/, '');
+    const server_raw = options.server || config?.server;
+    const server = server_raw ? normalize_server_url(server_raw) : undefined;
     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}.`);
@@ -362,7 +364,7 @@ async function try_bootstrap_site(server, token, zip_buffer, config, site_id, gr
 }
 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(/\/+$/, '');
+    let server = options.server ? normalize_server_url(options.server) : undefined;
     if (!server) {
         const sites_root = path.join(root_dir, 'sites');
         if (await path_exists(sites_root)) {

package/dist/utils/server-config.d.ts

@@ -12,6 +12,7 @@ export interface ServerConfig {
 }
 export declare const SERVER_CONFIG_FILE = "server.yaml";
 export declare function get_server_config_path(base_dir: string): string;
+export declare function normalize_server_url(server: string): string;
 export declare function format_group_name(group_id: string): string;
 export declare function normalize_server_config(config: ServerConfig): ServerConfig;
 export declare function resolve_format_options(config: ServerConfig): FormatOptions;

package/dist/utils/server-config.js

@@ -6,6 +6,17 @@ export const SERVER_CONFIG_FILE = 'server.yaml';
 export function get_server_config_path(base_dir) {
     return path.join(base_dir, SERVER_CONFIG_FILE);
 }
+// Normalize a user-supplied server value: prepend a protocol when missing and
+// strip trailing slashes. Bare localhost/127.0.0.1 stay on http:// (local dev);
+// everything else gets https://.
+export function normalize_server_url(server) {
+    let normalized = server.trim();
+    if (!/^https?:\/\//.test(normalized)) {
+        const is_local = /^(localhost|127\.0\.0\.1|\[::1\]|::1)(:\d+)?(\/|$)/.test(normalized);
+        normalized = `${is_local ? 'http' : 'https'}://${normalized}`;
+    }
+    return normalized.replace(/\/+$/, '');
+}
 export function format_group_name(group_id) {
     if (!group_id.trim())
         return 'Default';

package/package.json

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