@celilo/cli 0.3.12 → 0.3.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@celilo/cli",
-  "version": "0.3.12",
+  "version": "0.3.14",
   "description": "Celilo — home lab orchestration CLI",
   "type": "module",
   "bin": {

package/src/cli/commands/module-remove.ts

@@ -221,11 +221,22 @@ export async function handleModuleRemove(
     log.success('Infrastructure destroyed');
   }
 
-  // Remove DNS record (if dns_internal is available)
+  // Remove DNS record (if dns_internal is available). Wrapped in a
+  // FuelGauge with a gauge logger so the dns_internal capability calls
+  // inside (`deleteRecord`, etc.) nest as sub-events rather than
+  // leaking to scrollback as unindented top-level lines via
+  // cli/prompts.log.instantEvent (which pops every pending step).
+  const dnsGauge = new FuelGauge(`Removing ${moduleId} from DNS`, {
+    skipAnimation: !process.stdout.isTTY,
+  });
+  dnsGauge.start();
   try {
+    const dnsLogger = createGaugeLogger(dnsGauge, moduleId, 'auto_deregister_dns');
     const { autoDeregisterDns } = await import('../../services/dns-auto-register');
-    await autoDeregisterDns(moduleId, db, log);
+    await autoDeregisterDns(moduleId, db, dnsLogger);
+    dnsGauge.stop(true);
   } catch {
+    dnsGauge.stop(false);
     // Non-fatal -- continue with removal
   }
 

package/src/cli/commands/system-init.ts

@@ -210,6 +210,25 @@ async function initInteractive(cliOverrides: Record<string, string> = {}): Promi
   if (!has('ssh.public_key')) {
     const detectedKeys = autoDetectSSHKeys();
     const existingSshKey = defaults['ssh.public_key'];
+
+    // Fresh box, no key in ~/.ssh and no previously-saved key — point the
+    // user at ssh-keygen rather than making them paste at a blank prompt.
+    // They can also skip this branch by passing ssh.public_key=... on the CLI.
+    if (detectedKeys.length === 0 && !existingSshKey) {
+      p.cancel('No SSH key found in ~/.ssh/');
+      console.log();
+      console.log('Celilo uses an SSH key to reach managed machines');
+      console.log('(Proxmox hosts, VPS, Raspberry Pi, etc.). Generate one:');
+      console.log();
+      console.log('    ssh-keygen -t ed25519 -C "<your-email>"');
+      console.log();
+      console.log('Then re-run:  celilo system init');
+      console.log();
+      console.log('Or, to paste a key from elsewhere without generating one:');
+      console.log('    celilo system init ssh.public_key="ssh-ed25519 AAAA..."');
+      return { success: false, error: 'No SSH key available — run ssh-keygen first' };
+    }
+
     let keySelected = false;
 
     if (detectedKeys.length === 1) {
@@ -258,7 +277,9 @@ async function initInteractive(cliOverrides: Record<string, string> = {}): Promi
           ? 'SSH public key (press Enter to keep existing)'
           : 'SSH public key',
         defaultValue: String(existingSshKey || ''),
-        placeholder: String(existingSshKey) || 'ssh-ed25519 AAAA...',
+        // String(undefined) === 'undefined' (truthy), so guard explicitly —
+        // otherwise the prompt shows "undefined" as the placeholder text.
+        placeholder: existingSshKey ? String(existingSshKey) : 'ssh-ed25519 AAAA...',
         validate: (value) => {
           if (existingSshKey && !value) {
             return;

package/src/config/paths.ts

@@ -4,38 +4,22 @@ import { join } from 'node:path';
 /**
  * Get the module storage path based on environment and platform
  *
- * Priority:
- * 1. CELILO_DATA_DIR environment variable (explicit override)
- * 2. ENVIRONMENT=dev uses ./celilo-data/modules/ (for testing)
- * 3. Platform defaults:
- *    - macOS: ~/Library/Application Support/celilo/modules/
- *    - Linux: /var/lib/celilo/modules/
- *
  * @returns Absolute path to module storage directory
  */
 export function getModuleStoragePath(): string {
-  // Explicit override
-  if (process.env.CELILO_DATA_DIR) {
-    return join(process.env.CELILO_DATA_DIR, 'modules');
-  }
-
-  // Development mode
-  if (process.env.ENVIRONMENT === 'dev') {
-    return join(process.cwd(), 'celilo-data', 'modules');
-  }
-
-  // Platform defaults
-  if (platform() === 'darwin') {
-    return join(homedir(), 'Library', 'Application Support', 'celilo', 'modules');
-  }
-
-  // Linux/other
-  return '/var/lib/celilo/modules';
+  return join(getDataDir(), 'modules');
 }
 
 /**
  * Get the base data directory for Celilo
  *
+ * Priority:
+ * 1. CELILO_DATA_DIR environment variable (explicit override)
+ * 2. ENVIRONMENT=dev uses ./celilo-data/ (for testing)
+ * 3. Platform defaults — always user-scoped so the CLI works without root:
+ *    - macOS: ~/Library/Application Support/celilo/
+ *    - Linux: $XDG_DATA_HOME/celilo/ (defaults to ~/.local/share/celilo/)
+ *
  * @returns Absolute path to base data directory
  */
 export function getDataDir(): string {
@@ -49,13 +33,15 @@ export function getDataDir(): string {
     return join(process.cwd(), 'celilo-data');
   }
 
-  // Platform defaults
+  // macOS
   if (platform() === 'darwin') {
     return join(homedir(), 'Library', 'Application Support', 'celilo');
   }
 
-  // Linux/other
-  return '/var/lib/celilo';
+  // Linux/other — XDG Base Directory spec, user-scoped (no sudo needed).
+  // System-wide installs can opt in via CELILO_DATA_DIR=/var/lib/celilo.
+  const xdgDataHome = process.env.XDG_DATA_HOME || join(homedir(), '.local', 'share');
+  return join(xdgDataHome, 'celilo');
 }
 
 /**

package/src/db/client.ts

@@ -1,5 +1,5 @@
 import { Database } from 'bun:sqlite';
-import { existsSync } from 'node:fs';
+import { existsSync, mkdirSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { drizzle } from 'drizzle-orm/bun-sqlite';
@@ -166,6 +166,13 @@ export function createDbClient(config?: Partial<DatabaseConfig>) {
   const dbPath = config?.path ?? getDbPath();
   const readonly = config?.readonly ?? false;
 
+  // bun:sqlite's `create: true` makes the file but not the parent directory.
+  // First-run after a fresh install hits this — without recursive mkdir we
+  // get SQLITE_CANTOPEN before init can write its config.
+  if (!readonly) {
+    mkdirSync(dirname(dbPath), { recursive: true });
+  }
+
   const sqlite = new Database(dbPath, {
     readonly,
     create: true,

package/src/hooks/logger.ts

@@ -72,7 +72,12 @@ export function createGaugeLogger(
         // pushStep nests under the FuelGauge step that wraps the hook,
         // so inner log calls (logger.info within the capability impl)
         // are sub-events of this nested step.
-        display.pushStep(`→ ${name}`, `✓ ${name}`);
+        //
+        // No `→`/`✓` glyph in the message — the display's spinner
+        // (in-progress) and green ✔ (done) already convey the state.
+        // Sticking a literal `✓` into the doneMsg produced a double-
+        // checkmark line on completion (`✔ ✓ name`).
+        display.pushStep(name, name);
       } else {
         // Without a display, fall back to a plain info-style marker so
         // the line still appears in raw log output.

package/src/services/module-deploy.ts

@@ -1234,12 +1234,23 @@ async function deployModuleImpl(
         }
       }
 
-      // Auto-register module hostname in internal DNS (if available)
+      // Auto-register module hostname in internal DNS (if available).
+      // Wrapped in a FuelGauge with a gauge logger so the capability calls
+      // inside (`dns_internal.registerRecord`, etc.) nest as sub-events
+      // under a single step rather than leaking to scrollback as
+      // unindented top-level lines via cli/prompts.log.instantEvent.
       let dnsRegistered = true;
+      const dnsGauge = new FuelGauge(`Registering ${moduleId} in DNS`, {
+        skipAnimation: !process.stdout.isTTY,
+      });
+      dnsGauge.start();
       try {
+        const dnsLogger = createGaugeLogger(dnsGauge, moduleId, 'auto_register_dns');
         const { autoRegisterDns } = await import('./dns-auto-register');
-        await autoRegisterDns(moduleId, db, log);
+        await autoRegisterDns(moduleId, db, dnsLogger);
+        dnsGauge.stop(true);
       } catch (error) {
+        dnsGauge.stop(false);
         const msg = error instanceof Error ? error.message : String(error);
         log.warn(`DNS auto-registration failed: ${msg}`);
         dnsRegistered = false;