walheim 0.1.2

data/bin/whctl

@@ -0,0 +1,703 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'optparse'
+require_relative '../lib/walheim'
+
+# Generate help text for a resource's operations
+def generate_resource_help(handler_info)
+  handler_class = handler_info[:handler]
+  kind_name = handler_info[:name]
+
+  # Skip if resource doesn't have operation_info (e.g., Namespaces)
+  return [] unless handler_class.respond_to?(:operation_info)
+
+  # Get operation metadata from the resource class
+  operation_info = handler_class.operation_info
+
+  help_lines = []
+
+  operation_info.each do |operation, metadata|
+    # Check if this resource actually supports the operation
+    next unless Walheim::HandlerRegistry.supports_operation?(kind_name, operation)
+
+    # Add each usage line
+    metadata[:usage].each do |usage_line|
+      help_lines << "  #{usage_line.ljust(70)} #{metadata[:description]}"
+    end
+  end
+
+  help_lines
+end
+
+# Generate help for global commands
+def generate_global_help
+  [
+    "  create namespace {name} [--username {user}] [--hostname {host}]".ljust(72) + "Create a new namespace",
+    "  apply -f {manifest.yaml}".ljust(72) + "Apply resource from file (use -f - for stdin)",
+    "",
+    "Context commands:",
+    "  context new {name} --data-dir {path}".ljust(72) + "Create a new context",
+    "  context list".ljust(72) + "List all contexts",
+    "  context use {name}".ljust(72) + "Switch to a context",
+    "  context current".ljust(72) + "Show current context",
+    "  context delete {name}".ljust(72) + "Delete a context"
+  ]
+end
+
+# Handle help before parsing
+if ARGV.empty? || ARGV.include?('help') || ARGV.include?('--help') || ARGV.include?('-h')
+  puts 'Usage: whctl [global flags] <command> [arguments]'
+  puts ''
+  puts 'Global flags:'
+  puts '  --context CONTEXT     Override active context for this command'
+  puts '  --whconfig PATH       Use alternate config file (default: ~/.walheim/config)'
+  puts '  -d, --data-dir DIR    Data directory containing namespaces (deprecated: use contexts)'
+  puts ''
+  puts 'Available commands:'
+  puts ''
+
+  # Global commands
+  generate_global_help.each { |line| puts line }
+  puts ''
+
+  # Resource commands (dynamically generated)
+  Walheim::HandlerRegistry.all_visible.each do |handler_info|
+    kind_name = handler_info[:name]
+    kind_info = handler_info[:info]
+
+    # Show supported variations
+    variations = [kind_info[:singular]]
+    variations += kind_info[:aliases] if kind_info[:aliases]
+    variations_text = variations.empty? ? "" : " (aliases: #{variations.join(', ')})"
+
+    puts "#{kind_name.capitalize}#{variations_text}:"
+    generate_resource_help(handler_info).each { |line| puts line }
+    puts ''
+  end
+
+  exit 0
+end
+
+# Parse global flags first
+options = {}
+global_parser = OptionParser.new do |opts|
+  opts.on('--context CONTEXT', 'Override active context') { |v| options[:context] = v }
+  opts.on('--whconfig PATH', 'Alternate config file path') { |v| options[:whconfig] = v }
+  opts.on('-d DIR', '--data-dir DIR', 'Data directory (deprecated)') { |v| options[:data_dir] = v }
+end
+
+# Parse only global flags, leaving the rest for later
+begin
+  global_parser.order!(ARGV)
+rescue OptionParser::InvalidOption => e
+  warn "Error: #{e.message}"
+  exit 1
+end
+
+# Now get the command (first remaining arg)
+command = ARGV[0]
+
+# Parse command-specific flags
+command_parser = OptionParser.new do |opts|
+  opts.on('-n NAMESPACE', '--namespace NAMESPACE', 'Specify namespace') { |v| options[:namespace] = v }
+  opts.on('-A', '--all', 'All namespaces') { options[:all_namespaces] = true }
+  opts.on('-f FILE', '--file FILE', 'Manifest file path') { |v| options[:file] = v }
+  opts.on('-d DIR', '--data-dir DIR', 'Data directory containing namespaces') { |v| options[:data_dir] = v }
+  opts.on('--hostname HOSTNAME', 'Hostname for namespace') { |v| options[:hostname] = v }
+  opts.on('--username USERNAME', 'Username for namespace') { |v| options[:username] = v }
+
+  # Logs-specific options
+  opts.on('--follow', 'Follow log output') { options[:follow] = true }
+  opts.on('--tail N', Integer, 'Number of lines to show from end of logs') { |v| options[:tail] = v }
+  opts.on('--timestamps', 'Show timestamps') { options[:timestamps] = true }
+end
+
+# Parse command flags
+begin
+  command_parser.parse!(ARGV)
+rescue OptionParser::InvalidOption => e
+  warn "Error: #{e.message}"
+  exit 1
+end
+
+# Get positional arguments after all flags are removed
+kind = ARGV[1]
+name = ARGV[2]
+
+namespace = options[:namespace]
+all_namespaces = options[:all_namespaces]
+
+# Resolve data directory from context or --data-dir flag
+data_dir = nil
+
+# Skip context resolution for context commands (they manage config themselves)
+unless command == 'context'
+  # Try to load config and resolve data directory from context
+  begin
+    config = Walheim::Config.new(config_path: options[:whconfig])
+
+    # Determine which context to use
+    context_name = options[:context] || config.current_context
+
+    if context_name
+      # Get data directory from the specified or active context
+      data_dir = config.data_dir(context_name)
+    elsif options[:data_dir]
+      # Fall back to --data-dir if provided (deprecated path)
+      data_dir = options[:data_dir]
+      warn "Warning: --data-dir is deprecated. Use 'whctl context new' to create a context."
+    else
+      # No context and no --data-dir
+      warn 'Error: No Walheim configuration found.'
+      warn ''
+      warn 'Create your first context:'
+      warn '  whctl context new <name> --data-dir <path>'
+      warn ''
+      warn 'Example:'
+      warn '  whctl context new homelab --data-dir ~/my-homelab'
+      exit 1
+    end
+  rescue Walheim::Config::ConfigError, Walheim::Config::ValidationError => e
+    # Config file doesn't exist or is invalid
+    if options[:data_dir]
+      # Fall back to --data-dir if provided
+      data_dir = options[:data_dir]
+      warn "Warning: --data-dir is deprecated. Use 'whctl context new' to create a context."
+    else
+      warn 'Error: No Walheim configuration found.'
+      warn ''
+      warn 'Create your first context:'
+      warn '  whctl context new <name> --data-dir <path>'
+      exit 1
+    end
+  end
+end
+
+# Default to current directory if still not set (shouldn't happen but safety)
+data_dir ||= Dir.pwd
+
+# For handlers that need it - namespaced resources use namespaces_dir
+# Cluster resources use data_dir directly
+namespaces_dir = File.join(data_dir, 'namespaces')
+
+# Helper method to read YAML from file or stdin
+def read_yaml_input(file_path)
+  if file_path == '-'
+    # Read from stdin
+    YAML.load(STDIN.read)
+  else
+    # Read from file
+    YAML.load_file(file_path)
+  end
+end
+
+# Helper method to print resources table
+def print_resources_table(result, all_namespaces, kind_name)
+  require 'terminal-table'
+
+  if result.is_a?(Hash)
+    # Single resource - print YAML
+    puts YAML.dump(result[:manifest])
+    return
+  end
+
+  if result.empty?
+    puts all_namespaces ? "No #{kind_name} found" : "No #{kind_name} found in namespace"
+    return
+  end
+
+  # Extract summary field names from first result
+  summary_fields = result.first[:summary].keys
+
+  # Build header row
+  if all_namespaces
+    headers = ['NAMESPACE', 'NAME'] + summary_fields.map(&:to_s).map(&:upcase)
+  else
+    headers = ['NAME'] + summary_fields.map(&:to_s).map(&:upcase)
+  end
+
+  # Build data rows
+  rows = result.map do |resource|
+    row = if all_namespaces
+      [resource[:namespace], resource[:name]]
+    else
+      [resource[:name]]
+    end
+
+    # Add summary field values
+    summary_values = summary_fields.map { |field| resource[:summary][field] || 'N/A' }
+    row + summary_values
+  end
+
+  all_rows = [headers] + rows
+
+  table = Terminal::Table.new do |t|
+    t.rows = all_rows
+    t.style = {
+      border_x: '', border_y: '', border_i: '',
+      padding_left: 0, padding_right: 3,
+      border_top: false, border_bottom: false,
+      all_separators: false
+    }
+  end
+
+  puts table
+end
+
+def print_cluster_resources_table(result, kind_name)
+  require 'terminal-table'
+
+  if result.is_a?(Hash)
+    # Single resource - print YAML
+    puts YAML.dump(result[:manifest])
+    return
+  end
+
+  if result.empty?
+    puts "No #{kind_name} found"
+    return
+  end
+
+  # Extract summary field names from first result
+  summary_fields = result.first[:summary].keys
+
+  # Build header row (no NAMESPACE column for cluster resources)
+  headers = ['NAME'] + summary_fields.map(&:to_s).map(&:upcase)
+
+  # Build data rows
+  rows = result.map do |resource|
+    row = [resource[:name]]
+
+    # Add summary field values
+    summary_values = summary_fields.map { |field| resource[:summary][field] || 'N/A' }
+    row + summary_values
+  end
+
+  all_rows = [headers] + rows
+
+  table = Terminal::Table.new do |t|
+    t.rows = all_rows
+    t.style = {
+      border_x: '', border_y: '', border_i: '',
+      padding_left: 0, padding_right: 3,
+      border_top: false, border_bottom: false,
+      all_separators: false
+    }
+  end
+
+  puts table
+end
+
+# Route commands
+case command
+when 'get'
+  handler_info = Walheim::HandlerRegistry.get(kind)
+
+  unless handler_info
+    warn "Error: unknown kind '#{kind}'"
+    warn ''
+    warn 'Available kinds:'
+    Walheim::HandlerRegistry.all_visible.each do |h|
+      warn "  #{h[:name]}"
+    end
+    exit 1
+  end
+
+  handler = handler_info[:handler].new(data_dir: data_dir)
+
+  # Special handling for cluster resources (no namespace argument)
+  if handler.is_a?(Walheim::ClusterResource)
+    result = handler.get
+    print_cluster_resources_table(result, handler_info[:name])
+  else
+    # All other resources support namespace filtering
+    unless all_namespaces || namespace
+      warn 'Error: either -n {namespace} or --all/-A flag is required'
+      warn "Usage: whctl get #{handler_info[:name]} -n {namespace}"
+      warn "Usage: whctl get #{handler_info[:name]} --all"
+      exit 1
+    end
+
+    # Call handler and get data
+    result = if all_namespaces
+      handler.get(namespace: nil, name: nil)
+    else
+      handler.get(namespace: namespace, name: name)
+    end
+
+    # Format and print output
+    print_resources_table(result, all_namespaces, handler_info[:name])
+  end
+when 'apply'
+  # If -f is provided, extract namespace and name from manifest
+  if options[:file]
+    manifest_data = read_yaml_input(options[:file])
+    kind = manifest_data['kind']&.downcase + 's' # App -> apps
+    namespace = manifest_data['metadata']['namespace']
+    name = manifest_data['metadata']['name']
+
+    unless kind && namespace && name
+      warn 'Error: Manifest must contain kind, metadata.namespace, and metadata.name'
+      exit 1
+    end
+  end
+
+  handler_info = Walheim::HandlerRegistry.get(kind)
+
+  unless handler_info
+    warn "Error: unknown kind '#{kind}'"
+    exit 1
+  end
+
+  # Check if this resource supports apply operation
+  unless Walheim::HandlerRegistry.supports_operation?(kind, :apply)
+    warn "Error: apply not supported for kind '#{kind}'"
+    exit 1
+  end
+
+  # Validate required arguments
+  unless namespace && name
+    warn 'Error: -n and name are required (or use -f)'
+    warn "Usage: whctl apply #{handler_info[:name]} {name} -n {namespace}"
+    warn "Or: whctl apply -f {manifest.yaml}"
+    exit 1
+  end
+
+  # Execute operation
+  handler = handler_info[:handler].new(data_dir: data_dir)
+  handler.apply(namespace: namespace, name: name, manifest_source: options[:file])
+when 'delete'
+  handler_info = Walheim::HandlerRegistry.get(kind)
+
+  unless handler_info
+    warn "Error: unknown kind '#{kind}'"
+    exit 1
+  end
+
+  # Check if this resource supports delete operation
+  unless Walheim::HandlerRegistry.supports_operation?(kind, :delete)
+    warn "Error: delete not supported for kind '#{kind}'"
+    exit 1
+  end
+
+  # Validate required arguments
+  unless namespace && name
+    warn 'Error: -n and name are required'
+    warn "Usage: whctl delete #{handler_info[:name]} {name} -n {namespace}"
+    exit 1
+  end
+
+  # Execute operation
+  handler = handler_info[:handler].new(data_dir: data_dir)
+  handler.delete(namespace: namespace, name: name)
+when 'create'
+  # Only namespaces support create
+  if %w[namespace namespaces ns].include?(kind)
+    unless name
+      warn 'Error: namespace name is required'
+      warn 'Usage: whctl create namespace {name} [--username {user}] [--hostname {host}]'
+      exit 1
+    end
+
+    # Use namespace name as fallback for hostname
+    hostname = options[:hostname] || name
+
+    # Create namespace directory
+    namespace_path = File.join(namespaces_dir, name)
+    if Dir.exist?(namespace_path)
+      warn "Error: namespace '#{name}' already exists at #{namespace_path}"
+      exit 1
+    end
+
+    # Create directory structure
+    Dir.mkdir(namespace_path)
+    Dir.mkdir(File.join(namespace_path, 'apps'))
+    Dir.mkdir(File.join(namespace_path, 'secrets'))
+    Dir.mkdir(File.join(namespace_path, 'configmaps'))
+
+    # Create .namespace.yaml with optional username
+    config_path = File.join(namespace_path, '.namespace.yaml')
+    config_content = "hostname: #{hostname}\n"
+    config_content = "username: #{options[:username]}\n#{config_content}" if options[:username]
+    File.write(config_path, config_content)
+
+    puts "Created namespace '#{name}' at #{namespace_path}"
+    puts "  Username: #{options[:username] || '(from SSH config)'}"
+    puts "  Hostname: #{hostname}"
+  else
+    warn "Error: create not supported for kind '#{kind}'"
+    warn 'Usage: whctl create namespace {name} [--username {user}] [--hostname {host}]'
+    exit 1
+  end
+when 'start', 'pause', 'stop'
+  # Resource-specific operations
+  handler_info = Walheim::HandlerRegistry.get(kind)
+
+  unless handler_info
+    warn "Error: unknown kind '#{kind}'"
+    exit 1
+  end
+
+  # Check if this resource supports the operation
+  unless Walheim::HandlerRegistry.supports_operation?(kind, command.to_sym)
+    warn "Error: #{command} not supported for #{kind}"
+    exit 1
+  end
+
+  # Validate required arguments
+  unless namespace && name
+    warn 'Error: -n and name are required'
+    warn "Usage: whctl #{command} #{handler_info[:name]} {name} -n {namespace}"
+    exit 1
+  end
+
+  # Execute operation
+  handler = handler_info[:handler].new(data_dir: data_dir)
+  handler.send(command.to_sym, namespace: namespace, name: name)
+when 'logs'
+  # Resource-specific operation
+  handler_info = Walheim::HandlerRegistry.get(kind)
+
+  unless handler_info
+    warn "Error: unknown kind '#{kind}'"
+    exit 1
+  end
+
+  # Check if this resource supports logs operation
+  unless Walheim::HandlerRegistry.supports_operation?(kind, :logs)
+    warn "Error: logs not supported for #{kind}"
+    exit 1
+  end
+
+  # Validate required arguments
+  unless namespace && name
+    warn 'Error: -n and name are required'
+    warn "Usage: whctl logs #{handler_info[:name]} {name} -n {namespace} [--follow] [--tail N] [--timestamps]"
+    exit 1
+  end
+
+  # Build log options
+  log_options = {}
+  log_options[:follow] = true if options[:follow]
+  log_options[:tail] = options[:tail] if options[:tail]
+  log_options[:timestamps] = true if options[:timestamps]
+
+  # Execute operation
+  handler = handler_info[:handler].new(data_dir: data_dir)
+  handler.logs(namespace: namespace, name: name, **log_options)
+when 'import'
+  # Only apps support import
+  unless %w[apps app].include?(kind)
+    warn "Error: import only supported for apps"
+    warn 'Usage: whctl import app {name} -n {namespace} -f {docker-compose.yml}'
+    exit 1
+  end
+
+  # Require -f flag
+  unless options[:file]
+    warn 'Error: -f flag is required for import'
+    warn 'Usage: whctl import app {name} -n {namespace} -f {docker-compose.yml}'
+    warn 'Or: whctl import app {name} -n {namespace} -f - (read from stdin)'
+    exit 1
+  end
+
+  # Validate required arguments
+  unless namespace && name
+    warn 'Error: -n and name are required'
+    warn 'Usage: whctl import app {name} -n {namespace} -f {docker-compose.yml}'
+    exit 1
+  end
+
+  # Read docker-compose manifest
+  compose_manifest = read_yaml_input(options[:file])
+
+  # Execute import
+  handler_info = Walheim::HandlerRegistry.get('apps')
+  handler = handler_info[:handler].new(data_dir: data_dir)
+  handler.import(namespace: namespace, name: name, compose_manifest: compose_manifest)
+when 'context'
+  # Context management commands
+  subcommand = kind # The kind position is the subcommand for context
+  context_name = name # The name position is the context name
+
+  case subcommand
+  when 'new'
+    # whctl context new {name} --data-dir {path}
+    unless context_name
+      warn 'Error: context name is required'
+      warn 'Usage: whctl context new {name} --data-dir {path}'
+      exit 1
+    end
+
+    unless options[:data_dir]
+      warn 'Error: --data-dir flag is required'
+      warn 'Usage: whctl context new {name} --data-dir {path}'
+      exit 1
+    end
+
+    # Validate data_dir exists or can be created
+    expanded_data_dir = File.expand_path(options[:data_dir])
+    unless Dir.exist?(expanded_data_dir)
+      warn "Error: data directory '#{expanded_data_dir}' does not exist"
+      warn ''
+      warn 'Please create the directory first or provide a valid path'
+      exit 1
+    end
+
+    # Check for namespaces subdirectory
+    namespaces_path = File.join(expanded_data_dir, 'namespaces')
+    unless Dir.exist?(namespaces_path)
+      warn "Warning: data directory does not contain 'namespaces' subdirectory"
+      warn "Expected path: #{namespaces_path}"
+      warn ''
+      warn 'This directory should contain your homelab configuration.'
+      warn 'Creating namespaces directory...'
+      Dir.mkdir(namespaces_path)
+    end
+
+    # Load or create config
+    config = Walheim::Config.new(config_path: options[:whconfig])
+
+    begin
+      config.add_context(context_name, expanded_data_dir, activate: true)
+      config.save_config
+      puts "Created context '#{context_name}'"
+      puts "  Data directory: #{expanded_data_dir}"
+      puts "  Status: Active (automatically activated)"
+    rescue Walheim::Config::ValidationError => e
+      warn "Error: #{e.message}"
+      exit 1
+    rescue Walheim::Config::ConfigError => e
+      warn "Error: #{e.message}"
+      exit 1
+    end
+
+  when 'list'
+    # whctl context list
+    config = Walheim::Config.new(config_path: options[:whconfig])
+
+    unless Walheim::Config.exists?(config_path: options[:whconfig])
+      warn 'No Walheim configuration found.'
+      warn ''
+      warn 'Create your first context:'
+      warn '  whctl context new <name> --data-dir <path>'
+      exit 1
+    end
+
+    contexts = config.list_contexts
+    if contexts.empty?
+      puts 'No contexts configured.'
+      exit 0
+    end
+
+    require 'terminal-table'
+
+    rows = contexts.map do |ctx|
+      active_marker = ctx['active'] ? '*' : ''
+      [active_marker, ctx['name'], ctx['dataDir']]
+    end
+
+    table = Terminal::Table.new do |t|
+      t.headings = ['CURRENT', 'NAME', 'DATA DIRECTORY']
+      t.rows = rows
+      t.style = {
+        border_x: '', border_y: '', border_i: '',
+        padding_left: 0, padding_right: 3,
+        border_top: false, border_bottom: false,
+        all_separators: false
+      }
+    end
+
+    puts table
+
+  when 'use'
+    # whctl context use {name}
+    unless context_name
+      warn 'Error: context name is required'
+      warn 'Usage: whctl context use {name}'
+      exit 1
+    end
+
+    config = Walheim::Config.new(config_path: options[:whconfig])
+
+    begin
+      config.use_context(context_name)
+      config.save_config
+      puts "Switched to context '#{context_name}'"
+    rescue Walheim::Config::ConfigError => e
+      warn "Error: #{e.message}"
+      exit 1
+    end
+
+  when 'current'
+    # whctl context current
+    config = Walheim::Config.new(config_path: options[:whconfig])
+
+    unless Walheim::Config.exists?(config_path: options[:whconfig])
+      warn 'No Walheim configuration found.'
+      warn ''
+      warn 'Create your first context:'
+      warn '  whctl context new <name> --data-dir <path>'
+      exit 1
+    end
+
+    if config.current_context
+      puts "Current context: #{config.current_context}"
+      puts "Data directory: #{config.data_dir}"
+    else
+      puts 'No active context selected.'
+      puts ''
+      puts 'Available contexts:'
+      config.list_contexts.each do |ctx|
+        puts "  - #{ctx['name']}"
+      end
+      puts ''
+      puts 'Select a context:'
+      puts '  whctl context use <context-name>'
+    end
+
+  when 'delete'
+    # whctl context delete {name}
+    unless context_name
+      warn 'Error: context name is required'
+      warn 'Usage: whctl context delete {name}'
+      exit 1
+    end
+
+    config = Walheim::Config.new(config_path: options[:whconfig])
+
+    begin
+      config.delete_context(context_name)
+      config.save_config
+      puts "Deleted context '#{context_name}'"
+
+      # Show warning if this was the active context
+      unless config.current_context
+        puts ''
+        puts 'Note: This was your active context.'
+        puts 'Select a new context with:'
+        puts '  whctl context use <context-name>'
+      end
+    rescue Walheim::Config::ConfigError => e
+      warn "Error: #{e.message}"
+      exit 1
+    end
+
+  else
+    warn "Error: unknown context subcommand '#{subcommand}'"
+    warn ''
+    warn 'Available context commands:'
+    warn '  whctl context new {name} --data-dir {path}'
+    warn '  whctl context list'
+    warn '  whctl context use {name}'
+    warn '  whctl context current'
+    warn '  whctl context delete {name}'
+    exit 1
+  end
+else
+  warn "Error: unknown command '#{command}'"
+  warn 'Usage: whctl <command> [arguments]'
+  exit 1
+end