primo-cli 0.1.6 → 0.1.8

package/dist/commands/dev.js

@@ -3,7 +3,7 @@ import path from 'path';
 import { createHash, randomInt } from 'crypto';
 import chalk from 'chalk';
 import ora from 'ora';
-import { spawn } from 'child_process';
+import { spawn, execFileSync } from 'child_process';
 import archiver from 'archiver';
 import extract from 'extract-zip';
 import { dump as dump_yaml, load as load_yaml } from 'js-yaml';
@@ -420,18 +420,51 @@ async function kill_port(port) {
                 resolve(false);
                 return;
             }
+            // Don't kill ourselves or our ancestors — lsof returns every PID
+            // holding the port, which on macOS includes parent processes that
+            // inherited the fd. SIGKILL'ing them takes this CLI down too.
+            const self_ancestry = get_self_ancestry();
+            let killed_any = false;
             for (const pid of pid_list) {
+                const pid_num = parseInt(pid, 10);
+                if (self_ancestry.has(pid_num))
+                    continue;
                 try {
-                    process.kill(parseInt(pid, 10), 'SIGKILL');
+                    process.kill(pid_num, 'SIGKILL');
+                    killed_any = true;
                 }
                 catch {
                     // Process may have already exited
                 }
             }
-            resolve(true);
+            resolve(killed_any);
         });
     });
 }
+function get_self_ancestry() {
+    const ancestry = new Set();
+    let pid = process.pid;
+    while (pid && pid > 1) {
+        ancestry.add(pid);
+        pid = get_parent_pid(pid);
+        if (pid && ancestry.has(pid))
+            break;
+    }
+    return ancestry;
+}
+function get_parent_pid(pid) {
+    try {
+        const result = execFileSync('ps', ['-o', 'ppid=', '-p', String(pid)], {
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'ignore']
+        });
+        const parsed = parseInt(String(result).trim(), 10);
+        return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 // Fetch with timeout helper
 async function fetch_with_timeout(url, options = {}, timeout_ms = 10000) {
     const controller = new AbortController();
@@ -970,8 +1003,12 @@ export async function dev_server(options) {
         console.log(chalk.dim('  Press Ctrl+C to stop'));
         // Handle cleanup
         const cleanup = async () => {
-            if (is_cleaning_up)
-                return;
+            if (is_cleaning_up) {
+                // Second Ctrl-C while we're still cleaning up — bail immediately
+                // so the user isn't stuck waiting on an in-flight push/sync.
+                console.log(chalk.dim('\n  Force exit'));
+                process.exit(130);
+            }
             is_cleaning_up = true;
             console.log(chalk.dim('\n  Shutting down...'));
             for (const watcher of watchers) {
@@ -2066,7 +2103,18 @@ async function create_site_zip(dir, excluded_paths = new Set()) {
                 }
                 const site_json = path.join(dir, SITE_CONFIG_FILE);
                 if (!is_excluded_path(SITE_CONFIG_FILE, excluded_paths)) {
-                    archive.file(site_json, { name: SITE_CONFIG_FILE });
+                    // Strip `host` if present — `site.yaml` no longer carries it,
+                    // but older dirs pulled by previous CLI versions still do,
+                    // and the local CMS's /import endpoint persists whatever
+                    // host the zipped yaml declares, overwriting bootstrap's
+                    // *.localhost value and breaking preview routing.
+                    const sanitized = await read_site_yaml_without_host(site_json);
+                    if (sanitized !== null) {
+                        archive.append(sanitized, { name: SITE_CONFIG_FILE });
+                    }
+                    else {
+                        archive.file(site_json, { name: SITE_CONFIG_FILE });
+                    }
                 }
                 await archive.finalize();
             }
@@ -2076,6 +2124,22 @@ async function create_site_zip(dir, excluded_paths = new Set()) {
         })();
     });
 }
+async function read_site_yaml_without_host(site_yaml_path) {
+    try {
+        const raw = await fs.readFile(site_yaml_path, 'utf-8');
+        const parsed = load_yaml(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+            return null;
+        const data = parsed;
+        if (!('host' in data))
+            return null;
+        const { host: _, ...rest } = data;
+        return dump_yaml(rest, { lineWidth: -1, noRefs: true });
+    }
+    catch {
+        return null;
+    }
+}
 async function sync_from_cms(site_dir, api_url, config, server_config, workspace_dir, sync_policy = { mode: 'both' }) {
     const response = await fetch_with_timeout(`${api_url}/api/palacms/export/${config.site_id}`, {}, 15000);
     if (!response.ok)

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/index.js

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
 import { Command } from 'commander';
 import chalk from 'chalk';
 import { init_workspace } from './commands/init.js';
@@ -12,11 +15,13 @@ import { login } from './commands/login.js';
 import { validate_site } from './commands/validate.js';
 import { deploy } from './commands/deploy.js';
 import { build_site } from './commands/build.js';
+const pkg_path = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'package.json');
+const pkg_version = JSON.parse(fs.readFileSync(pkg_path, 'utf-8')).version;
 const program = new Command();
 program
     .name('primo')
     .description('Build sites visually, edit them anywhere')
-    .version('0.1.3');
+    .version(pkg_version);
 // Top-level help: prepend a Deploy-vs-build-vs-push decision tree so first-time
 // users can pick a command without reading every description. Use 'before' so
 // it only renders for the root program, not subcommand help.

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.6",
+  "version": "0.1.8",
   "description": "Local development CLI for Primo",
   "type": "module",
   "bin": {