@celilo/cli 0.3.16 → 0.3.18

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

@@ -0,0 +1,258 @@
+/**
+ * Proxmox template selection — shared between `service add proxmox` and
+ * `service reconfigure`. Queries Proxmox's live appliance catalog
+ * (`pveam available`) and prompts the user to pick an Ubuntu LXC template by
+ * canonical name.
+ *
+ * Why this exists: Proxmox bumps template revisions over time
+ * (ubuntu-24.04 went from -1 to -2, 25.04 ships as -1.1) and an older home-lab
+ * deployment guide naming `-1` produces 404s on the mirror. Using the catalog
+ * means the canonical filename always matches what `pveam download` accepts.
+ */
+
+import * as p from '@clack/prompts';
+import {
+  type ProxmoxAppliance,
+  type ProxmoxCredentials,
+  checkTaskStatus,
+  downloadAppliance,
+  listAvailableAppliances,
+} from '../../api-clients/proxmox';
+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" */
+  template: string;
+  /**
+   * 'catalog' = filename came from Proxmox's aplinfo, so it's known good for
+   * downloadAppliance. 'manual' = user typed it because aplinfo was unavailable;
+   * caller should expect they'll need to `pveam download` themselves.
+   */
+  source: 'catalog' | 'manual';
+}
+
+export type TemplateSelectionResult =
+  | { kind: 'selected'; choice: UbuntuTemplateChoice }
+  | { kind: 'cancelled' }
+  | { kind: 'error'; message: string };
+
+interface ParsedUbuntu {
+  appliance: ProxmoxAppliance;
+  major: number;
+  minor: number;
+  isLts: boolean;
+}
+
+function parseUbuntuPackage(appliance: ProxmoxAppliance): ParsedUbuntu | null {
+  const match = appliance.package.match(/^ubuntu-(\d+)\.(\d+)-standard$/);
+  if (!match) return null;
+  const major = Number(match[1]);
+  const minor = Number(match[2]);
+  // Ubuntu LTS = even major, .04 minor (20.04, 22.04, 24.04, 26.04, ...).
+  const isLts = minor === 4 && major % 2 === 0;
+  return { appliance, major, minor, isLts };
+}
+
+function compareDescending(a: ParsedUbuntu, b: ParsedUbuntu): number {
+  if (a.major !== b.major) return b.major - a.major;
+  return b.minor - a.minor;
+}
+
+/**
+ * Build the option list used by the select prompt and tests.
+ * Exported so tests can assert on filtering/sorting without mocking @clack.
+ */
+export function buildUbuntuOptions(appliances: ProxmoxAppliance[]): ParsedUbuntu[] {
+  return appliances
+    .map(parseUbuntuPackage)
+    .filter((entry): entry is ParsedUbuntu => entry !== null)
+    .filter((entry) => (entry.appliance.section ?? 'system') === 'system')
+    .sort(compareDescending);
+}
+
+/**
+ * Pre-select rule:
+ *   1. Exact match on currentTemplate (reconfigure with current revision still on mirror).
+ *   2. Family match on currentTemplate package (e.g. user has 24.04 -1 cached, mirror has -2).
+ *   3. Newest LTS in the catalog.
+ *   4. Newest entry overall.
+ */
+export function pickInitialTemplate(
+  options: ParsedUbuntu[],
+  currentTemplate?: string,
+): string | undefined {
+  if (options.length === 0) return undefined;
+
+  if (currentTemplate) {
+    const exact = options.find((e) => e.appliance.template === currentTemplate);
+    if (exact) return exact.appliance.template;
+
+    const familyName = currentTemplate.match(/^(ubuntu-\d+\.\d+-standard)/)?.[1];
+    if (familyName) {
+      const family = options.find((e) => e.appliance.package === familyName);
+      if (family) return family.appliance.template;
+    }
+  }
+
+  const newestLts = options.find((e) => e.isLts);
+  return (newestLts ?? options[0]).appliance.template;
+}
+
+export async function selectUbuntuApplianceFromCatalog(
+  credentials: ProxmoxCredentials,
+  nodeName: string,
+  opts: { currentTemplate?: string } = {},
+): Promise<TemplateSelectionResult> {
+  console.log('\nFetching Proxmox template catalog...');
+  const result = await listAvailableAppliances(credentials, nodeName);
+
+  if (!result.success) {
+    console.log(`⚠ Could not fetch template catalog from Proxmox: ${result.message}`);
+    console.log('  You can still configure the service by entering a template filename manually.');
+    console.log(
+      '  After saving, run `pveam download <storage> <template>` on the Proxmox host before deploying.',
+    );
+
+    const manual = await promptText({
+      message: 'Template filename:',
+      placeholder: 'ubuntu-24.04-standard_24.04-2_amd64.tar.zst',
+      validate: validateRequired('Template filename'),
+    });
+
+    if (typeof manual !== 'string' || manual.trim() === '') {
+      return { kind: 'cancelled' };
+    }
+
+    return { kind: 'selected', choice: { template: manual.trim(), source: 'manual' } };
+  }
+
+  const options = buildUbuntuOptions(result.data);
+
+  if (options.length === 0) {
+    return {
+      kind: 'error',
+      message:
+        'Proxmox aplinfo returned no Ubuntu standard templates. Run `pveam update` on the Proxmox host and re-try.',
+    };
+  }
+
+  const initialValue = pickInitialTemplate(options, opts.currentTemplate);
+
+  const selection = await p.select<string>({
+    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' : ''}`,
+      hint: e.isLts
+        ? `revision ${e.appliance.version}`
+        : `revision ${e.appliance.version} · non-LTS`,
+    })),
+    initialValue,
+  });
+
+  if (p.isCancel(selection)) {
+    return { kind: 'cancelled' };
+  }
+
+  return { kind: 'selected', choice: { template: selection, source: 'catalog' } };
+}
+
+export interface ApplianceDownloadOutcome {
+  /** True iff the template ended up available in the chosen storage. */
+  ready: boolean;
+  /**
+   * One of:
+   *   'started-failed' — POST to aplinfo failed (Proxmox rejected the request).
+   *   'task-failed'    — Download started but pveam exited non-OK (typically exit 8 = HTTP error).
+   *   'timeout'        — Polling exhausted the budget without seeing 'stopped'.
+   *   'ok'             — pveam exited 0 and template should now exist in storage.
+   */
+  reason: 'started-failed' | 'task-failed' | 'timeout' | 'ok';
+  /** The pveam exit status when reason='task-failed', or null otherwise. */
+  exitStatus?: string;
+  /** The error message from Proxmox when reason='started-failed'. */
+  startError?: string;
+}
+
+export interface RunApplianceDownloadInput {
+  credentials: ProxmoxCredentials;
+  targetNode: string;
+  templateStorage: string;
+  templateFilename: string;
+  /** Polling budget in 5s ticks; defaults to 60 (= 5 minutes). */
+  maxAttempts?: number;
+  /** Override the default 5000ms tick — primarily to keep tests fast. */
+  pollIntervalMs?: number;
+}
+
+/**
+ * Trigger a `pveam download` on the Proxmox host and poll until it finishes.
+ * Drives a FuelGauge for user-visible progress. Distinguishes real failures
+ * (Proxmox rejected the start, or pveam exited non-OK) from timeout, so the
+ * caller can render an accurate next-steps message instead of always blaming
+ * "5-minute timeout" for any non-success path (the bug that motivated this
+ * refactor).
+ */
+export async function runApplianceDownload(
+  input: RunApplianceDownloadInput,
+): Promise<ApplianceDownloadOutcome> {
+  const {
+    credentials,
+    targetNode,
+    templateStorage,
+    templateFilename,
+    maxAttempts = 60,
+    pollIntervalMs = 5000,
+  } = input;
+
+  const startResult = await downloadAppliance(
+    credentials,
+    targetNode,
+    templateStorage,
+    templateFilename,
+  );
+
+  if (!startResult.success) {
+    console.log(`\n✗ Failed to start download: ${startResult.message}`);
+    return { ready: false, reason: 'started-failed', startError: startResult.message };
+  }
+
+  const upid = startResult.data;
+  const gauge = new FuelGauge(`Downloading ${templateFilename}`);
+  gauge.start();
+
+  let attempts = 0;
+  while (attempts < maxAttempts) {
+    await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+    attempts++;
+
+    const statusResult = await checkTaskStatus(credentials, targetNode, upid);
+    if (!statusResult.success) {
+      gauge.addOutput(`Waiting for status... (${attempts * 5}s elapsed)`);
+      continue;
+    }
+
+    if (statusResult.data.status !== 'stopped') {
+      gauge.addOutput(`Status: ${statusResult.data.status} (${attempts * 5}s elapsed)`);
+      continue;
+    }
+
+    const exit = statusResult.data.exitstatus;
+    if (exit === 'OK') {
+      gauge.stop(true);
+      return { ready: true, reason: 'ok' };
+    }
+
+    gauge.stop(false);
+    console.log(`\n✗ pveam download failed: ${exit ?? 'unknown exit status'}`);
+    return { ready: false, reason: 'task-failed', exitStatus: exit ?? undefined };
+  }
+
+  gauge.stop(false);
+  console.log(
+    `\n✗ Template download did not complete within ${(maxAttempts * pollIntervalMs) / 1000}s`,
+  );
+  return { ready: false, reason: 'timeout' };
+}

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

@@ -7,10 +7,6 @@ import * as p from '@clack/prompts';
 import {
   buildProxmoxApiUrl,
   buildTemplatePath,
-  buildTemplateUrl,
-  checkTaskStatus,
-  downloadTemplate,
-  extractTemplateFilename,
   listAvailableTemplates,
   listNodeStorage,
 } from '../../api-clients/proxmox';
@@ -20,10 +16,13 @@ import {
   testConnection as testServiceConnection,
   updateVerificationStatus,
 } from '../../services/container-service';
-import { FuelGauge } from '../fuel-gauge';
 import { celiloIntro, celiloOutro, promptPassword, promptText } from '../prompts';
 import type { CommandResult } from '../types';
 import { validateRequired } from '../validators';
+import {
+  runApplianceDownload,
+  selectUbuntuApplianceFromCatalog,
+} from './proxmox-template-selection';
 
 /**
  * Handle service add proxmox command
@@ -123,35 +122,19 @@ export async function handleServiceAddProxmox(
       validate: validateRequired('Storage'),
     });
 
-    const ubuntuVersion = await p.select({
-      message: 'Ubuntu LTS version for default template:',
-      options: [
-        { value: '24.04', label: 'Ubuntu 24.04 LTS (Noble Numbat)' },
-        { value: '22.04', label: 'Ubuntu 22.04 LTS (Jammy Jellyfish)', hint: 'Recommended' },
-        { value: '20.04', label: 'Ubuntu 20.04 LTS (Focal Fossa)' },
-      ],
-      initialValue: '22.04',
-    });
-
-    if (p.isCancel(ubuntuVersion)) {
-      p.cancel('Operation cancelled');
-      return { success: false, error: 'Cancelled by user' };
-    }
-
-    // Find storage that supports vztmpl content
+    // 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(
-      {
-        api_url: apiUrl,
-        api_token_id: apiTokenId,
-        api_token_secret: apiTokenSecret,
-      },
-      targetNode,
-    );
+    const storageListResult = await listNodeStorage(credentials, targetNode);
 
-    let templateStorage = 'local'; // Default fallback
+    let templateStorage = 'local';
     if (storageListResult.success) {
-      // Find first active storage that supports 'vztmpl' content
       const vztmplStorage = storageListResult.data.find(
         (s) => s.active && s.enabled && s.content.includes('vztmpl'),
       );
@@ -163,37 +146,34 @@ export async function handleServiceAddProxmox(
       }
     }
 
-    // Build template path
-    const lxcTemplate = buildTemplatePath(templateStorage, ubuntuVersion as string);
-    const templateFilename = extractTemplateFilename(lxcTemplate);
+    // 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 template exists
+    // Check if the template is already cached in the chosen storage.
     console.log(`\nChecking if template '${templateFilename}' exists...`);
-    const templatesResult = await listAvailableTemplates(
-      {
-        api_url: apiUrl,
-        api_token_id: apiTokenId,
-        api_token_secret: apiTokenSecret,
-      },
-      targetNode,
-      templateStorage,
-    );
+    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 template download fails
+    // 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: {
-        api_url: apiUrl,
-        api_token_id: apiTokenId,
-        api_token_secret: apiTokenSecret,
-      },
+      apiCredentials: credentials,
       providerConfig: {
         default_target_node: targetNode,
         lxc_template: lxcTemplate,
@@ -203,7 +183,6 @@ export async function handleServiceAddProxmox(
 
     console.log(`✓ Service '${service.serviceId}' saved\n`);
 
-    // Now attempt template download (service is already saved)
     let templateReady = templateExists;
 
     if (!templateExists) {
@@ -220,89 +199,32 @@ export async function handleServiceAddProxmox(
       }
 
       if (shouldDownload) {
-        const templateUrl = buildTemplateUrl(ubuntuVersion as string);
-
-        const downloadResult = await downloadTemplate(
-          {
-            api_url: apiUrl,
-            api_token_id: apiTokenId,
-            api_token_secret: apiTokenSecret,
-          },
+        const downloadOutcome = await runApplianceDownload({
+          credentials,
           targetNode,
           templateStorage,
-          templateUrl,
-        );
-
-        if (!downloadResult.success) {
-          console.log(`\n✗ Failed to start download: ${downloadResult.message}`);
-        } else {
-          // Wait for download to complete with fuel-gauge progress
-          const upid = downloadResult.data;
-          const gauge = new FuelGauge(`Downloading ${templateFilename}`);
-          gauge.start();
-
-          let downloadComplete = false;
-          let attempts = 0;
-          const maxAttempts = 60;
-
-          while (!downloadComplete && attempts < maxAttempts) {
-            await new Promise((resolve) => setTimeout(resolve, 5000));
-
-            const statusResult = await checkTaskStatus(
-              {
-                api_url: apiUrl,
-                api_token_id: apiTokenId,
-                api_token_secret: apiTokenSecret,
-              },
-              targetNode,
-              upid,
-            );
-
-            if (statusResult.success) {
-              if (statusResult.data.status === 'stopped') {
-                if (statusResult.data.exitstatus === 'OK') {
-                  downloadComplete = true;
-                  templateReady = true;
-                  gauge.stop(true);
-                } else {
-                  gauge.stop(false);
-                  console.log(`\n✗ Template download failed: ${statusResult.data.exitstatus}`);
-                  break;
-                }
-              } else {
-                gauge.addOutput(`Status: ${statusResult.data.status} (${attempts * 5}s elapsed)`);
-              }
-            } else {
-              gauge.addOutput(`Waiting for status... (${attempts * 5}s elapsed)`);
-            }
-
-            attempts++;
-          }
-
-          if (!downloadComplete && !templateReady) {
-            gauge.stop(false);
-            console.log('\n✗ Template download timed out after 5 minutes');
-          }
-        }
-
-        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}`);
-        }
+          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(`✓ Template '${templateFilename}' found`);
     }

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

@@ -5,29 +5,24 @@
 
 import * as p from '@clack/prompts';
 import {
+  type ProxmoxCredentials,
   buildTemplatePath,
-  buildTemplateUrl,
-  checkTaskStatus,
-  downloadTemplate,
   extractTemplateFilename,
   listAvailableTemplates,
   listNodeStorage,
 } from '../../api-clients/proxmox';
 import {
-  getContainerServiceByName,
+  getContainerServiceByServiceId,
   getServiceCredentials,
   updateServiceProviderConfig,
 } from '../../services/container-service';
-import { FuelGauge } from '../fuel-gauge';
 import { celiloIntro, celiloOutro, promptText } from '../prompts';
 import type { CommandResult } from '../types';
 import { validateRequired } from '../validators';
-
-interface ProxmoxCredentials {
-  api_url: string;
-  api_token_id: string;
-  api_token_secret: string;
-}
+import {
+  runApplianceDownload,
+  selectUbuntuApplianceFromCatalog,
+} from './proxmox-template-selection';
 
 interface ProxmoxProviderConfig {
   default_target_node: string;
@@ -48,7 +43,7 @@ export async function handleServiceReconfigure(
   }
 
   try {
-    const service = await getContainerServiceByName(serviceId);
+    const service = await getContainerServiceByServiceId(serviceId);
     if (!service) {
       return { success: false, error: `Service '${serviceId}' not found` };
     }
@@ -87,27 +82,8 @@ export async function handleServiceReconfigure(
       validate: validateRequired('Storage'),
     });
 
-    // Detect current Ubuntu version from template filename
-    const currentTemplateFile = extractTemplateFilename(currentConfig.lxc_template);
-    const versionMatch = currentTemplateFile.match(/ubuntu-(\d+\.\d+)-/);
-    const currentVersion = versionMatch?.[1] || '22.04';
-
-    const ubuntuVersion = await p.select({
-      message: 'Ubuntu LTS version for default template:',
-      options: [
-        { value: '24.04', label: 'Ubuntu 24.04 LTS (Noble Numbat)' },
-        { value: '22.04', label: 'Ubuntu 22.04 LTS (Jammy Jellyfish)' },
-        { value: '20.04', label: 'Ubuntu 20.04 LTS (Focal Fossa)' },
-      ],
-      initialValue: currentVersion,
-    });
-
-    if (p.isCancel(ubuntuVersion)) {
-      p.cancel('Operation cancelled');
-      return { success: false, error: 'Cancelled by user' };
-    }
-
-    // Find template storage
+    // Find template storage. Done before catalog selection so the user only
+    // ever sees the chosen storage in subsequent messages.
     console.log('\nFinding storage for templates...');
     const storageListResult = await listNodeStorage(credentials, targetNode);
 
@@ -122,10 +98,22 @@ export async function handleServiceReconfigure(
       }
     }
 
-    const lxcTemplate = buildTemplatePath(templateStorage, ubuntuVersion as string);
-    const templateFilename = extractTemplateFilename(lxcTemplate);
+    // Pick a template from Proxmox's live catalog. Pre-selects the family
+    // matching the existing volid (e.g. user has 24.04 -1 cached, mirror has -2).
+    const selectionResult = await selectUbuntuApplianceFromCatalog(credentials, targetNode, {
+      currentTemplate: extractTemplateFilename(currentConfig.lxc_template),
+    });
+    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 new template exists
+    // Check if new template exists in storage.
     console.log(`\nChecking if template '${templateFilename}' exists...`);
     const templatesResult = await listAvailableTemplates(credentials, targetNode, templateStorage);
 
@@ -147,54 +135,23 @@ export async function handleServiceReconfigure(
           '\nTemplate not downloaded. Service will be updated but may fail verification.',
         );
       } else {
-        const templateUrl = buildTemplateUrl(ubuntuVersion as string);
-        const downloadResult = await downloadTemplate(
+        const outcome = await runApplianceDownload({
           credentials,
           targetNode,
           templateStorage,
-          templateUrl,
-        );
-
-        if (!downloadResult.success) {
-          return {
-            success: false,
-            error: `Failed to download template: ${downloadResult.message}\n\nTroubleshooting:\n  1. SSH into your Proxmox host and test: curl -I https://download.proxmox.com\n  2. Try downloading manually: pveam download ${templateStorage} ${templateFilename}\n  3. Check DNS and firewall settings on the Proxmox host`,
-          };
-        }
-
-        const upid = downloadResult.data;
-        const gauge = new FuelGauge(`Downloading ${templateFilename}`);
-        gauge.start();
-
-        let downloadComplete = false;
-        let attempts = 0;
-
-        while (!downloadComplete && attempts < 60) {
-          await new Promise((resolve) => setTimeout(resolve, 5000));
-          const statusResult = await checkTaskStatus(credentials, targetNode, upid);
-
-          if (statusResult.success && statusResult.data.status === 'stopped') {
-            if (statusResult.data.exitstatus === 'OK') {
-              downloadComplete = true;
-              gauge.stop(true);
-            } else {
-              gauge.stop(false);
-              return {
-                success: false,
-                error: `Template download failed: ${statusResult.data.exitstatus}\n\nThis usually means the Proxmox host cannot reach download.proxmox.com.\n\nTroubleshooting:\n  1. Try a different Ubuntu version: celilo service reconfigure ${serviceId}\n  2. Download manually: pveam download ${templateStorage} ${templateFilename}\n  3. Check DNS and firewall settings on the Proxmox host`,
-              };
-            }
-          } else {
-            gauge.addOutput(`Status: downloading... (${attempts * 5}s elapsed)`);
-          }
-          attempts++;
-        }
-
-        if (!downloadComplete) {
-          gauge.stop(false);
+          templateFilename,
+        });
+
+        if (!outcome.ready) {
+          const detail =
+            outcome.reason === 'task-failed'
+              ? `pveam download exited with status: ${outcome.exitStatus ?? 'unknown'}`
+              : outcome.reason === 'started-failed'
+                ? `Proxmox rejected the download request: ${outcome.startError ?? 'unknown error'}`
+                : 'Template download did not complete in time';
           return {
             success: false,
-            error: 'Template download timed out after 5 minutes.',
+            error: `${detail}\n\nTroubleshooting:\n  1. SSH into your Proxmox host and run: pveam update && pveam download ${templateStorage} ${templateFilename}\n  2. Re-try: celilo service reconfigure ${serviceId}\n  3. Check DNS and firewall settings on the Proxmox host`,
           };
         }
       }