kdep 0.1.0

data/lib/kdep/commands/restart.rb

@@ -0,0 +1,109 @@
+require "optparse"
+
+module Kdep
+  module Commands
+    class Restart
+      RESTARTABLE_PRESETS = %w[web worker].freeze
+      NON_RESTARTABLE_PRESETS = %w[job cronjob].freeze
+
+      def self.option_parser
+        OptionParser.new do |opts|
+          opts.banner = "Usage: kdep restart [deploy] [--type TYPE]"
+          opts.separator ""
+          opts.separator "Triggers a rolling restart of a Deployment or StatefulSet."
+          opts.separator ""
+          opts.on("--type TYPE", "Resource type: deployment, statefulset (overrides preset)") do |_|
+            # parsed via into: hash
+          end
+        end
+      end
+
+      def initialize(global_options:, command_options:, args:)
+        @global_options = global_options
+        @command_options = command_options
+        @args = args
+        @ui = Kdep::UI.new(color: false)
+      end
+
+      def execute
+        deploy_name = @args[0]
+
+        # Discover kdep/ directory
+        discovery = Kdep::Discovery.new
+        kdep_dir = discovery.find_kdep_dir
+        unless kdep_dir
+          @ui.error("No kdep/ directory found")
+          exit 1
+        end
+
+        # Resolve deploy directory
+        deploy_dir = resolve_deploy_dir(kdep_dir, deploy_name, discovery)
+        unless deploy_dir
+          exit 1
+        end
+
+        # Load config
+        config = Kdep::Config.new(deploy_dir, nil).load
+
+        # Validate context
+        Kdep::ContextGuard.new(config["context"]).validate!
+
+        namespace = config["namespace"]
+        app_name = config["name"]
+        preset = config["preset"]
+
+        # Determine resource type
+        resource_type = determine_resource_type(preset)
+
+        # Execute rollout restart
+        Kdep::Kubectl.run("rollout", "restart", "#{resource_type}/#{app_name}", "-n", namespace)
+        @ui.info("Restarted #{resource_type}/#{app_name} in #{namespace}")
+      end
+
+      private
+
+      def determine_resource_type(preset)
+        if @command_options[:type]
+          return @command_options[:type]
+        end
+
+        resource_type_for_preset(preset)
+      end
+
+      def resource_type_for_preset(preset)
+        if NON_RESTARTABLE_PRESETS.include?(preset)
+          @ui.error("#{preset} workloads cannot be restarted (use --type to override)")
+          exit 1
+        end
+
+        "deployment"
+      end
+
+      def resolve_deploy_dir(kdep_dir, deploy_name, discovery)
+        if deploy_name
+          deploy_dir = File.join(kdep_dir, deploy_name)
+          unless File.directory?(deploy_dir)
+            @ui.error("Deploy target not found: #{deploy_name}")
+            deploys = discovery.find_deploys
+            if deploys.any?
+              @ui.info("Available deploys: #{deploys.join(', ')}")
+            end
+            return nil
+          end
+          deploy_dir
+        else
+          deploys = discovery.find_deploys
+          if deploys.length == 1
+            File.join(kdep_dir, deploys[0])
+          elsif deploys.length > 1
+            @ui.error("Multiple deploys found, specify one: #{deploys.join(', ')}")
+            nil
+          else
+            @ui.error("No deploy targets found in kdep/")
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kdep/commands/scale.rb

@@ -0,0 +1,136 @@
+require "optparse"
+
+module Kdep
+  module Commands
+    class Scale
+      NON_SCALABLE_PRESETS = %w[job cronjob].freeze
+
+      def self.option_parser
+        OptionParser.new do |opts|
+          opts.banner = "Usage: kdep scale [deploy] N [--type TYPE]"
+          opts.separator ""
+          opts.separator "Scales a Deployment or StatefulSet to N replicas."
+          opts.separator ""
+          opts.on("--type TYPE", "Resource type: deployment, statefulset (overrides preset)") do |_|
+            # parsed via into: hash
+          end
+        end
+      end
+
+      def initialize(global_options:, command_options:, args:)
+        @global_options = global_options
+        @command_options = command_options
+        @args = args
+        @ui = Kdep::UI.new(color: false)
+      end
+
+      def execute
+        if @args.length == 1 && @args[0] && @args[0].match?(/\A\d+\z/)
+          deploy_name = nil
+          @replica_count = @args[0].to_i
+        else
+          deploy_name = @args[0]
+        end
+
+        # Discover kdep/ directory
+        discovery = Kdep::Discovery.new
+        kdep_dir = discovery.find_kdep_dir
+        unless kdep_dir
+          @ui.error("No kdep/ directory found")
+          exit 1
+        end
+
+        # Resolve deploy directory
+        deploy_dir = resolve_deploy_dir(kdep_dir, deploy_name, discovery)
+        unless deploy_dir
+          exit 1
+        end
+
+        # Load config
+        config = Kdep::Config.new(deploy_dir, nil).load
+
+        # Validate context
+        Kdep::ContextGuard.new(config["context"]).validate!
+
+        namespace = config["namespace"]
+        app_name = config["name"]
+        preset = config["preset"]
+
+        # Parse and validate replica count
+        replicas = parse_replicas
+        unless replicas
+          @ui.error("Usage: kdep scale [deploy] N -- replica count required")
+          exit 1
+        end
+
+        # Determine resource type
+        resource_type = determine_resource_type(preset)
+
+        # Execute scale
+        Kdep::Kubectl.run("scale", "#{resource_type}/#{app_name}", "--replicas=#{replicas}", "-n", namespace)
+        @ui.info("Scaled #{resource_type}/#{app_name} to #{replicas} replicas in #{namespace}")
+      end
+
+      private
+
+      def parse_replicas
+        return @replica_count if @replica_count
+
+        # Second arg should be the replica count (first arg is deploy name)
+        replica_str = @args[1]
+        return nil unless replica_str
+
+        # Must be a non-negative integer
+        unless replica_str.match?(/\A\d+\z/)
+          @ui.error("Invalid replica count: #{replica_str} (must be a non-negative integer)")
+          exit 1
+        end
+
+        replica_str.to_i
+      end
+
+      def determine_resource_type(preset)
+        if @command_options[:type]
+          return @command_options[:type]
+        end
+
+        resource_type_for_preset(preset)
+      end
+
+      def resource_type_for_preset(preset)
+        if NON_SCALABLE_PRESETS.include?(preset)
+          @ui.error("#{preset} workloads cannot be scaled (use --type to override)")
+          exit 1
+        end
+
+        "deployment"
+      end
+
+      def resolve_deploy_dir(kdep_dir, deploy_name, discovery)
+        if deploy_name
+          deploy_dir = File.join(kdep_dir, deploy_name)
+          unless File.directory?(deploy_dir)
+            @ui.error("Deploy target not found: #{deploy_name}")
+            deploys = discovery.find_deploys
+            if deploys.any?
+              @ui.info("Available deploys: #{deploys.join(', ')}")
+            end
+            return nil
+          end
+          deploy_dir
+        else
+          deploys = discovery.find_deploys
+          if deploys.length == 1
+            File.join(kdep_dir, deploys[0])
+          elsif deploys.length > 1
+            @ui.error("Multiple deploys found, specify one: #{deploys.join(', ')}")
+            nil
+          else
+            @ui.error("No deploy targets found in kdep/")
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kdep/commands/secrets.rb

@@ -0,0 +1,223 @@
+require "optparse"
+require "json"
+require "base64"
+
+module Kdep
+  module Commands
+    class Secrets
+      def self.option_parser
+        OptionParser.new do |opts|
+          opts.banner = "Usage: kdep secrets <list|create|check> [deploy]"
+          opts.separator ""
+          opts.separator "Manage image pull secrets in the deploy namespace."
+          opts.separator ""
+          opts.separator "Sub-commands:"
+          opts.separator "  list     List image pull secrets"
+          opts.separator "  create   Create a docker-registry secret"
+          opts.separator "  check    Decode and inspect an existing secret"
+          opts.separator ""
+          opts.separator "Options:"
+          opts.on("--server=URL", "Docker registry server URL")
+          opts.on("--username=NAME", "Registry username")
+          opts.on("--password=PASS", "Registry password")
+          opts.on("--name=SECRET_NAME", "Secret name (default: registry-credentials)")
+        end
+      end
+
+      def initialize(global_options:, command_options:, args:)
+        @global_options = global_options
+        @command_options = command_options
+        @args = args
+        @ui = Kdep::UI.new(color: false)
+      end
+
+      def execute
+        sub = @args.shift            # Sub-command first (list, create, check)
+        deploy_name = @args.shift    # Deploy name second (optional)
+
+        # If no sub-command given, show usage
+        unless sub
+          show_usage
+          return
+        end
+
+        # Only proceed with deploy resolution for known sub-commands
+        unless %w[list create check].include?(sub)
+          show_usage
+          return
+        end
+
+        # Discover kdep/ directory
+        discovery = Kdep::Discovery.new
+        kdep_dir = discovery.find_kdep_dir
+        unless kdep_dir
+          @ui.error("No kdep/ directory found")
+          exit 1
+        end
+
+        # Resolve deploy directory
+        deploy_dir = resolve_deploy_dir(kdep_dir, deploy_name, discovery)
+        unless deploy_dir
+          exit 1
+        end
+
+        # Load config
+        @config = Kdep::Config.new(deploy_dir, nil).load
+
+        # Validate context
+        Kdep::ContextGuard.new(@config["context"]).validate!
+
+        @namespace = @config["namespace"]
+
+        # Dispatch sub-command
+        case sub
+        when "list"   then list_secrets
+        when "create" then create_secret
+        when "check"  then check_secrets
+        end
+      end
+
+      private
+
+      def list_secrets
+        data = Kdep::Kubectl.run_json(
+          "get", "secrets", "-n", @namespace,
+          "--field-selector", "type=kubernetes.io/dockerconfigjson"
+        )
+
+        items = data["items"]
+        if items.nil? || items.empty?
+          @ui.info("No image pull secrets in #{@namespace}")
+          return
+        end
+
+        items.each do |secret|
+          name = secret["metadata"]["name"]
+          created = secret["metadata"]["creationTimestamp"]
+          @ui.info("#{name}  created: #{created}")
+        end
+      end
+
+      def create_secret
+        server = @command_options[:server]
+        username = @command_options[:username]
+        password = @command_options[:password]
+        secret_name = @command_options[:name] || "registry-credentials"
+
+        # Default server from config registry if available
+        if server.nil? && @config["registry"]
+          # Extract hostname from registry (e.g., "ghcr.io/myorg" -> "ghcr.io")
+          registry = @config["registry"]
+          server = registry.include?("/") ? registry.split("/").first : registry
+        end
+
+        # Validate required flags
+        missing = []
+        missing << "--username" unless username
+        missing << "--password" unless password
+        missing << "--server" unless server
+
+        unless missing.empty?
+          @ui.error("Missing required flags: #{missing.join(', ')}")
+          @ui.info("Usage: kdep secrets create [deploy] --server=URL --username=NAME --password=PASS [--name=SECRET_NAME]")
+          exit 1
+        end
+
+        Kdep::Kubectl.run(
+          "create", "secret", "docker-registry", secret_name,
+          "--docker-server=#{server}",
+          "--docker-username=#{username}",
+          "--docker-password=#{password}",
+          "-n", @namespace
+        )
+
+        @ui.info("Created secret #{secret_name} in #{@namespace}")
+      end
+
+      def check_secrets
+        secret_name = @command_options[:name] || @args.shift
+
+        unless secret_name
+          # No name given; list secrets and check all found
+          data = Kdep::Kubectl.run_json(
+            "get", "secrets", "-n", @namespace,
+            "--field-selector", "type=kubernetes.io/dockerconfigjson"
+          )
+          items = data["items"]
+          if items.nil? || items.empty?
+            @ui.info("No image pull secrets found in #{@namespace}")
+            return
+          end
+          items.each do |secret|
+            check_single_secret(secret["metadata"]["name"])
+          end
+          return
+        end
+
+        check_single_secret(secret_name)
+      end
+
+      def check_single_secret(secret_name)
+        data = Kdep::Kubectl.run_json("get", "secret", secret_name, "-n", @namespace)
+
+        raw = data["data"] && data["data"][".dockerconfigjson"]
+        unless raw
+          @ui.error("Secret #{secret_name} does not contain .dockerconfigjson")
+          return
+        end
+
+        begin
+          decoded = Base64.decode64(raw)
+          config = JSON.parse(decoded)
+          auths = config["auths"] || {}
+
+          if auths.empty?
+            @ui.info("Secret #{secret_name}: no auth entries found")
+            return
+          end
+
+          auths.each_key do |server|
+            @ui.info("Found credentials for #{server}")
+          end
+        rescue JSON::ParserError => e
+          @ui.error("Failed to parse dockerconfigjson from #{secret_name}: #{e.message}")
+        end
+      end
+
+      def show_usage
+        @ui.info("Usage: kdep secrets <sub-command> [deploy]")
+        @ui.info("")
+        @ui.info("Sub-commands:")
+        @ui.info("  list     List image pull secrets")
+        @ui.info("  create   Create a docker-registry secret")
+        @ui.info("  check    Decode and inspect an existing secret")
+      end
+
+      def resolve_deploy_dir(kdep_dir, deploy_name, discovery)
+        if deploy_name
+          deploy_dir = File.join(kdep_dir, deploy_name)
+          unless File.directory?(deploy_dir)
+            @ui.error("Deploy target not found: #{deploy_name}")
+            deploys = discovery.find_deploys
+            if deploys.any?
+              @ui.info("Available deploys: #{deploys.join(', ')}")
+            end
+            return nil
+          end
+          deploy_dir
+        else
+          deploys = discovery.find_deploys
+          if deploys.length == 1
+            File.join(kdep_dir, deploys[0])
+          elsif deploys.length > 1
+            @ui.error("Multiple deploys found, specify one: #{deploys.join(', ')}")
+            nil
+          else
+            @ui.error("No deploy targets found in kdep/")
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kdep/commands/sh.rb

@@ -0,0 +1,117 @@
+require "optparse"
+
+module Kdep
+  module Commands
+    class Sh
+      def self.option_parser
+        OptionParser.new do |opts|
+          opts.banner = "Usage: kdep sh [deploy] [container]"
+          opts.separator ""
+          opts.separator "Opens an interactive shell inside a running pod."
+          opts.separator ""
+          opts.on("-c", "--container=NAME", "Container name for multi-container pods")
+        end
+      end
+
+      def initialize(global_options:, command_options:, args:)
+        @global_options = global_options
+        @command_options = command_options
+        @args = args
+        @ui = Kdep::UI.new(color: false)
+      end
+
+      def execute
+        deploy_name = @args[0]
+
+        # Discover kdep/ directory
+        discovery = Kdep::Discovery.new
+        kdep_dir = discovery.find_kdep_dir
+        unless kdep_dir
+          @ui.error("No kdep/ directory found")
+          exit 1
+        end
+
+        # Resolve deploy directory
+        deploy_dir = resolve_deploy_dir(kdep_dir, deploy_name, discovery)
+        unless deploy_dir
+          exit 1
+        end
+
+        # Load config
+        config = Kdep::Config.new(deploy_dir, nil).load
+
+        # Validate context
+        Kdep::ContextGuard.new(config["context"]).validate!
+
+        # Find running pod
+        namespace = config["namespace"]
+        app_name = config["name"]
+        pod_name = find_pod(namespace, app_name)
+
+        # Exec into pod
+        exec_shell(pod_name, namespace)
+      end
+
+      private
+
+      def find_pod(namespace, app_name)
+        data = Kdep::Kubectl.run_json(
+          "get", "pods",
+          "-n", namespace,
+          "-l", "app=#{app_name}",
+          "--field-selector", "status.phase=Running"
+        )
+        pods = data["items"]
+
+        if pods.nil? || pods.empty?
+          @ui.error("No running pods found for #{app_name} in #{namespace}")
+          exit 1
+        end
+
+        pods[0]["metadata"]["name"]
+      end
+
+      def exec_shell(pod_name, namespace)
+        container = @command_options[:container]
+
+        args = ["kubectl", "exec", "-it", pod_name, "-n", namespace]
+
+        if container
+          args << "-c"
+          args << container
+        end
+
+        args << "--"
+        args << "/bin/sh"
+
+        Kernel.exec(*args)
+      end
+
+      def resolve_deploy_dir(kdep_dir, deploy_name, discovery)
+        if deploy_name
+          deploy_dir = File.join(kdep_dir, deploy_name)
+          unless File.directory?(deploy_dir)
+            @ui.error("Deploy target not found: #{deploy_name}")
+            deploys = discovery.find_deploys
+            if deploys.any?
+              @ui.info("Available deploys: #{deploys.join(', ')}")
+            end
+            return nil
+          end
+          deploy_dir
+        else
+          deploys = discovery.find_deploys
+          if deploys.length == 1
+            File.join(kdep_dir, deploys[0])
+          elsif deploys.length > 1
+            @ui.error("Multiple deploys found, specify one: #{deploys.join(', ')}")
+            nil
+          else
+            @ui.error("No deploy targets found in kdep/")
+            nil
+          end
+        end
+      end
+    end
+  end
+end