kdep 0.4.9 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 92fded408b48545949833a1473e7b905dc7ce0b8b7c58415ad77b532f0205227
-  data.tar.gz: 2af6988f918a2ba676a4a2d5780a950581f0e93596e772d4e04f3ca65b9fdba0
+  metadata.gz: 0f5fd6a62da416ea9cdccd6d6370050509846001fec09b066b63ac8c79918106
+  data.tar.gz: a792a173492ad869938ad623743af357e1a1ee6a8d7c85d2f591bcde7511d378
 SHA512:
-  metadata.gz: 8f1d30adf7eb1fe069115dc5cea6458f1e83ef4ef3025fb32912b9fee74f0b68582606fa71aa2e0b306e3ed80a5dda2dacec74760b3e9eb02884e794c18ec75c
-  data.tar.gz: d6b64df4bbe169c1f80c2169f6c3378d6ab62ce57096f6aa0d4f5cf8f3251f25cde1ffbfce1e490028a60bb9872f1848fc9bef016cc34aed23160e4e0144b99b
+  metadata.gz: 4640ab8f5039e3e5b4a9135a11afe42738659bf41376f38f0db463f13d1086317dc9c9631b2fb378157f86a1a255d7a29a58cdf816fcc0fe1d045c6b537d1d4a
+  data.tar.gz: bae5c85f87d19d2320cccbc169a0b08bb5f4b56b565dd81a1002c904c5e5a9d4ac570c053fc88ee6163534051809b72931a0395ff4cc0882127c32ad7126a068

data/lib/kdep/commands/apply.rb

@@ -71,6 +71,7 @@ module Kdep
         writer = Kdep::Writer.new(output_dir)
         writer.clean
         renderer = Kdep::Renderer.new(config, deploy_dir, env: env)
+        Kdep::Renderer.preflight_secrets!(@ui, renderer, resources)
         validator = Kdep::Validator.new
         validation_errors = []
 
@@ -78,6 +79,10 @@ module Kdep
           index = idx + 1
           begin
             content = renderer.render_resource(resource_name)
+          rescue Kdep::Renderer::MissingSecretsError => e
+            @ui.error("#{resource_name}: #{e.message}")
+            @ui.error("nada foi aplicado")
+            exit 1
           rescue => e
             @ui.error("#{resource_name}: #{e.message}")
             next

data/lib/kdep/commands/bump.rb

@@ -3,6 +3,10 @@ require "optparse"
 module Kdep
   module Commands
     class Bump
+      DEFAULT_ROLLOUT_TIMEOUT = "5m".freeze
+      # kubectl duration: 90s, 5m, 1h30m
+      DURATION_FORMAT = /\A(\d+(ms|s|m|h))+\z/
+
       def self.option_parser
         OptionParser.new do |opts|
           opts.banner = "Usage: kdep bump [deploy] [env]"
@@ -12,6 +16,8 @@ module Kdep
           opts.on("--skip-apply", "Build and push only, skip render+apply")
           opts.on("--dry-run", "Run full pipeline but skip kubectl apply")
           opts.on("--no-dashboard", "Skip TUI dashboard after deploy")
+          opts.on("--wait", "Wait for the rollout instead of the dashboard; exit 1 if it fails (for scripts/CI)")
+          opts.on("--timeout=DURATION", "Rollout wait timeout with --wait, e.g. 90s, 10m (default: #{DEFAULT_ROLLOUT_TIMEOUT}; 0 = forever)")
           opts.on("--platform=PLATFORM", "Target platform (e.g., linux/amd64)")
           opts.on("--init-state", "Seed state.yml at 0.0 when missing (non-interactive)")
           opts.on("--no-check", "Skip preflight check: validators")
@@ -29,6 +35,14 @@ module Kdep
         deploy_name = @args[0]
         env = @args[1]
 
+        # A malformed duration would only surface in `kubectl rollout status`,
+        # after build, push and apply -- reporting a good deploy as failed.
+        timeout = @command_options[:timeout]
+        if timeout && !(timeout == "0" || timeout.match?(DURATION_FORMAT))
+          @ui.error("--timeout=#{timeout}: expected a duration like 90s, 5m or 1h30m")
+          exit 1
+        end
+
         # Step 1: Discovery + config
         discovery = Kdep::Discovery.new
         kdep_dir = discovery.find_kdep_dir
@@ -58,6 +72,7 @@ module Kdep
         # (context guard, rollout tracking, etc.).
         preset = config["preset"]
         if preset == "helm"
+          @ui.warn("--wait is not supported for helm presets; the rollout is not awaited") if @command_options[:wait]
           run_helm_pipeline(deploy_dir, env)
           return
         elsif preset == "custom" || config["build"] == false
@@ -106,6 +121,12 @@ module Kdep
         registry_url = config["registry"]
         repo_root = File.dirname(kdep_dir)
 
+        # O Secret é conferido ANTES do docker build/push: falha aqui não empurra imagem nem aplica nada.
+        unless @command_options[:"skip-apply"]
+          Kdep::Renderer.preflight_secrets!(@ui, Kdep::Renderer.new(config, deploy_dir, env: env),
+                                            Kdep::Preset.new(config["preset"], deploy_dir).resources)
+        end
+
         begin
           # Step 4: Increment minor version.
           parsed = Kdep::VersionTagger.parse(current_tag)
@@ -198,8 +219,13 @@ module Kdep
               # Save new tag to state.yml
               Kdep::State.write(deploy_dir, tag: next_version)
 
-              # Launch TUI dashboard for live monitoring
-              unless @command_options[:"no-dashboard"]
+              # Follow the rollout: --wait blocks on it (scripts/CI), otherwise
+              # the TUI dashboard when there is a terminal to draw it on.
+              if @command_options[:wait]
+                wait_for_rollout(config, deploy_dir, namespace)
+              elsif @command_options[:"no-dashboard"]
+                # explicitly opted out
+              elsif Kdep::Dashboard.interactive?
                 dashboard = Kdep::Dashboard.new(
                   "name" => config["name"],
                   "namespace" => namespace,
@@ -207,10 +233,16 @@ module Kdep
                   "image" => image
                 )
                 dashboard.run
+              else
+                @ui.warn("rollout not awaited -- pass --wait to block until it completes (exit 1 if it fails)")
               end
             end
           end
 
+        rescue Kdep::Renderer::MissingSecretsError => e
+          @ui.error(e.message)
+          @ui.error("nada foi aplicado (a imagem pode já ter sido enviada ao registry)")
+          exit 1
         rescue Kdep::Docker::Error => e
           @ui.error(e.message)
           exit 1
@@ -222,6 +254,29 @@ module Kdep
 
       private
 
+      def wait_for_rollout(config, deploy_dir, namespace)
+        deploy = File.basename(deploy_dir)
+        resources = Kdep::Workload.preset_resources(config["preset"], deploy_dir)
+        kinds = Kdep::Workload.rollout_kinds(resources)
+
+        if kinds.empty?
+          what = Kdep::Workload.batch_kind(resources) || "no deployment/statefulset/daemonset"
+          @ui.warn("--wait: preset '#{config["preset"]}' declares #{what}; no rollout to wait for")
+          return
+        end
+
+        timeout = @command_options[:timeout] || DEFAULT_ROLLOUT_TIMEOUT
+        kinds.each do |kind|
+          name = Kdep::Workload.name_for(kind, config)
+          @ui.info("waiting for #{kind}/#{name} rollout (timeout #{timeout})...")
+          next if Kdep::Kubectl.rollout_status(kind, name, namespace: namespace, timeout: timeout)
+
+          @ui.error("rollout of #{kind}/#{name} did not complete within #{timeout}. " \
+                    "Check `kdep status #{deploy}` and `kdep log #{deploy}`.")
+          exit 1
+        end
+      end
+
       # Feature E: helm-preset bump = helm-install pipeline. Preflight
       # already ran; context guard runs inside HelmInstall; rollout flush
       # and configmap overlays are internal to it.
@@ -256,6 +311,7 @@ module Kdep
         writer.clean
         renderer = Kdep::Renderer.new(config, deploy_dir, env: env)
         preset_resources = Kdep::Preset.new(config["preset"], deploy_dir).resources
+        Kdep::Renderer.preflight_secrets!(@ui, renderer, preset_resources)
 
         preset_resources.each_with_index do |resource, idx|
           content = renderer.render_resource(resource)
@@ -268,6 +324,8 @@ module Kdep
             Kdep::Kubectl.apply(file_path, namespace: namespace)
             @ui.info("applied: #{File.basename(file_path)}")
           end
+
+          wait_for_rollout(config, deploy_dir, namespace) if @command_options[:wait]
         end
       end
 

data/lib/kdep/commands/dashboard.rb

@@ -39,6 +39,13 @@ module Kdep
         # Load config (nil env -- dashboard monitors live state)
         config = Kdep::Config.new(deploy_dir, nil).load
 
+        # Checked before any cluster access: nothing to show without a terminal
+        unless Kdep::Dashboard.interactive?
+          @ui.error("kdep dashboard needs an interactive terminal (stdin and stdout). " \
+                    "From a script, use `kdep status` or `kdep log`.")
+          exit 1
+        end
+
         # Validate context before any cluster operation
         begin
           Kdep::ContextGuard.new(config["context"]).validate!

data/lib/kdep/commands/helm_install.rb

@@ -73,6 +73,10 @@ module Kdep
           exit 1
         end
 
+        # O Secret extra (preset helm: secret + ingress) é conferido ANTES do helm upgrade.
+        Kdep::Renderer.preflight_secrets!(@ui, Kdep::Renderer.new(config, @deploy_dir, env: @env),
+                                          Kdep::Preset.new("helm", @deploy_dir).resources)
+
         # Load secrets for --set interpolation
         @secrets = load_secrets(@deploy_dir)
 
@@ -277,6 +281,9 @@ module Kdep
           index = next_index
           begin
             content = renderer.render_resource(resource_name)
+          rescue Kdep::Renderer::MissingSecretsError => e
+            @ui.error("#{resource_name}: #{e.message}")
+            exit 1
           rescue => e
             render_errors << "#{resource_name}: #{e.message}"
             next

data/lib/kdep/commands/log.rb

@@ -3,9 +3,6 @@ require "optparse"
 module Kdep
   module Commands
     class Log
-      # kubectl refuses to follow more than --max-log-requests streams (default 5)
-      MIN_LOG_REQUESTS = 5
-
       def self.option_parser
         OptionParser.new do |opts|
           opts.banner = "Usage: kdep log [deploy]"
@@ -64,39 +61,26 @@ module Kdep
 
       private
 
-      # kubectl logs -l streams every pod the selector matches, whatever its
-      # phase (Completed leftovers, Pending surge pods), so the stream limit
-      # must count all of them -- only the guard looks at Running.
       def count_pods(namespace, app_name)
-        data = Kdep::Kubectl.run_json(
-          "get", "pods",
-          "-n", namespace,
-          "-l", "app=#{app_name}"
-        )
-        pods = data["items"] || []
+        pod_count, running = Kdep::PodLogs.count(namespace, app_name)
 
-        if pods.none? { |pod| pod.dig("status", "phase") == "Running" }
+        if running.zero?
           @ui.error("No running pods found for #{app_name} in #{namespace}")
           exit 1
         end
 
-        pods.length
+        pod_count
       end
 
       def stream_logs(namespace, app_name, pod_count)
-        follow = @command_options.fetch(:follow, true)
-        tail = @command_options.fetch(:tail, 100)
-        container = @command_options[:container]
-
-        args = ["kubectl", "logs", "-n", namespace, "-l", "app=#{app_name}", "--prefix", "--ignore-errors"]
-        args << "--max-log-requests=#{[pod_count, MIN_LOG_REQUESTS].max}"
-        args << "-f" if follow
-        args << "--tail=#{tail}"
-
-        if container
-          args << "-c"
-          args << container
-        end
+        args = Kdep::PodLogs.kubectl_args(
+          namespace: namespace,
+          app_name: app_name,
+          pod_count: pod_count,
+          tail: @command_options.fetch(:tail, 100),
+          follow: @command_options.fetch(:follow, true),
+          container: @command_options[:container]
+        )
 
         io = IO.popen(args, "r")
 

data/lib/kdep/commands/restart.rb

@@ -3,9 +3,6 @@ require "optparse"
 module Kdep
   module Commands
     class Restart
-      WORKLOAD_KINDS = %w[deployment statefulset daemonset].freeze
-      NON_RESTARTABLE_KINDS = %w[job cronjob].freeze
-
       def self.option_parser
         OptionParser.new do |opts|
           opts.banner = "Usage: kdep restart [deploy] [--type TYPE]"
@@ -73,10 +70,7 @@ module Kdep
 
       private
 
-      # The preset file lists the resources kdep applies, so the workload kind
-      # is declared there -- deriving it from the preset *name* got every
-      # non-Deployment target wrong (daemonset, statefulset, custom). Reading
-      # the list also handles `custom`, whose resources live in the deploy dir.
+      # Kind comes from the preset's resource list (see Kdep::Workload).
       def determine_resource_type(preset, deploy_dir)
         if @command_options[:type]
           return @command_options[:type]
@@ -86,14 +80,14 @@ module Kdep
       end
 
       def resource_type_for_preset(preset, deploy_dir)
-        resources = preset_resources(preset, deploy_dir)
+        resources = Kdep::Workload.preset_resources(preset, deploy_dir)
 
-        if (kind = resources.find { |r| NON_RESTARTABLE_KINDS.include?(r) })
+        if (kind = Kdep::Workload.batch_kind(resources))
           @ui.error("#{kind} workloads cannot be restarted (use --type to override)")
           exit 1
         end
 
-        found = resources & WORKLOAD_KINDS
+        found = Kdep::Workload.rollout_kinds(resources)
 
         if found.size > 1
           @ui.error("Multiple workloads in preset '#{preset}': #{found.join(', ')}. Use --type to pick one.")
@@ -106,12 +100,6 @@ module Kdep
         found.first || "deployment"
       end
 
-      def preset_resources(preset, deploy_dir)
-        Kdep::Preset.new(preset, deploy_dir).resources
-      rescue StandardError
-        []
-      end
-
       def resolve_deploy_dir(kdep_dir, deploy_name, discovery)
         if deploy_name
           deploy_dir = File.join(kdep_dir, deploy_name)

data/lib/kdep/dashboard.rb

@@ -7,6 +7,7 @@ require "kdep/dashboard/log_panel"
 require "kdep/dashboard/resources_panel"
 require "kdep/dashboard/health_panel"
 require "kdep/kubectl"
+require "kdep/pod_logs"
 
 module Kdep
   class Dashboard
@@ -14,6 +15,13 @@ module Kdep
     PANEL_NAMES = { rollout: "Rollout", logs: "Logs", resources: "Resources", health: "Health" }.freeze
     REFRESH_INTERVAL = 0.25
 
+    # The dashboard reads keys through $stdin.raw and draws on $stdout, so
+    # both must be terminals -- a script with a piped or /dev/null stdin
+    # still has a TTY stdout and used to crash with Errno::ENOTTY.
+    def self.interactive?
+      $stdin.tty? && $stdout.tty?
+    end
+
     def initialize(config)
       @config = config
       @name = config["name"]
@@ -29,8 +37,8 @@ module Kdep
     end
 
     def run
-      unless $stdout.tty?
-        puts "Dashboard skipped: not a TTY"
+      unless self.class.interactive?
+        puts "Dashboard skipped: not an interactive terminal"
         return
       end
 
@@ -152,8 +160,9 @@ module Kdep
     def start_log_thread
       t = Thread.new do
         begin
-          cmd = ["kubectl", "logs", "-n", @namespace, "-l", "app=#{@name}",
-                 "-f", "--tail=50", "--all-containers", "--prefix"]
+          pod_count, _running = PodLogs.count(@namespace, @name)
+          cmd = PodLogs.kubectl_args(namespace: @namespace, app_name: @name, pod_count: pod_count,
+                                     tail: 50, all_containers: true)
           io = IO.popen(cmd, "r", err: [:child, :out])
           @mutex.synchronize { @ios << io }
           while @running && (line = io.gets)

data/lib/kdep/kubectl.rb

@@ -40,6 +40,12 @@ module Kdep
       end
     end
 
+    # Streams kubectl's own progress to the terminal; true when the rollout
+    # completed within the timeout.
+    def self.rollout_status(kind, name, namespace:, timeout:)
+      system("kubectl", "rollout", "status", "#{kind}/#{name}", "-n", namespace, "--timeout=#{timeout}")
+    end
+
     # Declarative rollout-restart helper used by Kdep::RolloutTracker (Feature F).
     def self.rollout_restart(kind, name, namespace:)
       run("rollout", "restart", "#{kind}/#{name}", "-n", namespace)

data/lib/kdep/pod_logs.rb

@@ -0,0 +1,42 @@
+require "kdep/kubectl"
+
+module Kdep
+  # Shared by `kdep log` and the dashboard log panel: both stream every pod
+  # behind the app label instead of picking one.
+  module PodLogs
+    # kubectl refuses to follow more than --max-log-requests streams (default 5)
+    MIN_LOG_REQUESTS = 5
+    # The count and `kubectl logs -l` are two selector lookups. Right after a
+    # bump the ReplicaSet is creating surge pods between them, so a limit equal
+    # to the count gets refused -- leave room for a full surge.
+    SURGE_HEADROOM = 2
+
+    # kubectl logs -l streams every pod the selector matches, whatever its
+    # phase (Completed leftovers, Pending surge pods), so the stream limit
+    # must count all of them. Returns [matching, running].
+    def self.count(namespace, app_name)
+      data = Kdep::Kubectl.run_json("get", "pods", "-n", namespace, "-l", "app=#{app_name}")
+      pods = data["items"] || []
+      running = pods.count { |pod| pod.dig("status", "phase") == "Running" }
+      [pods.length, running]
+    end
+
+    # --ignore-errors keeps one pod still in ContainerCreating from ending
+    # every other stream mid-rollout.
+    def self.kubectl_args(namespace:, app_name:, pod_count:, tail:, follow: true, container: nil, all_containers: false)
+      args = ["kubectl", "logs", "-n", namespace, "-l", "app=#{app_name}", "--prefix", "--ignore-errors"]
+      args << "--max-log-requests=#{[pod_count * SURGE_HEADROOM, MIN_LOG_REQUESTS].max}"
+      args << "-f" if follow
+      args << "--tail=#{tail}"
+
+      if container
+        args << "-c"
+        args << container
+      elsif all_containers
+        args << "--all-containers"
+      end
+
+      args
+    end
+  end
+end

data/lib/kdep/renderer.rb

@@ -3,6 +3,22 @@ require "yaml"
 
 module Kdep
   class Renderer
+    # O app declara env_from para o Secret que o kdep renderiza, mas não há secrets.yml (ou está vazio):
+    # aplicar esse Secret sem `data` apagaria todas as chaves dele no cluster (incidente de 12/11/2026).
+    class MissingSecretsError < StandardError; end
+
+    # Preflight comum a bump/apply/helm: roda ANTES de qualquer build, helm upgrade ou apply.
+    # Erro -> mensagem + exit 1, nada aplicado. :skip -> aviso (o Secret do cluster fica intocado).
+    def self.preflight_secrets!(ui, renderer, resources)
+      return unless resources.include?("secret")
+
+      ui.warn(renderer.secret_skip_message) if renderer.check_secrets! == :skip
+    rescue MissingSecretsError => e
+      ui.error(e.message)
+      ui.error("nada foi aplicado")
+      exit 1
+    end
+
     # Convention: Infisical project slug = K8s namespace stripped of -stage/-dev
     # suffix; envSlug = stage/dev/prod derived from the same suffix.
     NS_ENV_SUFFIXES = { "-stage" => "stage", "-staging" => "stage", "-dev" => "dev" }.freeze
@@ -39,6 +55,7 @@ module Kdep
         return nil if secret_keys_for_env.empty?
         effective_config = @config.merge("infisical" => infisical_render_context)
       when "secret"
+        return nil if check_secrets! == :skip
         secrets = legacy_load_secrets
       end
 
@@ -179,5 +196,59 @@ module Kdep
       content = File.read(secrets_path)
       YAML.safe_load(content) || {}
     end
+
+    public
+
+    # Decide o que fazer com o Secret nativo (kdep/<deploy>/secrets.yml). Nunca aplica um Secret que apague chaves:
+    #   - secrets.yml com chaves, todas com valor        -> :render
+    #   - secrets.yml ausente ou vazio, env_from padrão  -> :skip (não renderiza; o Secret do cluster fica intocado)
+    #   - secrets.yml ausente ou vazio, env_from EXPLÍCITO para este Secret -> MissingSecretsError
+    #   - alguma chave com valor nil ou ""               -> MissingSecretsError (apagaria o valor no cluster)
+    # Incidente de 12/11/2026: o secret-mcp-leadfy-bi foi aplicado sem data e perdeu todas as chaves.
+    def check_secrets!
+      return :render if env_spec
+
+      secrets = legacy_load_secrets
+      unless secrets.is_a?(Hash)
+        raise MissingSecretsError, "#{secrets_path} não é um mapa CHAVE: valor"
+      end
+
+      if secrets.empty?
+        return :skip unless explicit_secret_ref?
+
+        state = File.exist?(secrets_path) ? "está vazio" : "não existe"
+        raise MissingSecretsError,
+              "#{secrets_path} #{state}, mas o app.yml tem env_from secret/#{secret_name}: " \
+              "aplicar o Secret sem data apagaria todas as chaves de #{secret_name} no cluster. " \
+              "Crie o secrets.yml com as chaves (ou tire o secret do env_from) antes de render/apply/bump."
+      end
+
+      vazias = secrets.select { |_k, v| v.nil? || v.to_s.empty? }.keys
+      unless vazias.empty?
+        raise MissingSecretsError,
+              "#{secrets_path}: chave(s) sem valor (#{vazias.join(", ")}). Aplicar assim apagaria o valor " \
+              "delas em #{secret_name} no cluster. Preencha ou remova antes de render/apply/bump."
+      end
+      :render
+    end
+
+    def secret_skip_message
+      "#{secrets_path} não existe (ou está vazio): o Secret #{secret_name} não é renderizado nem aplicado; " \
+        "o que estiver no cluster fica intocado (se ele não existir, o pod falha ao subir)."
+    end
+
+    private
+
+    def secret_name
+      @config["secret_name"] || "secret-#{@config["name"]}"
+    end
+
+    def secrets_path
+      File.join(@deploy_dir, "secrets.yml")
+    end
+
+    def explicit_secret_ref?
+      Array(@config["env_from"]).map(&:to_s).include?("secret/#{secret_name}")
+    end
   end
 end

data/lib/kdep/version.rb

@@ -1,3 +1,3 @@
 module Kdep
-  VERSION = "0.4.9"
+  VERSION = "0.6.0"
 end

data/lib/kdep/workload.rb

@@ -0,0 +1,37 @@
+require "kdep/preset"
+
+module Kdep
+  # The preset file lists the resources kdep applies, so the workload kind is
+  # declared there -- deriving it from the preset *name* got every
+  # non-Deployment target wrong (daemonset, statefulset, custom). Reading the
+  # list also handles `custom`, whose resources live in the deploy dir.
+  # Shared by `kdep restart` and `kdep bump --wait`.
+  module Workload
+    KINDS = %w[deployment statefulset daemonset].freeze
+    BATCH_KINDS = %w[job cronjob].freeze
+
+    def self.preset_resources(preset, deploy_dir)
+      Kdep::Preset.new(preset, deploy_dir).resources
+    rescue StandardError
+      []
+    end
+
+    # Workloads that have a rollout (restart / rollout status)
+    def self.rollout_kinds(resources)
+      resources & KINDS
+    end
+
+    # The workload's metadata.name, resolved exactly as the templates do.
+    def self.name_for(kind, config)
+      case kind
+      when "statefulset" then config["statefulset_name"] || config["deployment_name"] || config["name"]
+      when "daemonset"   then config["daemonset_name"] || config["name"]
+      else                    config["deployment_name"] || config["name"]
+      end
+    end
+
+    def self.batch_kind(resources)
+      resources.find { |r| BATCH_KINDS.include?(r) }
+    end
+  end
+end

data/lib/kdep.rb

@@ -5,6 +5,7 @@ require "kdep/yaml_compat"
 require "kdep/defaults"
 require "kdep/config"
 require "kdep/preset"
+require "kdep/workload"
 require "kdep/discovery"
 require "kdep/template_context"
 require "kdep/renderer"
@@ -12,6 +13,7 @@ require "kdep/validator"
 require "kdep/writer"
 require "kdep/old_format"
 require "kdep/kubectl"
+require "kdep/pod_logs"
 require "kdep/context_guard"
 require "kdep/cluster_health"
 require "kdep/docker"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kdep
 version: !ruby/object:Gem::Version
-  version: 0.4.9
+  version: 0.6.0
 platform: ruby
 authors:
 - Leadfy
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-10 00:00:00.000000000 Z
+date: 2026-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: envspec
@@ -131,6 +131,7 @@ files:
 - lib/kdep/kubectl.rb
 - lib/kdep/old_format.rb
 - lib/kdep/path_resolver.rb
+- lib/kdep/pod_logs.rb
 - lib/kdep/preset.rb
 - lib/kdep/registry.rb
 - lib/kdep/renderer.rb
@@ -143,6 +144,7 @@ files:
 - lib/kdep/validator.rb
 - lib/kdep/version.rb
 - lib/kdep/version_tagger.rb
+- lib/kdep/workload.rb
 - lib/kdep/writer.rb
 - lib/kdep/yaml_compat.rb
 - lib/kdep/yaml_duplicate_keys.rb