@celilo/cli 0.5.0-alpha.10 → 0.5.0-alpha.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@celilo/cli",
-  "version": "0.5.0-alpha.10",
+  "version": "0.5.0-alpha.12",
   "description": "Celilo — home lab orchestration CLI",
   "type": "module",
   "bin": {

package/src/cli/commands/proxmox-vm-template-build.ts

@@ -33,7 +33,12 @@ import { FuelGauge } from '../fuel-gauge';
 
 const UBUNTU_2404_AMD64_URL =
   'https://cloud-images.ubuntu.com/noble/current/noble-server-cloudimg-amd64.img';
-const UBUNTU_2404_AMD64_FILENAME = 'noble-server-cloudimg-amd64.img';
+// Stored under the storage's import/ namespace, so the filename must end in an
+// extension PVE accepts for `import` content (UPLOAD_IMPORT_EXT_RE_1 =
+// ova|qcow2|raw|vmdk) — a `.img` is rejected with "invalid filename or wrong
+// extension". Ubuntu's cloud image is qcow2 format despite the upstream `.img`
+// URL, so we download it under a `.qcow2` name. The URL above is unchanged.
+const UBUNTU_2404_AMD64_FILENAME = 'noble-server-cloudimg-amd64.qcow2';
 const DEFAULT_TEMPLATE_NAME = 'ubuntu-2404-cloudinit';
 
 export interface VmTemplateBuildParams {

package/src/services/proxmox-state-recovery.ts

@@ -23,14 +23,29 @@ interface TerraformState {
     instances?: Array<{
       attributes?: {
         vmid?: number;
+        // proxmox_lxc carries the IP here ("10.0.10.12/24" or "dhcp").
         network?: Array<{
           ip?: string;
         }>;
+        // proxmox_vm_qemu carries the cloud-init IP here ("ip=10.0.10.12/24,gw=…").
+        ipconfig0?: string;
       };
     }>;
   }>;
 }
 
+/**
+ * Extract the CIDR from a qemu cloud-init `ipconfig0` string
+ * ("ip=10.0.10.12/24,gw=10.0.10.1" → "10.0.10.12/24"). Returns undefined for a
+ * DHCP config or anything without an explicit `ip=`.
+ */
+function extractIpFromIpconfig(ipconfig0: string | undefined): string | undefined {
+  if (!ipconfig0) return undefined;
+  const match = ipconfig0.match(/(?:^|,)ip=([^,]+)/);
+  const value = match?.[1];
+  return value && value !== 'dhcp' ? value : undefined;
+}
+
 /**
  * Ensure module_configs has vmid and target_ip from Terraform state
  * This recovers from state drift scenarios where container was deleted/recreated
@@ -82,19 +97,23 @@ export async function ensureProxmoxConfigFromState(
     );
   }
 
-  // Find proxmox_lxc resource
-  const lxcResource = state.resources?.find((r) => r.type === 'proxmox_lxc');
-  if (!lxcResource || !lxcResource.instances || lxcResource.instances.length === 0) {
-    throw new Error('No proxmox_lxc resource found in Terraform state');
+  // Find the provisioned guest: an LXC (proxmox_lxc) or a VM (proxmox_vm_qemu).
+  const guest = state.resources?.find(
+    (r) => r.type === 'proxmox_lxc' || r.type === 'proxmox_vm_qemu',
+  );
+  if (!guest || !guest.instances || guest.instances.length === 0) {
+    throw new Error('No proxmox_lxc or proxmox_vm_qemu resource found in Terraform state');
   }
 
-  const attributes = lxcResource.instances[0].attributes;
+  const attributes = guest.instances[0].attributes;
   if (!attributes) {
-    throw new Error('No attributes found in proxmox_lxc resource');
+    throw new Error(`No attributes found in ${guest.type} resource`);
   }
 
   const vmid = attributes.vmid;
-  const containerIp = attributes.network?.[0]?.ip;
+  // LXC exposes the IP at network[0].ip; a qemu VM exposes it via the cloud-init
+  // ipconfig0 ("ip=<cidr>,gw=<gw>"). Use whichever the guest type provides.
+  const containerIp = attributes.network?.[0]?.ip ?? extractIpFromIpconfig(attributes.ipconfig0);
 
   if (!vmid) {
     throw new Error('vmid not found in Terraform state');

package/src/templates/generator.test.ts

@@ -790,7 +790,28 @@ describe("targetNodeFromTfState (ISS-0090 — terraform state is celilo's placem
     expect(targetNodeFromTfState(state)).toBe('node3');
   });
 
-  test('returns null when there is no proxmox_lxc resource (fresh/empty state)', () => {
+  test('reads the node from a proxmox_vm_qemu target_node attribute (type:vm)', () => {
+    const state = {
+      resources: [
+        {
+          type: 'proxmox_vm_qemu',
+          instances: [{ attributes: { target_node: 'node3', id: 'node3/qemu/208' } }],
+        },
+      ],
+    };
+    expect(targetNodeFromTfState(state)).toBe('node3');
+  });
+
+  test('parses the qemu resource id when target_node is absent (type:vm)', () => {
+    const state = {
+      resources: [
+        { type: 'proxmox_vm_qemu', instances: [{ attributes: { id: 'node3/qemu/208' } }] },
+      ],
+    };
+    expect(targetNodeFromTfState(state)).toBe('node3');
+  });
+
+  test('returns null when there is no proxmox_lxc/proxmox_vm_qemu resource (fresh/empty state)', () => {
     expect(targetNodeFromTfState({ resources: [] })).toBeNull();
     expect(targetNodeFromTfState({})).toBeNull();
   });

package/src/templates/generator.ts

@@ -216,10 +216,11 @@ export function injectProxmoxDns(content: string, hasNameserver: boolean): strin
 }
 
 /**
- * Extract the node a proxmox_lxc resource is deployed on from a parsed terraform
- * state object. Pure logic (Rule 10), split from the file read for testability.
- * Prefers the explicit `target_node` attribute; falls back to parsing the
- * resource id (`<node>/lxc/<vmid>`). Returns null when there's no proxmox_lxc
+ * Extract the node a Proxmox guest is deployed on from a parsed terraform state
+ * object — an LXC (proxmox_lxc) or a VM (proxmox_vm_qemu). Pure logic (Rule 10),
+ * split from the file read for testability. Prefers the explicit `target_node`
+ * attribute; falls back to parsing the resource id (`<node>/lxc/<vmid>` for an
+ * LXC, `<node>/qemu/<vmid>` for a VM). Returns null when there's no such
  * resource (e.g. an empty/fresh state).
  */
 export function targetNodeFromTfState(state: {
@@ -228,15 +229,17 @@ export function targetNodeFromTfState(state: {
     instances?: Array<{ attributes?: { target_node?: string; id?: string } }>;
   }>;
 }): string | null {
-  const lxc = state.resources?.find((r) => r.type === 'proxmox_lxc');
-  const attrs = lxc?.instances?.[0]?.attributes;
+  const guest = state.resources?.find(
+    (r) => r.type === 'proxmox_lxc' || r.type === 'proxmox_vm_qemu',
+  );
+  const attrs = guest?.instances?.[0]?.attributes;
   if (!attrs) {
     return null;
   }
   if (attrs.target_node) {
     return attrs.target_node;
   }
-  // id format: "<node>/lxc/<vmid>"
+  // id format: "<node>/lxc/<vmid>" (LXC) or "<node>/qemu/<vmid>" (VM)
   return attrs.id?.split('/')[0] || null;
 }
 
@@ -745,6 +748,10 @@ export async function generateTemplates(options: GenerateOptions): Promise<Gener
         default_target_node: string;
         lxc_template: string;
         storage: string;
+        // Optional: only set once a cloud-init VM template has been built/selected
+        // for the service (see service reconfigure). Required by `type: vm` modules;
+        // absent for services that only deploy LXCs.
+        vm_template?: string;
       };
 
       // ISS-0090: deploy follows REALITY. Resolve the node from Proxmox (it sees
@@ -774,6 +781,13 @@ export async function generateTemplates(options: GenerateOptions): Promise<Gener
       // any stale __infra_target_node a prior generate left behind.
       upsertModuleConfig(db, moduleId, '__infra_lxc_template', providerConfig.lxc_template);
       upsertModuleConfig(db, moduleId, '__infra_storage', providerConfig.storage);
+      // vm_template is only present once a VM template exists for the service.
+      // Persist it when set so `type: vm` modules can resolve $self:vm_template;
+      // a `type: vm` deploy against a service without one then fails loudly at
+      // variable resolution (the intended "no VM template configured" error).
+      if (providerConfig.vm_template) {
+        upsertModuleConfig(db, moduleId, '__infra_vm_template', providerConfig.vm_template);
+      }
       deleteModuleConfig(db, moduleId, '__infra_target_node');
 
       log.success(`Infrastructure resolved: target_node=${decision.node} (${decision.source})`);
@@ -816,7 +830,7 @@ export async function generateTemplates(options: GenerateOptions): Promise<Gener
 
     // lxc_template / storage are provider config (intent, not drift-prone) — read
     // them back from the __infra_* rows persisted above.
-    const infraKeys = ['lxc_template', 'storage'];
+    const infraKeys = ['lxc_template', 'storage', 'vm_template'];
     for (const key of infraKeys) {
       const infraConfig = db
         .select()