kettle-dev 2.5.11 → 2.5.13

data/lib/kettle/dev/ci_monitor.rb

@@ -4,6 +4,7 @@
 require "uri"
 require "json"
 require "net/http"
+require "kettle/ndjson"
 
 module Kettle
   module Dev
@@ -47,10 +48,10 @@ module Kettle
       #
       # @param restart_hint [String] guidance command shown on failure
       # @return [void]
-      def monitor_all!(restart_hint: "bundle exec kettle-release start_step=10", workflows: nil, **options)
+      def monitor_all!(restart_hint: "bundle exec kettle-release start_step=10", workflows: nil, keepalive: nil, event_recorder: nil, **options)
         checks_any = false
-        checks_any |= monitor_github_internal!(restart_hint: restart_hint, workflows: workflows)
-        checks_any |= monitor_gitlab_internal!(restart_hint: restart_hint)
+        checks_any |= monitor_github_internal!(restart_hint: restart_hint, workflows: workflows, keepalive: keepalive, event_recorder: event_recorder)
+        checks_any |= monitor_gitlab_internal!(restart_hint: restart_hint, keepalive: keepalive, event_recorder: event_recorder)
         abort("CI configuration not detected (GitHub or GitLab). Ensure CI is configured and remotes point to the correct hosts.") unless checks_any
       end
 
@@ -267,7 +268,7 @@ module Kettle
       end
       module_function :collect_gitlab
 
-      def monitor_github_internal!(restart_hint:, workflows: nil)
+      def monitor_github_internal!(restart_hint:, workflows: nil, keepalive: nil, event_recorder: nil)
         root = Kettle::Dev::CIHelpers.project_root
         workflows = Array(workflows).empty? ? Kettle::Dev::CIHelpers.workflows_list(root) : Array(workflows)
         gh_remote = preferred_github_remote
@@ -288,8 +289,31 @@ module Kettle
 
         passed = {}
         started = {}
+        emit_ci_monitor_event(
+          event_recorder,
+          action: "github_discover",
+          status: "started",
+          provider: "github",
+          remote: gh_remote,
+          owner: owner,
+          repo: repo,
+          branch: branch,
+          head_sha: head_sha,
+          workflows: workflows,
+          total: total
+        )
         puts "Ensuring GitHub Actions workflows pass on #{branch} (#{owner}/#{repo}) via remote '#{gh_remote}'"
         puts "Waiting for GitHub Actions runs to start for HEAD #{head_sha[0, 12]}."
+        emit_ci_monitor_event(
+          event_recorder,
+          action: "github_wait",
+          status: "started",
+          provider: "github",
+          branch: branch,
+          head_sha: head_sha,
+          completed: 0,
+          total: total
+        )
         pbar = if defined?(ProgressBar)
           ProgressBar.create(title: "CI", total: total, format: "%t %b %c/%C", length: 30)
         end
@@ -306,27 +330,107 @@ module Kettle
         start_timeout = github_start_timeout
         poll_interval = github_poll_interval
         start_deadline = monotonic_time + start_timeout
+        keepalive_timer = keepalive_timer(keepalive)
         idx = 0
+        all_started_emitted = false
         loop do
+          keepalive_timer.call
           wf = workflows[idx]
           run = Kettle::Dev::CIHelpers.latest_run(owner: owner, repo: repo, workflow_file: wf, branch: branch, require_head: true, head_sha: head_sha)
+          completed_workflow = nil
           if run
-            started[wf] = true
+            unless started[wf]
+              started[wf] = true
+              emit_ci_monitor_event(
+                event_recorder,
+                action: "github_workflow",
+                status: "started",
+                provider: "github",
+                workflow: wf,
+                url: run["html_url"],
+                run_status: run["status"],
+                conclusion: run["conclusion"],
+                completed: passed.size,
+                total: total
+              )
+            end
+            if started.size == total && !all_started_emitted
+              all_started_emitted = true
+              emit_ci_monitor_event(
+                event_recorder,
+                action: "github_started",
+                status: "ok",
+                provider: "github",
+                completed: passed.size,
+                total: total,
+                started: started.size
+              )
+            end
             if Kettle::Dev::CIHelpers.success?(run)
               unless passed[wf]
                 passed[wf] = true
+                completed_workflow = wf
                 pbar&.increment
+                emit_ci_monitor_event(
+                  event_recorder,
+                  action: "github_workflow",
+                  status: "ok",
+                  provider: "github",
+                  workflow: wf,
+                  url: run["html_url"],
+                  run_status: run["status"],
+                  conclusion: run["conclusion"],
+                  completed: passed.size,
+                  total: total
+                )
               end
             elsif Kettle::Dev::CIHelpers.failed?(run)
               puts
               wf_url = run["html_url"] || "https://github.com/#{owner}/#{repo}/actions/workflows/#{wf}"
+              emit_ci_monitor_event(
+                event_recorder,
+                action: "github_workflow",
+                status: "failed",
+                provider: "github",
+                workflow: wf,
+                url: wf_url,
+                run_status: run["status"],
+                conclusion: run["conclusion"],
+                completed: passed.size,
+                total: total,
+                reason: "Workflow failed"
+              )
               abort("Workflow failed: #{wf} -> #{wf_url} Fix the workflow, then restart this tool from CI validation with: #{restart_hint}")
             end
           end
+          emit_ci_monitor_event(
+            event_recorder,
+            action: "github_tick",
+            status: "started",
+            provider: "github",
+            workflow: wf,
+            run_status: run && run["status"],
+            conclusion: run && run["conclusion"],
+            completed_workflow: completed_workflow,
+            completed: passed.size,
+            total: total,
+            started: started.size
+          )
           break if passed.size == total
           if started.size < total && monotonic_time >= start_deadline
             missing = (workflows - started.keys).join(", ")
             puts
+            emit_ci_monitor_event(
+              event_recorder,
+              action: "github_timeout",
+              status: "failed",
+              provider: "github",
+              missing: workflows - started.keys,
+              head_sha: head_sha,
+              total: total,
+              completed: passed.size,
+              reason: "Timed out waiting for workflows to start"
+            )
             abort("Timed out after #{start_timeout}s waiting for GitHub Actions workflows to start for HEAD #{head_sha[0, 12]}: #{missing}. Confirm GitHub Actions started, then restart this tool from CI validation with: #{restart_hint}")
           end
 
@@ -334,6 +438,15 @@ module Kettle
           sleep(poll_interval)
         end
         pbar&.finish unless pbar&.finished?
+        emit_ci_monitor_event(
+          event_recorder,
+          action: "github_complete",
+          status: "ok",
+          provider: "github",
+          workflows: workflows,
+          completed: passed.size,
+          total: total
+        )
         puts "\nAll GitHub workflows passing (#{passed.size}/#{total})."
         true
       end
@@ -364,7 +477,32 @@ module Kettle
       end
       module_function :github_poll_interval
 
-      def monitor_gitlab_internal!(restart_hint:)
+      def keepalive_timer(keepalive)
+        interval = keepalive_interval
+        last_run = nil
+        lambda do
+          if keepalive
+            now = monotonic_time
+            if !last_run || (now - last_run) >= interval
+              keepalive.call
+              last_run = now
+            end
+          end
+        end
+      end
+      module_function :keepalive_timer
+
+      def keepalive_interval
+        seconds = begin
+          Float(ENV["KETTLE_RELEASE_SECRET_KEEPALIVE_INTERVAL"])
+        rescue
+          nil
+        end
+        (seconds && seconds >= 0) ? seconds : 240.0
+      end
+      module_function :keepalive_interval
+
+      def monitor_gitlab_internal!(restart_hint:, keepalive: nil, event_recorder: nil)
         root = Kettle::Dev::CIHelpers.project_root
         gitlab_ci = File.exist?(File.join(root, ".gitlab-ci.yml"))
         gl_remote = gitlab_remote_candidates.first
@@ -376,15 +514,39 @@ module Kettle
         owner, repo = Kettle::Dev::CIHelpers.repo_info_gitlab
         return false unless owner && repo
 
+        emit_ci_monitor_event(
+          event_recorder,
+          action: "gitlab_discover",
+          status: "started",
+          provider: "gitlab",
+          remote: gl_remote,
+          owner: owner,
+          repo: repo,
+          branch: branch,
+          total: 1
+        )
         puts "Ensuring GitLab pipeline passes on #{branch} (#{owner}/#{repo}) via remote '#{gl_remote}'"
         pbar = if defined?(ProgressBar)
           ProgressBar.create(title: "CI", total: 1, format: "%t %b %c/%C", length: 30)
         end
+        keepalive_timer = keepalive_timer(keepalive)
         loop do
+          keepalive_timer.call
           pipe = Kettle::Dev::CIHelpers.gitlab_latest_pipeline(owner: owner, repo: repo, branch: branch)
           if pipe
+            pipe_url = pipe["web_url"] || "https://gitlab.com/#{owner}/#{repo}/-/pipelines"
             if Kettle::Dev::CIHelpers.gitlab_success?(pipe)
               pbar&.increment unless pbar&.finished?
+              emit_ci_monitor_event(
+                event_recorder,
+                action: "gitlab_pipeline",
+                status: "ok",
+                provider: "gitlab",
+                url: pipe_url,
+                run_status: pipe["status"],
+                completed: 1,
+                total: 1
+              )
               break
             elsif Kettle::Dev::CIHelpers.gitlab_failed?(pipe)
               # Special-case: if failure is due to exhausted minutes/insufficient quota, treat as unknown and continue
@@ -392,27 +554,93 @@ module Kettle
               if /insufficient|quota|minute/i.match?(reason)
                 puts "\nGitLab reports pipeline cannot run due to quota/minutes exhaustion. Result is unknown; continuing."
                 pbar&.finish unless pbar&.finished?
+                emit_ci_monitor_event(
+                  event_recorder,
+                  action: "gitlab_pipeline",
+                  status: "skipped",
+                  provider: "gitlab",
+                  url: pipe_url,
+                  run_status: pipe["status"],
+                  reason: reason,
+                  completed: 0,
+                  total: 1
+                )
                 break
               else
                 puts
-                url = pipe["web_url"] || "https://gitlab.com/#{owner}/#{repo}/-/pipelines"
+                emit_ci_monitor_event(
+                  event_recorder,
+                  action: "gitlab_pipeline",
+                  status: "failed",
+                  provider: "gitlab",
+                  url: pipe_url,
+                  run_status: pipe["status"],
+                  reason: reason,
+                  completed: 0,
+                  total: 1
+                )
+                url = pipe_url
                 abort("Pipeline failed: #{url} Fix the pipeline, then restart this tool from CI validation with: #{restart_hint}")
               end
             elsif pipe["status"] == "blocked"
               # Blocked pipeline (e.g., awaiting approvals) — treat as unknown and continue
               puts "\nGitLab pipeline is blocked. Result is unknown; continuing."
               pbar&.finish unless pbar&.finished?
+              emit_ci_monitor_event(
+                event_recorder,
+                action: "gitlab_pipeline",
+                status: "skipped",
+                provider: "gitlab",
+                url: pipe_url,
+                run_status: pipe["status"],
+                reason: "blocked",
+                completed: 0,
+                total: 1
+              )
               break
             end
           end
           sleep(1)
         end
         pbar&.finish unless pbar&.finished?
+        emit_ci_monitor_event(
+          event_recorder,
+          action: "gitlab_complete",
+          status: "ok",
+          provider: "gitlab",
+          completed: 1,
+          total: 1
+        )
         puts "\nGitLab pipeline passing."
         true
       end
       module_function :monitor_gitlab_internal!
 
+      def emit_ci_monitor_event(event_recorder, action:, status:, provider:, **payload)
+        mark = case status.to_s
+        when "started"
+          ">"
+        when "ok", "skipped"
+          "."
+        when "failed"
+          "!"
+        else
+          "?"
+        end
+        Kettle::Ndjson.emit_event(
+          event_recorder,
+          "ci_monitor",
+          payload.merge(
+            action: action,
+            phase: "release",
+            provider: provider,
+            status: status,
+            mark: mark
+          )
+        )
+      end
+      module_function :emit_ci_monitor_event
+
       # -- tiny wrappers around GitAdapter-like helpers used by ReleaseCLI --
       def remotes_with_urls
         Kettle::Dev::GitAdapter.new.remotes_with_urls

data/lib/kettle/dev/interactive_release_command.rb

@@ -5,11 +5,12 @@ require "open3"
 module Kettle
   module Dev
     class InteractiveReleaseCommand
-      def initialize(secrets_provider:, input: $stdin, output: $stdout, error: $stderr)
+      def initialize(secrets_provider:, input: $stdin, output: $stdout, error: $stderr, secret_event_handler: nil)
         @secrets_provider = secrets_provider
         @input = input
         @output = output
         @error = error
+        @secret_event_handler = secret_event_handler
         @gem_signing_passphrase = nil
       end
 
@@ -21,7 +22,7 @@ module Kettle
 
       private
 
-      attr_reader :secrets_provider
+      attr_reader :secrets_provider, :secret_event_handler
 
       def call_with_pty(env, cmd)
         stdout_str = +""
@@ -77,18 +78,20 @@ module Kettle
 
       def handle_prompt(input, chunk)
         if otp_prompt?(chunk)
-          write_secret(input, secrets_provider.rubygems_otp, label: "RubyGems MFA code") if otp_response_prompt?(chunk)
+          write_secret(input, label: "RubyGems MFA code", source: "rubygems_otp") { secrets_provider.rubygems_otp } if otp_response_prompt?(chunk)
           return
         end
 
-        write_secret(input, gem_signing_passphrase, label: "gem signing passphrase") if signing_password_prompt?(chunk)
+        write_secret(input, label: "gem signing passphrase", source: "gem_signing_passphrase") { gem_signing_passphrase } if signing_password_prompt?(chunk)
       end
 
       def gem_signing_passphrase
         @gem_signing_passphrase ||= secrets_provider.gem_signing_passphrase.to_s
       end
 
-      def write_secret(input, value, label:)
+      def write_secret(input, label:, source:)
+        emit_secret_event(source: source, action: "prompt_response", status: "started", label: label)
+        value = yield
         secret = value.to_s
         if secret.empty?
           raise Kettle::Dev::Error, "#{label} prompt reached, but the configured release secrets provider returned no value. Aborting because secret prompts are not allowed when a secrets provider is configured."
@@ -97,6 +100,14 @@ module Kettle
         @output.puts("#{label} loaded from configured secrets provider.")
         input.write("#{secret}\n")
         input.flush
+        emit_secret_event(source: source, action: "prompt_response", status: "ok", label: label)
+      rescue Kettle::Dev::Error => error
+        emit_secret_event(source: source, action: "prompt_response", status: "failed", label: label, reason: error.message)
+        raise
+      end
+
+      def emit_secret_event(payload)
+        secret_event_handler&.call(payload)
       end
 
       def otp_prompt?(chunk)

data/lib/kettle/dev/lockfile_reset.rb

@@ -79,12 +79,34 @@ module Kettle
           command << " #{key}=#{Shellwords.escape(value)}"
         end
         command << " bundle lock"
+        reset_platforms(path).each do |platform|
+          command << " --add-platform=#{Shellwords.escape(platform)}"
+        end
         command << " --update"
         command << " #{update_gems.map { |gem_name| Shellwords.escape(gem_name) }.join(" ")}" unless update_gems.empty?
         command << " --add-checksums"
         command
       end
 
+      def reset_platforms(path)
+        (lockfile_platforms(path) | [Gem::Platform.local.to_s]).reject(&:empty?).sort
+      end
+
+      def lockfile_platforms(path)
+        in_platforms = false
+        File.readlines(path).filter_map do |line|
+          stripped = line.strip
+          if stripped.match?(/\A[A-Z][A-Z ]*\z/)
+            in_platforms = stripped == "PLATFORMS"
+            next
+          end
+          next unless in_platforms
+          next if stripped.empty?
+
+          stripped
+        end
+      end
+
       def reset_update_gems(path)
         (
           path_source_gems(path).to_a |

data/lib/kettle/dev/pre_release_cli.rb

@@ -10,6 +10,7 @@ require "net/http"
 require "openssl"
 require "time"
 require_relative "cache_progress"
+require "kettle/ndjson"
 begin
   require "addressable/uri"
 rescue LoadError
@@ -271,9 +272,10 @@ module Kettle
       end
 
       # @param check_num [Integer] 1-based index to resume from
-      def initialize(check_num: 1)
+      def initialize(check_num: 1, event_recorder: nil)
         @check_num = (check_num || 1).to_i
         @check_num = 1 if @check_num < 1
+        @event_recorder = event_recorder
         @image_url_cache_path = configured_image_url_cache_path
         @refresh_image_url_cache = env_truthy?(ENV["KETTLE_IMAGE_URL_CACHE_REFRESH"])
         @image_url_skip_patterns = configured_image_url_skip_patterns
@@ -294,7 +296,14 @@ module Kettle
         checks[begin_idx..-1].each_with_index do |check, i|
           idx = begin_idx + i + 1
           puts "[kettle-pre-release] Running check ##{idx} of #{checks.size}"
-          check.call
+          emit_pre_release_event(action: "check", status: "started", check: check_name(check), index: idx, total: checks.size)
+          begin
+            check.call
+            emit_pre_release_event(action: "check", status: "ok", check: check_name(check), index: idx, total: checks.size)
+          rescue => error
+            emit_pre_release_event(action: "check", status: "failed", check: check_name(check), index: idx, total: checks.size, reason: "#{error.class}: #{error.message}")
+            raise
+          end
         end
         nil
       end
@@ -335,8 +344,7 @@ module Kettle
           modified = false
 
           urls.each do |url_str|
-            addr = Addressable::URI.parse(url_str)
-            normalized = addr.normalize.to_s
+            normalized = normalized_markdown_image_url(url_str)
             next if normalized == url_str
 
             # Replace exact occurrences of the URL in the markdown content
@@ -356,9 +364,17 @@ module Kettle
         end
 
         puts "[kettle-pre-release] Normalization candidates: #{total_candidates}. Files changed: #{changed.uniq.size}."
+        emit_pre_release_event(action: "markdown_urls", status: "ok", candidates: total_candidates, changed_files: changed.uniq.size)
         nil
       end
 
+      def normalized_markdown_image_url(url_str)
+        addr = Addressable::URI.parse(url_str)
+        normalized = addr.normalize
+        normalized.query = addr.query if addr.query && normalized.query != addr.query
+        normalized.to_s
+      end
+
       # Check 3: Validate Markdown image links by cached HTTP HEAD/GET.
       # @return [void]
       def check_markdown_images_http!
@@ -402,10 +418,12 @@ module Kettle
         puts "[kettle-pre-release] Image URL checks: #{progress.cached_count} cached, #{progress.live_count} live."
         puts "[kettle-pre-release] Skipped #{progress.skipped_count} image URL check(s)." if skipped.any?
         if failures.any?
+          emit_pre_release_event(action: "image_links", status: "failed", urls: urls.size, cached: progress.cached_count, live: progress.live_count, skipped: progress.skipped_count, failures: failures.size)
           warn("[kettle-pre-release] #{failures.size} image URL(s) failed validation:")
           failures.each { |u| warn("  - #{u}") }
           Kettle::Dev::ExitAdapter.abort("Image link validation failed")
         else
+          emit_pre_release_event(action: "image_links", status: "ok", urls: urls.size, cached: progress.cached_count, live: progress.live_count, skipped: progress.skipped_count, failures: 0)
           puts "[kettle-pre-release] All image links validated."
         end
         nil
@@ -413,6 +431,33 @@ module Kettle
 
       private
 
+      def check_name(check)
+        check.name.to_s.sub(/\Acheck_/, "").sub(/!\z/, "")
+      end
+
+      def emit_pre_release_event(action:, status:, **payload)
+        mark = case status.to_s
+        when "started"
+          ">"
+        when "ok", "skipped"
+          "."
+        when "failed"
+          "!"
+        else
+          "?"
+        end
+        Kettle::Ndjson.emit_event(
+          @event_recorder,
+          "pre_release",
+          payload.merge(
+            action: action,
+            phase: "release",
+            status: status,
+            mark: mark
+          )
+        )
+      end
+
       def image_url_cache
         return nil if @image_url_cache_path.to_s.empty?