primo-cli 0.1.15 → 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/deploy.js

@@ -2,7 +2,7 @@ import fs from 'fs/promises';
 import path from 'path';
 import chalk from 'chalk';
 import ora from 'ora';
-import { select, confirm } from '@inquirer/prompts';
+import { select } 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';
@@ -301,6 +301,30 @@ async function deploy_to_railway(inventory, auto_push) {
         spinner.fail('Failed to set up Railway project');
         throw error;
     }
+    // Attach a persistent volume at /app/pb_data BEFORE the first deploy. If the
+    // container starts without it, primo writes the SQLite db to ephemeral
+    // storage and it's lost on the next image change or restart. Mounting after
+    // data already exists starts from an empty volume, so ordering matters.
+    spinner.start('Ensuring persistent volume at /app/pb_data...');
+    try {
+        if (railway_volume_exists(inventory.root_dir, PB_DATA_MOUNT_PATH)) {
+            spinner.succeed('Persistent volume already mounted at /app/pb_data');
+        }
+        else {
+            execSync(`railway volume add --mount-path ${PB_DATA_MOUNT_PATH}`, {
+                cwd: inventory.root_dir,
+                stdio: 'ignore'
+            });
+            spinner.succeed('Created persistent volume at /app/pb_data');
+        }
+    }
+    catch {
+        // Volume creation can fail (e.g. plan limits, already-attached on another
+        // service). Don't abort the deploy — warn and fall back to the manual
+        // dashboard step so the user can still finish.
+        spinner.warn('Could not attach volume automatically — mount it manually');
+        console.log(chalk.dim('    Settings → Volumes → mount on /app/pb_data (size 1GB+)'));
+    }
     console.log('');
     console.log(chalk.dim('Building and deploying...'));
     console.log('');
@@ -323,10 +347,9 @@ async function deploy_to_railway(inventory, auto_push) {
             if (url) {
                 await record_workspace_server(inventory.root_dir, 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.
+            // Volume is already attached (before deploy), so just wait for the
+            // server to come online and push. If anything fails we fall back to
+            // the "next steps" message so the user can finish by hand.
             const pushed = url
                 ? await finish_railway_deploy(inventory, url, auto_push)
                 : false;
@@ -336,30 +359,33 @@ async function deploy_to_railway(inventory, auto_push) {
     });
 }
 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('');
+    // The persistent volume is attached before deploy, so there's no manual
+    // dashboard step left — just wait for the server and push.
     if (!auto_push)
         return false;
-    let confirmed = false;
+    const ready = await wait_for_ready(url);
+    if (!ready)
+        return false;
+    return await run_auto_push(inventory);
+}
+const PB_DATA_MOUNT_PATH = '/app/pb_data';
+// Check whether the linked Railway project already has a volume mounted at the
+// given path. The list JSON field name has varied across CLI versions, so we
+// accept a few spellings rather than pinning one.
+function railway_volume_exists(cwd, mount_path) {
     try {
-        confirmed = await confirm({
-            message: 'Mounted the volume? (press enter to upload your workspace)',
-            default: true
+        const out = execSync('railway volume list --json', { cwd, stdio: ['ignore', 'pipe', 'ignore'] }).toString();
+        const volumes = JSON.parse(out);
+        if (!Array.isArray(volumes))
+            return false;
+        return volumes.some((v) => {
+            const path = v.mountPath ?? v.mount_path ?? v.mountpath;
+            return typeof path === 'string' && path.replace(/\/+$/, '') === mount_path.replace(/\/+$/, '');
         });
     }
     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 {
@@ -411,13 +437,6 @@ function print_post_deploy_next_steps(provider, url, ctx) {
     }
     console.log(chalk.bold('Next steps'));
     console.log('');
-    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('  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)'));

package/dist/commands/dev.js

@@ -1921,6 +1921,14 @@ async function import_site_files(site_dir, api_url, config, port, server_config,
             if (bootstrap_response.ok) {
                 try {
                     const result = await bootstrap_response.json();
+                    // Bootstrap runs the same import as the regular path, so it
+                    // must write back created ids too — otherwise the very first
+                    // push never renames upload files to their canonical suffixed
+                    // names or rewrites symbolic refs, and later pushes keep
+                    // re-sending the un-suffixed names (the upload dup bug).
+                    if (result.created_ids) {
+                        await write_created_ids(site_dir, result.created_ids, server_config, workspace_dir);
+                    }
                     warning_count = print_import_warnings(config.name, result.warnings);
                 }
                 catch {

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/dist/utils/uploads.d.ts

@@ -0,0 +1,34 @@
+export declare class UploadsUnsupportedError extends Error {
+    constructor();
+}
+export declare class SiteNotFoundError extends Error {
+    constructor();
+}
+export interface LocalUpload {
+    filename: string;
+    abs_path: string;
+    hash: string;
+}
+export declare function collect_local_uploads(site_dir: string): Promise<LocalUpload[]>;
+export interface UploadPutResult {
+    filename: string;
+    id: string;
+    canonical: string;
+    hash: string;
+    changed: boolean;
+}
+export interface SyncUploadsOptions {
+    server: string;
+    site_id: string;
+    token: string | undefined;
+    site_dir: string;
+    on_progress?: (done: number, total: number) => void;
+    concurrency?: number;
+}
+export interface SyncUploadsResult {
+    total: number;
+    uploaded: number;
+    skipped: number;
+    results: UploadPutResult[];
+}
+export declare function sync_uploads(opts: SyncUploadsOptions): Promise<SyncUploadsResult>;

package/dist/utils/uploads.js

@@ -0,0 +1,148 @@
+import fs from 'fs/promises';
+import path from 'path';
+import crypto from 'crypto';
+// Incremental upload sync. Instead of packing every binary into the import
+// zip — which made large-media sites exceed the hosting proxy's request
+// timeout on a single synchronous /import call — we push uploads out of band:
+// hash them locally, ask the server which hashes it's missing, and PUT only
+// those, one small request each.
+//
+// Servers predating these endpoints answer /check with 404; callers detect
+// that via UploadsUnsupportedError and fall back to shipping uploads in the
+// zip (the legacy path).
+export class UploadsUnsupportedError extends Error {
+    constructor() {
+        super('server does not support incremental uploads');
+        this.name = 'UploadsUnsupportedError';
+    }
+}
+// The site doesn't exist on the server yet — its media can't be pushed until
+// it's created (via bootstrap). Distinct from UploadsUnsupportedError so the
+// caller routes to bootstrap instead of the legacy zip-uploads path.
+export class SiteNotFoundError extends Error {
+    constructor() {
+        super('site not found on server');
+        this.name = 'SiteNotFoundError';
+    }
+}
+// PocketBase's router emits this exact message when no route matches. We use
+// it to tell "endpoint missing" (old server → unsupported) apart from a
+// handler-level 404 like "Site not found" (new server, site absent).
+const ROUTER_NOT_FOUND_MESSAGE = "The requested resource wasn't found.";
+// Classify a 404 body: true = the ROUTE is missing (old server), so uploads
+// are unsupported; false = a handler 404 (e.g. site not found).
+async function is_route_missing(res) {
+    try {
+        const body = (await res.clone().json());
+        return body?.message === ROUTER_NOT_FOUND_MESSAGE;
+    }
+    catch {
+        // Non-JSON 404 → treat as route missing (safest: fall back to zip).
+        return true;
+    }
+}
+const UPLOADS_DIR = 'uploads';
+const MANIFEST_FILE = '.manifest.json';
+function sha256_hex(buf) {
+    return crypto.createHash('sha256').update(buf).digest('hex');
+}
+// Enumerate uploads/ as a flat set of bare filenames, mirroring the server's
+// zip-import filter: skip dotfiles (the manifest lives there) and anything
+// nested. Hashes are read from bytes; a manifest with matching hashes could
+// let us skip re-hashing unchanged files, but hashing local disk is cheap
+// next to the network round-trip we're optimizing, so we always hash.
+export async function collect_local_uploads(site_dir) {
+    const dir = path.join(site_dir, UPLOADS_DIR);
+    let entries;
+    try {
+        entries = await fs.readdir(dir);
+    }
+    catch {
+        return []; // no uploads/ folder
+    }
+    const uploads = [];
+    for (const name of entries) {
+        if (name.startsWith('.') || name.includes('/'))
+            continue;
+        const abs_path = path.join(dir, name);
+        const stat = await fs.stat(abs_path);
+        if (!stat.isFile())
+            continue;
+        const buf = await fs.readFile(abs_path);
+        uploads.push({ filename: name, abs_path, hash: sha256_hex(buf) });
+    }
+    return uploads;
+}
+async function post_json(url, token, body) {
+    const headers = { 'Content-Type': 'application/json' };
+    if (token)
+        headers['Authorization'] = `Bearer ${token}`;
+    return fetch(url, { method: 'POST', headers, body: JSON.stringify(body) });
+}
+// Ask the server which of the given hashes it does not already hold.
+// Throws UploadsUnsupportedError on a 404 (old server without the endpoint).
+async function check_missing(server, site_id, token, hashes) {
+    const res = await post_json(`${server}/api/primo/uploads/${site_id}/check`, token, { hashes });
+    if (res.status === 404) {
+        throw (await is_route_missing(res)) ? new UploadsUnsupportedError() : new SiteNotFoundError();
+    }
+    if (!res.ok)
+        throw new Error(await res.text());
+    const data = (await res.json());
+    return new Set(data.missing || []);
+}
+// PUT a single upload. Returns the server's record id + canonical name so the
+// caller can reconcile local state (rename to the suffixed name, rewrite refs).
+async function put_upload(server, site_id, token, up) {
+    const buf = await fs.readFile(up.abs_path);
+    const form = new FormData();
+    form.append('filename', up.filename);
+    form.append('file', new Blob([buf]), up.filename);
+    const headers = {};
+    if (token)
+        headers['Authorization'] = `Bearer ${token}`;
+    const res = await fetch(`${server}/api/primo/uploads/${site_id}/put`, {
+        method: 'POST',
+        headers,
+        body: form
+    });
+    if (res.status === 404) {
+        throw (await is_route_missing(res)) ? new UploadsUnsupportedError() : new SiteNotFoundError();
+    }
+    if (!res.ok)
+        throw new Error(await res.text());
+    const data = (await res.json());
+    return { filename: up.filename, id: data.id, canonical: data.canonical, hash: data.hash, changed: data.changed };
+}
+// Sync uploads incrementally. Returns counts + per-file results, or throws
+// UploadsUnsupportedError if the server lacks the endpoints (caller falls back
+// to the legacy zip path).
+export async function sync_uploads(opts) {
+    const { server, site_id, token, site_dir } = opts;
+    const concurrency = Math.max(1, opts.concurrency ?? 4);
+    const local = await collect_local_uploads(site_dir);
+    if (local.length === 0) {
+        return { total: 0, uploaded: 0, skipped: 0, results: [] };
+    }
+    // One small request tells us the exact set to send. Dedup by hash so
+    // identical files (different names) are only weighed once server-side.
+    const missing_hashes = await check_missing(server, site_id, token, local.map((u) => u.hash));
+    const to_send = local.filter((u) => missing_hashes.has(u.hash));
+    const skipped = local.length - to_send.length;
+    const results = [];
+    let done = 0;
+    // Simple bounded worker pool over the send list.
+    let cursor = 0;
+    async function worker() {
+        while (cursor < to_send.length) {
+            const idx = cursor++;
+            const r = await put_upload(server, site_id, token, to_send[idx]);
+            results.push(r);
+            done++;
+            opts.on_progress?.(done, to_send.length);
+        }
+    }
+    const workers = Array.from({ length: Math.min(concurrency, to_send.length) }, () => worker());
+    await Promise.all(workers);
+    return { total: local.length, uploaded: to_send.length, skipped, results };
+}

package/package.json

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