primo-cli 0.1.2 → 0.1.4

package/dist/commands/init.d.ts

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

package/dist/commands/init.js

@@ -2,67 +2,89 @@ 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();
+import { SITE_CONFIG_FILE } from '../utils/site-config.js';
+import { SERVER_CONFIG_FILE, read_server_config, write_server_config } from '../utils/server-config.js';
+export async function init_workspace(options) {
+    const cwd = process.cwd();
+    // Refuse to init inside a site directory
     try {
-        const base_dir = process.cwd();
-        const server_config_path = path.join(base_dir, 'server.json');
-        // Check if server.json already exists
+        await fs.access(path.join(cwd, SITE_CONFIG_FILE));
+        console.log(chalk.red(`Found ${SITE_CONFIG_FILE} in the current directory.`));
+        console.log(chalk.red('Run `primo init` from outside a site directory.'));
+        process.exit(1);
+    }
+    catch {
+        // Not inside a site directory, continue.
+    }
+    // If a name is provided, create that folder and init inside it.
+    // Otherwise, init in cwd.
+    let base_dir = cwd;
+    if (options.name) {
+        if (!/^[a-z0-9.-]+$/i.test(options.name)) {
+            console.log(chalk.red('Name must contain only letters, numbers, dots, and hyphens.'));
+            process.exit(1);
+        }
+        base_dir = path.join(cwd, options.name);
         try {
-            await fs.access(server_config_path);
-            spinner.fail('server.json already exists');
+            await fs.access(base_dir);
+            console.log(chalk.red(`Directory "${options.name}" already exists`));
             process.exit(1);
         }
         catch {
-            // Good, doesn't exist
+            // Directory doesn't exist, good to proceed
         }
-        // Check if pala.json exists (single-site mode)
-        const pala_config_path = path.join(base_dir, 'pala.json');
+    }
+    const server_config_path = path.join(base_dir, SERVER_CONFIG_FILE);
+    // If cwd init, bail if a server is already here.
+    if (!options.name) {
         try {
-            await fs.access(pala_config_path);
-            spinner.fail('This directory contains a site (pala.json). Run pala init in a parent directory.');
+            await fs.access(server_config_path);
+            console.log(chalk.red(`Workspace already initialized (${SERVER_CONFIG_FILE} exists).`));
+            console.log(chalk.dim('Run `primo new <site>` to add a site.'));
             process.exit(1);
         }
         catch {
-            // Good, not a site directory
+            // No server config, good to proceed
         }
-        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
+    }
+    const spinner = ora('Initializing workspace...').start();
+    try {
+        await fs.mkdir(base_dir, { recursive: true });
+        await fs.mkdir(path.join(base_dir, 'sites'), { recursive: true });
+        await fs.mkdir(path.join(base_dir, 'library'), { recursive: true });
+        await write_server_config(base_dir, {
+            port: 3000,
+            site_groups: [
+                {
+                    id: 'default',
+                    name: 'Default',
+                    index: 0
                 }
-            }
+            ]
+        });
+        // Re-read and ensure default group is present (normalize round-trip)
+        const server_config = await read_server_config(base_dir);
+        const site_groups = server_config.site_groups ?? [];
+        if (!site_groups.some((group) => group.id === 'default')) {
+            site_groups.push({
+                id: 'default',
+                name: 'Default',
+                index: site_groups.length
+            });
+            await write_server_config(base_dir, { ...server_config, site_groups });
         }
-        spinner.succeed('Server initialized');
+        spinner.succeed(`Workspace initialized: ${chalk.cyan(base_dir)}`);
+        const rel = path.relative(cwd, base_dir) || '.';
         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(chalk.dim('  Next steps:'));
+        if (rel !== '.') {
+            console.log(chalk.dim(`    cd ${rel}`));
         }
+        console.log(chalk.dim('    primo new <site-name>'));
         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}`);
+        spinner.fail(`Failed to initialize workspace: ${error instanceof Error ? error.message : error}`);
         process.exit(1);
     }
 }

package/dist/commands/login.d.ts

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

package/dist/commands/login.js

@@ -1,21 +1,39 @@
 import chalk from 'chalk';
 import ora from 'ora';
 import readline from 'readline';
+import fs from 'fs/promises';
 import { save_auth_token } from '../utils/auth.js';
+import { read_server_config, get_server_config_path } from '../utils/server-config.js';
 export async function login(options) {
-    const server = normalize_server_url(options.server);
+    let server_url = options.server;
+    if (!server_url) {
+        // Fall back to `server:` in server.yaml when run from a workspace.
+        try {
+            await fs.access(get_server_config_path(process.cwd()));
+            const config = await read_server_config(process.cwd());
+            if (config.server)
+                server_url = config.server;
+        }
+        catch {
+            // not in a workspace, fall through
+        }
+    }
+    if (!server_url) {
+        console.log('');
+        console.log(chalk.red('Server URL required.'));
+        console.log(chalk.dim('  Pass -s <url>, or run from a workspace whose server.yaml has a `server:` field.'));
+        console.log('');
+        process.exit(1);
+    }
+    const server = normalize_server_url(server_url);
     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 password = await prompt_password('Password: ');
     const spinner = ora('Authenticating...').start();
     try {
         // Authenticate with PocketBase