primo-cli 0.1.14 → 0.1.16

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/utils/binary.js

@@ -9,7 +9,7 @@ import ora from 'ora';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const PRIMO_HOME = path.join(os.homedir(), '.primo');
 const BIN_DIR = path.join(PRIMO_HOME, 'bin');
-const VERSION = '3.2.2'; // matches primo releases
+const VERSION = '3.2.3'; // matches primo releases
 // Path to locally built binary (for development)
 // The binary is at primo/primo (inside the primo repo directory)
 const LOCAL_BINARY = path.resolve(__dirname, '..', '..', '..', 'primo', 'primo');

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