primo-cli 0.1.3 → 0.1.4

package/dist/commands/deploy.d.ts

@@ -1,6 +1,6 @@
 interface DeployOptions {
-    dir: string;
     provider?: string;
+    dryRun?: boolean;
 }
 export declare function deploy(options: DeployOptions): Promise<void>;
 export {};

package/dist/commands/deploy.js

@@ -2,66 +2,144 @@ import fs from 'fs/promises';
 import path from 'path';
 import chalk from 'chalk';
 import ora from 'ora';
-import inquirer from 'inquirer';
-import { exec, execSync, spawn } from 'child_process';
-import { promisify } from 'util';
-const exec_async = promisify(exec);
-export async function deploy(options) {
-    const spinner = ora('Preparing deployment...').start();
+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';
+async function path_exists(p) {
     try {
-        const site_dir = path.resolve(options.dir);
-        // Read pala.json
-        const config_path = path.join(site_dir, 'pala.json');
-        let config;
+        await fs.access(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function inventory_workspace(root_dir) {
+    const server_config_path = get_server_config_path(root_dir);
+    if (!await path_exists(server_config_path)) {
+        console.log('');
+        console.log(chalk.red(`No ${SERVER_CONFIG_FILE} found in ${root_dir}.`));
+        console.log('');
+        console.log(chalk.dim('  primo deploy must be run from a workspace root.'));
+        console.log(chalk.dim('  A workspace root is the directory containing server.yaml.'));
+        console.log(chalk.dim('  Run `primo init` to create one, or `cd` into an existing workspace.'));
+        console.log('');
+        process.exit(1);
+    }
+    // Confirm parseable; we don't need the contents but failing fast is helpful.
+    await read_server_config(root_dir);
+    const sites = [];
+    const sites_root = path.join(root_dir, 'sites');
+    if (await path_exists(sites_root)) {
+        const entries = await fs.readdir(sites_root, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory() || entry.name.startsWith('.'))
+                continue;
+            const site_dir = path.join(sites_root, entry.name);
+            if (!await path_exists(get_site_config_path(site_dir)))
+                continue;
+            try {
+                const config = await read_site_config(site_dir);
+                sites.push({ dir: site_dir, config });
+            }
+            catch {
+                // Skip sites with invalid config
+            }
+        }
+    }
+    const has_library = await path_exists(path.join(root_dir, 'library'));
+    return {
+        root_dir,
+        server_config_path,
+        sites,
+        has_library
+    };
+}
+function normalize_provider(raw) {
+    if (typeof raw !== 'string')
+        return undefined;
+    const v = raw.trim().toLowerCase();
+    if (v === 'railway')
+        return 'railway';
+    if (v === 'fly' || v === 'fly.io' || v === 'flyio')
+        return 'fly';
+    return undefined;
+}
+function workspace_app_name(root_dir) {
+    return path.basename(root_dir).toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/-+/g, '-') || 'primo-workspace';
+}
+export async function deploy(options) {
+    const root_dir = process.cwd();
+    const inventory = await inventory_workspace(root_dir);
+    if (options.dryRun) {
+        print_dry_run(inventory, options.provider);
+        return;
+    }
+    let provider = normalize_provider(options.provider);
+    if (!provider) {
         try {
-            const config_data = await fs.readFile(config_path, 'utf-8');
-            config = JSON.parse(config_data);
+            const choice = await select({
+                message: 'Where do you want to deploy?',
+                choices: [
+                    { name: 'Railway', value: 'railway' },
+                    { name: 'Fly.io', value: 'fly' }
+                ]
+            });
+            provider = normalize_provider(choice);
         }
         catch {
-            spinner.fail('No pala.json found. Initialize a site first.');
+            // User cancelled (Ctrl+C / Esc) — exit quietly.
+            console.log('');
             process.exit(1);
         }
-        spinner.stop();
-        // Determine provider
-        let provider = options.provider;
-        if (!provider) {
-            const { selected_provider } = await inquirer.prompt([{
-                    type: 'list',
-                    name: 'selected_provider',
-                    message: 'Choose deployment provider:',
-                    choices: [
-                        { name: 'Railway - Simple container hosting', value: 'railway' },
-                        { name: 'Fly.io - Edge deployment', value: 'fly' }
-                    ]
-                }]);
-            provider = selected_provider;
+    }
+    if (!provider) {
+        console.log('');
+        console.log(chalk.red('No provider selected.'));
+        console.log(chalk.dim('  Pass -p railway or -p fly, or pick one from the prompt.'));
+        console.log('');
+        process.exit(1);
+    }
+    const cli_installed = await check_provider_cli(provider);
+    if (!cli_installed) {
+        console.log('');
+        console.log(chalk.yellow(`${provider} CLI not found. Install it first:`));
+        if (provider === 'railway') {
+            console.log(chalk.dim('  npm install -g @railway/cli'));
+            console.log(chalk.dim('  railway login'));
         }
-        // Check if provider CLI is installed
-        const cli_installed = await check_provider_cli(provider);
-        if (!cli_installed) {
-            console.log('');
-            console.log(chalk.yellow(`${provider} CLI not found. Please install it first:`));
-            if (provider === 'railway') {
-                console.log(chalk.dim('  npm install -g @railway/cli'));
-                console.log(chalk.dim('  railway login'));
-            }
-            else {
-                console.log(chalk.dim('  curl -L https://fly.io/install.sh | sh'));
-                console.log(chalk.dim('  fly auth login'));
-            }
-            process.exit(1);
+        else {
+            console.log(chalk.dim('  curl -L https://fly.io/install.sh | sh'));
+            console.log(chalk.dim('  fly auth login'));
+        }
+        process.exit(1);
+    }
+    const provider_logged_in = await check_provider_auth(provider);
+    if (!provider_logged_in) {
+        console.log('');
+        console.log(chalk.red(`Not logged in to ${provider}.`));
+        if (provider === 'railway') {
+            console.log(chalk.dim('  Run `railway login` and try again.'));
+        }
+        else {
+            console.log(chalk.dim('  Run `fly auth login` and try again.'));
+        }
+        console.log('');
+        process.exit(1);
+    }
+    const spinner = ora('Generating deployment files...').start();
+    try {
+        await generate_dockerfile(inventory);
+        if (provider === 'fly') {
+            await generate_fly_toml(inventory);
         }
-        // Generate deployment files
-        spinner.start('Generating deployment files...');
-        await generate_dockerfile(site_dir, config);
-        await generate_fly_toml(site_dir, config);
         spinner.succeed('Deployment files generated');
-        // Deploy based on provider
         if (provider === 'railway') {
-            await deploy_to_railway(site_dir, config);
+            await deploy_to_railway(inventory);
         }
         else {
-            await deploy_to_fly(site_dir, config);
+            await deploy_to_fly(inventory);
         }
     }
     catch (error) {
@@ -69,6 +147,52 @@ export async function deploy(options) {
         process.exit(1);
     }
 }
+function print_dry_run(inventory, provider) {
+    console.log('');
+    console.log(chalk.bold('Deploy preview (dry-run)'));
+    console.log('');
+    console.log(`  Workspace: ${chalk.cyan(inventory.root_dir)}`);
+    console.log(`  Provider:  ${chalk.cyan(provider || '(prompted at deploy time)')}`);
+    console.log(`  Image:     ${chalk.cyan(PRIMO_SERVER_IMAGE)}`);
+    console.log('');
+    console.log(chalk.bold('  Will create on the provider:'));
+    console.log(`    ${chalk.green('+')} A service running ${PRIMO_SERVER_IMAGE}`);
+    console.log(`    ${chalk.green('+')} A persistent volume mounted at /app/pb_data`);
+    if (provider === 'fly') {
+        console.log(`    ${chalk.green('+')} fly.toml in this workspace`);
+    }
+    console.log(`    ${chalk.green('+')} Dockerfile in this workspace`);
+    console.log('');
+    console.log(chalk.bold('  Will be uploaded after first boot via primo push:'));
+    console.log(`    ${chalk.dim('—')} ${SERVER_CONFIG_FILE}`);
+    if (inventory.has_library) {
+        console.log(`    ${chalk.dim('—')} library/`);
+    }
+    else {
+        console.log(chalk.dim('      (no library/ directory found)'));
+    }
+    if (inventory.sites.length > 0) {
+        console.log(`    ${chalk.dim('—')} sites/ (${inventory.sites.length} site${inventory.sites.length === 1 ? '' : 's'})`);
+        for (const site of inventory.sites) {
+            const slug = path.basename(site.dir);
+            console.log(chalk.dim(`        - ${slug}  (${site.config.name})`));
+        }
+    }
+    else {
+        console.log(chalk.yellow('      (no sites found under sites/)'));
+    }
+    console.log(chalk.dim('      (first push bootstraps; subsequent pushes update incrementally)'));
+    console.log('');
+    if (provider) {
+        console.log(chalk.dim(`  Auth: run \`${provider === 'railway' ? 'railway whoami' : 'fly auth whoami'}\` to confirm provider login.`));
+    }
+    else {
+        console.log(chalk.dim('  Auth: provider not selected; pass -p railway|fly to dry-run with auth context.'));
+    }
+    console.log('');
+    console.log(chalk.dim('  No files were written. Run without --dry-run to deploy.'));
+    console.log('');
+}
 async function check_provider_cli(provider) {
     try {
         if (provider === 'railway') {
@@ -83,70 +207,59 @@ async function check_provider_cli(provider) {
         return false;
     }
 }
-async function generate_dockerfile(site_dir, config) {
-    const dockerfile = `# Pala CMS Deployment
-FROM golang:1.22-alpine AS builder
-
-# Install build dependencies
-RUN apk add --no-cache git
-
-# Build palacms (or download from releases)
-WORKDIR /build
-RUN git clone https://github.com/palacms/palacms.git . && \\
-    go build -o palacms .
-
-# Runtime stage
-FROM alpine:3.19
-
-RUN apk add --no-cache ca-certificates
-
-WORKDIR /app
-
-# Copy binary
-COPY --from=builder /build/palacms /app/palacms
-
-# Copy site files
-COPY blocks/ /app/pb_data/blocks/
-COPY pages/ /app/pb_data/pages/
-COPY page-types/ /app/pb_data/page-types/
-COPY site/ /app/pb_data/site/
-COPY uploads/ /app/pb_data/uploads/ 2>/dev/null || true
-COPY pala.json /app/pb_data/
-
-# Set permissions
-RUN chmod +x /app/palacms
-
-# Environment variables
-ENV PB_DATA_DIR=/app/pb_data
-
-# Expose port
+async function check_provider_auth(provider) {
+    try {
+        if (provider === 'railway') {
+            execSync('railway whoami', { stdio: 'ignore' });
+        }
+        else {
+            execSync('fly auth whoami', { stdio: 'ignore' });
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// Pinned to the upstream-published image. palacms'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';
+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
+    // after deploy via `primo push`, which calls /api/palacms/bootstrap on
+    // first push (server with no sites) and /api/palacms/import/<id> on
+    // subsequent pushes. The volume mounted at /app/pb_data persists the
+    // SQLite database between restarts.
+    void inventory;
+    const dockerfile = `# Primo CMS deployment (generated by primo deploy)
+FROM ${PRIMO_SERVER_IMAGE}
 EXPOSE 8080
-
-# Start server
-CMD ["/app/palacms", "serve", "--http", "0.0.0.0:8080"]
 `;
-    await fs.writeFile(path.join(site_dir, 'Dockerfile'), dockerfile);
-    // Create .dockerignore
+    await fs.writeFile(path.join(inventory.root_dir, 'Dockerfile'), dockerfile);
+    // .dockerignore keeps the build context small (Railway uploads cwd to its
+    // builder). Nothing in the workspace gets baked into the image — we just
+    // FROM the upstream image directly.
     const dockerignore = `node_modules/
 .git/
-.pala-dev/
-.vite-cache/
+.primo/
 *.log
 .DS_Store
 `;
-    await fs.writeFile(path.join(site_dir, '.dockerignore'), dockerignore);
+    await fs.writeFile(path.join(inventory.root_dir, '.dockerignore'), dockerignore);
 }
-async function generate_fly_toml(site_dir, config) {
-    const app_name = config.name.toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/-+/g, '-');
-    const fly_toml = `# Fly.io configuration for ${config.name}
-app = "${app_name}"
+async function generate_fly_toml(inventory) {
+    const app_name = workspace_app_name(inventory.root_dir);
+    // palacms binds 0.0.0.0:8080 in its CMD; mount /app/pb_data on a persistent
+    // volume so the SQLite db + uploads survive restarts. Auto-start/stop keeps
+    // the small instance free-tier-friendly.
+    const fly_toml = `app = "${app_name}"
 primary_region = "sjc"
 
 [build]
 
-[env]
-  PB_DATA_DIR = "/app/pb_data"
-
 [http_service]
   internal_port = 8080
   force_https = true
@@ -163,24 +276,21 @@ primary_region = "sjc"
   source = "pb_data"
   destination = "/app/pb_data"
 `;
-    await fs.writeFile(path.join(site_dir, 'fly.toml'), fly_toml);
+    await fs.writeFile(path.join(inventory.root_dir, 'fly.toml'), fly_toml);
 }
-async function deploy_to_railway(site_dir, config) {
+async function deploy_to_railway(inventory) {
     console.log('');
     console.log(chalk.cyan('Deploying to Railway...'));
-    console.log('');
-    // Check if project exists or create new one
     const spinner = ora('Setting up Railway project...').start();
+    const project_name = workspace_app_name(inventory.root_dir);
     try {
-        // Try to link existing project
         try {
-            execSync('railway status', { cwd: site_dir, stdio: 'ignore' });
+            execSync('railway status', { cwd: inventory.root_dir, stdio: 'ignore' });
             spinner.succeed('Linked to existing Railway project');
         }
         catch {
-            // No project linked, create new one
             spinner.text = 'Creating new Railway project...';
-            execSync(`railway init --name "${config.name}"`, { cwd: site_dir, stdio: 'inherit' });
+            execSync(`railway init --name "${project_name}"`, { cwd: inventory.root_dir, stdio: 'inherit' });
             spinner.succeed('Created new Railway project');
         }
     }
@@ -188,74 +298,116 @@ async function deploy_to_railway(site_dir, config) {
         spinner.fail('Failed to set up Railway project');
         throw error;
     }
-    // Deploy
     console.log('');
     console.log(chalk.dim('Building and deploying...'));
     console.log('');
     const deploy_process = spawn('railway', ['up', '--detach'], {
-        cwd: site_dir,
+        cwd: inventory.root_dir,
         stdio: 'inherit'
     });
     return new Promise((resolve, reject) => {
-        deploy_process.on('close', (code) => {
-            if (code === 0) {
-                console.log('');
-                console.log(chalk.green('✓ Deployment started!'));
-                console.log('');
-                console.log(chalk.dim('  Run `railway open` to view your deployment'));
-                console.log(chalk.dim('  Run `railway logs` to view logs'));
-                resolve();
-            }
-            else {
+        deploy_process.on('close', async (code) => {
+            if (code !== 0) {
                 reject(new Error(`Railway deployment failed with code ${code}`));
+                return;
+            }
+            // Generate (or fetch existing) public domain so the user can hit
+            // the server immediately. railway domain is idempotent — calling
+            // it on a service that already has a generated domain returns the
+            // same URL.
+            const domain = await try_railway_domain(inventory.root_dir);
+            const url = domain ? `https://${domain}` : undefined;
+            if (url) {
+                await record_workspace_server(inventory.root_dir, url);
             }
+            print_post_deploy_next_steps('railway', url);
+            resolve();
         });
     });
 }
-async function deploy_to_fly(site_dir, config) {
+async function try_railway_domain(cwd) {
+    try {
+        const out = execSync('railway domain --json', { cwd, stdio: ['ignore', 'pipe', 'ignore'] }).toString();
+        const parsed = JSON.parse(out);
+        const raw = parsed.domain || parsed.url;
+        if (!raw)
+            return undefined;
+        // railway sometimes returns bare hostname, sometimes full URL
+        return raw.replace(/^https?:\/\//, '').replace(/\/+$/, '');
+    }
+    catch {
+        return undefined;
+    }
+}
+async function record_workspace_server(root_dir, url) {
+    try {
+        const config = await read_server_config(root_dir);
+        if (config.server === url)
+            return;
+        await write_server_config(root_dir, { ...config, server: url });
+    }
+    catch {
+        // Don't fail the deploy if we can't write the file — user can add
+        // the server URL manually.
+    }
+}
+function print_post_deploy_next_steps(provider, url) {
     console.log('');
-    console.log(chalk.cyan('Deploying to Fly.io...'));
+    console.log(chalk.green('✓ Deployment started'));
+    console.log('');
+    if (url) {
+        console.log(chalk.bold('  URL: ') + chalk.cyan(url));
+        console.log(chalk.dim('  (saved as `server:` in server.yaml — primo push/login pick it up automatically)'));
+        console.log('');
+    }
+    console.log(chalk.bold('Next steps'));
     console.log('');
-    const app_name = config.name.toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/-+/g, '-');
-    // Check if app exists
+    if (provider === 'railway') {
+        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('  Then 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)'));
+    console.log('');
+}
+async function deploy_to_fly(inventory) {
+    console.log('');
+    console.log(chalk.cyan('Deploying to Fly.io...'));
+    const app_name = workspace_app_name(inventory.root_dir);
     const spinner = ora('Checking Fly.io app...').start();
     try {
-        execSync(`fly status --app ${app_name}`, { cwd: site_dir, stdio: 'ignore' });
+        execSync(`fly status --app ${app_name}`, { cwd: inventory.root_dir, stdio: 'ignore' });
         spinner.succeed(`Found existing app: ${app_name}`);
     }
     catch {
-        // App doesn't exist, create it
         spinner.text = 'Creating Fly.io app...';
-        execSync(`fly apps create ${app_name}`, { cwd: site_dir, stdio: 'inherit' });
-        // Create volume for persistent data
+        execSync(`fly apps create ${app_name}`, { cwd: inventory.root_dir, stdio: 'inherit' });
         spinner.text = 'Creating persistent volume...';
         execSync(`fly volumes create pb_data --size 1 --region sjc --app ${app_name}`, {
-            cwd: site_dir,
+            cwd: inventory.root_dir,
             stdio: 'inherit'
         });
         spinner.succeed(`Created app: ${app_name}`);
     }
-    // Deploy
     console.log('');
     console.log(chalk.dim('Building and deploying...'));
     console.log('');
     const deploy_process = spawn('fly', ['deploy'], {
-        cwd: site_dir,
+        cwd: inventory.root_dir,
         stdio: 'inherit'
     });
     return new Promise((resolve, reject) => {
-        deploy_process.on('close', (code) => {
-            if (code === 0) {
-                console.log('');
-                console.log(chalk.green('✓ Deployment complete!'));
-                console.log('');
-                console.log(chalk.cyan(`  https://${app_name}.fly.dev`));
-                console.log(chalk.cyan(`  https://${app_name}.fly.dev/_/ (admin)`));
-                resolve();
-            }
-            else {
+        deploy_process.on('close', async (code) => {
+            if (code !== 0) {
                 reject(new Error(`Fly deployment failed with code ${code}`));
+                return;
             }
+            const url = `https://${app_name}.fly.dev`;
+            await record_workspace_server(inventory.root_dir, url);
+            print_post_deploy_next_steps('fly', url);
+            resolve();
         });
     });
 }

package/dist/commands/dev.d.ts

@@ -1,6 +1,8 @@
 interface DevOptions {
     dir: string;
     port: string;
+    force?: boolean;
+    author?: string;
 }
 export declare function dev_server(options: DevOptions): Promise<void>;
 export {};