@celilo/cli 0.5.0-alpha.1 → 0.5.0-alpha.11

package/drizzle/0009_dns_registrations.sql

@@ -0,0 +1,13 @@
+CREATE TABLE `dns_registrations` (
+	`id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+	`provider_module_id` text NOT NULL,
+	`consumer_module_id` text NOT NULL,
+	`fqdn` text NOT NULL,
+	`ip` text,
+	`registered_at` integer DEFAULT (unixepoch()) NOT NULL,
+	`refreshed_at` integer,
+	FOREIGN KEY (`provider_module_id`) REFERENCES `modules`(`id`) ON UPDATE no action ON DELETE cascade,
+	FOREIGN KEY (`consumer_module_id`) REFERENCES `modules`(`id`) ON UPDATE no action ON DELETE cascade
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX `dns_registrations_provider_fqdn_idx` ON `dns_registrations` (`provider_module_id`,`fqdn`);

package/drizzle/0010_dns_internal_records.sql

@@ -0,0 +1,12 @@
+CREATE TABLE `dns_internal_records` (
+	`id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+	`provider_module_id` text NOT NULL,
+	`consumer_module_id` text NOT NULL,
+	`host` text NOT NULL,
+	`ip` text NOT NULL,
+	`registered_at` integer DEFAULT (unixepoch()) NOT NULL,
+	FOREIGN KEY (`provider_module_id`) REFERENCES `modules`(`id`) ON UPDATE no action ON DELETE cascade,
+	FOREIGN KEY (`consumer_module_id`) REFERENCES `modules`(`id`) ON UPDATE no action ON DELETE cascade
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX `dns_internal_records_provider_host_idx` ON `dns_internal_records` (`provider_module_id`,`host`);

package/drizzle/0011_backups_name.sql

@@ -0,0 +1 @@
+ALTER TABLE `backups` ADD `name` text;

package/drizzle/meta/_journal.json

@@ -64,6 +64,27 @@
       "when": 1781064000000,
       "tag": "0008_aspect_consent",
       "breakpoints": true
+    },
+    {
+      "idx": 9,
+      "version": "6",
+      "when": 1781280898000,
+      "tag": "0009_dns_registrations",
+      "breakpoints": true
+    },
+    {
+      "idx": 10,
+      "version": "6",
+      "when": 1781481600000,
+      "tag": "0010_dns_internal_records",
+      "breakpoints": true
+    },
+    {
+      "idx": 11,
+      "version": "6",
+      "when": 1781481660000,
+      "tag": "0011_backups_name",
+      "breakpoints": true
     }
   ]
-}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@celilo/cli",
-  "version": "0.5.0-alpha.1",
+  "version": "0.5.0-alpha.11",
   "description": "Celilo — home lab orchestration CLI",
   "type": "module",
   "bin": {
@@ -52,9 +52,9 @@
   },
   "dependencies": {
     "@aws-sdk/client-s3": "^3.1024.0",
-    "@celilo/capabilities": "^0.3.0",
+    "@celilo/capabilities": "^0.4.2",
     "@celilo/cli-display": "^0.1.9",
-    "@celilo/event-bus": "^0.1.5",
+    "@celilo/event-bus": "^0.1.7",
     "@clack/prompts": "^1.1.0",
     "ajv": "^8.18.0",
     "drizzle-orm": "^0.36.4",

package/src/ansible/inventory.test.ts

@@ -61,7 +61,7 @@ describe('generateHostsIni', () => {
       },
       {
         hostname: 'dns-ext',
-        ansibleHost: '188.166.157.2',
+        ansibleHost: '192.0.2.20',
         ansibleUser: 'root',
         groups: ['dns_external'],
       },
@@ -72,7 +72,7 @@ describe('generateHostsIni', () => {
     expect(result).toContain('[homebridge]');
     expect(result).toContain('[dns_external]');
     expect(result).toContain('iot ansible_host=192.168.0.110 ansible_user=root');
-    expect(result).toContain('dns-ext ansible_host=188.166.157.2 ansible_user=root');
+    expect(result).toContain('dns-ext ansible_host=192.0.2.20 ansible_user=root');
   });
 
   test('includes SSH private key file path when provided', () => {
@@ -136,8 +136,8 @@ describe('generateHostVarsYaml', () => {
   test('generates YAML for arrays', () => {
     const vars = {
       zone_records: [
-        { name: 'ns1', type: 'A', value: '188.166.157.2' },
-        { name: 'www', type: 'A', value: '71.36.99.96' },
+        { name: 'ns1', type: 'A', value: '192.0.2.20' },
+        { name: 'www', type: 'A', value: '203.0.113.10' },
       ],
     };
 
@@ -146,9 +146,9 @@ describe('generateHostVarsYaml', () => {
     expect(result).toContain('zone_records:');
     expect(result).toContain('- name: ns1');
     expect(result).toContain('type: A');
-    expect(result).toContain('value: 188.166.157.2');
+    expect(result).toContain('value: 192.0.2.20');
     expect(result).toContain('- name: www');
-    expect(result).toContain('value: 71.36.99.96');
+    expect(result).toContain('value: 203.0.113.10');
   });
 
   test('generates YAML for nested objects', () => {
@@ -359,13 +359,13 @@ describe('Database integration', () => {
       );
 
       upsertModuleConfig(db, 'dns', 'zone_records', [
-        { name: 'ns1', type: 'A', value: '188.166.157.2' },
+        { name: 'ns1', type: 'A', value: '192.0.2.20' },
       ]);
 
       const vars = buildHostVars('dns', db);
 
       expect(Array.isArray(vars.zone_records)).toBe(true);
-      expect(vars.zone_records).toEqual([{ name: 'ns1', type: 'A', value: '188.166.157.2' }]);
+      expect(vars.zone_records).toEqual([{ name: 'ns1', type: 'A', value: '192.0.2.20' }]);
     });
   });
 
@@ -416,13 +416,13 @@ describe('Database integration', () => {
       );
 
       upsertModuleConfig(db, 'dns-external', 'hostname', 'dns-ext');
-      upsertModuleConfig(db, 'dns-external', 'vps_ip', '188.166.157.2');
+      upsertModuleConfig(db, 'dns-external', 'vps_ip', '192.0.2.20');
 
       const host = extractInventoryHost('dns-external', db);
 
       expect(host).not.toBeNull();
       expect(host?.hostname).toBe('dns-ext');
-      expect(host?.ansibleHost).toBe('188.166.157.2'); // VPS IP used directly
+      expect(host?.ansibleHost).toBe('192.0.2.20'); // VPS IP used directly
       expect(host?.ansibleUser).toBe('root');
       expect(host?.groups).toEqual(['dns-external']);
     });

package/src/ansible/validation.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, test } from 'bun:test';
+import { skipIntegration } from '../test-utils/integration-guard';
 import {
   isAnsibleInventoryAvailable,
   isAnsibleLintAvailable,
@@ -54,17 +55,23 @@ describe('validateWithAnsibleLint', () => {
 });
 
 describe('validatePlaybookSyntax', () => {
-  test('returns error when playbook does not exist', async () => {
-    const result = await validatePlaybookSyntax('/nonexistent/playbook.yml', '/tmp');
-    expect(result.success).toBe(false);
-    expect(result.error).toContain('Playbook not found');
-  });
+  test.skipIf(skipIntegration({ tools: ['ansible'] }))(
+    'returns error when playbook does not exist',
+    async () => {
+      const result = await validatePlaybookSyntax('/nonexistent/playbook.yml', '/tmp');
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('Playbook not found');
+    },
+  );
 
-  test('returns error when inventory does not exist', async () => {
-    const result = await validatePlaybookSyntax('/tmp/playbook.yml', '/nonexistent/inventory');
-    expect(result.success).toBe(false);
-    expect(result.error).toContain('not found');
-  });
+  test.skipIf(skipIntegration({ tools: ['ansible'] }))(
+    'returns error when inventory does not exist',
+    async () => {
+      const result = await validatePlaybookSyntax('/tmp/playbook.yml', '/nonexistent/inventory');
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('not found');
+    },
+  );
 
   test('returns error when ansible-playbook not installed', async () => {
     if (!isAnsiblePlaybookAvailable()) {
@@ -76,11 +83,14 @@ describe('validatePlaybookSyntax', () => {
 });
 
 describe('validateInventory', () => {
-  test('returns error when inventory does not exist', async () => {
-    const result = await validateInventory('/nonexistent/inventory');
-    expect(result.success).toBe(false);
-    expect(result.error).toContain('Inventory not found');
-  });
+  test.skipIf(skipIntegration({ tools: ['ansible'] }))(
+    'returns error when inventory does not exist',
+    async () => {
+      const result = await validateInventory('/nonexistent/inventory');
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('Inventory not found');
+    },
+  );
 
   test('returns error when ansible-inventory not installed', async () => {
     if (!isAnsibleInventoryAvailable()) {

package/src/api-clients/proxmox.test.ts

@@ -1,5 +1,14 @@
 import { describe, expect, test } from 'bun:test';
-import { findNodeForVmid } from './proxmox';
+import {
+  type ProxmoxClusterResource,
+  buildCloudImageVolid,
+  filterVmTemplates,
+  findNodeForVmid,
+  pollTaskUntilDone,
+  selectFreeVmid,
+  selectImportStorage,
+  summarizeNodeCapacities,
+} from './proxmox';
 
 describe('findNodeForVmid (ISS-0090 — Proxmox is source of truth for current location)', () => {
   // A trimmed /cluster/resources payload: guest rows carry a vmid; node/storage
@@ -28,3 +37,204 @@ describe('findNodeForVmid (ISS-0090 — Proxmox is source of truth for current l
     expect(findNodeForVmid([], 200)).toBeNull();
   });
 });
+
+describe('summarizeNodeCapacities (ISS-0060 — per-node capacity reconciled from Proxmox)', () => {
+  const GB = 1024 * 1024 * 1024;
+  const resources: ProxmoxClusterResource[] = [
+    {
+      type: 'node',
+      node: 'node3',
+      status: 'online',
+      maxmem: 16 * GB,
+      mem: 4 * GB,
+      maxcpu: 8,
+      cpu: 0.25,
+      maxdisk: 200 * GB,
+      disk: 50 * GB,
+      uptime: 3600,
+    },
+    {
+      type: 'node',
+      node: 'node2',
+      status: 'offline',
+      maxmem: 8 * GB,
+      mem: 7 * GB,
+      maxcpu: 4,
+      cpu: 0.9,
+      maxdisk: 100 * GB,
+      disk: 90 * GB,
+      uptime: 0,
+    },
+    // Guest + storage rows must be ignored.
+    { type: 'lxc', vmid: 200, node: 'node2', status: 'running' },
+    { type: 'storage', node: 'node3', status: 'available' },
+  ];
+
+  test('derives free RAM/CPU/disk and online state from node rows only', () => {
+    const caps = summarizeNodeCapacities(resources);
+    expect(caps).toHaveLength(2); // guest + storage rows dropped
+    // Sorted by node name → node2 first.
+    expect(caps[0]).toEqual({
+      node: 'node2',
+      online: false,
+      memTotalMb: 8192,
+      memFreeMb: 1024,
+      cpuCores: 4,
+      cpuUsedPct: 90,
+      diskTotalGb: 100,
+      diskFreeGb: 10,
+      uptimeSec: 0,
+    });
+    expect(caps[1]).toMatchObject({
+      node: 'node3',
+      online: true,
+      memFreeMb: 12288,
+      cpuUsedPct: 25,
+      diskFreeGb: 150,
+    });
+  });
+
+  test('tolerates missing fields (treats absent capacity as 0, offline unless status==online)', () => {
+    const caps = summarizeNodeCapacities([{ type: 'node', node: 'bare' }]);
+    expect(caps[0]).toEqual({
+      node: 'bare',
+      online: false,
+      memTotalMb: 0,
+      memFreeMb: 0,
+      cpuCores: 0,
+      cpuUsedPct: 0,
+      diskTotalGb: 0,
+      diskFreeGb: 0,
+      uptimeSec: 0,
+    });
+  });
+
+  test('empty inventory → no nodes', () => {
+    expect(summarizeNodeCapacities([])).toEqual([]);
+  });
+});
+
+describe('filterVmTemplates — extract VM templates from a /nodes/{node}/qemu listing', () => {
+  test('keeps only guests flagged template===1 and projects to {vmid, name}', () => {
+    const guests = [
+      { vmid: 100, name: 'running-vm' }, // no template flag → a live VM
+      { vmid: 9000, name: 'ubuntu-2404-cloudinit', template: 1 },
+      { vmid: 201, name: 'another-vm', template: 0 }, // explicitly not a template
+      { vmid: 9001, name: 'ubuntu-2204-cloudinit', template: 1 },
+    ];
+    expect(filterVmTemplates(guests)).toEqual([
+      { vmid: 9000, name: 'ubuntu-2404-cloudinit' },
+      { vmid: 9001, name: 'ubuntu-2204-cloudinit' },
+    ]);
+  });
+
+  test('returns an empty array when no guests are templates', () => {
+    expect(filterVmTemplates([{ vmid: 100, name: 'vm', template: 0 }])).toEqual([]);
+  });
+
+  test('returns an empty array for an empty listing', () => {
+    expect(filterVmTemplates([])).toEqual([]);
+  });
+});
+
+describe('selectImportStorage — pick a storage that accepts import content', () => {
+  test('returns the first active, enabled storage whose content includes import', () => {
+    const storages = [
+      { storage: 'local-lvm', content: 'images,rootdir', active: 1, enabled: 1 },
+      { storage: 'local', content: 'import,vztmpl,backup', active: 1, enabled: 1 },
+    ];
+    expect(selectImportStorage(storages)).toBe('local');
+  });
+
+  test('does NOT pick an iso-only storage (import-from rejects iso content)', () => {
+    // Regression guard: the cloud image must land in the import namespace, not
+    // iso/, or the VM-create `import-from=` fails with `has wrong type 'iso'`.
+    const storages = [
+      { storage: 'iso-only', content: 'iso,vztmpl,backup', active: 1, enabled: 1 },
+      { storage: 'data', content: 'import,images', active: 1, enabled: 1 },
+    ];
+    expect(selectImportStorage(storages)).toBe('data');
+  });
+
+  test('skips an import-capable storage that is inactive', () => {
+    const storages = [
+      { storage: 'cold', content: 'import', active: 0, enabled: 1 },
+      { storage: 'local', content: 'import', active: 1, enabled: 1 },
+    ];
+    expect(selectImportStorage(storages)).toBe('local');
+  });
+
+  test('skips an import-capable storage that is disabled', () => {
+    const storages = [
+      { storage: 'off', content: 'import', active: 1, enabled: 0 },
+      { storage: 'local', content: 'import', active: 1, enabled: 1 },
+    ];
+    expect(selectImportStorage(storages)).toBe('local');
+  });
+
+  test('returns null when no storage accepts import content', () => {
+    const storages = [{ storage: 'local-lvm', content: 'images,rootdir', active: 1, enabled: 1 }];
+    expect(selectImportStorage(storages)).toBeNull();
+  });
+
+  test('returns null for an empty storage list', () => {
+    expect(selectImportStorage([])).toBeNull();
+  });
+});
+
+describe('selectFreeVmid — first free VMID >= minVmid (template hygiene)', () => {
+  test('returns the default minimum (9000) when nothing is in use', () => {
+    expect(selectFreeVmid([])).toBe(9000);
+  });
+
+  test('returns 9000 when only low (IPAM-range) VMIDs are used', () => {
+    expect(selectFreeVmid([200, 201, 202])).toBe(9000);
+  });
+
+  test('skips a contiguous block of used template VMIDs', () => {
+    expect(selectFreeVmid([9000, 9001, 9002])).toBe(9003);
+  });
+
+  test('finds a gap inside the used set', () => {
+    // 9000 used, 9001 free → returns 9001
+    expect(selectFreeVmid([9000, 9002, 9003])).toBe(9001);
+  });
+
+  test('honors a custom minVmid floor', () => {
+    expect(selectFreeVmid([9000], 9500)).toBe(9500);
+  });
+
+  test('never returns a VMID below the floor even if low ones are free', () => {
+    // 100/101 are free but below the 9000 floor — must stay out of the IPAM range
+    expect(selectFreeVmid([9000])).toBe(9001);
+  });
+});
+
+describe('buildCloudImageVolid — volid for a cloud image on import storage', () => {
+  test('places the filename under the storage import/ namespace', () => {
+    expect(buildCloudImageVolid('local', 'noble-server-cloudimg-amd64.img')).toBe(
+      'local:import/noble-server-cloudimg-amd64.img',
+    );
+  });
+
+  test('works with an arbitrary storage name', () => {
+    expect(buildCloudImageVolid('nas', 'jammy.img')).toBe('nas:import/jammy.img');
+  });
+});
+
+describe('pollTaskUntilDone — synchronous-task guard (null/empty UPID)', () => {
+  const creds = {
+    api_url: 'https://proxmox.invalid:8006/api2/json',
+    api_token_id: 'root@pam!test',
+    api_token_secret: 'unused',
+  };
+
+  test('resolves to OK immediately for an empty UPID without hitting the network', async () => {
+    // An empty UPID means the API call completed synchronously (e.g. converting
+    // a diskless VM to a template returns null data, not a worker UPID). The
+    // guard must short-circuit BEFORE any task-status lookup — proxmox.invalid
+    // would otherwise throw a DNS/connection error, so a clean 'OK' proves it
+    // never tried to poll.
+    expect(await pollTaskUntilDone(creds, 'pve', '')).toBe('OK');
+  });
+});