primo-cli 0.1.7 → 0.1.9

package/dist/commands/deploy.js

@@ -221,11 +221,11 @@ async function check_provider_auth(provider) {
         return false;
     }
 }
-// Pinned to the upstream-published image. palacms's main.yml workflow
+// Pinned to the upstream-published image. primocms's main.yml workflow
 // publishes branch tags for whitelisted prefixes (main, feature/**, rc/**),
 // with slashes slugified to dashes (feature/local-dev-cli → :feature-local-dev-cli).
-// Bump to a release tag (:v3.0.0) when palacms cuts a stable release.
-const PRIMO_SERVER_IMAGE = 'ghcr.io/palacms/palacms:feature-local-dev-cli';
+// 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
     // unchanged. Workspace data (server.yaml, sites/, library/) is uploaded

package/dist/commands/dev.js

@@ -36,8 +36,12 @@ let site_sync_baselines = new Map();
 // the same conflict block every pull cycle when palacms'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
-// Map of filepath -> mtime (ms) when we wrote it
+// Track files written by sync to prevent watcher from re-pushing them.
+// Keyed by absolute path; value is the SHA-256 of the content we wrote.
+// We compare against the file's *current* hash in the watcher, so a user
+// edit that happens within the polling cycle is detected by content
+// divergence rather than mtime±tolerance (which used to drop edits made
+// within 3 seconds of a sync-write).
 const synced_files = new Map();
 const synced_deleted_paths = new Map();
 const warned_empty_schema_writebacks = new Set();
@@ -49,11 +53,25 @@ const MCP_CONFIG_FILE = '.mcp.json';
 const SITE_SYNC_DIRS = ['blocks', 'page-types', 'pages', 'site'];
 const LOCAL_PUSH_DEBOUNCE_MS = 150;
 const LOCAL_ZIP_COMPRESSION_LEVEL = 0;
-// Tolerance for matching a file mtime against the synced_files map to decide
-// whether an fs.watch event was caused by our own sync-write. Wider values
-// trade duplicate push work for safety against slow I/O and flaky watchers
-// (macOS fs.watch fires inconsistently for recursive writes).
-const SYNC_MTIME_TOLERANCE_MS = 3000;
+function hash_content(content) {
+    return createHash('sha256').update(content).digest('hex');
+}
+// Returns true iff the file at `full_path` still has the exact content
+// we last synced to it. Used by watcher event handlers to ignore their
+// own writes without the old mtime-tolerance race that swallowed user
+// edits made within seconds of a sync-write.
+async function event_matches_synced_write(full_path) {
+    const expected_hash = synced_files.get(full_path);
+    if (!expected_hash)
+        return false;
+    try {
+        const current = await fs.readFile(full_path);
+        return hash_content(current) === expected_hash;
+    }
+    catch {
+        return false;
+    }
+}
 // When the user writes a file locally, suppress CMS->local pulls for this
 // long to prevent a pull that was in-flight before the watcher fired from
 // stomping the just-written content on arrival.
@@ -636,8 +654,11 @@ export async function dev_server(options) {
         if (sites.length > 0 || !is_server_mode) {
             console.log('');
         }
-        // Start watching for file changes
-        const dirs_to_watch = ['blocks', 'page-types', 'pages', 'site'];
+        // Start watching for file changes. `uploads` is included so dropping
+        // an image into uploads/ triggers a push — the server-side reconcile
+        // creates a site_uploads record for it and the writeback renames
+        // the local file to the canonical (suffixed) name.
+        const dirs_to_watch = ['blocks', 'page-types', 'pages', 'site', 'uploads'];
         const known_sites = new Set(sites.map(s => s.dir));
         if (is_server_mode) {
             const library_path = path.join(base_dir, LIBRARY_DIR);
@@ -676,16 +697,18 @@ export async function dev_server(options) {
                 const on_event = (full_path) => {
                     if (should_skip_synced_delete(full_path))
                         return;
-                    const synced_mtime = synced_files.get(full_path);
-                    if (synced_mtime) {
-                        // Our own sync-write — skip.
-                        fs.stat(full_path)
-                            .then(stat => {
-                            if (Math.abs(stat.mtimeMs - synced_mtime) < SYNC_MTIME_TOLERANCE_MS) {
-                                synced_files.delete(full_path);
-                                return;
-                            }
+                    if (synced_files.has(full_path)) {
+                        // We last wrote this file from a CMS pull. If the
+                        // content on disk still matches our write, the
+                        // chokidar event is just our own write echoing
+                        // back — drop it. If it differs, the user edited
+                        // the file (possibly very shortly after our pull
+                        // landed) and we must push.
+                        event_matches_synced_write(full_path)
+                            .then(matches => {
                             synced_files.delete(full_path);
+                            if (matches)
+                                return;
                             push_or_ignore_library_change(full_path);
                         })
                             .catch(() => {
@@ -818,7 +841,16 @@ export async function dev_server(options) {
                         }
                         console.log(chalk.dim(`  ${site.config.name}: normalize ${normalize_ms}ms, zip ${import_timings.zip_ms}ms, ${import_timings.mode} ${import_timings.request_ms}ms${reload_ms ? `, reload ${reload_ms}ms` : ''}`));
                         console.log(chalk.green(`  ✓ ${site.config.name} pushed`));
-                        await write_sync_status(site.dir, { ok: true });
+                        if (import_timings.warning_count > 0) {
+                            await write_sync_status(site.dir, {
+                                ok: true,
+                                warnings: import_timings.warning_count,
+                                warned_at: new Date().toISOString()
+                            });
+                        }
+                        else {
+                            await write_sync_status(site.dir, { ok: true });
+                        }
                     }
                     catch (err) {
                         const message = err instanceof Error ? err.message : String(err);
@@ -880,15 +912,20 @@ export async function dev_server(options) {
                     const on_event = (full_path) => {
                         if (should_skip_synced_delete(full_path))
                             return;
-                        const synced_mtime = synced_files.get(full_path);
-                        if (synced_mtime) {
-                            fs.stat(full_path)
-                                .then(stat => {
-                                if (Math.abs(stat.mtimeMs - synced_mtime) < SYNC_MTIME_TOLERANCE_MS) {
-                                    synced_files.delete(full_path);
-                                    return;
-                                }
+                        if (synced_files.has(full_path)) {
+                            // We last wrote this file from a CMS pull. Compare
+                            // the file's *current* content against the hash we
+                            // stored: if identical, this watcher event is the
+                            // echo of our own write and must be ignored; if
+                            // different, the user edited the file (possibly
+                            // within ms of our pull) and the edit must push,
+                            // which is exactly the case the old mtime-tolerance
+                            // check used to swallow for site/head.svelte.
+                            event_matches_synced_write(full_path)
+                                .then(matches => {
                                 synced_files.delete(full_path);
+                                if (matches)
+                                    return;
                                 push_or_ignore_file_change(full_path);
                             })
                                 .catch(() => {
@@ -1273,15 +1310,8 @@ function track_duplicate(duplicates, category, id, occurrence) {
     existing.push(occurrence);
     by_id.set(id, existing);
 }
-async function mark_written_file(file_path) {
-    synced_files.set(file_path, Date.now());
-    try {
-        const stat = await fs.stat(file_path);
-        synced_files.set(file_path, stat.mtimeMs);
-    }
-    catch {
-        // Ignore files that disappeared
-    }
+function mark_written_file(file_path, content) {
+    synced_files.set(file_path, hash_content(content));
 }
 function mark_deleted_path(file_path) {
     synced_deleted_paths.set(file_path, Date.now());
@@ -1831,8 +1861,10 @@ async function import_site_files(site_dir, api_url, config, port, server_config,
     const zip_started = Date.now();
     const zip_buffer = await create_site_zip(site_dir, preparation.excluded_paths);
     const zip_ms = Date.now() - zip_started;
-    // Always use a localhost-style host in dev — the production host stays in
-    // site.yaml for push, but local routing must hit *.localhost
+    // Dev sites route via *.localhost. The host is computed from name+port
+    // here and passed only to bootstrap (which seeds new sites with this
+    // routing host); site.yaml does not carry host at all, and the regular
+    // import path never sets host — so dashboard-managed routing is safe.
     const host = local_dev_host(config.name || path.basename(site_dir), port);
     if (!use_bootstrap) {
         const import_form = new FormData();
@@ -2294,13 +2326,12 @@ async function sync_directory(src, dest, relative_path = '', options = {}) {
                         console.log(chalk.dim(`  trash failed for ${file_relative}`));
                     }
                 }
-                // Track this file BEFORE writing to avoid race with watcher
-                // Use current time as estimate, watcher allows 1 second tolerance
-                synced_files.set(dest_path, Date.now());
+                // Track this file's content hash BEFORE writing so the
+                // chokidar event our own write produces can be matched
+                // against `synced_files` and dropped, while a genuine user
+                // edit (different content) still falls through and pushes.
+                synced_files.set(dest_path, hash_content(src_content));
                 await fs.writeFile(dest_path, src_content);
-                // Update with actual mtime after write
-                const stat = await fs.stat(dest_path);
-                synced_files.set(dest_path, stat.mtimeMs);
                 // Surface shrinkage on the change line itself so a user
                 // scanning the dev log notices when a YAML list silently
                 // loses entries (the failure mode reported during the
@@ -2365,6 +2396,14 @@ async function has_library_content(library_dir) {
 }
 async function write_created_ids(site_dir, created_ids, server_config, workspace_dir) {
     const format_options = resolve_format_options(server_config);
+    // Upload writeback is special: rename local files and rewrite any yaml
+    // that still references symbolic paths. Surfaced under a non-standard
+    // `_uploads` key in created_ids["uploads/.manifest.json"] so the rest of
+    // this loop's `_id`/`sections` logic doesn't get confused by it.
+    const uploads_payload = created_ids['uploads/.manifest.json'];
+    if (uploads_payload && typeof uploads_payload._uploads === 'object' && uploads_payload._uploads !== null) {
+        await write_upload_writeback(site_dir, uploads_payload._uploads, server_config, workspace_dir);
+    }
     for (const [relative_path, id_data] of Object.entries(created_ids)) {
         if (!id_data._id && !Array.isArray(id_data.sections))
             continue;
@@ -2400,7 +2439,7 @@ async function write_created_ids(site_dir, created_ids, server_config, workspace
                 const raw = dump_yaml(data, { lineWidth: -1 });
                 const formatted = await format_file_contents(file_path, raw, workspace_dir, format_options);
                 await fs.writeFile(file_path, formatted, 'utf-8');
-                await mark_written_file(file_path);
+                mark_written_file(file_path, formatted);
             }
         }
         catch {
@@ -2408,3 +2447,148 @@ async function write_created_ids(site_dir, created_ids, server_config, workspace
         }
     }
 }
+// write_upload_writeback reconciles the local uploads/ folder and yaml refs
+// with what the server actually stored on the latest push.
+//
+// For each entry `symbolic -> {id, canonical}`:
+//   - If canonical != symbolic, rename uploads/<symbolic> to uploads/<canonical>
+//     on disk so subsequent pulls/pushes round-trip without churn.
+//   - Rewrite any yaml file that still says `upload: "uploads/<symbolic>"` to
+//     the record id, matching what the server stored. This converges the local
+//     copy with the server's canonical content shape without needing a pull.
+//
+// The watcher is told about each rename and rewrite via mark_written_file /
+// mark_deleted_path so it doesn't echo our own writes back as user edits.
+async function write_upload_writeback(site_dir, uploads_map, server_config, workspace_dir) {
+    // Build a symbolic -> record-id map for the yaml rewrite pass. Skip
+    // malformed entries instead of failing the whole writeback so a partial
+    // server response can still rename what it can.
+    const symbolic_to_id = new Map();
+    const renames = [];
+    for (const [symbolic, raw_entry] of Object.entries(uploads_map)) {
+        if (!raw_entry || typeof raw_entry !== 'object')
+            continue;
+        const entry = raw_entry;
+        const id = typeof entry.id === 'string' ? entry.id : '';
+        const canonical = typeof entry.canonical === 'string' ? entry.canonical : '';
+        if (!id)
+            continue;
+        symbolic_to_id.set(symbolic, id);
+        if (canonical && canonical !== symbolic) {
+            renames.push({ symbolic, canonical });
+        }
+    }
+    // Rename the on-disk files. Best-effort: if the symbolic file is missing
+    // (already renamed by a prior push, or removed by the user) we silently
+    // move on — the yaml rewrite still keeps content consistent.
+    const uploads_dir = path.join(site_dir, 'uploads');
+    for (const { symbolic, canonical } of renames) {
+        const from = path.join(uploads_dir, symbolic);
+        const to = path.join(uploads_dir, canonical);
+        try {
+            await fs.rename(from, to);
+            mark_deleted_path(from);
+            mark_written_file(to, await fs.readFile(to));
+        }
+        catch {
+            // missing source or permission issue — skip
+        }
+    }
+    // Rewrite symbolic upload references across all yaml under the site dir.
+    // Walking the tree is bounded by site size and only re-marshals files
+    // that mention `uploads/` literally, so the cost is small even on large
+    // sites. Restricting to known sync subdirs avoids touching artifacts in
+    // dot-directories or build output.
+    if (symbolic_to_id.size === 0)
+        return;
+    const format_options = resolve_format_options(server_config);
+    for (const subdir of SITE_SYNC_DIRS) {
+        const root = path.join(site_dir, subdir);
+        const files = await walk_yaml_files(root).catch(() => []);
+        for (const file_path of files) {
+            try {
+                const content = await fs.readFile(file_path, 'utf-8');
+                if (!content.includes('uploads/'))
+                    continue;
+                const parsed = load_yaml(content);
+                if (!parsed || typeof parsed !== 'object')
+                    continue;
+                const { value: rewritten, changed } = rewrite_symbolic_upload_refs(parsed, symbolic_to_id);
+                if (!changed)
+                    continue;
+                const raw = dump_yaml(rewritten, { lineWidth: -1 });
+                const formatted = await format_file_contents(file_path, raw, workspace_dir, format_options);
+                await fs.writeFile(file_path, formatted, 'utf-8');
+                mark_written_file(file_path, formatted);
+            }
+            catch {
+                // skip unreadable / unparseable file
+            }
+        }
+    }
+}
+async function walk_yaml_files(root) {
+    const out = [];
+    const stack = [root];
+    while (stack.length > 0) {
+        const dir = stack.pop();
+        let entries;
+        try {
+            entries = await fs.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (entry.name.startsWith('.'))
+                continue;
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                stack.push(full);
+            }
+            else if (entry.isFile() && entry.name.endsWith('.yaml')) {
+                out.push(full);
+            }
+        }
+    }
+    return out;
+}
+// rewrite_symbolic_upload_refs is the CLI mirror of the server's rewriteUploadRefs.
+// Walking on the CLI side handles the case where the server's in-zip rewrite
+// updated the imported content but the source files on disk still reference
+// the symbolic path. Without this pass, the next push would resend the
+// symbolic ref and force the server to re-resolve every time.
+function rewrite_symbolic_upload_refs(value, map) {
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        const obj = value;
+        let changed = false;
+        const result = {};
+        for (const [k, v] of Object.entries(obj)) {
+            if (k === 'upload' && typeof v === 'string' && v.startsWith('uploads/')) {
+                const filename = v.substring('uploads/'.length);
+                const id = map.get(filename);
+                if (id) {
+                    result[k] = id;
+                    changed = true;
+                    continue;
+                }
+            }
+            const child = rewrite_symbolic_upload_refs(v, map);
+            result[k] = child.value;
+            if (child.changed)
+                changed = true;
+        }
+        return { value: result, changed };
+    }
+    if (Array.isArray(value)) {
+        let changed = false;
+        const result = value.map(item => {
+            const child = rewrite_symbolic_upload_refs(item, map);
+            if (child.changed)
+                changed = true;
+            return child.value;
+        });
+        return { value: result, changed };
+    }
+    return { value, changed: false };
+}

package/dist/commands/new.js

@@ -87,9 +87,6 @@ export async function new_site(options) {
         const config = {
             name: display_name,
             site_id: generate_id(),
-            // Leave host empty for local dev - dev.ts will generate coffee-shop.localhost:3000
-            // Only set host if it looks like a real domain (has a dot)
-            host: site_name.includes('.') ? site_name : '',
             group: 'default'
         };
         await write_site_config(site_dir, config);

package/dist/commands/pull.js

@@ -48,6 +48,15 @@ async function read_configured_server_config(dir) {
         return null;
     }
 }
+function is_remote_server(server) {
+    try {
+        const hostname = new URL(server).hostname;
+        return hostname !== 'localhost' && hostname !== '127.0.0.1' && hostname !== '::1';
+    }
+    catch {
+        return false;
+    }
+}
 export async function pull_site(options) {
     const spinner = ora('Connecting...').start();
     try {
@@ -79,21 +88,36 @@ export async function pull_site(options) {
         }
         // Decide root dir: explicit --output wins; if cwd already has a configured
         // server.yaml, pull in place; otherwise nest under server hostname.
+        // Refuse to auto-create a `localhost/` folder — the user almost certainly
+        // didn't mean that. Require --output or --server explicitly in that case.
+        if (!options.output && !used_configured && !is_remote_server(server)) {
+            spinner.fail(`Resolved to ${server} but no output dir was given. ` +
+                `Pass --server <url> or --output <dir> to pull a local server.`);
+            process.exit(1);
+        }
         const root_dir = options.output
             ? path.resolve(options.output)
             : used_configured
                 ? process.cwd()
                 : path.resolve(server_folder_name(server));
-        await fs.mkdir(root_dir, { recursive: true });
-        // List all sites
+        // Validate the server is reachable BEFORE creating the output dir, so a
+        // failed pull doesn't leave an empty folder behind.
         spinner.text = 'Fetching sites...';
-        const sites_response = await fetch(`${server}/api/collections/sites/records?perPage=200`, {
-            headers
-        });
+        let sites_response;
+        try {
+            sites_response = await fetch(`${server}/api/collections/sites/records?perPage=200`, {
+                headers
+            });
+        }
+        catch (error) {
+            spinner.fail(`Could not reach ${server}: ${error instanceof Error ? error.message : error}`);
+            process.exit(1);
+        }
         if (!sites_response.ok) {
             spinner.fail(`Failed to fetch sites (${sites_response.status})`);
             process.exit(1);
         }
+        await fs.mkdir(root_dir, { recursive: true });
         const sites_data = await sites_response.json();
         const sites = sites_data.items || [];
         if (sites.length === 0) {
@@ -127,13 +151,15 @@ export async function pull_site(options) {
         }
         // Fetch site groups so server.yaml has them
         const site_groups = await fetch_site_groups(server, headers);
-        // Preserve any existing server.yaml (port, format, server URL) and just
-        // refresh site_groups from the source of truth.
+        // Preserve any existing server.yaml (port, format) and refresh
+        // site_groups from the source of truth. Also persist the server URL
+        // when it's a remote so subsequent bare `primo pull` runs in this dir
+        // don't fall back to localhost detection.
         const existing = await read_configured_server_config(root_dir);
         await write_server_config(root_dir, {
             ...existing,
-            port: existing?.port ?? 3000,
-            site_groups: site_groups.length > 0 ? site_groups : existing?.site_groups
+            site_groups: site_groups.length > 0 ? site_groups : existing?.site_groups,
+            server: existing?.server ?? (is_remote_server(server) ? server : undefined)
         });
         spinner.succeed(`Server pulled to ${chalk.cyan(root_dir)}`);
         console.log('');
@@ -170,7 +196,6 @@ async function pull_one_site(server, headers, site, site_dir, spinner) {
     await fs.unlink(temp_zip);
     await write_site_config(site_dir, {
         name: site.name || 'Imported Site',
-        host: site.host || '',
         site_id: site.id,
         server,
         group: site.group

package/dist/commands/push.js

@@ -300,8 +300,6 @@ async function try_bootstrap_site(server, token, zip_buffer, config, site_id) {
     form.append('site_id', site_id);
     if (config?.name)
         form.append('name', config.name);
-    if (config?.host)
-        form.append('host', config.host);
     if (config?.group)
         form.append('group', config.group);
     form.append('file', new Blob([zip_buffer]), 'site.zip');

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

@@ -16,4 +16,5 @@ 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;
 export declare function read_server_config(base_dir: string): Promise<ServerConfig>;
+export declare const DEFAULT_PORT = 3000;
 export declare function write_server_config(base_dir: string, config: ServerConfig): Promise<void>;

package/dist/utils/server-config.js

@@ -44,6 +44,12 @@ export async function read_server_config(base_dir) {
     const config_data = await fs.readFile(get_server_config_path(base_dir), 'utf-8');
     return normalize_server_config(load_yaml(config_data));
 }
+export const DEFAULT_PORT = 3000;
 export async function write_server_config(base_dir, config) {
-    await fs.writeFile(get_server_config_path(base_dir), dump_yaml(normalize_server_config(config), { lineWidth: -1, noRefs: true }));
+    const normalized = normalize_server_config(config);
+    // Drop port from the file when it's the default — it's noise otherwise.
+    const for_write = normalized.port === DEFAULT_PORT
+        ? { ...normalized, port: undefined }
+        : normalized;
+    await fs.writeFile(get_server_config_path(base_dir), dump_yaml(for_write, { lineWidth: -1, noRefs: true }));
 }

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

@@ -1,7 +1,6 @@
 export interface SiteConfig {
     name: string;
     site_id: string;
-    host?: string;
     server?: string;
     group?: string;
 }

package/package.json

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