@kustodian/cli 1.1.0 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kustodian/cli",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "CLI framework with DI and middleware for Kustodian",
   "type": "module",
   "main": "./src/index.ts",
@@ -37,15 +37,15 @@
     "registry": "https://npm.pkg.github.com"
   },
   "dependencies": {
-    "@kustodian/core": "workspace:*",
-    "@kustodian/generator": "workspace:*",
-    "@kustodian/loader": "workspace:*",
-    "@kustodian/nodes": "workspace:*",
-    "@kustodian/plugin-k0s": "workspace:*",
-    "@kustodian/plugins": "workspace:*",
-    "@kustodian/registry": "workspace:*",
-    "@kustodian/schema": "workspace:*",
-    "@kustodian/sources": "workspace:*",
+    "@kustodian/core": "1.1.0",
+    "@kustodian/generator": "1.2.0",
+    "@kustodian/loader": "1.1.0",
+    "@kustodian/nodes": "1.1.0",
+    "@kustodian/plugin-k0s": "1.1.0",
+    "@kustodian/plugins": "1.0.1",
+    "@kustodian/registry": "1.1.0",
+    "@kustodian/schema": "1.3.0",
+    "@kustodian/sources": "1.3.0",
     "ora": "^9.0.0",
     "yaml": "^2.8.2"
   }

package/src/commands/apply.ts

@@ -1,6 +1,7 @@
 import { exec } from 'node:child_process';
 import { promisify } from 'node:util';
 import { is_success, success } from '@kustodian/core';
+import { validate_template_requirements } from '@kustodian/generator';
 import { find_project_root, load_project } from '@kustodian/loader';
 import type { NodeListType } from '@kustodian/nodes';
 import type { ClusterType } from '@kustodian/schema';
@@ -278,6 +279,38 @@ export const apply_command = define_command({
     if (!skip_templates) {
       console.log('\n[4/4] Deploying templates...');
 
+      // Validate template requirements
+      console.log('  → Validating template requirements...');
+      const enabled_template_refs =
+        loaded_cluster.cluster.spec.templates?.filter((t) => t.enabled !== false) || [];
+
+      if (enabled_template_refs.length > 0) {
+        const enabled_templates = project.templates
+          .filter((t) => enabled_template_refs.some((ref) => ref.name === t.template.metadata.name))
+          .map((t) => t.template);
+
+        const requirements_result = validate_template_requirements(
+          enabled_templates,
+          loaded_cluster.nodes,
+        );
+
+        if (!requirements_result.valid) {
+          console.error('  ✗ Template requirement validation failed:');
+          for (const error of requirements_result.errors) {
+            console.error(`    - ${error.template}: ${error.message}`);
+          }
+          return {
+            success: false as const,
+            error: {
+              code: 'REQUIREMENT_VALIDATION_ERROR',
+              message: 'Template requirements not met',
+            },
+          };
+        }
+
+        console.log('    ✓ All template requirements satisfied');
+      }
+
       if (loaded_cluster.cluster.spec.oci) {
         // OCI Mode - generate in memory and apply directly
         console.log('  → Cluster uses OCI deployment');

package/src/commands/update.ts

@@ -1,15 +1,25 @@
 import * as path from 'node:path';
 
-import { failure, is_success, success } from '@kustodian/core';
+import { type ResultType, failure, is_success, success } from '@kustodian/core';
+import type { KustodianErrorType } from '@kustodian/core';
 import { read_yaml_file, write_yaml_file } from '@kustodian/loader';
 import { find_project_root, load_project } from '@kustodian/loader';
 import {
+  type ImageReferenceType,
+  type RegistryClientType,
+  type TagInfoType,
   check_version_update,
   create_client_for_image,
+  create_helm_client,
   filter_semver_tags,
   parse_image_reference,
 } from '@kustodian/registry';
-import { type VersionSubstitutionType, is_version_substitution } from '@kustodian/schema';
+import {
+  type HelmSubstitutionType,
+  type VersionSubstitutionType,
+  is_helm_substitution,
+  is_version_substitution,
+} from '@kustodian/schema';
 
 import { define_command } from '../command.js';
 
@@ -20,7 +30,8 @@ interface UpdateResultType {
   cluster: string;
   template: string;
   substitution: string;
-  image: string;
+  source: string; // Image name or Helm chart reference
+  source_type: 'image' | 'helm';
   current: string;
   latest: string;
   constraint?: string | undefined;
@@ -96,12 +107,13 @@ export const update_command = define_command({
       });
     }
 
-    // Collect all version substitutions from templates enabled in this cluster
+    // Collect all version and helm substitutions from templates enabled in this cluster
     const version_subs: Array<{
       template_name: string;
       kustomization_name: string;
-      substitution: VersionSubstitutionType;
+      substitution: VersionSubstitutionType | HelmSubstitutionType;
       current_value: string | undefined;
+      type: 'version' | 'helm';
     }> = [];
 
     for (const loaded_template of project.templates) {
@@ -127,6 +139,19 @@ export const update_command = define_command({
               kustomization_name: kustomization.name,
               substitution: sub,
               current_value: template_config?.values?.[sub.name] ?? sub.default,
+              type: 'version',
+            });
+          } else if (is_helm_substitution(sub)) {
+            if (substitution_filter && sub.name !== substitution_filter) {
+              continue;
+            }
+
+            version_subs.push({
+              template_name: template.metadata.name,
+              kustomization_name: kustomization.name,
+              substitution: sub,
+              current_value: template_config?.values?.[sub.name] ?? sub.default,
+              type: 'helm',
             });
           }
         }
@@ -146,19 +171,53 @@ export const update_command = define_command({
       console.log(`Found ${version_subs.length} version substitution(s) to check\n`);
     }
 
-    // Check each version substitution
+    // Check each version and helm substitution
     const results: UpdateResultType[] = [];
     const updates_to_apply: Map<string, Record<string, string>> = new Map();
 
-    for (const { template_name, substitution, current_value } of version_subs) {
-      const image_ref = parse_image_reference(substitution.registry.image);
-      const client = create_client_for_image(image_ref);
+    for (const { template_name, substitution, current_value, type } of version_subs) {
+      let source_name: string;
+      let client: RegistryClientType;
+
+      if (type === 'version') {
+        const version_sub = substitution as VersionSubstitutionType;
+        const image_ref = parse_image_reference(version_sub.registry.image);
+        source_name = version_sub.registry.image;
+        client = create_client_for_image(image_ref);
+      } else {
+        // helm type
+        const helm_sub = substitution as HelmSubstitutionType;
+        source_name = helm_sub.helm.oci || helm_sub.helm.repository || '';
+        source_name = `${source_name}/${helm_sub.helm.chart}`;
+        // Create helm config object to satisfy exactOptionalPropertyTypes
+        const helm_config: { repository?: string; oci?: string; chart: string } = {
+          chart: helm_sub.helm.chart,
+        };
+        if (helm_sub.helm.repository) {
+          helm_config.repository = helm_sub.helm.repository;
+        }
+        if (helm_sub.helm.oci) {
+          helm_config.oci = helm_sub.helm.oci;
+        }
+        client = create_helm_client(helm_config);
+      }
 
       if (!json_output) {
-        console.log(`Checking ${substitution.name} (${substitution.registry.image})...`);
+        console.log(`Checking ${substitution.name} (${source_name})...`);
       }
 
-      const tags_result = await client.list_tags(image_ref);
+      // For version type, we need to pass the image reference
+      // For helm type, the parameter is optional and ignored
+      let tags_result: ResultType<TagInfoType[], KustodianErrorType>;
+      if (type === 'version') {
+        tags_result = await client.list_tags(parse_image_reference(source_name));
+      } else {
+        // Helm client - the list_tags parameter is optional for helm clients
+        type ListTagsFn = (
+          ref?: ImageReferenceType,
+        ) => Promise<ResultType<TagInfoType[], KustodianErrorType>>;
+        tags_result = await (client.list_tags as ListTagsFn)(undefined);
+      }
       if (!is_success(tags_result)) {
         if (!json_output) {
           console.error(`  Failed to fetch tags: ${tags_result.error.message}`);
@@ -184,7 +243,8 @@ export const update_command = define_command({
         cluster: cluster_name,
         template: template_name,
         substitution: substitution.name,
-        image: substitution.registry.image,
+        source: source_name,
+        source_type: type === 'version' ? 'image' : 'helm',
         current: check.current_version,
         latest: check.latest_version,
         constraint: substitution.constraint,

package/src/commands/validate.ts

@@ -1,5 +1,5 @@
 import { failure, success } from '@kustodian/core';
-import { validate_dependency_graph } from '@kustodian/generator';
+import { validate_dependency_graph, validate_template_requirements } from '@kustodian/generator';
 import { find_project_root, load_project } from '@kustodian/loader';
 
 import { define_command } from '../command.js';
@@ -82,6 +82,46 @@ export const validate_command = define_command({
       }
     }
 
+    // Validate template requirements for each cluster
+    console.log('\nValidating template requirements...');
+    let has_requirement_errors = false;
+
+    for (const cluster_data of clusters) {
+      const cluster_name = cluster_data.cluster.metadata.name;
+      const enabled_template_refs =
+        cluster_data.cluster.spec.templates?.filter((t) => t.enabled !== false) || [];
+
+      if (enabled_template_refs.length === 0) {
+        continue;
+      }
+
+      // Get enabled templates
+      const enabled_templates = project.templates
+        .filter((t) => enabled_template_refs.some((ref) => ref.name === t.template.metadata.name))
+        .map((t) => t.template);
+
+      // Validate requirements
+      const requirements_result = validate_template_requirements(
+        enabled_templates,
+        cluster_data.nodes,
+      );
+
+      if (!requirements_result.valid) {
+        has_requirement_errors = true;
+        console.error(`\nRequirement validation errors for cluster '${cluster_name}':`);
+        for (const error of requirements_result.errors) {
+          console.error(`  ✗ ${error.template}: ${error.message}`);
+        }
+      }
+    }
+
+    if (has_requirement_errors) {
+      return failure({
+        code: 'REQUIREMENT_VALIDATION_ERROR',
+        message: 'Template requirement validation failed',
+      });
+    }
+
     // Validate dependency graph
     console.log('\nValidating dependency graph...');
     const templates = project.templates.map((t) => t.template);