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

package/src/cli/commands/service-add-proxmox.ts

@@ -3,7 +3,6 @@
  * Configure a Proxmox container service
  */
 
-import * as p from '@clack/prompts';
 import {
   buildProxmoxApiUrl,
   buildTemplatePath,
@@ -11,18 +10,31 @@ import {
   listNodeStorage,
 } from '../../api-clients/proxmox';
 import type { NetworkZone } from '../../db/schema';
+import {
+  askConfirm,
+  askMultiselect,
+  askSelect,
+  askText,
+  withInterviewSession,
+} from '../../services/bus-interview';
 import {
   addContainerService,
   testConnection as testServiceConnection,
   updateVerificationStatus,
 } from '../../services/container-service';
-import { celiloIntro, celiloOutro, promptPassword, promptText } from '../prompts';
+import { celiloIntro, celiloOutro } from '../prompts';
+import { resolveServiceCredential } from '../service-credential';
 import type { CommandResult } from '../types';
-import { validateRequired } from '../validators';
 import {
   runApplianceDownload,
   selectUbuntuApplianceFromCatalog,
 } from './proxmox-template-selection';
+import { buildCloudInitTemplate, detectExistingVmTemplates } from './proxmox-vm-template-build';
+
+// Sentinel VM-template choices returned by the select. Any other value is an
+// existing template name.
+const VM_BUILD = '__build__';
+const VM_SKIP = '__skip__';
 
 /**
  * Handle service add proxmox command
@@ -32,233 +44,295 @@ import {
  */
 export async function handleServiceAddProxmox(
   _args: string[],
-  _flags: Record<string, boolean | string> = {},
+  flags: Record<string, boolean | string> = {},
 ): Promise<CommandResult> {
-  try {
-    celiloIntro('Add Proxmox Container Service');
-
-    // Prompt for service configuration
-    const name = await promptText({
-      message: 'Human-readable name:',
-      defaultValue: 'Proxmox Home Lab',
-      placeholder: 'Proxmox Home Lab',
-      validate: validateRequired('Service name'),
-    });
-
-    // Prompt for zones (multi-select)
-    const zones = await p.multiselect<NetworkZone>({
-      message: 'Zones this service can provision to:',
-      options: [
-        { value: 'internal' as NetworkZone, label: 'internal' },
-        { value: 'dmz' as NetworkZone, label: 'dmz' },
-        { value: 'app' as NetworkZone, label: 'app' },
-        { value: 'secure' as NetworkZone, label: 'secure' },
-        { value: 'external' as NetworkZone, label: 'external' },
-      ],
-      required: true,
-      initialValues: ['internal', 'dmz', 'app', 'secure'] as NetworkZone[], // Common defaults
-    });
-
-    if (p.isCancel(zones)) {
-      p.cancel('Operation cancelled');
-      return { success: false, error: 'Cancelled by user' };
-    }
+  // Non-secret prompts route through the bus interview (ISS-0127); the API
+  // token id + secret are service credentials that travel by flag/env only
+  // (D7). `withInterviewSession` renders bus questions locally on a TTY.
+  const scope = 'service-add:proxmox';
+
+  return withInterviewSession(async () => {
+    try {
+      celiloIntro('Add Proxmox Container Service');
+
+      const name = await askText({
+        scope,
+        key: 'name',
+        message: 'Human-readable name',
+        defaultValue: 'Proxmox Home Lab',
+        placeholder: 'Proxmox Home Lab',
+        required: true,
+      });
+
+      const zones = await askMultiselect({
+        scope,
+        key: 'zones',
+        message: 'Zones this service can provision to',
+        options: [
+          { value: 'internal', label: 'internal' },
+          { value: 'dmz', label: 'dmz' },
+          { value: 'app', label: 'app' },
+          { value: 'secure', label: 'secure' },
+          { value: 'external', label: 'external' },
+        ],
+        required: true,
+      });
+
+      console.log('\nProxmox Configuration');
+      console.log('─────────────────────');
+
+      const ipAddress = await askText({
+        scope,
+        key: 'ip_address',
+        message: 'Proxmox IP address',
+        placeholder: 'e.g., 192.168.1.100 or proxmox.local',
+        required: true,
+      });
+
+      const port = await askText({
+        scope,
+        key: 'port',
+        message: 'Proxmox API port',
+        defaultValue: '8006',
+        placeholder: '8006',
+        required: true,
+        type: 'integer',
+        pattern: '^[0-9]+$',
+      });
+
+      // Build the full API URL
+      const apiUrl = buildProxmoxApiUrl(ipAddress, Number(port));
+
+      // API token ID + secret are service credentials — flag/env only (D7).
+      const apiTokenId = await resolveServiceCredential({
+        field: 'API token ID',
+        flag: 'api-token-id',
+        envVar: 'PROXMOX_API_TOKEN_ID',
+        flagValue: flags['api-token-id'],
+      });
+
+      const apiTokenSecret = await resolveServiceCredential({
+        field: 'API token secret',
+        flag: 'api-token-secret',
+        envVar: 'PROXMOX_API_TOKEN_SECRET',
+        flagValue: flags['api-token-secret'],
+      });
 
-    console.log('\nProxmox Configuration');
-    console.log('─────────────────────');
-
-    const ipAddress = await promptText({
-      message: 'Proxmox IP address:',
-      placeholder: 'e.g., 192.168.1.100 or proxmox.local',
-      validate: validateRequired('IP address'),
-    });
-
-    const port = await promptText({
-      message: 'Proxmox API port:',
-      defaultValue: '8006',
-      placeholder: '8006',
-      validate: (value): string | Error | undefined => {
-        // validateRequired returns undefined for valid inputs (including undefined with defaults)
-        const requiredError = validateRequired('Port')(value);
-        if (requiredError !== undefined) return requiredError;
-
-        // If value is undefined, default will be used - that's valid
-        if (value === undefined) return undefined;
-
-        const portNum = Number(value);
-        if (Number.isNaN(portNum) || portNum < 1 || portNum > 65535) {
-          return 'Port must be a number between 1 and 65535';
+      const targetNode = await askText({
+        scope,
+        key: 'default_target_node',
+        message: 'Default target node',
+        defaultValue: 'pve',
+        placeholder: 'pve',
+        required: true,
+      });
+
+      const storage = await askText({
+        scope,
+        key: 'storage',
+        message: 'Default storage',
+        defaultValue: 'local-lvm',
+        placeholder: 'local-lvm',
+        required: true,
+      });
+
+      // Build credentials here — needed for VM template detection below and
+      // for LXC template catalog lookup further down.
+      const credentials = {
+        api_url: apiUrl,
+        api_token_id: apiTokenId,
+        api_token_secret: apiTokenSecret,
+      };
+
+      // VM template for `requires.system.type: vm` modules.
+      // Auto-detect existing templates on the node; offer to build if none found.
+      // See v2/PROXMOX_VM_TEMPLATE.md.
+      let vmTemplate: string | undefined;
+      const existingTemplates = await detectExistingVmTemplates(credentials, targetNode);
+      if (existingTemplates.length > 0) {
+        const templateChoice = await askSelect({
+          scope,
+          key: 'vm_template',
+          message: 'VM template for VM-type modules',
+          options: [
+            ...existingTemplates.map((t) => ({
+              value: t.name,
+              label: `${t.name} (VMID ${t.vmid})`,
+            })),
+            { value: VM_BUILD, label: 'Build a new Ubuntu 24.04 cloud-init template now' },
+            { value: VM_SKIP, label: 'Skip — I only need LXC modules' },
+          ],
+        });
+        if (templateChoice === VM_BUILD) {
+          vmTemplate = await buildCloudInitTemplate({
+            credentials,
+            nodeName: targetNode,
+            diskStorage: storage,
+          });
+        } else if (templateChoice !== VM_SKIP) {
+          vmTemplate = templateChoice;
         }
-        return undefined;
-      },
-    });
-
-    // Build the full API URL
-    const apiUrl = buildProxmoxApiUrl(ipAddress, Number(port));
-
-    const apiTokenId = await promptText({
-      message: 'API Token ID:',
-      defaultValue: 'root@pam!celilo',
-      placeholder: 'root@pam!celilo',
-      validate: validateRequired('API token ID'),
-    });
-
-    const apiTokenSecret = await promptPassword({
-      message: 'API Token Secret:',
-      validate: validateRequired('API token secret'),
-    });
-
-    const targetNode = await promptText({
-      message: 'Default target node:',
-      defaultValue: 'pve',
-      placeholder: 'pve',
-      validate: validateRequired('Target node'),
-    });
-
-    const storage = await promptText({
-      message: 'Default storage:',
-      defaultValue: 'local-lvm',
-      placeholder: 'local-lvm',
-      validate: validateRequired('Storage'),
-    });
-
-    // Find storage that supports vztmpl content. We do this BEFORE prompting
-    // for a template so the user only ever sees one storage in subsequent
-    // messages, and so the saved volid uses the right storage.
-    const credentials = {
-      api_url: apiUrl,
-      api_token_id: apiTokenId,
-      api_token_secret: apiTokenSecret,
-    };
-    console.log('\nFinding storage for templates...');
-    const storageListResult = await listNodeStorage(credentials, targetNode);
-
-    let templateStorage = 'local';
-    if (storageListResult.success) {
-      const vztmplStorage = storageListResult.data.find(
-        (s) => s.active && s.enabled && s.content.includes('vztmpl'),
-      );
-      if (vztmplStorage) {
-        templateStorage = vztmplStorage.storage;
-        console.log(`✓ Using storage '${templateStorage}' for templates`);
       } else {
-        console.log(`⚠ No storage found with 'vztmpl' support, using '${templateStorage}'`);
+        const shouldBuild = await askConfirm({
+          scope,
+          key: 'vm_template_build',
+          message:
+            'No VM templates found. Build a Ubuntu 24.04 cloud-init template now? (~2–10 min)',
+          defaultValue: false,
+        });
+        if (shouldBuild) {
+          vmTemplate = await buildCloudInitTemplate({
+            credentials,
+            nodeName: targetNode,
+            diskStorage: storage,
+          });
+        } else {
+          const manualEntry = await askText({
+            scope,
+            key: 'vm_template_manual',
+            message: 'VM template name (optional — leave blank to skip)',
+            placeholder: 'e.g., ubuntu-2404-cloudinit',
+          });
+          vmTemplate = manualEntry.trim() || undefined;
+        }
       }
-    }
-
-    // Pick a template from Proxmox's live catalog (replaces the old hardcoded
-    // version select that built `-1`-revision URLs by hand).
-    const selectionResult = await selectUbuntuApplianceFromCatalog(credentials, targetNode);
-    if (selectionResult.kind === 'cancelled') {
-      p.cancel('Operation cancelled');
-      return { success: false, error: 'Cancelled by user' };
-    }
-    if (selectionResult.kind === 'error') {
-      return { success: false, error: selectionResult.message };
-    }
-    const templateFilename = selectionResult.choice.template;
-    const lxcTemplate = buildTemplatePath(templateStorage, templateFilename);
 
-    // Check if the template is already cached in the chosen storage.
-    console.log(`\nChecking if template '${templateFilename}' exists...`);
-    const templatesResult = await listAvailableTemplates(credentials, targetNode, templateStorage);
+      // Find storage that supports vztmpl content. We do this BEFORE prompting
+      // for a template so the user only ever sees one storage in subsequent
+      // messages, and so the saved volid uses the right storage.
+      console.log('\nFinding storage for templates...');
+      const storageListResult = await listNodeStorage(credentials, targetNode);
 
-    let templateExists = false;
-    if (templatesResult.success) {
-      templateExists = templatesResult.data.some((t) => t.volid.includes(templateFilename));
-    }
+      let templateStorage = 'local';
+      if (storageListResult.success) {
+        const vztmplStorage = storageListResult.data.find(
+          (s) => s.active && s.enabled && s.content.includes('vztmpl'),
+        );
+        if (vztmplStorage) {
+          templateStorage = vztmplStorage.storage;
+          console.log(`✓ Using storage '${templateStorage}' for templates`);
+        } else {
+          console.log(`⚠ No storage found with 'vztmpl' support, using '${templateStorage}'`);
+        }
+      }
 
-    // Save the service FIRST so credentials aren't lost if the download fails.
-    const service = await addContainerService({
-      name,
-      providerName: 'proxmox',
-      zones: zones as unknown as NetworkZone[],
-      apiCredentials: credentials,
-      providerConfig: {
-        default_target_node: targetNode,
-        lxc_template: lxcTemplate,
-        storage,
-      },
-    });
-
-    console.log(`✓ Service '${service.serviceId}' saved\n`);
-
-    let templateReady = templateExists;
-
-    if (!templateExists) {
-      console.log(`✗ Template '${templateFilename}' not found in storage '${templateStorage}'`);
-
-      const shouldDownload = await p.confirm({
-        message: 'Download template now?',
-        initialValue: true,
+      // Pick a template from Proxmox's live catalog (replaces the old hardcoded
+      // version select that built `-1`-revision URLs by hand).
+      const selectionResult = await selectUbuntuApplianceFromCatalog(credentials, targetNode, {
+        scope,
       });
-
-      if (p.isCancel(shouldDownload)) {
-        p.cancel('Operation cancelled');
+      if (selectionResult.kind === 'cancelled') {
         return { success: false, error: 'Cancelled by user' };
       }
+      if (selectionResult.kind === 'error') {
+        return { success: false, error: selectionResult.message };
+      }
+      const templateFilename = selectionResult.choice.template;
+      const lxcTemplate = buildTemplatePath(templateStorage, templateFilename);
+
+      // Check if the template is already cached in the chosen storage.
+      console.log(`\nChecking if template '${templateFilename}' exists...`);
+      const templatesResult = await listAvailableTemplates(
+        credentials,
+        targetNode,
+        templateStorage,
+      );
+
+      let templateExists = false;
+      if (templatesResult.success) {
+        templateExists = templatesResult.data.some((t) => t.volid.includes(templateFilename));
+      }
+
+      // Save the service FIRST so credentials aren't lost if the download fails.
+      const service = await addContainerService({
+        name,
+        providerName: 'proxmox',
+        zones: zones as unknown as NetworkZone[],
+        apiCredentials: credentials,
+        providerConfig: {
+          default_target_node: targetNode,
+          lxc_template: lxcTemplate,
+          storage,
+          ...(vmTemplate ? { vm_template: vmTemplate } : {}),
+        },
+      });
 
-      if (shouldDownload) {
-        const downloadOutcome = await runApplianceDownload({
-          credentials,
-          targetNode,
-          templateStorage,
-          templateFilename,
+      console.log(`✓ Service '${service.serviceId}' saved\n`);
+
+      let templateReady = templateExists;
+
+      if (!templateExists) {
+        console.log(`✗ Template '${templateFilename}' not found in storage '${templateStorage}'`);
+
+        const shouldDownload = await askConfirm({
+          scope,
+          key: 'download_template',
+          message: 'Download template now?',
+          defaultValue: true,
         });
-        templateReady = downloadOutcome.ready;
+
+        if (shouldDownload) {
+          const downloadOutcome = await runApplianceDownload({
+            credentials,
+            targetNode,
+            templateStorage,
+            templateFilename,
+          });
+          templateReady = downloadOutcome.ready;
+        } else {
+          console.log(
+            '\nTemplate not downloaded. Service saved but will need a template before deployment.',
+          );
+        }
+
+        if (!templateReady) {
+          console.log(
+            '\nTemplate is not available. The service has been saved but needs a template.\n',
+          );
+          console.log('Next steps:');
+          console.log(
+            `  1. Try a different version: celilo service reconfigure ${service.serviceId}`,
+          );
+          console.log(
+            `  2. Download manually: ssh root@${ipAddress} pveam download ${templateStorage} ${templateFilename}`,
+          );
+          console.log(`  3. Then verify: celilo service verify ${service.serviceId}`);
+        }
       } else {
-        console.log(
-          '\nTemplate not downloaded. Service saved but will need a template before deployment.',
-        );
+        console.log(`✓ Template '${templateFilename}' found`);
       }
 
-      if (!templateReady) {
+      // Test connection
+      console.log('\nTesting connection...');
+      const testResult = await testServiceConnection(service);
+      await updateVerificationStatus(service.id, testResult);
+
+      if (!testResult.success) {
+        console.log(`✗ Connection test failed: ${testResult.message}`);
         console.log(
-          '\nTemplate is not available. The service has been saved but needs a template.\n',
+          '\nService saved but not verified. The service will not be used until verification succeeds.',
         );
-        console.log('Next steps:');
-        console.log(
-          `  1. Try a different version: celilo service reconfigure ${service.serviceId}`,
+
+        celiloOutro(
+          `Service '${service.serviceId}' (${name}) added but not verified.\n\nNext steps:\n  - Fix the connection issue\n  - Re-verify: celilo service verify ${service.serviceId}\n  - Check status: celilo service list`,
         );
-        console.log(
-          `  2. Download manually: ssh root@${ipAddress} pveam download ${templateStorage} ${templateFilename}`,
+      } else {
+        console.log(`✓ ${testResult.message}`);
+
+        celiloOutro(
+          `Service '${service.serviceId}' (${name}) added and verified successfully!\n\nService ID: ${service.serviceId}\n\nNext steps:\n  - Generate module: celilo module generate <module-id>\n  - List services: celilo service list`,
         );
-        console.log(`  3. Then verify: celilo service verify ${service.serviceId}`);
       }
-    } else {
-      console.log(`✓ Template '${templateFilename}' found`);
-    }
 
-    // Test connection
-    console.log('\nTesting connection...');
-    const testResult = await testServiceConnection(service);
-    await updateVerificationStatus(service.id, testResult);
-
-    if (!testResult.success) {
-      console.log(`✗ Connection test failed: ${testResult.message}`);
-      console.log(
-        '\nService saved but not verified. The service will not be used until verification succeeds.',
-      );
-
-      celiloOutro(
-        `Service '${service.serviceId}' (${name}) added but not verified.\n\nNext steps:\n  - Fix the connection issue\n  - Re-verify: celilo service verify ${service.serviceId}\n  - Check status: celilo service list`,
-      );
-    } else {
-      console.log(`✓ ${testResult.message}`);
-
-      celiloOutro(
-        `Service '${service.serviceId}' (${name}) added and verified successfully!\n\nService ID: ${service.serviceId}\n\nNext steps:\n  - Generate module: celilo module generate <module-id>\n  - List services: celilo service list`,
-      );
+      return {
+        success: true,
+        message: `Added Proxmox service: ${service.id}`,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Failed to add Proxmox service: ${error instanceof Error ? error.message : String(error)}`,
+      };
     }
-
-    return {
-      success: true,
-      message: `Added Proxmox service: ${service.id}`,
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: `Failed to add Proxmox service: ${error instanceof Error ? error.message : String(error)}`,
-    };
-  }
+  });
 }

package/src/cli/commands/service-reconfigure.test.ts

@@ -0,0 +1,115 @@
+import { describe, expect, test } from 'bun:test';
+import {
+  type ProxmoxProviderConfig,
+  buildVmTemplateChoices,
+  resolveReconfiguredProviderConfig,
+} from './service-reconfigure';
+
+describe('buildVmTemplateChoices — VM-template reconfigure menu', () => {
+  const templates = [
+    { vmid: 9000, name: 'ubuntu-2404-cloudinit' },
+    { vmid: 9001, name: 'ubuntu-2204-cloudinit' },
+  ];
+
+  test('current set + detected templates: keep first, others (current deduped), build, clear', () => {
+    const choices = buildVmTemplateChoices('ubuntu-2404-cloudinit', templates);
+    expect(choices.map((c) => c.value)).toEqual([
+      '__keep__',
+      'ubuntu-2204-cloudinit', // the other detected template — current is not re-listed
+      '__build__',
+      '__clear__',
+    ]);
+    expect(choices[0].label).toBe('Keep current (ubuntu-2404-cloudinit)');
+  });
+
+  test('current unset: no keep/clear; detected templates, build, then skip', () => {
+    const choices = buildVmTemplateChoices(undefined, templates);
+    expect(choices.map((c) => c.value)).toEqual([
+      'ubuntu-2404-cloudinit',
+      'ubuntu-2204-cloudinit',
+      '__build__',
+      '__skip__',
+    ]);
+  });
+
+  test('current set, no templates detected: keep, build, clear', () => {
+    const choices = buildVmTemplateChoices('ubuntu-2404-cloudinit', []);
+    expect(choices.map((c) => c.value)).toEqual(['__keep__', '__build__', '__clear__']);
+  });
+
+  test('current unset, no templates detected: build, skip', () => {
+    const choices = buildVmTemplateChoices(undefined, []);
+    expect(choices.map((c) => c.value)).toEqual(['__build__', '__skip__']);
+  });
+
+  test('a detected template carries its VMID in the label', () => {
+    const choices = buildVmTemplateChoices(undefined, [{ vmid: 9002, name: 'debian-12' }]);
+    expect(choices[0]).toEqual({ value: 'debian-12', label: 'debian-12 (VMID 9002)' });
+  });
+});
+
+describe('resolveReconfiguredProviderConfig — drop-bug guard (ISS-0128)', () => {
+  const current: ProxmoxProviderConfig = {
+    default_target_node: 'pve',
+    lxc_template: 'local:vztmpl/ubuntu-24.04.tar.zst',
+    storage: 'local-lvm',
+    vm_template: 'ubuntu-2404-cloudinit',
+  };
+
+  test('keeping the VM template (edit echoes current) preserves it while applying other edits', () => {
+    const result = resolveReconfiguredProviderConfig({
+      default_target_node: 'pve2',
+      lxc_template: 'local:vztmpl/ubuntu-24.04-2.tar.zst',
+      storage: 'fast-lvm',
+      vm_template: 'ubuntu-2404-cloudinit', // VM_KEEP resolves to the current value
+    });
+    expect(result).toEqual({
+      default_target_node: 'pve2',
+      lxc_template: 'local:vztmpl/ubuntu-24.04-2.tar.zst',
+      storage: 'fast-lvm',
+      vm_template: 'ubuntu-2404-cloudinit',
+    });
+  });
+
+  test('the pre-fix behavior would have dropped vm_template — guard against regressing', () => {
+    // Reconfiguring only the LXC fields must NOT lose the VM template: the
+    // handler threads currentConfig.vm_template through as the edit value.
+    const result = resolveReconfiguredProviderConfig({
+      default_target_node: current.default_target_node,
+      lxc_template: 'local:vztmpl/new.tar.zst',
+      storage: current.storage,
+      vm_template: current.vm_template,
+    });
+    expect(result.vm_template).toBe('ubuntu-2404-cloudinit');
+  });
+
+  test('clearing (undefined edit) removes the field entirely, not sets it undefined', () => {
+    const result = resolveReconfiguredProviderConfig({
+      default_target_node: 'pve',
+      lxc_template: current.lxc_template,
+      storage: current.storage,
+      vm_template: undefined,
+    });
+    expect('vm_template' in result).toBe(false);
+  });
+
+  test('setting a new template overwrites the old', () => {
+    const result = resolveReconfiguredProviderConfig({
+      default_target_node: 'pve',
+      lxc_template: current.lxc_template,
+      storage: current.storage,
+      vm_template: 'debian-12-cloudinit',
+    });
+    expect(result.vm_template).toBe('debian-12-cloudinit');
+  });
+
+  test('no VM template edit leaves it absent', () => {
+    const result = resolveReconfiguredProviderConfig({
+      default_target_node: 'pve',
+      lxc_template: 'local:vztmpl/x.tar.zst',
+      storage: 'local-lvm',
+      vm_template: undefined,
+    });
+    expect('vm_template' in result).toBe(false);
+  });
+});