@celilo/cli 0.5.0-alpha.8 → 0.5.0

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

@@ -13,7 +13,6 @@ import { cpSync, existsSync, readFileSync, readdirSync } from 'node:fs';
 import { unlink } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join, resolve } from 'node:path';
-import * as p from '@clack/prompts';
 import { eq } from 'drizzle-orm';
 import { parse as parseYaml } from 'yaml';
 import { registerModuleCapabilities } from '../../capabilities/registration';
@@ -23,6 +22,7 @@ import { ModuleManifestSchema } from '../../manifest/schema';
 import type { ModuleManifest } from '../../manifest/schema';
 import { cleanupTempDir, extractPackage } from '../../module/packaging/extract';
 import { RegistryClient } from '../../registry/client';
+import { askConfirm, withInterviewSession } from '../../services/bus-interview';
 import { getFlag } from '../parser';
 import { log } from '../prompts';
 import type { CommandResult } from '../types';
@@ -508,11 +508,15 @@ async function runRegistrySweep(
     log.message('Each breaking update will be applied only on explicit confirmation.\n');
 
     for (const plan of breaking) {
-      const proceed = await p.confirm({
-        message: `Apply breaking update for ${plan.moduleId} (${plan.installedVersion} → ${plan.targetVersion})?`,
-        initialValue: false,
-      });
-      if (p.isCancel(proceed) || !proceed) {
+      const proceed = await withInterviewSession(() =>
+        askConfirm({
+          scope: `module-upgrade:${plan.moduleId}`,
+          key: 'apply_breaking',
+          message: `Apply breaking update for ${plan.moduleId} (${plan.installedVersion} → ${plan.targetVersion})?`,
+          defaultValue: false,
+        }),
+      );
+      if (!proceed) {
         skippedBreaking++;
         continue;
       }

package/src/cli/commands/proxmox-node-list.ts

@@ -0,0 +1,101 @@
+/**
+ * `celilo proxmox node list` — live per-node capacity from the Proxmox cluster
+ * (ISS-0060, Phase 1 of v2/PROXMOX_CAPACITY_AND_LIFECYCLE.md).
+ *
+ * Reads reality from the Proxmox API via `ProxmoxClient`, never a cached DB
+ * value — the foundation for capacity-aware placement (ISS-0061) and
+ * reconcile-on-read (the rest of ISS-0060 / ISS-0090).
+ */
+
+import { ProxmoxClient, type ProxmoxCredentials } from '../../api-clients/proxmox';
+import { getServiceCredentials, listContainerServices } from '../../services/container-service';
+import { celiloIntro } from '../prompts';
+import type { CommandResult } from '../types';
+
+function formatUptime(sec: number): string {
+  if (sec <= 0) return '—';
+  const days = Math.floor(sec / 86400);
+  const hours = Math.floor((sec % 86400) / 3600);
+  return days > 0 ? `${days}d${hours}h` : `${hours}h`;
+}
+
+/**
+ * Resolve which Proxmox service to introspect: an explicit service-id arg, else
+ * the sole Proxmox service. Returns an error message when the choice is
+ * ambiguous or the named service doesn't exist.
+ */
+function resolveProxmoxService(
+  services: Awaited<ReturnType<typeof listContainerServices>>,
+  requested: string | undefined,
+): { service: (typeof services)[number] } | { error: string } {
+  const proxmox = services.filter((s) => s.providerName === 'proxmox');
+  if (proxmox.length === 0) {
+    return {
+      error: 'No Proxmox container service configured. Add one: celilo service add proxmox',
+    };
+  }
+  if (requested) {
+    const match = proxmox.find((s) => s.serviceId === requested);
+    if (!match) {
+      return {
+        error: `No Proxmox service '${requested}'. Known: ${proxmox.map((s) => s.serviceId).join(', ')}`,
+      };
+    }
+    return { service: match };
+  }
+  if (proxmox.length > 1) {
+    return {
+      error: `Multiple Proxmox services — specify one: celilo proxmox node list <service-id>\n  ${proxmox
+        .map((s) => s.serviceId)
+        .join('\n  ')}`,
+    };
+  }
+  return { service: proxmox[0] };
+}
+
+export async function handleProxmoxNodeList(
+  args: string[],
+  _flags: Record<string, boolean | string> = {},
+): Promise<CommandResult> {
+  celiloIntro('Proxmox nodes');
+
+  const resolved = resolveProxmoxService(await listContainerServices(), args[0]);
+  if ('error' in resolved) {
+    console.log(`✗ ${resolved.error}`);
+    return { success: false, error: resolved.error };
+  }
+  const { service } = resolved;
+
+  const creds = (await getServiceCredentials(service.id)) as ProxmoxCredentials;
+  const result = await new ProxmoxClient(creds).nodeCapacities();
+  if (!result.success) {
+    console.log(`✗ Could not reach Proxmox (${service.serviceId}): ${result.message}`);
+    return { success: false, error: result.message };
+  }
+
+  if (result.data.length === 0) {
+    console.log('No nodes reported by the cluster.');
+    return { success: true, message: 'No nodes' };
+  }
+
+  console.log(`Service: ${service.serviceId} (${service.name})\n`);
+  console.log(
+    'NODE        STATUS    RAM free/total      CPU             DISK free/total     UPTIME',
+  );
+  console.log(
+    '─────────────────────────────────────────────────────────────────────────────────────',
+  );
+  for (const n of result.data) {
+    const status = n.online ? 'online' : 'OFFLINE';
+    const ram = `${(n.memFreeMb / 1024).toFixed(1)}/${(n.memTotalMb / 1024).toFixed(1)} GB`;
+    const cpu = `${n.cpuCores} cores ${n.cpuUsedPct}%`;
+    const disk = `${n.diskFreeGb}/${n.diskTotalGb} GB`;
+    console.log(
+      `${n.node.padEnd(11)} ${status.padEnd(9)} ${ram.padEnd(19)} ${cpu.padEnd(15)} ${disk.padEnd(19)} ${formatUptime(
+        n.uptimeSec,
+      )}`,
+    );
+  }
+  console.log('');
+  return { success: true, message: `${result.data.length} node(s)` };
+}

package/src/cli/commands/proxmox-template-selection.ts

@@ -10,7 +10,6 @@
  * means the canonical filename always matches what `pveam download` accepts.
  */
 
-import * as p from '@clack/prompts';
 import {
   type ProxmoxAppliance,
   type ProxmoxCredentials,
@@ -18,9 +17,8 @@ import {
   downloadAppliance,
   listAvailableAppliances,
 } from '../../api-clients/proxmox';
+import { askSelect, askText } from '../../services/bus-interview';
 import { FuelGauge } from '../fuel-gauge';
-import { promptText } from '../prompts';
-import { validateRequired } from '../validators';
 
 export interface UbuntuTemplateChoice {
   /** Canonical filename, e.g. "ubuntu-24.04-standard_24.04-2_amd64.tar.zst" */
@@ -103,7 +101,7 @@ export function pickInitialTemplate(
 export async function selectUbuntuApplianceFromCatalog(
   credentials: ProxmoxCredentials,
   nodeName: string,
-  opts: { currentTemplate?: string } = {},
+  opts: { scope: string; currentTemplate?: string },
 ): Promise<TemplateSelectionResult> {
   console.log('\nFetching Proxmox template catalog...');
   const result = await listAvailableAppliances(credentials, nodeName);
@@ -115,13 +113,17 @@ export async function selectUbuntuApplianceFromCatalog(
       '  After saving, run `pveam download <storage> <template>` on the Proxmox host before deploying.',
     );
 
-    const manual = await promptText({
-      message: 'Template filename:',
+    // Manual fallback over the bus (ISS-0127) — drivable headlessly by
+    // answering `interview.required.<scope>.lxc_template_manual`.
+    const manual = await askText({
+      scope: opts.scope,
+      key: 'lxc_template_manual',
+      message: 'Template filename',
       placeholder: 'ubuntu-24.04-standard_24.04-2_amd64.tar.zst',
-      validate: validateRequired('Template filename'),
+      required: true,
     });
 
-    if (typeof manual !== 'string' || manual.trim() === '') {
+    if (manual.trim() === '') {
       return { kind: 'cancelled' };
     }
 
@@ -140,8 +142,11 @@ export async function selectUbuntuApplianceFromCatalog(
 
   const initialValue = pickInitialTemplate(options, opts.currentTemplate);
 
-  const selection = await p.select<string>({
-    message: 'Default Ubuntu template:',
+  // Template choice over the bus (ISS-0127), keyed `lxc_template` within scope.
+  const selection = await askSelect({
+    scope: opts.scope,
+    key: 'lxc_template',
+    message: 'Default Ubuntu template',
     options: options.map((e) => ({
       value: e.appliance.template,
       label: `Ubuntu ${e.major}.${String(e.minor).padStart(2, '0')}${e.isLts ? ' LTS' : ''}`,
@@ -149,13 +154,9 @@ export async function selectUbuntuApplianceFromCatalog(
         ? `revision ${e.appliance.version}`
         : `revision ${e.appliance.version} · non-LTS`,
     })),
-    initialValue,
+    defaultValue: initialValue,
   });
 
-  if (p.isCancel(selection)) {
-    return { kind: 'cancelled' };
-  }
-
   return { kind: 'selected', choice: { template: selection, source: 'catalog' } };
 }
 

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

@@ -25,7 +25,7 @@ import {
   deleteVm,
   downloadCloudImage,
   findFreeTemplateVmid,
-  findIsoStorage,
+  findImportStorage,
   listVmTemplates,
   pollTaskUntilDone,
 } from '../../api-clients/proxmox';
@@ -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 {
@@ -69,21 +74,23 @@ export async function buildCloudInitTemplate(params: VmTemplateBuildParams): Pro
   let vmid: number | null = null;
 
   try {
-    // Step 1: find ISO storage
-    gauge.addOutput('Finding ISO-capable storage on the node…');
-    const isoStorageResult = await findIsoStorage(credentials, nodeName);
-    if (!isoStorageResult.success) {
-      throw new Error(`Could not list node storage: ${isoStorageResult.message}`);
+    // Step 1: find import-capable storage. The cloud image is consumed via the
+    // VM-create `import-from=`, which requires an `import`/`images` source — a
+    // `.img` in the `iso/` namespace is rejected (`has wrong type 'iso'`).
+    gauge.addOutput('Finding import-capable storage on the node…');
+    const importStorageResult = await findImportStorage(credentials, nodeName);
+    if (!importStorageResult.success) {
+      throw new Error(`Could not list node storage: ${importStorageResult.message}`);
     }
-    const isoStorage = isoStorageResult.data;
-    if (!isoStorage) {
+    const importStorage = importStorageResult.data;
+    if (!importStorage) {
       throw new Error(
-        'No ISO-capable storage found on the node. ' +
-          "Enable 'iso' content on a storage (typically 'local') in the Proxmox UI: " +
+        'No import-capable storage found on the node. ' +
+          "Enable 'import' content on a storage (typically 'local') in the Proxmox UI: " +
           'Datacenter → Storage → Edit → Content.',
       );
     }
-    gauge.addOutput(`ISO storage: ${isoStorage}`);
+    gauge.addOutput(`Import storage: ${importStorage}`);
 
     // Step 2: find a free template VMID
     gauge.addOutput('Finding a free template VMID (>= 9000)…');
@@ -92,21 +99,21 @@ export async function buildCloudInitTemplate(params: VmTemplateBuildParams): Pro
     vmid = vmidResult.data;
     gauge.addOutput(`Using VMID ${vmid}`);
 
-    // Step 3: download cloud image to ISO storage
+    // Step 3: download cloud image to import storage
     gauge.addOutput(
-      `Downloading Ubuntu 24.04 cloud image to '${isoStorage}' (~600 MB, may take several minutes)…`,
+      `Downloading Ubuntu 24.04 cloud image to '${importStorage}' (~600 MB, may take several minutes)…`,
     );
     const downloadResult = await downloadCloudImage(
       credentials,
       nodeName,
-      isoStorage,
+      importStorage,
       UBUNTU_2404_AMD64_URL,
       UBUNTU_2404_AMD64_FILENAME,
     );
     if (!downloadResult.success) {
       if (downloadResult.message.includes('403') || downloadResult.message.includes('not found')) {
         throw new Error(
-          `Proxmox storage download-url endpoint rejected the request. This endpoint requires Proxmox VE 7.2+. Error: ${downloadResult.message}`,
+          `Proxmox storage download-url endpoint rejected the request. Downloading to 'import' content requires Proxmox VE 8.2+. Error: ${downloadResult.message}`,
         );
       }
       throw new Error(`Cloud image download failed: ${downloadResult.message}`);
@@ -116,14 +123,14 @@ export async function buildCloudInitTemplate(params: VmTemplateBuildParams): Pro
     gauge.addOutput('Cloud image downloaded');
 
     // Step 4: create VM from cloud image
-    const isoVolid = buildCloudImageVolid(isoStorage, UBUNTU_2404_AMD64_FILENAME);
+    const imageVolid = buildCloudImageVolid(importStorage, UBUNTU_2404_AMD64_FILENAME);
     gauge.addOutput(`Creating VM ${vmid} '${DEFAULT_TEMPLATE_NAME}' (importing disk)…`);
     const createResult = await createVmFromCloudImage({
       credentials,
       nodeName,
       vmid,
       name: DEFAULT_TEMPLATE_NAME,
-      isoVolid,
+      imageVolid,
       diskStorage,
     });
     if (!createResult.success) {

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

@@ -3,16 +3,16 @@
  * Configure a Digital Ocean VPS service
  */
 
-import * as p from '@clack/prompts';
 import type { NetworkZone } from '../../db/schema';
+import { askMultiselect, 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';
 
 /**
  * Handle service add digitalocean command
@@ -22,112 +22,123 @@ import { validateRequired } from '../validators';
  */
 export async function handleServiceAddDigitalOcean(
   _args: string[],
-  _flags: Record<string, boolean | string> = {},
+  flags: Record<string, boolean | string> = {},
 ): Promise<CommandResult> {
-  try {
-    celiloIntro('Add Digital Ocean VPS Service');
-
-    // Prompt for service configuration
-    const name = await promptText({
-      message: 'Human-readable name:',
-      defaultValue: 'Digital Ocean VPS',
-      placeholder: 'Digital Ocean VPS',
-      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: ['external' as NetworkZone], // Digital Ocean is typically for external-facing services
-    });
-
-    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 DO API
+  // token is a service credential that travels by flag/env only (D7).
+  const scope = 'service-add:digitalocean';
+
+  return withInterviewSession(async () => {
+    try {
+      celiloIntro('Add Digital Ocean VPS Service');
+
+      const name = await askText({
+        scope,
+        key: 'name',
+        message: 'Human-readable name',
+        defaultValue: 'Digital Ocean VPS',
+        placeholder: 'Digital Ocean VPS',
+        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('\nDigital Ocean Configuration');
+      console.log('──────────────────────────');
+
+      // API token is a service credential — flag/env only (D7).
+      const apiToken = await resolveServiceCredential({
+        field: 'API token (Personal Access Token)',
+        flag: 'api-token',
+        envVar: 'DIGITALOCEAN_API_TOKEN',
+        flagValue: flags['api-token'],
+      });
+
+      const defaultRegion = await askText({
+        scope,
+        key: 'default_region',
+        message: 'Default region',
+        defaultValue: 'nyc3',
+        placeholder: 'nyc3',
+        required: true,
+      });
+
+      const defaultSize = await askText({
+        scope,
+        key: 'default_size',
+        message: 'Default droplet size',
+        defaultValue: 's-1vcpu-1gb',
+        placeholder: 's-1vcpu-1gb',
+        required: true,
+      });
+
+      const defaultImage = await askText({
+        scope,
+        key: 'default_image',
+        message: 'Default image',
+        defaultValue: 'ubuntu-22-04-x64',
+        placeholder: 'ubuntu-22-04-x64',
+        required: true,
+      });
+
+      // Store the service first so we can test it
+      const service = await addContainerService({
+        name,
+        providerName: 'digitalocean',
+        zones: zones as unknown as NetworkZone[],
+        apiCredentials: {
+          api_token: apiToken,
+        },
+        providerConfig: {
+          default_region: defaultRegion,
+          default_size: defaultSize,
+          default_image: defaultImage,
+        },
+      });
+
+      // 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 Digital Ocean service: ${service.id}`,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Failed to add Digital Ocean service: ${error instanceof Error ? error.message : String(error)}`,
+      };
     }
-
-    console.log('\nDigital Ocean Configuration');
-    console.log('──────────────────────────');
-
-    const apiToken = await promptPassword({
-      message: 'API Token (Personal Access Token):',
-      validate: validateRequired('API token'),
-    });
-
-    const defaultRegion = await promptText({
-      message: 'Default region:',
-      defaultValue: 'nyc3',
-      placeholder: 'nyc3',
-      validate: validateRequired('Region'),
-    });
-
-    const defaultSize = await promptText({
-      message: 'Default droplet size:',
-      defaultValue: 's-1vcpu-1gb',
-      placeholder: 's-1vcpu-1gb',
-      validate: validateRequired('Droplet size'),
-    });
-
-    const defaultImage = await promptText({
-      message: 'Default image:',
-      defaultValue: 'ubuntu-22-04-x64',
-      placeholder: 'ubuntu-22-04-x64',
-      validate: validateRequired('Image'),
-    });
-
-    // Store the service first so we can test it
-    const service = await addContainerService({
-      name,
-      providerName: 'digitalocean',
-      zones: zones as NetworkZone[],
-      apiCredentials: {
-        api_token: apiToken,
-      },
-      providerConfig: {
-        default_region: defaultRegion,
-        default_size: defaultSize,
-        default_image: defaultImage,
-      },
-    });
-
-    // 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 Digital Ocean service: ${service.id}`,
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: `Failed to add Digital Ocean service: ${error instanceof Error ? error.message : String(error)}`,
-    };
-  }
+  });
 }