@celilo/cli 0.1.0

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

@@ -0,0 +1,133 @@
+/**
+ * Service Add Digital Ocean Command
+ * Configure a Digital Ocean VPS service
+ */
+
+import * as p from '@clack/prompts';
+import type { NetworkZone } from '../../db/schema';
+import {
+  addContainerService,
+  testConnection as testServiceConnection,
+  updateVerificationStatus,
+} from '../../services/container-service';
+import { celiloIntro, celiloOutro, promptPassword, promptText } from '../prompts';
+import type { CommandResult } from '../types';
+import { validateRequired } from '../validators';
+
+/**
+ * Handle service add digitalocean command
+ *
+ * @param args - Command arguments (unused for interactive mode)
+ * @param flags - Command flags
+ */
+export async function handleServiceAddDigitalOcean(
+  _args: 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' };
+    }
+
+    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)}`,
+    };
+  }
+}

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

@@ -0,0 +1,342 @@
+/**
+ * Service Add Proxmox Command
+ * Configure a Proxmox container service
+ */
+
+import * as p from '@clack/prompts';
+import {
+  buildProxmoxApiUrl,
+  buildTemplatePath,
+  buildTemplateUrl,
+  checkTaskStatus,
+  downloadTemplate,
+  extractTemplateFilename,
+  listAvailableTemplates,
+  listNodeStorage,
+} from '../../api-clients/proxmox';
+import type { NetworkZone } from '../../db/schema';
+import {
+  addContainerService,
+  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';
+
+/**
+ * Handle service add proxmox command
+ *
+ * @param args - Command arguments (unused for interactive mode)
+ * @param flags - Command flags
+ */
+export async function handleServiceAddProxmox(
+  _args: 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' };
+    }
+
+    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';
+        }
+        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'),
+    });
+
+    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
+    console.log('\nFinding storage for templates...');
+    const storageListResult = await listNodeStorage(
+      {
+        api_url: apiUrl,
+        api_token_id: apiTokenId,
+        api_token_secret: apiTokenSecret,
+      },
+      targetNode,
+    );
+
+    let templateStorage = 'local'; // Default fallback
+    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'),
+      );
+      if (vztmplStorage) {
+        templateStorage = vztmplStorage.storage;
+        console.log(`✓ Using storage '${templateStorage}' for templates`);
+      } else {
+        console.log(`⚠ No storage found with 'vztmpl' support, using '${templateStorage}'`);
+      }
+    }
+
+    // Build template path
+    const lxcTemplate = buildTemplatePath(templateStorage, ubuntuVersion as string);
+    const templateFilename = extractTemplateFilename(lxcTemplate);
+
+    // Check if template exists
+    console.log(`\nChecking if template '${templateFilename}' exists...`);
+    const templatesResult = await listAvailableTemplates(
+      {
+        api_url: apiUrl,
+        api_token_id: apiTokenId,
+        api_token_secret: apiTokenSecret,
+      },
+      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
+    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,
+      },
+      providerConfig: {
+        default_target_node: targetNode,
+        lxc_template: lxcTemplate,
+        storage,
+      },
+    });
+
+    console.log(`✓ Service '${service.serviceId}' saved\n`);
+
+    // Now attempt template download (service is already saved)
+    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,
+      });
+
+      if (p.isCancel(shouldDownload)) {
+        p.cancel('Operation cancelled');
+        return { success: false, error: 'Cancelled by user' };
+      }
+
+      if (shouldDownload) {
+        const templateUrl = buildTemplateUrl(ubuntuVersion as string);
+
+        const downloadResult = await downloadTemplate(
+          {
+            api_url: apiUrl,
+            api_token_id: apiTokenId,
+            api_token_secret: apiTokenSecret,
+          },
+          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}`);
+        }
+      } else {
+        console.log(
+          '\nTemplate not downloaded. Service saved but will need a template before deployment.',
+        );
+      }
+    } 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)}`,
+    };
+  }
+}

package/src/cli/commands/service-config-get.ts

@@ -0,0 +1,83 @@
+/**
+ * Service config get command
+ */
+
+import { getContainerServiceByServiceId } from '../../services/container-service';
+import { getArg, validateRequiredArgs } from '../parser';
+import type { CommandResult } from '../types';
+
+/**
+ * Handle service config get command
+ *
+ * Usage: celilo service config get <service-id> [key]
+ *
+ * @param args - Command arguments
+ * @returns Command result
+ */
+export async function handleServiceConfigGet(args: string[]): Promise<CommandResult> {
+  const error = validateRequiredArgs(args, 1);
+  if (error) {
+    return {
+      success: false,
+      error: `${error}\n\nUsage: celilo service config get <service-id> [key]`,
+    };
+  }
+
+  const serviceId = getArg(args, 0);
+  const key = getArg(args, 1);
+
+  if (!serviceId) {
+    return {
+      success: false,
+      error: 'Service ID is required',
+    };
+  }
+
+  const service = await getContainerServiceByServiceId(serviceId);
+  if (!service) {
+    return {
+      success: false,
+      error: `Service not found: ${serviceId}`,
+    };
+  }
+
+  // Configurable fields
+  const configurableFields: Record<string, unknown> = {
+    name: service.name,
+    zones: service.zones,
+    providerConfig: service.providerConfig,
+  };
+
+  if (key) {
+    // Get specific config value
+    if (!(key in configurableFields)) {
+      const validKeys = Object.keys(configurableFields).join(', ');
+      return {
+        success: false,
+        error: `Invalid config key '${key}' for service.\n\nValid keys: ${validKeys}`,
+      };
+    }
+
+    const value = configurableFields[key];
+    const formatted = typeof value === 'object' ? JSON.stringify(value, null, 2) : String(value);
+
+    return {
+      success: true,
+      message: `${key} = ${formatted}`,
+      data: { key, value },
+    };
+  }
+
+  // Get all config for service
+  const lines = [`Configuration for ${serviceId}:`, ''];
+  for (const [configKey, value] of Object.entries(configurableFields)) {
+    const formatted = typeof value === 'object' ? JSON.stringify(value) : String(value);
+    lines.push(`${configKey} = ${formatted}`);
+  }
+
+  return {
+    success: true,
+    message: lines.join('\n'),
+    data: configurableFields,
+  };
+}

package/src/cli/commands/service-config-set.ts

@@ -0,0 +1,145 @@
+/**
+ * Service config set command
+ */
+
+import { eq } from 'drizzle-orm';
+import { z } from 'zod';
+import { getDb } from '../../db/client';
+import { type NetworkZone, containerServices } from '../../db/schema';
+import { getContainerServiceByServiceId } from '../../services/container-service';
+import { getArg, validateRequiredArgs } from '../parser';
+import type { CommandResult } from '../types';
+
+/**
+ * Handle service config set command
+ *
+ * Usage: celilo service config set <service-id> <key> <value>
+ *
+ * @param args - Command arguments
+ * @returns Command result
+ */
+export async function handleServiceConfigSet(args: string[]): Promise<CommandResult> {
+  const error = validateRequiredArgs(args, 3);
+  if (error) {
+    return {
+      success: false,
+      error: `${error}\n\nUsage: celilo service config set <service-id> <key> <value>`,
+    };
+  }
+
+  const serviceId = getArg(args, 0);
+  const key = getArg(args, 1);
+  const valueRaw = getArg(args, 2);
+
+  if (!serviceId || !key || !valueRaw) {
+    return {
+      success: false,
+      error: 'Service ID, key, and value are required',
+    };
+  }
+
+  const service = await getContainerServiceByServiceId(serviceId);
+  if (!service) {
+    return {
+      success: false,
+      error: `Service not found: ${serviceId}`,
+    };
+  }
+
+  // Validate key
+  const validKeys = ['name', 'zones', 'providerConfig'];
+  if (!validKeys.includes(key)) {
+    return {
+      success: false,
+      error: `Invalid config key '${key}'.\n\nValid keys: ${validKeys.join(', ')}`,
+    };
+  }
+
+  const db = getDb();
+  const now = new Date();
+
+  try {
+    // Handle different key types
+    if (key === 'name') {
+      // Simple string value
+      await db
+        .update(containerServices)
+        .set({
+          name: valueRaw,
+          updatedAt: now,
+        })
+        .where(eq(containerServices.id, service.id));
+
+      return {
+        success: true,
+        message: `Updated service ${serviceId}: ${key} = ${valueRaw}`,
+      };
+    }
+
+    if (key === 'zones') {
+      // Parse as JSON array of NetworkZone
+      const ZonesSchema = z.array(z.enum(['internal', 'dmz', 'app', 'secure', 'external']));
+      const parsed = JSON.parse(valueRaw);
+      const zones = ZonesSchema.parse(parsed) as NetworkZone[];
+
+      await db
+        .update(containerServices)
+        .set({
+          zones, // Drizzle auto-stringifies with mode: 'json'
+          updatedAt: now,
+        })
+        .where(eq(containerServices.id, service.id));
+
+      return {
+        success: true,
+        message: `Updated service ${serviceId}: ${key} = ${JSON.stringify(zones)}`,
+      };
+    }
+
+    if (key === 'providerConfig') {
+      // Parse as JSON object
+      const parsed = JSON.parse(valueRaw);
+      if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        return {
+          success: false,
+          error: 'providerConfig must be a JSON object',
+        };
+      }
+
+      await db
+        .update(containerServices)
+        .set({
+          providerConfig: parsed, // Drizzle auto-stringifies with mode: 'json'
+          updatedAt: now,
+        })
+        .where(eq(containerServices.id, service.id));
+
+      return {
+        success: true,
+        message: `Updated service ${serviceId}: ${key} = ${JSON.stringify(parsed)}`,
+      };
+    }
+
+    return {
+      success: false,
+      error: `Config key '${key}' is not implemented`,
+    };
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      return {
+        success: false,
+        error: `Invalid JSON value: ${error.message}`,
+      };
+    }
+    if (error instanceof z.ZodError) {
+      return {
+        success: false,
+        error: `Validation failed: ${error.errors.map((e) => e.message).join(', ')}`,
+      };
+    }
+    return {
+      success: false,
+      error: `Failed to set config: ${error instanceof Error ? error.message : String(error)}`,
+    };
+  }
+}