walheim 0.1.2 → 0.2.1

data/lib/walheim/resources/apps.rb

@@ -1,20 +1,22 @@
 # frozen_string_literal: true
 
-require_relative '../namespaced_resource'
-require_relative '../sync'
-require_relative '../handler_registry'
+require_relative "../namespaced_resource"
+require_relative "../sync"
+require_relative "../handler_registry"
 
 module Resources
   class Apps < Walheim::NamespacedResource
-    def initialize(namespaces_dir: 'namespaces')
-      super
-      @syncer = Walheim::Sync.new(namespaces_dir: namespaces_dir)
+    def initialize(data_dir: Dir.pwd)
+      super(data_dir: data_dir)
+      # Sync needs the full path to namespaces directory
+      @namespaces_dir = File.join(data_dir, "namespaces")
+      @syncer = Walheim::Sync.new(namespaces_dir: @namespaces_dir)
     end
 
     def self.kind_info
       {
-        plural: 'apps',
-        singular: 'app',
+        plural: "apps",
+        singular: "app",
         aliases: %w[application applications]
       }
     end
@@ -31,11 +33,11 @@ module Resources
       {
         image: lambda { |manifest|
           # Extract first service's image from compose spec
-          manifest.dig('spec', 'compose', 'services')&.values&.first&.dig('image') || 'N/A'
+          manifest.dig("spec", "compose", "services")&.values&.first&.dig("image") || "N/A"
         },
         status: lambda { |_manifest|
           # Could check if app is running, for now just show 'Configured'
-          'Configured'
+          "Configured"
         }
       }
     end
@@ -44,32 +46,47 @@ module Resources
       # Start with base operations
       ops = super
 
+      namespace_opt = { type: :string, aliases: [ :n ], desc: "Target namespace", required: true }
+
       # Add apps-specific operations
       ops.merge({
                   import: {
-                    description: 'Import docker-compose as Walheim App',
-                    usage: ['import app {name} -n {namespace} -f {docker-compose.yml}']
+                    description: "Import docker-compose as Walheim App",
+                    usage: [ "import app {name} -n {namespace} -f {docker-compose.yml}" ],
+                    options: {
+                      namespace: namespace_opt,
+                      file: { type: :string, aliases: [ :f ], desc: "docker-compose.yml path", required: true }
+                    }
                   },
                   start: {
-                    description: 'Compile, sync, and start app on host',
-                    usage: ['start app {name} -n {namespace}']
+                    description: "Compile, sync, and start app on host",
+                    usage: [ "start app {name} -n {namespace}" ],
+                    options: { namespace: namespace_opt }
                   },
                   pause: {
-                    description: 'Stop app containers (keep files)',
-                    usage: ['pause app {name} -n {namespace}']
+                    description: "Stop app containers (keep files)",
+                    usage: [ "pause app {name} -n {namespace}" ],
+                    options: { namespace: namespace_opt }
                   },
                   stop: {
-                    description: 'Stop app and remove files from host',
-                    usage: ['stop app {name} -n {namespace}']
+                    description: "Stop app and remove files from host",
+                    usage: [ "stop app {name} -n {namespace}" ],
+                    options: { namespace: namespace_opt }
                   },
                   logs: {
-                    description: 'View logs from remote containers',
+                    description: "View logs from remote containers",
                     usage: [
-                      'logs app {name} -n {namespace}',
-                      'logs app {name} -n {namespace} --follow',
-                      'logs app {name} -n {namespace} --tail 100',
-                      'logs app {name} -n {namespace} --timestamps'
-                    ]
+                      "logs app {name} -n {namespace}",
+                      "logs app {name} -n {namespace} --follow",
+                      "logs app {name} -n {namespace} --tail 100",
+                      "logs app {name} -n {namespace} --timestamps"
+                    ],
+                    options: {
+                      namespace: namespace_opt,
+                      follow: { type: :boolean, desc: "Follow log output" },
+                      tail: { type: :numeric, desc: "Number of lines from end" },
+                      timestamps: { type: :boolean, desc: "Show timestamps" }
+                    }
                   }
                 })
     end
@@ -86,14 +103,14 @@ module Resources
 
       # Convert docker-compose to Walheim App manifest
       app_manifest = {
-        'apiVersion' => 'walheim/v1alpha1',
-        'kind' => 'App',
-        'metadata' => {
-          'name' => name,
-          'namespace' => namespace
+        "apiVersion" => "walheim/v1alpha1",
+        "kind" => "App",
+        "metadata" => {
+          "name" => name,
+          "namespace" => namespace
         },
-        'spec' => {
-          'compose' => compose_manifest
+        "spec" => {
+          "compose" => compose_manifest
         }
       }
 
@@ -114,7 +131,7 @@ module Resources
       generate_compose_file(namespace, name, app_manifest)
 
       # Sync files to remote
-      result = @syncer.sync(namespace: namespace, kind: 'apps', name: name)
+      result = @syncer.sync(namespace: namespace, kind: "apps", name: name)
 
       # Run docker compose up
       remote_host = result[:username] ? "#{result[:username]}@#{result[:hostname]}" : result[:hostname]
@@ -123,7 +140,7 @@ module Resources
       compose_result = system(ssh_command)
 
       unless compose_result
-        warn 'Error: docker compose up failed'
+        warn "Error: docker compose up failed"
         exit 1
       end
 
@@ -133,8 +150,8 @@ module Resources
     def pause(namespace:, name:)
       # Get namespace config
       namespace_config = load_namespace_config(namespace)
-      username = namespace_config['username']
-      hostname = namespace_config['hostname']
+      username = namespace_config["username"]
+      hostname = namespace_config["hostname"]
 
       remote_host = username ? "#{username}@#{hostname}" : hostname
       remote_dir = "/data/walheim/apps/#{name}"
@@ -153,7 +170,7 @@ module Resources
       result = system(ssh_command)
 
       unless result
-        warn 'Error: docker compose down failed'
+        warn "Error: docker compose down failed"
         exit 1
       end
 
@@ -166,8 +183,8 @@ module Resources
 
       # Then remove files from remote
       namespace_config = load_namespace_config(namespace)
-      username = namespace_config['username']
-      hostname = namespace_config['hostname']
+      username = namespace_config["username"]
+      hostname = namespace_config["hostname"]
 
       remote_host = username ? "#{username}@#{hostname}" : hostname
       remote_dir = "/data/walheim/apps/#{name}"
@@ -177,7 +194,7 @@ module Resources
       result = system(ssh_command)
 
       unless result
-        warn 'Error: failed to remove remote files'
+        warn "Error: failed to remove remote files"
         exit 1
       end
 
@@ -187,8 +204,8 @@ module Resources
     def logs(namespace:, name:, follow: false, tail: nil, timestamps: false)
       # Get namespace config
       namespace_config = load_namespace_config(namespace)
-      username = namespace_config['username']
-      hostname = namespace_config['hostname']
+      username = namespace_config["username"]
+      hostname = namespace_config["hostname"]
 
       remote_host = username ? "#{username}@#{hostname}" : hostname
       remote_dir = "/data/walheim/apps/#{name}"
@@ -203,10 +220,10 @@ module Resources
       end
 
       # Build docker compose logs command with options
-      logs_cmd = 'docker compose logs'
-      logs_cmd += ' --follow' if follow
+      logs_cmd = "docker compose logs"
+      logs_cmd += " --follow" if follow
       logs_cmd += " --tail #{tail}" if tail
-      logs_cmd += ' --timestamps' if timestamps
+      logs_cmd += " --timestamps" if timestamps
 
       # Execute logs command (this will stream output to terminal)
       ssh_command = "ssh #{remote_host} 'cd #{remote_dir} && #{logs_cmd}'"
@@ -219,12 +236,12 @@ module Resources
     private
 
     def load_app_manifest(namespace, name)
-      app_dir = File.join(@namespaces_dir, namespace, 'apps', name)
-      app_yaml_path = File.join(app_dir, '.app.yaml')
+      app_dir = File.join(@namespaces_dir, namespace, "apps", name)
+      app_yaml_path = File.join(app_dir, ".app.yaml")
 
       unless File.exist?(app_yaml_path)
         warn "Error: No app manifest found at #{app_yaml_path}"
-        warn 'Use \'whctl import\' to convert docker-compose.yml to Walheim App format'
+        warn "Use 'whctl import' to convert docker-compose.yml to Walheim App format"
         exit 1
       end
 
@@ -234,58 +251,58 @@ module Resources
       validate_k8s_manifest(manifest, namespace, name)
 
       {
-        metadata: manifest['metadata'],
-        env_from: manifest['spec']['envFrom'] || [],
-        env: manifest['spec']['env'] || [],
-        compose: manifest['spec']['compose']
+        metadata: manifest["metadata"],
+        env_from: manifest["spec"]["envFrom"] || [],
+        env: manifest["spec"]["env"] || [],
+        compose: manifest["spec"]["compose"]
       }
     end
 
     def validate_k8s_manifest(manifest, namespace, name)
       # Check required top-level fields
-      unless manifest['apiVersion'] == 'walheim/v1alpha1'
+      unless manifest["apiVersion"] == "walheim/v1alpha1"
         warn "Error: apiVersion must be 'walheim/v1alpha1', got '#{manifest['apiVersion']}'"
         exit 1
       end
 
-      unless manifest['kind'] == 'App'
+      unless manifest["kind"] == "App"
         warn "Error: kind must be 'App', got '#{manifest['kind']}'"
         exit 1
       end
 
-      unless manifest['metadata']
-        warn 'Error: metadata is required'
+      unless manifest["metadata"]
+        warn "Error: metadata is required"
         exit 1
       end
 
-      unless manifest['spec']
-        warn 'Error: spec is required'
+      unless manifest["spec"]
+        warn "Error: spec is required"
         exit 1
       end
 
       # Check metadata fields
-      metadata_name = manifest['metadata']['name']
+      metadata_name = manifest["metadata"]["name"]
       unless metadata_name == name
         warn "Error: metadata.name '#{metadata_name}' must match directory name '#{name}'"
         exit 1
       end
 
-      metadata_namespace = manifest['metadata']['namespace']
+      metadata_namespace = manifest["metadata"]["namespace"]
       unless metadata_namespace == namespace
         warn "Error: metadata.namespace '#{metadata_namespace}' must match parent namespace '#{namespace}'"
         exit 1
       end
 
       # Check spec.compose exists
-      return if manifest['spec']['compose']
+      return if manifest["spec"]["compose"]
 
-      warn 'Error: spec.compose is required'
+      warn "Error: spec.compose is required"
       exit 1
     end
 
     def generate_compose_file(namespace, name, app_manifest)
-      app_dir = File.join(@namespaces_dir, namespace, 'apps', name)
-      compose_path = File.join(app_dir, 'docker-compose.yml')
+      app_dir = File.join(@namespaces_dir, namespace, "apps", name)
+      compose_path = File.join(app_dir, "docker-compose.yml")
 
       # Start with base compose content
       compose_content = deep_copy(app_manifest[:compose])
@@ -295,13 +312,13 @@ module Resources
 
       # Process envFrom and inject into compose (lower precedence)
       unless app_manifest[:env_from].empty?
-        puts 'Processing envFrom...'
+        puts "Processing envFrom..."
         compose_content = inject_env_from(compose_content, app_manifest[:env_from], namespace)
       end
 
       # Process env and inject into compose (higher precedence)
       unless app_manifest[:env].empty?
-        puts 'Processing env...'
+        puts "Processing env..."
         compose_content = inject_env(compose_content, app_manifest[:env])
       end
 
@@ -312,27 +329,29 @@ module Resources
 
     def inject_walheim_labels(compose, namespace, name)
       # Process each service and inject Walheim metadata labels
-      compose['services']&.each do |service_name, service_config|
-        service_config['labels'] ||= []
+      compose["services"]&.each_value do |service_config|
+        service_config["labels"] ||= []
 
         # Define Walheim metadata labels (stable labels only to avoid unnecessary restarts)
         walheim_labels = [
-          'walheim.managed=true',
+          "walheim.managed=true",
           "walheim.namespace=#{namespace}",
           "walheim.app=#{name}"
         ]
 
         # Inject labels (handle both array and hash formats)
-        if service_config['labels'].is_a?(Array)
+        if service_config["labels"].is_a?(Array)
           # Remove any existing walheim.* labels first to avoid duplicates
-          service_config['labels'].reject! { |label| label.to_s.start_with?('walheim.managed=', 'walheim.namespace=', 'walheim.app=') }
+          service_config["labels"].reject! do |label|
+            label.to_s.start_with?("walheim.managed=", "walheim.namespace=", "walheim.app=")
+          end
           # Add new labels
-          service_config['labels'].concat(walheim_labels)
+          service_config["labels"].concat(walheim_labels)
         else
           # Hash format
-          service_config['labels']['walheim.managed'] = 'true'
-          service_config['labels']['walheim.namespace'] = namespace
-          service_config['labels']['walheim.app'] = name
+          service_config["labels"]["walheim.managed"] = "true"
+          service_config["labels"]["walheim.namespace"] = namespace
+          service_config["labels"]["walheim.app"] = name
         end
       end
 
@@ -343,13 +362,13 @@ module Resources
       return compose if env_from_list.empty?
 
       # Process each service
-      compose['services']&.each do |service_name, service_config|
-        service_config['environment'] ||= {}
-        service_config['labels'] ||= []
+      compose["services"]&.each do |service_name, service_config|
+        service_config["environment"] ||= {}
+        service_config["labels"] ||= []
 
         # Convert array-style to hash if needed
-        if service_config['environment'].is_a?(Array)
-          service_config['environment'] = array_env_to_hash(service_config['environment'])
+        if service_config["environment"].is_a?(Array)
+          service_config["environment"] = array_env_to_hash(service_config["environment"])
         end
 
         # Track total injected for this service
@@ -358,27 +377,27 @@ module Resources
         # Inject from each envFrom source
         env_from_list.each do |source|
           # Check if this service should receive injections from this source
-          service_names = source['serviceNames']
+          service_names = source["serviceNames"]
           next if service_names && !service_names.empty? && !service_names.include?(service_name)
 
-          if source['secretRef']
-            secret_name = source['secretRef']['name']
-            injected_keys = inject_from_secret(service_config['environment'], secret_name, namespace)
+          if source["secretRef"]
+            secret_name = source["secretRef"]["name"]
+            injected_keys = inject_from_secret(service_config["environment"], secret_name, namespace)
 
             # Add tracking label if any keys were injected
             if injected_keys.any?
-              add_tracking_label(service_config['labels'], "walheim.injected-env.secret.#{secret_name}", injected_keys)
+              add_tracking_label(service_config["labels"], "walheim.injected-env.secret.#{secret_name}", injected_keys)
               puts "  #{service_name}: Injected #{injected_keys.size} variable(s) from secret #{secret_name}: #{injected_keys.join(', ')}"
             end
 
             total_injected += injected_keys.size
-          elsif source['configMapRef']
-            configmap_name = source['configMapRef']['name']
-            injected_keys = inject_from_configmap(service_config['environment'], configmap_name, namespace)
+          elsif source["configMapRef"]
+            configmap_name = source["configMapRef"]["name"]
+            injected_keys = inject_from_configmap(service_config["environment"], configmap_name, namespace)
 
             # Add tracking label if any keys were injected
             if injected_keys.any?
-              add_tracking_label(service_config['labels'], "walheim.injected-env.configmap.#{configmap_name}",
+              add_tracking_label(service_config["labels"], "walheim.injected-env.configmap.#{configmap_name}",
                                  injected_keys)
               puts "  #{service_name}: Injected #{injected_keys.size} variable(s) from configmap #{configmap_name}: #{injected_keys.join(', ')}"
             end
@@ -394,8 +413,8 @@ module Resources
     def array_env_to_hash(env_array)
       env_hash = {}
       env_array.each do |env_line|
-        if env_line.include?('=')
-          key, value = env_line.split('=', 2)
+        if env_line.include?("=")
+          key, value = env_line.split("=", 2)
           env_hash[key] = value
         elsif env_line.is_a?(Hash)
           env_hash.merge!(env_line)
@@ -435,7 +454,7 @@ module Resources
     end
 
     def add_tracking_label(labels, label_key, injected_keys)
-      label_value = injected_keys.join(',')
+      label_value = injected_keys.join(",")
 
       # Add label (handle both array and hash formats)
       if labels.is_a?(Array)
@@ -449,13 +468,13 @@ module Resources
       return compose if env_list.empty?
 
       # Process each service
-      compose['services']&.each do |service_name, service_config|
-        service_config['environment'] ||= {}
-        service_config['labels'] ||= []
+      compose["services"]&.each do |service_name, service_config|
+        service_config["environment"] ||= {}
+        service_config["labels"] ||= []
 
         # Convert array-style to hash if needed
-        if service_config['environment'].is_a?(Array)
-          service_config['environment'] = array_env_to_hash(service_config['environment'])
+        if service_config["environment"].is_a?(Array)
+          service_config["environment"] = array_env_to_hash(service_config["environment"])
         end
 
         # Track which keys were set by spec.env
@@ -464,23 +483,23 @@ module Resources
         # Process each env entry
         env_list.each do |env_entry|
           # Check if this service should receive this env var
-          service_names = env_entry['serviceNames']
+          service_names = env_entry["serviceNames"]
           next if service_names && !service_names.empty? && !service_names.include?(service_name)
 
-          var_name = env_entry['name']
-          var_value = env_entry['value']
+          var_name = env_entry["name"]
+          var_value = env_entry["value"]
 
           # Perform variable substitution using current environment
-          substituted_value = substitute_variables(var_value, service_config['environment'])
+          substituted_value = substitute_variables(var_value, service_config["environment"])
 
           # Always overwrite (highest precedence)
-          service_config['environment'][var_name] = substituted_value
+          service_config["environment"][var_name] = substituted_value
           injected_keys << var_name
         end
 
         # Add tracking label if any keys were set
         if injected_keys.any?
-          add_tracking_label(service_config['labels'], 'walheim.injected-env.override', injected_keys)
+          add_tracking_label(service_config["labels"], "walheim.injected-env.override", injected_keys)
           puts "  #{service_name}: Set #{injected_keys.size} variable(s) from spec.env: #{injected_keys.join(', ')}"
         end
       end
@@ -498,9 +517,9 @@ module Resources
     end
 
     def load_configmap_data(namespace, configmap_name)
-      require 'base64'
+      require "base64"
 
-      configmap_path = File.join(@namespaces_dir, namespace, 'configmaps', configmap_name, 'configmap.yaml')
+      configmap_path = File.join(@namespaces_dir, namespace, "configmaps", configmap_name, "configmap.yaml")
 
       unless File.exist?(configmap_path)
         warn "Error: configmap '#{configmap_name}' not found at #{configmap_path}"
@@ -510,7 +529,7 @@ module Resources
       configmap = YAML.load_file(configmap_path)
 
       # Extract data (plaintext only for configmaps)
-      configmap['data'] || {}
+      configmap["data"] || {}
     end
 
     def deep_copy(obj)
@@ -518,18 +537,18 @@ module Resources
     end
 
     def manifest_filename
-      '.app.yaml'
+      ".app.yaml"
     end
 
     def validate_manifest(manifest, namespace, name)
-      manifest_hash = YAML.load(manifest)
-      validate_k8s_manifest(manifest_hash, namespace, name) if manifest_hash['kind'] == 'App'
+      manifest_hash = YAML.safe_load(manifest)
+      validate_k8s_manifest(manifest_hash, namespace, name) if manifest_hash["kind"] == "App"
     end
 
     def load_secret_data(namespace, secret_name)
-      require 'base64'
+      require "base64"
 
-      secret_path = File.join(@namespaces_dir, namespace, 'secrets', secret_name, 'secret.yaml')
+      secret_path = File.join(@namespaces_dir, namespace, "secrets", secret_name, "secret.yaml")
 
       unless File.exist?(secret_path)
         warn "Error: secret '#{secret_name}' not found at #{secret_path}"
@@ -539,8 +558,8 @@ module Resources
       secret = YAML.load_file(secret_path)
 
       # Extract data (base64-encoded) and stringData (plaintext)
-      data = secret['data'] || {}
-      string_data = secret['stringData'] || {}
+      data = secret["data"] || {}
+      string_data = secret["stringData"] || {}
 
       # Decode base64 data
       decoded_data = {}
@@ -553,7 +572,7 @@ module Resources
     end
 
     def load_namespace_config(namespace)
-      config_path = File.join(@namespaces_dir, namespace, '.namespace.yaml')
+      config_path = File.join(@namespaces_dir, namespace, ".namespace.yaml")
 
       unless File.exist?(config_path)
         warn "Error: namespace config '#{config_path}' not found"

data/lib/walheim/resources/configmaps.rb

@@ -1,15 +1,15 @@
 # frozen_string_literal: true
 
-require_relative '../namespaced_resource'
-require_relative '../handler_registry'
+require_relative "../namespaced_resource"
+require_relative "../handler_registry"
 
 module Resources
   class ConfigMaps < Walheim::NamespacedResource
     def self.kind_info
       {
-        plural: 'configmaps',
-        singular: 'configmap',
-        aliases: ['cm']  # Abbreviation
+        plural: "configmaps",
+        singular: "configmap",
+        aliases: [ "cm" ] # Abbreviation
       }
     end
 
@@ -24,7 +24,7 @@ module Resources
     def self.summary_fields
       {
         keys: lambda { |manifest|
-          (manifest['data'] || {}).keys.join(', ')
+          (manifest["data"] || {}).keys.join(", ")
         }
       }
     end
@@ -32,7 +32,7 @@ module Resources
     private
 
     def manifest_filename
-      'configmap.yaml'
+      "configmap.yaml"
     end
   end
 end