primo-cli 0.1.0

package/dist/commands/import.d.ts

@@ -0,0 +1,9 @@
+interface ImportOptions {
+    server?: string;
+    site?: string;
+    dir: string;
+    token?: string;
+    preview?: boolean;
+}
+export declare function import_site(options: ImportOptions): Promise<void>;
+export {};

package/dist/commands/import.js

@@ -0,0 +1,118 @@
+import fs from 'fs/promises';
+import path from 'path';
+import chalk from 'chalk';
+import ora from 'ora';
+import archiver from 'archiver';
+import { get_auth_token } from '../utils/auth.js';
+export async function import_site(options) {
+    const spinner = ora('Reading local files...').start();
+    try {
+        const site_dir = path.resolve(options.dir);
+        // Read pala.json for server/site info
+        const config_path = path.join(site_dir, 'pala.json');
+        let config = null;
+        try {
+            const config_data = await fs.readFile(config_path, 'utf-8');
+            config = JSON.parse(config_data);
+        }
+        catch {
+            // No config file, must provide options
+        }
+        const server = options.server || config?.server;
+        const site_id = options.site || config?.site_id;
+        if (!server) {
+            spinner.fail('Server URL required. Use --server or ensure pala.json has server field.');
+            process.exit(1);
+        }
+        if (!site_id) {
+            spinner.fail('Site ID required. Use --site or ensure pala.json has site_id field.');
+            process.exit(1);
+        }
+        // Get auth token
+        const token = options.token || await get_auth_token(server);
+        if (!token) {
+            spinner.fail('Authentication required. Use --token or run `pala login` first.');
+            process.exit(1);
+        }
+        // Create ZIP of the site directory
+        spinner.text = 'Packaging files...';
+        const zip_buffer = await create_zip(site_dir);
+        // Send to server
+        const endpoint = options.preview
+            ? `${server}/api/palacms/import/${site_id}/preview`
+            : `${server}/api/palacms/import/${site_id}`;
+        spinner.text = options.preview ? 'Previewing changes...' : 'Importing changes...';
+        const form_data = new FormData();
+        form_data.append('file', new Blob([zip_buffer]), 'site.zip');
+        const response = await fetch(endpoint, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${token}`
+            },
+            body: form_data
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            spinner.fail(`Import failed: ${error}`);
+            process.exit(1);
+        }
+        const result = await response.json();
+        if (options.preview) {
+            spinner.succeed('Preview complete');
+            console.log('');
+            print_diff(result.diff);
+            console.log('');
+            console.log(chalk.dim('  Run without --preview to apply these changes'));
+        }
+        else {
+            spinner.succeed('Import complete');
+            console.log('');
+            print_diff(result.diff);
+        }
+    }
+    catch (error) {
+        spinner.fail(`Import failed: ${error instanceof Error ? error.message : error}`);
+        process.exit(1);
+    }
+}
+async function create_zip(dir) {
+    return new Promise((resolve, reject) => {
+        const archive = archiver('zip', { zlib: { level: 9 } });
+        const chunks = [];
+        archive.on('data', chunk => chunks.push(chunk));
+        archive.on('end', () => resolve(Buffer.concat(chunks)));
+        archive.on('error', reject);
+        // Add directories
+        const dirs_to_include = ['blocks', 'page-types', 'pages', 'site', 'uploads'];
+        for (const subdir of dirs_to_include) {
+            const full_path = path.join(dir, subdir);
+            archive.directory(full_path, subdir);
+        }
+        // Add pala.json
+        archive.file(path.join(dir, 'pala.json'), { name: 'pala.json' });
+        archive.finalize();
+    });
+}
+function print_diff(diff) {
+    let has_changes = false;
+    for (const [section, changes] of Object.entries(diff)) {
+        const { added, modified, deleted } = changes;
+        if (added.length === 0 && modified.length === 0 && deleted.length === 0) {
+            continue;
+        }
+        has_changes = true;
+        console.log(chalk.bold(`  ${section}:`));
+        for (const item of added) {
+            console.log(chalk.green(`    + ${item}`));
+        }
+        for (const item of modified) {
+            console.log(chalk.yellow(`    ~ ${item}`));
+        }
+        for (const item of deleted) {
+            console.log(chalk.red(`    - ${item}`));
+        }
+    }
+    if (!has_changes) {
+        console.log(chalk.dim('  No changes detected'));
+    }
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,5 @@
+interface InitOptions {
+    port?: string;
+}
+export declare function init_server(options: InitOptions): Promise<void>;
+export {};

package/dist/commands/init.js

@@ -0,0 +1,68 @@
+import fs from 'fs/promises';
+import path from 'path';
+import chalk from 'chalk';
+import ora from 'ora';
+export async function init_server(options) {
+    const spinner = ora('Initializing Pala server...').start();
+    try {
+        const base_dir = process.cwd();
+        const server_config_path = path.join(base_dir, 'server.json');
+        // Check if server.json already exists
+        try {
+            await fs.access(server_config_path);
+            spinner.fail('server.json already exists');
+            process.exit(1);
+        }
+        catch {
+            // Good, doesn't exist
+        }
+        // Check if pala.json exists (single-site mode)
+        const pala_config_path = path.join(base_dir, 'pala.json');
+        try {
+            await fs.access(pala_config_path);
+            spinner.fail('This directory contains a site (pala.json). Run pala init in a parent directory.');
+            process.exit(1);
+        }
+        catch {
+            // Good, not a site directory
+        }
+        const port = options.port ? parseInt(options.port, 10) : 3000;
+        const server_config = {
+            port
+        };
+        await fs.writeFile(server_config_path, JSON.stringify(server_config, null, 2) + '\n');
+        // Discover existing sites
+        const entries = await fs.readdir(base_dir, { withFileTypes: true });
+        const sites = [];
+        for (const entry of entries) {
+            if (entry.isDirectory() && !entry.name.startsWith('.')) {
+                const site_config = path.join(base_dir, entry.name, 'pala.json');
+                try {
+                    await fs.access(site_config);
+                    sites.push(entry.name);
+                }
+                catch {
+                    // Not a site
+                }
+            }
+        }
+        spinner.succeed('Server initialized');
+        console.log('');
+        console.log(`  ${chalk.cyan('server.json')} created`);
+        console.log(`  ${chalk.dim('Port:')} ${port}`);
+        if (sites.length > 0) {
+            console.log('');
+            console.log(`  ${chalk.dim('Discovered sites:')}`);
+            for (const site of sites) {
+                console.log(`    ${chalk.dim('•')} ${site}`);
+            }
+        }
+        console.log('');
+        console.log(chalk.green('  Run `pala new <hostname>` to create a site'));
+        console.log(chalk.green('  Run `pala dev` to start the server'));
+    }
+    catch (error) {
+        spinner.fail(`Failed to initialize: ${error instanceof Error ? error.message : error}`);
+        process.exit(1);
+    }
+}

package/dist/commands/login.d.ts

@@ -0,0 +1,7 @@
+interface LoginOptions {
+    server: string;
+    email?: string;
+    password?: string;
+}
+export declare function login(options: LoginOptions): Promise<void>;
+export {};

package/dist/commands/login.js

@@ -0,0 +1,124 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import readline from 'readline';
+import { save_auth_token } from '../utils/auth.js';
+export async function login(options) {
+    const server = normalize_server_url(options.server);
+    console.log('');
+    console.log(chalk.bold(`Logging in to ${server}`));
+    console.log('');
+    // Get email and password
+    let email = options.email;
+    let password = options.password;
+    if (!email) {
+        email = await prompt('Email: ');
+    }
+    if (!password) {
+        password = await prompt_password('Password: ');
+    }
+    const spinner = ora('Authenticating...').start();
+    try {
+        // Authenticate with PocketBase
+        const response = await fetch(`${server}/api/collections/users/auth-with-password`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                identity: email,
+                password: password
+            })
+        });
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ message: 'Authentication failed' }));
+            spinner.fail(`Login failed: ${error.message || 'Invalid credentials'}`);
+            process.exit(1);
+        }
+        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'));
+    }
+    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}`;
+    }
+    // Remove trailing slash
+    return server.replace(/\/+$/, '');
+}
+function prompt(question) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer);
+        });
+    });
+}
+function prompt_password(question) {
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+        // Disable echoing for password input
+        if (process.stdin.isTTY) {
+            process.stdout.write(question);
+            const stdin = process.stdin;
+            stdin.setRawMode(true);
+            stdin.resume();
+            let password = '';
+            stdin.on('data', function handler(char) {
+                const c = char.toString('utf8');
+                switch (c) {
+                    case '\n':
+                    case '\r':
+                    case '\u0004': // Ctrl+D
+                        stdin.setRawMode(false);
+                        stdin.pause();
+                        stdin.removeListener('data', handler);
+                        process.stdout.write('\n');
+                        rl.close();
+                        resolve(password);
+                        break;
+                    case '\u0003': // Ctrl+C
+                        process.exit();
+                        break;
+                    case '\u007F': // Backspace
+                        if (password.length > 0) {
+                            password = password.slice(0, -1);
+                            process.stdout.clearLine(0);
+                            process.stdout.cursorTo(0);
+                            process.stdout.write(question + '*'.repeat(password.length));
+                        }
+                        break;
+                    default:
+                        password += c;
+                        process.stdout.clearLine(0);
+                        process.stdout.cursorTo(0);
+                        process.stdout.write(question + '*'.repeat(password.length));
+                        break;
+                }
+            });
+        }
+        else {
+            // Non-TTY fallback
+            rl.question(question, (answer) => {
+                rl.close();
+                resolve(answer);
+            });
+        }
+    });
+}

package/dist/commands/new.d.ts

@@ -0,0 +1,7 @@
+interface NewOptions {
+    name?: string;
+    template?: string;
+    skipDev?: boolean;
+}
+export declare function new_site(options: NewOptions): Promise<void>;
+export {};