walheim 0.2.0 → 0.3.0

data/lib/walheim/cli.rb

@@ -1,25 +1,30 @@
 # frozen_string_literal: true
 
-require 'thor'
-require_relative 'cli/helpers'
-require_relative 'cli/base_command'
-require_relative 'cli/resource_command'
+require "thor"
+require_relative "cli/helpers"
+require_relative "cli/base_command"
+require_relative "cli/resource_command"
 
 module Walheim
   class CLI < Thor
+    # Exit with non-zero status on errors
+    def self.exit_on_failure?
+      true
+    end
+
     # Global flags
     class_option :context,
                  type: :string,
-                 desc: 'Override active context'
+                 desc: "Override active context"
 
     class_option :whconfig,
                  type: :string,
-                 desc: 'Alternate config file path'
+                 desc: "Alternate config file path"
 
     class_option :data_dir,
                  type: :string,
-                 aliases: [:d],
-                 desc: 'Data directory (deprecated: use contexts)'
+                 aliases: [ :d ],
+                 desc: "Data directory (deprecated: use contexts)"
 
     # Dynamically register operations
     def self.register_operations
@@ -29,11 +34,50 @@ module Walheim
     end
 
     # Version command
-    desc 'version', 'Show version'
+    desc "version", "Show version"
     def version
       puts "whctl version #{Walheim::VERSION}"
     end
 
+    # Exec command - custom implementation to support variadic arguments
+    desc "exec app NAME [--] COMMAND...", "Execute command in app container"
+    method_option :namespace,
+                  type: :string,
+                  aliases: [ :n ],
+                  desc: "Target namespace",
+                  required: true
+    method_option :service,
+                  type: :string,
+                  aliases: [ :s ],
+                  desc: "Target service (defaults to first)"
+    method_option :interactive,
+                  type: :boolean,
+                  aliases: [ :it ],
+                  desc: "Allocate pseudo-TTY and keep stdin open",
+                  default: false
+    def exec(kind, name, *command)
+      # Validate kind is 'app' or 'apps'
+      unless %w[app apps].include?(kind.downcase)
+        warn "Error: exec only supports 'app' kind, got '#{kind}'"
+        exit 1
+      end
+
+      # Resolve data directory from context
+      data_dir = BaseCommand.send(:resolve_data_dir, options, self.class.class_options.transform_keys(&:to_sym).transform_values { |v| options[v.name] rescue nil })
+
+      # Initialize Apps handler
+      handler = Resources::Apps.new(data_dir: data_dir)
+
+      # Call exec_command method
+      handler.exec_command(
+        namespace: options[:namespace],
+        name: name,
+        service: options[:service],
+        interactive: options[:interactive],
+        command: command
+      )
+    end
+
     # Override help to maintain kubectl-style help
     def self.help(shell, subcommand = false)
       list = printable_commands(true, subcommand)
@@ -42,19 +86,20 @@ module Walheim
       end
 
       # Group commands by category
-      shell.say 'Usage: whctl [global flags] <command> [arguments]'
-      shell.say ''
-      shell.say 'Global flags:'
-      shell.say '  --context CONTEXT     Override active context for this command'
-      shell.say '  --whconfig PATH       Use alternate config file (default: ~/.walheim/config)'
-      shell.say '  -d, --data-dir DIR    Data directory containing namespaces (deprecated: use contexts)'
-      shell.say ''
-      shell.say 'Available commands:'
-      shell.say ''
+      shell.say "Usage: whctl [global flags] <command> [arguments]"
+      shell.say ""
+      shell.say "Global flags:"
+      shell.say "  --context CONTEXT     Override active context for this command"
+      shell.say "  --whconfig PATH       Use alternate config file (default: ~/.walheim/config)"
+      shell.say "  -d, --data-dir DIR    Data directory containing namespaces (deprecated: use contexts)"
+      shell.say ""
+      shell.say "Available commands:"
+      shell.say ""
 
       # Print commands
       list.each do |command|
-        next if command[0] == 'help'
+        next if command[0] == "help"
+
         shell.say "  #{command[0].ljust(30)} #{command[1]}"
       end
     end

data/lib/walheim/cluster_resource.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'resource'
+require_relative "resource"
 
 module Walheim
   # ClusterResource represents resources that are cluster-scoped (not namespaced)
@@ -69,9 +69,9 @@ module Walheim
     # Apply operation - create or update
     def apply(name:, manifest_source: nil)
       manifest_data = if manifest_source
-        File.read(manifest_source)
+                        File.read(manifest_source)
       else
-        read_manifest_from_db(name)
+                        read_manifest_from_db(name)
       end
 
       if resource_exists?(name)
@@ -91,7 +91,7 @@ module Walheim
 
       manifest_path = File.join(resource_dir(name), manifest_filename)
       manifest_content = File.read(manifest_path)
-      manifest_data = YAML.load(manifest_content)
+      manifest_data = YAML.safe_load(manifest_content)
 
       # Compute summary fields
       summary = {}
@@ -123,7 +123,7 @@ module Walheim
     def find_resource_names
       base_dir = File.join(@data_dir, self.class.kind_info[:plural])
       Dir.entries(base_dir)
-         .select { |entry| File.directory?(File.join(base_dir, entry)) && !entry.start_with?('.') }
+         .select { |entry| File.directory?(File.join(base_dir, entry)) && !entry.start_with?(".") }
          .select { |entry| File.exist?(File.join(base_dir, entry, manifest_filename)) }
          .sort
     end

data/lib/walheim/config.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'yaml'
-require 'fileutils'
+require "yaml"
+require "fileutils"
 
 module Walheim
   # Configuration management for Walheim contexts
@@ -10,9 +10,9 @@ module Walheim
     class ConfigError < StandardError; end
     class ValidationError < ConfigError; end
 
-    DEFAULT_CONFIG_PATH = File.expand_path('~/.walheim/config')
-    API_VERSION = 'walheim.io/v1'
-    KIND = 'Config'
+    DEFAULT_CONFIG_PATH = File.expand_path("~/.walheim/config")
+    API_VERSION = "walheim.io/v1"
+    KIND = "Config"
 
     attr_reader :current_context, :contexts, :config_path
 
@@ -35,18 +35,18 @@ module Walheim
       data = YAML.load_file(@config_path)
       validate_schema!(data)
 
-      @current_context = data['currentContext']
-      @contexts = data['contexts'].map do |ctx|
+      @current_context = data["currentContext"]
+      @contexts = data["contexts"].map do |ctx|
         {
-          'name' => ctx['name'],
-          'dataDir' => expand_path(ctx['dataDir'])
+          "name" => ctx["name"],
+          "dataDir" => expand_path(ctx["dataDir"])
         }
       end
 
       validate_current_context!
     rescue Psych::SyntaxError => e
       raise ConfigError, "Invalid YAML in config file: #{e.message}"
-    rescue => e
+    rescue StandardError => e
       raise ConfigError, "Failed to load config: #{e.message}"
     end
 
@@ -56,13 +56,13 @@ module Walheim
     # @raise [ConfigError] if file cannot be written
     def save_config
       data = {
-        'apiVersion' => API_VERSION,
-        'kind' => KIND,
-        'currentContext' => @current_context,
-        'contexts' => @contexts.map do |ctx|
+        "apiVersion" => API_VERSION,
+        "kind" => KIND,
+        "currentContext" => @current_context,
+        "contexts" => @contexts.map do |ctx|
           {
-            'name' => ctx['name'],
-            'dataDir' => ctx['dataDir']
+            "name" => ctx["name"],
+            "dataDir" => ctx["dataDir"]
           }
         end
       }
@@ -74,7 +74,7 @@ module Walheim
       temp_file = "#{@config_path}.tmp.#{Process.pid}"
       File.write(temp_file, YAML.dump(data))
       File.rename(temp_file, @config_path)
-    rescue => e
+    rescue StandardError => e
       File.delete(temp_file) if temp_file && File.exist?(temp_file)
       raise ConfigError, "Failed to save config: #{e.message}"
     end
@@ -86,12 +86,12 @@ module Walheim
     # @raise [ConfigError] if context not found or no current context
     def data_dir(context_name = nil)
       name = context_name || @current_context
-      raise ConfigError, 'No active context selected' if name.nil?
+      raise ConfigError, "No active context selected" if name.nil?
 
       context = find_context(name)
       raise ConfigError, "Context '#{name}' not found" if context.nil?
 
-      context['dataDir']
+      context["dataDir"]
     end
 
     # Add a new context
@@ -105,8 +105,8 @@ module Walheim
       raise ValidationError, "Context '#{name}' already exists" if find_context(name)
 
       @contexts << {
-        'name' => name,
-        'dataDir' => expand_path(data_dir)
+        "name" => name,
+        "dataDir" => expand_path(data_dir)
       }
 
       @current_context = name if activate
@@ -134,6 +134,7 @@ module Walheim
     # @raise [ConfigError] if context not found
     def use_context(name)
       raise ConfigError, "Context '#{name}' not found" unless find_context(name)
+
       @current_context = name
     end
 
@@ -142,7 +143,7 @@ module Walheim
     # @return [Array<Hash>] Array of context hashes with 'name', 'dataDir', and 'active' keys
     def list_contexts
       @contexts.map do |ctx|
-        ctx.merge('active' => ctx['name'] == @current_context)
+        ctx.merge("active" => ctx["name"] == @current_context)
       end
     end
 
@@ -159,7 +160,8 @@ module Walheim
     # Resolve the config file path with precedence: param > $WHCONFIG > default
     def resolve_config_path(config_path)
       return expand_path(config_path) if config_path
-      return expand_path(ENV['WHCONFIG']) if ENV['WHCONFIG']
+      return expand_path(ENV["WHCONFIG"]) if ENV["WHCONFIG"]
+
       DEFAULT_CONFIG_PATH
     end
 
@@ -170,27 +172,27 @@ module Walheim
 
     # Find a context by name
     def find_context(name)
-      @contexts.find { |ctx| ctx['name'] == name }
+      @contexts.find { |ctx| ctx["name"] == name }
     end
 
     # Validate config schema
     def validate_schema!(data)
-      raise ValidationError, 'Config must be a Hash' unless data.is_a?(Hash)
-      raise ValidationError, "Invalid apiVersion: expected '#{API_VERSION}'" unless data['apiVersion'] == API_VERSION
-      raise ValidationError, "Invalid kind: expected '#{KIND}'" unless data['kind'] == KIND
-      raise ValidationError, 'Missing required field: contexts' unless data['contexts']
-      raise ValidationError, 'contexts must be an Array' unless data['contexts'].is_a?(Array)
-      raise ValidationError, 'contexts array cannot be empty' if data['contexts'].empty?
+      raise ValidationError, "Config must be a Hash" unless data.is_a?(Hash)
+      raise ValidationError, "Invalid apiVersion: expected '#{API_VERSION}'" unless data["apiVersion"] == API_VERSION
+      raise ValidationError, "Invalid kind: expected '#{KIND}'" unless data["kind"] == KIND
+      raise ValidationError, "Missing required field: contexts" unless data["contexts"]
+      raise ValidationError, "contexts must be an Array" unless data["contexts"].is_a?(Array)
+      raise ValidationError, "contexts array cannot be empty" if data["contexts"].empty?
 
       # Validate each context
-      data['contexts'].each_with_index do |ctx, index|
+      data["contexts"].each_with_index do |ctx, index|
         raise ValidationError, "Context at index #{index} must be a Hash" unless ctx.is_a?(Hash)
-        raise ValidationError, "Context at index #{index} missing 'name'" unless ctx['name']
-        raise ValidationError, "Context at index #{index} missing 'dataDir'" unless ctx['dataDir']
+        raise ValidationError, "Context at index #{index} missing 'name'" unless ctx["name"]
+        raise ValidationError, "Context at index #{index} missing 'dataDir'" unless ctx["dataDir"]
       end
 
       # Check for duplicate context names
-      names = data['contexts'].map { |ctx| ctx['name'] }
+      names = data["contexts"].map { |ctx| ctx["name"] }
       duplicates = names.select { |name| names.count(name) > 1 }.uniq
       raise ValidationError, "Duplicate context names: #{duplicates.join(', ')}" unless duplicates.empty?
     end

data/lib/walheim/handler_registry.rb

@@ -57,9 +57,7 @@ module Walheim
         handlers.values.uniq { |h| h[:handler] }.each do |handler_info|
           handler_class = handler_info[:handler]
           # Get operations from operation_info metadata
-          if handler_class.respond_to?(:operation_info)
-            handler_class.operation_info.keys.each { |op| ops[op] = true }
-          end
+          handler_class.operation_info.each_key { |op| ops[op] = true } if handler_class.respond_to?(:operation_info)
         end
         ops.keys.sort
       end
@@ -75,6 +73,7 @@ module Walheim
       def cluster_resource?(kind)
         handler_info = get(kind)
         return false unless handler_info
+
         handler_info[:handler] < Walheim::ClusterResource
       end
     end

data/lib/walheim/namespaced_resource.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-require_relative 'resource'
+require_relative "resource"
 
 module Walheim
   # NamespacedResource represents resources that are scoped to a namespace
   # Examples: Apps, Secrets, ConfigMaps
   # These resources live under namespaces/{namespace}/{kind}/{name}/
   class NamespacedResource < Resource
-    # Override operation_info to add namespace flags
+    # Override operation_info to add namespace flags and dispatch params
     def self.operation_info
       ops = super
 
@@ -15,15 +15,15 @@ module Walheim
       namespace_options = {
         namespace: {
           type: :string,
-          aliases: [:n],
-          desc: 'Target namespace',
-          required: false  # Validated at runtime
+          aliases: [ :n ],
+          desc: "Target namespace",
+          required: false # Validated at runtime
         },
         all: {
           type: :boolean,
-          aliases: [:A],
-          desc: 'All namespaces',
-          banner: ''  # No value needed for boolean
+          aliases: [ :A ],
+          desc: "All namespaces",
+          banner: "" # No value needed for boolean
         }
       }
 
@@ -31,6 +31,17 @@ module Walheim
       ops[:apply][:options].merge!(namespace: namespace_options[:namespace])
       ops[:delete][:options].merge!(namespace: namespace_options[:namespace])
 
+      # Add namespace parameter to dispatch
+      ops[:get][:dispatch][:named_params] = { namespace: :namespace }
+      ops[:get][:dispatch][:namespace_handling] = :optional_with_all
+
+      ops[:apply][:dispatch][:named_params] ||= {}
+      ops[:apply][:dispatch][:named_params][:namespace] = :namespace
+      ops[:apply][:dispatch][:namespace_handling] = :required
+
+      ops[:delete][:dispatch][:named_params] = { namespace: :namespace }
+      ops[:delete][:dispatch][:namespace_handling] = :required
+
       ops
     end
 
@@ -38,9 +49,9 @@ module Walheim
 
     def apply(namespace:, name:, manifest_source: nil)
       manifest_data = if manifest_source
-        File.read(manifest_source)
+                        File.read(manifest_source)
       else
-        read_manifest_from_db(namespace, name)
+                        read_manifest_from_db(namespace, name)
       end
 
       if resource_exists?(namespace, name)
@@ -105,7 +116,7 @@ module Walheim
         # Get single resource
         get_single_resource(namespace, name)
       else
-        raise ArgumentError, 'namespace is required when name is specified'
+        raise ArgumentError, "namespace is required when name is specified"
       end
     end
 
@@ -119,7 +130,7 @@ module Walheim
 
       manifest_path = File.join(resource_dir(namespace, name), manifest_filename)
       manifest_content = File.read(manifest_path)
-      manifest_data = YAML.load(manifest_content)
+      manifest_data = YAML.safe_load(manifest_content)
 
       # Compute summary fields
       summary = {}
@@ -137,7 +148,7 @@ module Walheim
 
     # Path to resource directory: {data_dir}/namespaces/{namespace}/{kind_plural}/{name}/
     def resource_dir(namespace, name)
-      File.join(@data_dir, 'namespaces', namespace, self.class.kind_info[:plural], name)
+      File.join(@data_dir, "namespaces", namespace, self.class.kind_info[:plural], name)
     end
 
     def resource_exists?(namespace, name)
@@ -169,7 +180,7 @@ module Walheim
     end
 
     def list_single_namespace(namespace)
-      namespaces_dir = File.join(@data_dir, 'namespaces')
+      namespaces_dir = File.join(@data_dir, "namespaces")
       namespace_path = File.join(namespaces_dir, namespace)
 
       unless Dir.exist?(namespace_path)
@@ -182,7 +193,10 @@ module Walheim
 
       # Find all resource directories
       resource_names = Dir.entries(resources_path)
-                          .select { |entry| File.directory?(File.join(resources_path, entry)) && !entry.start_with?('.') }
+                          .select do |entry|
+        File.directory?(File.join(resources_path,
+                                  entry)) && !entry.start_with?(".")
+      end
                           .sort
 
       # Return array of manifest hashes
@@ -192,13 +206,16 @@ module Walheim
     end
 
     def list_all_namespaces
-      namespaces_dir = File.join(@data_dir, 'namespaces')
+      namespaces_dir = File.join(@data_dir, "namespaces")
       return [] unless Dir.exist?(namespaces_dir)
 
       # Find all namespaces
       namespace_names = Dir.entries(namespaces_dir)
-                           .select { |entry| File.directory?(File.join(namespaces_dir, entry)) && !entry.start_with?('.') }
-                           .select { |entry| File.exist?(File.join(namespaces_dir, entry, '.namespace.yaml')) }
+                           .select do |entry|
+        File.directory?(File.join(namespaces_dir,
+                                  entry)) && !entry.start_with?(".")
+      end
+                           .select { |entry| File.exist?(File.join(namespaces_dir, entry, ".namespace.yaml")) }
                            .sort
 
       # Collect all resources from all namespaces
@@ -208,7 +225,10 @@ module Walheim
         next unless Dir.exist?(resources_path)
 
         resource_names = Dir.entries(resources_path)
-                            .select { |entry| File.directory?(File.join(resources_path, entry)) && !entry.start_with?('.') }
+                            .select do |entry|
+          File.directory?(File.join(resources_path,
+                                    entry)) && !entry.start_with?(".")
+        end
                             .sort
 
         resource_names.each do |resource_name|
@@ -216,7 +236,7 @@ module Walheim
         end
       end
 
-      all_resources.sort_by { |resource| [resource[:namespace], resource[:name]] }
+      all_resources.sort_by { |resource| [ resource[:namespace], resource[:name] ] }
     end
   end
 end

data/lib/walheim/resource.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require 'yaml'
-require 'fileutils'
-require 'terminal-table'
+require "yaml"
+require "fileutils"
+require "terminal-table"
 
 module Walheim
   # Base Resource class containing common functionality for all resource types
@@ -18,7 +18,7 @@ module Walheim
 
     # Metadata - must be overridden by subclasses
     def self.kind_info
-      raise NotImplementedError, 'Subclass must implement kind_info'
+      raise NotImplementedError, "Subclass must implement kind_info"
     end
 
     # Lifecycle hooks - can be overridden by subclasses
@@ -32,33 +32,49 @@ module Walheim
 
     # Summary fields for get output - can be overridden by subclasses
     def self.summary_fields
-      {}  # Default: no summary fields
+      {} # Default: no summary fields
     end
 
-    # Operation metadata - defines how operations appear in help
+    # Operation metadata - defines how operations appear in help and how they're dispatched
     # Subclasses can override to add custom operations
     def self.operation_info
       {
         get: {
-          description: 'List or retrieve resources',
+          description: "List or retrieve resources",
           usage: [
             "get #{kind_info[:plural]} -n {namespace}",
             "get #{kind_info[:plural]} --all/-A",
             "get #{kind_info[:singular]} {name} -n {namespace}"
           ],
-          options: {}  # Subclasses will override
+          options: {},  # Subclasses will override
+          dispatch: {
+            method: :get,
+            params: [ :name ],
+            output: :table
+          }
         },
         apply: {
-          description: 'Create or update a resource',
-          usage: ["apply #{kind_info[:singular]} {name} -n {namespace}"],
+          description: "Create or update a resource",
+          usage: [ "apply #{kind_info[:singular]} {name} -n {namespace}" ],
           options: {
-            file: { type: :string, aliases: [:f], desc: 'Manifest file (use - for stdin)' }
+            file: { type: :string, aliases: [ :f ], desc: "Manifest file (use - for stdin)" }
+          },
+          dispatch: {
+            method: :apply,
+            params: [ :name ],
+            named_params: {
+              manifest_source: :file
+            }
           }
         },
         delete: {
-          description: 'Delete a resource',
-          usage: ["delete #{kind_info[:singular]} {name} -n {namespace}"],
-          options: {}  # Subclasses will override
+          description: "Delete a resource",
+          usage: [ "delete #{kind_info[:singular]} {name} -n {namespace}" ],
+          options: {},  # Subclasses will override
+          dispatch: {
+            method: :delete,
+            params: [ :name ]
+          }
         }
       }
     end