fastlane-plugin-wpmreleasetoolkit 14.6.0 → 14.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 787be90be7c62894c1cbee1a45d28d7815991f7158a654703f31c8db0d541f61
-  data.tar.gz: 8f6312bdc9f3ecd5f9fbc17a78d22b91483cd7ee7d4e4fa511b9bb367a26c08c
+  metadata.gz: 614ca9504d0baa99cc411f83e7bb94f179260a0e8154d738aecfed47a4de7ce5
+  data.tar.gz: 7edfec9cb051abe68182905d8ee0620c73a0da73c02e829e7dcb69f1593ea49e
 SHA512:
-  metadata.gz: f23b5d15c71550aa20af5536f2f6517a780f4cc2a0a286e21316a431e803bcd29e66dd2e93432d1998ebb922ff72b80f0fbeaabcbf5472fb1dbf3dd600900134
-  data.tar.gz: a69a5537a36109cdb5442c3a0c302ccc0bc8702c6380c6ac68c4c9a7beb95d0777996f53505de54f4142a4fd1f9cd6e1637d726c917a751f43529d9427825fe9
+  metadata.gz: 32d6b0a90838debf53ba8fc6c5fbdf729a5159a12c0b69ffa8be1709cca3be571d28e1471d2736bb911c97f67d6720b2aec2320bbcd221362a873b14d597ecf0
+  data.tar.gz: d9170171309d3b0f11cf102757bd4bdcdc380ef207f7b06d17e2f03e4aef17094c77bf84e1eba17de43cf2e29f833b9a8de4277dab853118a26ba6fa23e391d2

data/lib/fastlane/plugin/wpmreleasetoolkit/actions/common/find_or_create_pull_request_action.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require 'fastlane/action'
+require_relative '../../helper/github_helper'
+
+module Fastlane
+  module Actions
+    class FindOrCreatePullRequestAction < Action
+      def self.run(params)
+        github_helper = Fastlane::Helper::GithubHelper.new(github_token: params[:github_token])
+
+        existing_pr = github_helper.find_pull_request(
+          repository: params[:repository],
+          head: params[:head],
+          base: params[:base]
+        )
+
+        unless existing_pr.nil?
+          UI.message("An open Pull Request already exists for `#{params[:head]}`: #{existing_pr.html_url}")
+          return existing_pr.html_url
+        end
+
+        other_action.create_pull_request(
+          api_url: params[:api_url],
+          api_token: params[:github_token],
+          repo: params[:repository],
+          title: params[:title],
+          body: params[:body],
+          draft: params[:draft],
+          head: params[:head],
+          base: params[:base],
+          labels: params[:labels],
+          assignees: params[:assignees],
+          reviewers: params[:reviewers],
+          team_reviewers: params[:team_reviewers],
+          milestone: params[:milestone]
+        )
+      end
+
+      def self.description
+        'Returns the URL of the open Pull Request for a head branch, creating one if none exists yet'
+      end
+
+      def self.details
+        <<~DETAILS
+          Looks for an open Pull Request whose head is the given branch and which targets the given base,
+          and returns its URL if found. Otherwise, creates a new Pull Request and returns its URL.
+
+          This is useful for "rolling" automations (e.g. a daily translations or dependency-update job) that
+          force-push the same head branch on every run: GitHub automatically refreshes the diff of the existing
+          PR, so this action only needs to open a PR the first time.
+        DETAILS
+      end
+
+      def self.authors
+        ['Automattic']
+      end
+
+      def self.return_type
+        :string
+      end
+
+      def self.return_value
+        'The URL of the existing or newly-created Pull Request'
+      end
+
+      def self.available_options
+        # Parameters we forward as-is from Fastlane's `create_pull_request` action
+        forwarded_param_keys = %i[
+          api_url
+          draft
+          labels
+          assignees
+          reviewers
+          team_reviewers
+          milestone
+        ].freeze
+
+        forwarded_params = Fastlane::Actions::CreatePullRequestAction.available_options.select do |opt|
+          forwarded_param_keys.include?(opt.key)
+        end
+
+        [
+          *forwarded_params,
+          Fastlane::Helper::GithubHelper.github_token_config_item, # forwarded to `api_token` in the `create_pull_request` action
+          FastlaneCore::ConfigItem.new(
+            key: :repository,
+            env_name: 'GHHELPER_REPOSITORY',
+            description: 'The remote path of the GH repository on which we work, e.g. `wordpress-mobile/wordpress-ios`',
+            optional: false,
+            type: String
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :title,
+            description: 'The title of the Pull Request to create if none exists yet',
+            optional: false,
+            type: String
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :body,
+            description: 'The body of the Pull Request to create if none exists yet',
+            optional: true,
+            type: String
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :head,
+            description: 'The head branch of the Pull Request (the branch with the changes)',
+            optional: false,
+            type: String
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :base,
+            description: 'The base branch the Pull Request targets (e.g. `trunk`)',
+            optional: false,
+            type: String
+          ),
+        ]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/wpmreleasetoolkit/actions/common/openai_ask_action.rb

@@ -8,8 +8,10 @@ module Fastlane
   module Actions
     class OpenaiAskAction < Action
       OPENAI_API_ENDPOINT = URI('https://api.openai.com/v1/chat/completions').freeze
+      # Preserve the previous `max_tokens` ceiling while using the current API field.
+      DEFAULT_MAX_COMPLETION_TOKENS = 2048
       DEFAULT_MAX_TOOL_ITERATIONS = 5
-      DEFAULT_MODEL = 'gpt-4o'
+      DEFAULT_MODEL = 'gpt-4.1'
 
       PREDEFINED_PROMPTS = {
         release_notes: <<~PROMPT
@@ -39,12 +41,16 @@ module Fastlane
         }
 
         # Backwards-compatible single-shot path when no tools are provided.
-        if tools.nil? || tools.empty?
+        if tools.nil?
           body = request_body(prompt: prompt, question: question, model: model)
           response = Net::HTTP.post(OPENAI_API_ENDPOINT, body, headers)
           return parse_text_response(response)
         end
 
+        validate_tools_array!(tools)
+        validate_max_tool_iterations!(max_tool_iterations)
+        validate_tools!(tools)
+
         run_with_tools(
           prompt: prompt,
           question: question,
@@ -62,7 +68,9 @@ module Fastlane
           format_message(role: 'user', text: question),
         ].compact
 
-        max_tool_iterations.times do
+        tool_iterations = 0
+
+        loop do
           body = request_body_with_messages(messages: messages, tools: tools, model: model)
           response = Net::HTTP.post(OPENAI_API_ENDPOINT, body, headers)
           assistant_message = parse_assistant_message(response)
@@ -71,26 +79,31 @@ module Fastlane
           # No tool calls — model produced a final answer.
           return assistant_message['content'] if tool_calls.nil? || tool_calls.empty?
 
+          if tool_iterations >= max_tool_iterations
+            UI.user_error!(
+              "OpenAI tool-use loop did not produce a final answer after #{max_tool_iterations} tool iterations. " \
+              'Refusing to execute additional tool calls. Increase `max_tool_iterations` or check that your prompt instructs the model to stop calling tools.'
+            )
+          end
+
           # Append the assistant's tool-call message verbatim, then run each handler
           # and append the corresponding `role: tool` results.
           messages << assistant_message
           tool_calls.each do |tool_call|
             messages << execute_tool_call(tool_call, tool_handlers)
           end
-        end
 
-        UI.user_error!(
-          "OpenAI tool-use loop did not terminate after #{max_tool_iterations} iterations. " \
-          'Increase `max_tool_iterations` or check that your prompt instructs the model to stop calling tools.'
-        )
+          tool_iterations += 1
+        end
       end
 
       def self.request_body(prompt:, question:, model: DEFAULT_MODEL)
         {
           model: model,
+          store: false,
           response_format: { type: 'text' },
           temperature: 1,
-          max_tokens: 2048,
+          max_completion_tokens: DEFAULT_MAX_COMPLETION_TOKENS,
           top_p: 1,
           messages: [
             format_message(role: 'system', text: prompt),
@@ -102,9 +115,10 @@ module Fastlane
       def self.request_body_with_messages(messages:, tools:, model: DEFAULT_MODEL)
         {
           model: model,
+          store: false,
           response_format: { type: 'text' },
           temperature: 1,
-          max_tokens: 2048,
+          max_completion_tokens: DEFAULT_MAX_COMPLETION_TOKENS,
           top_p: 1,
           messages: messages,
           tools: tools
@@ -140,8 +154,49 @@ module Fastlane
         end
       end
 
+      def self.validate_max_tool_iterations!(max_tool_iterations)
+        UI.user_error!("Parameter `max_tool_iterations` must be an Integer (got #{max_tool_iterations.class})") unless max_tool_iterations.is_a?(Integer)
+        UI.user_error!("Parameter `max_tool_iterations` must be >= 1 (got #{max_tool_iterations})") if max_tool_iterations < 1
+      end
+
+      def self.validate_tools_array!(tools)
+        UI.user_error!('Parameter `tools` must be a non-empty Array when provided') unless tools.is_a?(Array) && !tools.empty?
+      end
+
+      def self.validate_tools!(tools)
+        invalid_tools = tools.each_with_index.filter_map do |tool, index|
+          type = tool_type(tool)
+          next "tools[#{index}] type #{type.nil? ? '<missing>' : type.inspect}" unless type == 'function'
+
+          function = tool[:function] || tool['function']
+          name = function[:name] || function['name'] if function.is_a?(Hash)
+          next if valid_tool_name?(name)
+
+          "tools[#{index}] missing function.name"
+        end
+
+        return if invalid_tools.empty?
+
+        UI.user_error!(
+          'Parameter `tools` only supports OpenAI function tools with a non-empty `function.name`. ' \
+          "Invalid tool definitions: #{invalid_tools.join(', ')}"
+        )
+      end
+
+      def self.tool_type(tool)
+        return nil unless tool.is_a?(Hash)
+
+        (tool[:type] || tool['type'])&.to_s
+      end
+
+      def self.valid_tool_name?(name)
+        (name.is_a?(String) || name.is_a?(Symbol)) && !name.to_s.empty?
+      end
+
       def self.execute_tool_call(tool_call, tool_handlers)
-        name = tool_call.dig('function', 'name')
+        return unsupported_tool_call_result(tool_call) unless function_tool_call?(tool_call)
+
+        name = tool_call.dig('function', 'name').to_s
         raw_args = tool_call.dig('function', 'arguments') || '{}'
 
         result =
@@ -151,8 +206,8 @@ module Fastlane
           rescue JSON::ParserError
             # Short-circuit: the handler never sees malformed args. Tell the model the
             # tool-call payload was invalid so it can retry with valid JSON, and log the
-            # raw arguments locally for debugging without forwarding them to the API.
-            UI.error("Invalid JSON arguments for tool '#{name}'. Raw payload: #{raw_args}")
+            # local failure without recording raw arguments that might contain secrets.
+            UI.error("Invalid JSON arguments for tool '#{name}' in tool call '#{tool_call['id']}'. Raw payload omitted because it may contain secrets.")
             { error: "Invalid JSON arguments for tool '#{name}' — payload could not be parsed. Retry with valid JSON." }
           end
 
@@ -163,6 +218,40 @@ module Fastlane
         }
       end
 
+      def self.function_tool_call?(tool_call)
+        return false unless tool_call['type'] == 'function'
+        return false unless tool_call['function'].is_a?(Hash)
+
+        name = tool_call.dig('function', 'name')
+        valid_tool_name?(name)
+      end
+
+      def self.unsupported_tool_call_result(tool_call)
+        type = tool_call['type'] || '<missing>'
+        error =
+          if type == 'function'
+            'Function tool call is missing a non-empty function.name.'
+          else
+            "Unsupported tool call type '#{type}'. Only function tool calls are supported."
+          end
+        log_message =
+          if type == 'function'
+            "Invalid OpenAI function tool call '#{tool_call['id']}': missing a non-empty function.name."
+          else
+            "Unsupported OpenAI tool call type '#{type}' in tool call '#{tool_call['id']}'. Only function tool calls are supported."
+          end
+        UI.error(log_message)
+
+        {
+          role: 'tool',
+          tool_call_id: tool_call['id'],
+          content: serialize_tool_result(
+            name: type,
+            result: { error: error }
+          )
+        }
+      end
+
       # Serializes a tool result to a JSON string. Handlers are contracted to return
       # JSON-serializable values, but a buggy handler might return something like a
       # `Pathname`, `Proc`, or a custom object whose `to_json` raises. Failing the
@@ -175,7 +264,7 @@ module Fastlane
       def self.serialize_tool_result(name:, result:)
         JSON.generate(result)
       rescue StandardError => e
-        UI.error("Could not serialize tool result for '#{name}': #{e.class}: #{e.message}. Result class: #{result.class}")
+        UI.error("Could not serialize tool result for '#{name}': #{e.class}. Result class: #{result.class}. Error message omitted because it may contain secrets.")
         JSON.generate({ error: "Tool result for '#{name}' could not be serialized to JSON. Returned class: #{result.class}." })
       end
 
@@ -185,9 +274,9 @@ module Fastlane
       #
       # - Missing or non-callable handler: structured `{ error: ... }` so the model can recover.
       # - Handler raised: structured `{ error:, exception: }` carrying only the exception class
-      #   so the model can see the failure category and adjust. The full message and backtrace
-      #   are logged locally via `UI.error` but NOT forwarded to the model, because tool
-      #   results are sent to OpenAI and handler exception messages can contain secrets
+      #   so the model can see the failure category and adjust. The exception message and
+      #   backtrace are intentionally omitted from local logs and from the model response
+      #   because tool results and CI logs can expose release secrets
       #   (tokens, file contents, internal API responses). The loop keeps going rather than
       #   aborting the lane mid-conversation — the model is the better judge of whether the
       #   failure is recoverable than a global `rescue` here.
@@ -198,7 +287,7 @@ module Fastlane
         begin
           handler.call(args)
         rescue StandardError => e
-          UI.error("Handler for tool '#{name}' raised #{e.class}: #{e.message}\n#{e.backtrace&.first(5)&.join("\n")}")
+          UI.error("Handler for tool '#{name}' raised #{e.class}. Error message and backtrace omitted because they may contain secrets.")
           { error: "Handler for tool '#{name}' raised an exception", exception: e.class.name }
         end
       end
@@ -228,7 +317,8 @@ module Fastlane
           When `tools` and `tool_handlers` are provided, the action runs a tool-use (function-calling) loop:
           on each turn, if the model calls one or more tools, the corresponding handler is invoked locally
           and its return value is sent back to the model as a `role: tool` message. The loop ends when the
-          model returns a plain text response, or when `max_tool_iterations` is reached.
+          model returns a plain text response, or before executing tool calls beyond `max_tool_iterations`.
+          The model gets one final API turn to answer after the last permitted local tool execution round.
         DETAILS
       end
 
@@ -306,19 +396,20 @@ module Fastlane
                                        sensitive: true,
                                        type: String),
           FastlaneCore::ConfigItem.new(key: :model,
-                                       description: 'The OpenAI model to send the request to (e.g. `gpt-4o`, `gpt-4o-mini`, `gpt-4.1`). ' \
+                                       description: 'The OpenAI model to send the request to (e.g. `gpt-4.1`, `gpt-4.1-mini`, `gpt-4o`). ' \
                                                     "Defaults to `#{DEFAULT_MODEL}`",
                                        optional: true,
                                        default_value: DEFAULT_MODEL,
                                        type: String),
           FastlaneCore::ConfigItem.new(key: :tools,
-                                       description: 'Optional array of tool (function-calling) definitions in OpenAI format. ' \
+                                       description: 'Optional array of OpenAI function tool definitions. Each definition must have a non-empty `function.name`. ' \
                                                     'When provided, the action runs a tool-use loop',
                                        optional: true,
                                        default_value: nil,
                                        type: Array,
                                        verify_block: proc do |value|
-                                         UI.user_error!('Parameter `tools` must be a non-empty Array when provided') if value.empty?
+                                         validate_tools_array!(value)
+                                         validate_tools!(value)
                                        end),
           FastlaneCore::ConfigItem.new(key: :tool_handlers,
                                        description: 'Hash of tool name to a callable (e.g. a Proc) invoked when the model calls that tool. ' \
@@ -332,13 +423,14 @@ module Fastlane
                                          UI.user_error!("Parameter `tool_handlers` values must respond to :call. Non-callable handlers: #{non_callable.keys}") if non_callable.any?
                                        end),
           FastlaneCore::ConfigItem.new(key: :max_tool_iterations,
-                                       description: 'Maximum number of tool-use loop iterations before the action fails. ' \
+                                       description: 'Maximum number of local tool execution rounds before the action fails. ' \
+                                                    'The model can receive one final API turn to answer after the last permitted tool result. ' \
                                                     'Only used when `tools` are provided',
                                        optional: true,
                                        default_value: DEFAULT_MAX_TOOL_ITERATIONS,
                                        type: Integer,
                                        verify_block: proc do |value|
-                                         UI.user_error!("Parameter `max_tool_iterations` must be >= 1 (got #{value})") if value < 1
+                                         validate_max_tool_iterations!(value)
                                        end),
         ]
       end

data/lib/fastlane/plugin/wpmreleasetoolkit/actions/common/update_apps_cdn_build_metadata.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require 'fastlane/action'
+require 'net/http'
+require 'json'
+require_relative '../../helper/apps_cdn_helper'
+
+module Fastlane
+  module Actions
+    class UpdateAppsCdnBuildMetadataAction < Action
+      def self.run(params)
+        post_ids = params[:post_ids]
+        UI.message("Updating Apps CDN build metadata for #{post_ids.size} post(s): #{post_ids.join(', ')}...")
+
+        # Build the JSON body for the dedicated Apps CDN builds endpoint, which accepts
+        # the same string-based format as the upload flow (e.g. `visibility: 'Internal'`)
+        body = {}
+        body['post_status'] = params[:post_status] if params[:post_status]
+        body['visibility'] = params[:visibility].to_s.capitalize if params[:visibility]
+
+        UI.user_error!('No metadata to update. Provide at least one of: visibility, post_status') if body.empty?
+
+        results = post_ids.map do |post_id|
+          update_single_post(site_id: params[:site_id], api_token: params[:api_token], post_id: post_id, body: body)
+        end
+
+        UI.success("Successfully updated Apps CDN build metadata for #{results.size} post(s)")
+        results
+      end
+
+      # Update a single CDN build post with the given body via the dedicated
+      # `/wpcom/v2/sites/{site_id}/a8c-cdn/builds/{post_id}` endpoint.
+      #
+      # @param site_id [String] the WordPress.com site ID
+      # @param api_token [String] the WordPress.com API bearer token
+      # @param post_id [Integer] the ID of the build post to update
+      # @param body [Hash] the JSON body to send in the POST request
+      # @return [Integer] the ID of the updated post
+      # @raise [FastlaneCore::Interface::FastlaneError] if the API returns a non-success response
+      def self.update_single_post(site_id:, api_token:, post_id:, body:)
+        uri = Helper::AppsCdnHelper.wpcom_v2_url(site_id: site_id, path: "a8c-cdn/builds/#{post_id}")
+
+        request = Net::HTTP::Post.new(uri.request_uri)
+        request.body = JSON.generate(body)
+        request['Content-Type'] = 'application/json'
+        request['Accept'] = 'application/json'
+        request['Authorization'] = "Bearer #{api_token}"
+
+        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https', open_timeout: 10, read_timeout: 30) do |http|
+          http.request(request)
+        end
+
+        case response
+        when Net::HTTPSuccess
+          result = JSON.parse(response.body)
+          updated_id = result['id']
+
+          UI.message("  Updated post #{updated_id}")
+
+          updated_id
+        else
+          UI.error("Failed to update Apps CDN build metadata for post #{post_id}: #{response.code} #{response.message}")
+          UI.error(response.body)
+          UI.user_error!("Update of Apps CDN build metadata failed for post #{post_id}")
+        end
+      end
+
+      def self.description
+        'Updates metadata of one or more existing builds on the Apps CDN'
+      end
+
+      def self.authors
+        ['Automattic']
+      end
+
+      def self.return_value
+        'Returns an Array of post IDs (Integer) that were successfully updated. On error, raises a FastlaneError.'
+      end
+
+      def self.details
+        <<~DETAILS
+          Updates metadata (such as post status or visibility) for one or more existing build posts on a WordPress blog
+          that has the Apps CDN plugin enabled, using the dedicated `/wpcom/v2/sites/{site_id}/a8c-cdn/builds/{post_id}`
+          endpoint. Standard WP REST API writes are blocked for builds, so this endpoint is the only way to update them.
+          See PCYsg-15tP-p2 internal a8c documentation for details about the Apps CDN plugin.
+        DETAILS
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(
+            key: :site_id,
+            env_name: 'APPS_CDN_SITE_ID',
+            description: 'The WordPress.com CDN site ID where the build was uploaded',
+            optional: false,
+            type: String,
+            verify_block: proc do |value|
+              UI.user_error!('Site ID cannot be empty') if value.to_s.empty?
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :post_ids,
+            description: 'The IDs of the build posts to update',
+            optional: false,
+            type: Array,
+            verify_block: proc do |value|
+              UI.user_error!('Post IDs must be a non-empty array') unless value.is_a?(Array) && !value.empty?
+              value.each do |id|
+                UI.user_error!("Each post ID must be a positive integer, got: #{id.inspect}") unless id.is_a?(Integer) && id.positive?
+              end
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :api_token,
+            env_name: 'WPCOM_API_TOKEN',
+            description: 'The WordPress.com API token for authentication',
+            optional: false,
+            type: String,
+            verify_block: proc do |value|
+              UI.user_error!('API token cannot be empty') if value.to_s.empty?
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :visibility,
+            description: 'The new visibility for the build (:internal or :external)',
+            optional: true,
+            type: Symbol,
+            verify_block: Helper::AppsCdnHelper.verify_visibility_param
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :post_status,
+            description: "The new post status ('publish' or 'draft')",
+            optional: true,
+            type: String,
+            verify_block: Helper::AppsCdnHelper.verify_post_status_param
+          ),
+        ]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.example_code
+        [
+          'update_apps_cdn_build_metadata(
+            site_id: "12345678",
+            api_token: ENV["WPCOM_API_TOKEN"],
+            post_ids: [98765],
+            post_status: "publish"
+          )',
+          'update_apps_cdn_build_metadata(
+            site_id: "12345678",
+            api_token: ENV["WPCOM_API_TOKEN"],
+            post_ids: [12345, 67890, 11111],
+            visibility: :external
+          )',
+        ]
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/wpmreleasetoolkit/actions/common/upload_build_to_apps_cdn.rb

@@ -4,6 +4,7 @@ require 'fastlane/action'
 require 'net/http'
 require 'uri'
 require 'json'
+require_relative '../../helper/apps_cdn_helper'
 
 module Fastlane
   module Actions
@@ -17,8 +18,6 @@ module Fastlane
     class UploadBuildToAppsCdnAction < Action
       # See https://github.a8c.com/Automattic/wpcom/blob/trunk/wp-content/lib/a8c/cdn/src/enums/enum-resource-type.php
       RESOURCE_TYPE = 'Build'
-      # These are from the WordPress.com API, not the Apps CDN plugin
-      VALID_POST_STATUS = %w[publish draft].freeze
       # See https://github.a8c.com/Automattic/wpcom/blob/trunk/wp-content/lib/a8c/cdn/src/enums/enum-build-type.php
       VALID_BUILD_TYPES = %w[
         Alpha
@@ -48,17 +47,13 @@ module Fastlane
         'Full Install',
         'Update',
       ].freeze
-      # See https://github.a8c.com/Automattic/wpcom/blob/trunk/wp-content/lib/a8c/cdn/src/enums/enum-visibility.php
-      VALID_VISIBILITIES = %i[internal external].freeze
-
       def self.run(params)
         UI.message('Uploading build to Apps CDN...')
 
         file_path = params[:file_path]
         UI.user_error!("File not found at path '#{file_path}'") unless File.exist?(file_path)
 
-        api_endpoint = "https://public-api.wordpress.com/rest/v1.1/sites/#{params[:site_id]}/media/new"
-        uri = URI.parse(api_endpoint)
+        uri = Helper::AppsCdnHelper.rest_v1_1_url(site_id: params[:site_id], path: 'media/new')
 
         # Create the request body and headers
         parameters = {
@@ -261,9 +256,7 @@ module Fastlane
             description: 'The visibility of the build (:internal or :external)',
             optional: false,
             type: Symbol,
-            verify_block: proc do |value|
-              UI.user_error!("Visibility must be one of: #{VALID_VISIBILITIES.map { "`:#{_1}`" }.join(', ')}") unless VALID_VISIBILITIES.include?(value.to_s.downcase.to_sym)
-            end
+            verify_block: Helper::AppsCdnHelper.verify_visibility_param
           ),
           FastlaneCore::ConfigItem.new(
             key: :post_status,
@@ -271,9 +264,7 @@ module Fastlane
             optional: true,
             default_value: 'publish',
             type: String,
-            verify_block: proc do |value|
-              UI.user_error!("Post status must be one of: #{VALID_POST_STATUS.join(', ')}") unless VALID_POST_STATUS.include?(value)
-            end
+            verify_block: Helper::AppsCdnHelper.verify_post_status_param
           ),
           FastlaneCore::ConfigItem.new(
             key: :version,

data/lib/fastlane/plugin/wpmreleasetoolkit/helper/apps_cdn_helper.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module Fastlane
+  module Helper
+    module AppsCdnHelper
+      API_BASE_URL = 'https://public-api.wordpress.com'
+
+      # See https://github.a8c.com/Automattic/wpcom/blob/trunk/wp-content/lib/a8c/cdn/src/enums/enum-visibility.php
+      VALID_VISIBILITIES = %i[internal external].freeze
+
+      # These are from the WordPress.com API, not the Apps CDN plugin
+      VALID_POST_STATUS = %w[publish draft].freeze
+
+      # Builds a WordPress.com REST API v1.1 URI scoped to a site.
+      #
+      # @param site_id [String] the WordPress.com site ID
+      # @param path [String] the API path relative to the site (e.g. 'media/new')
+      # @return [URI] the parsed full API URI
+      def self.rest_v1_1_url(site_id:, path:)
+        URI.parse("#{API_BASE_URL}/rest/v1.1/sites/#{site_id}/#{path}")
+      end
+
+      # Builds a WordPress.com REST API wpcom/v2 URI scoped to a site.
+      #
+      # @param site_id [String] the WordPress.com site ID
+      # @param path [String] the API path relative to the site (e.g. 'a8c-cdn/builds/123')
+      # @return [URI] the parsed full API URI
+      def self.wpcom_v2_url(site_id:, path:)
+        URI.parse("#{API_BASE_URL}/wpcom/v2/sites/#{site_id}/#{path}")
+      end
+
+      # Returns a proc that validates a visibility parameter value against {VALID_VISIBILITIES}.
+      # Intended for use as a `verify_block` in Fastlane ConfigItem definitions.
+      #
+      # @return [Proc] a proc that raises FastlaneError if the value is invalid
+      def self.verify_visibility_param
+        proc do |value|
+          UI.user_error!("Visibility must be one of: #{VALID_VISIBILITIES.map { "`:#{_1}`" }.join(', ')}") unless VALID_VISIBILITIES.include?(value.to_s.downcase.to_sym)
+        end
+      end
+
+      # Returns a proc that validates a post status parameter value against {VALID_POST_STATUS}.
+      # Intended for use as a `verify_block` in Fastlane ConfigItem definitions.
+      #
+      # @return [Proc] a proc that raises FastlaneError if the value is invalid
+      def self.verify_post_status_param
+        proc do |value|
+          UI.user_error!("Post status must be one of: #{VALID_POST_STATUS.join(', ')}") unless VALID_POST_STATUS.include?(value)
+        end
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/wpmreleasetoolkit/helper/configure_helper.rb

@@ -151,7 +151,7 @@ module Fastlane
       end
 
       ### A helper function to extract the distance from the provided string.
-      ### (ie – this function will recieve "behind 2" or "ahead 6" and return 2 or 6, respectively.
+      ### (ie – this function will receive "behind 2" or "ahead 6" and return 2 or 6, respectively.
       def self.parse_distance(match)
         distance = match.to_s.scan(/\d+/).first
 
@@ -265,7 +265,7 @@ module Fastlane
       end
 
       ## Updates the project encryption key defined in ~/.mobile-secrets/keys.json
-      ## The updated file is commited and push to the repo
+      ## The updated file is committed and pushed to the repo
       def self.update_project_encryption_key
         # Update keys.json with the new key
         keys_json = mobile_secrets_keys_json

data/lib/fastlane/plugin/wpmreleasetoolkit/helper/github_helper.rb

@@ -304,6 +304,23 @@ module Fastlane
         reuse_identifier
       end
 
+      # Find an existing Pull Request matching the given head (and optionally base) branch.
+      #
+      # @param [String] repository The repository name, including the organization (e.g. `wordpress-mobile/wordpress-ios`)
+      # @param [String] head The head branch to look for. May be given as `branch` or as the fully-qualified `owner:branch`;
+      #        when unqualified, it is automatically prefixed with the repository's owner.
+      # @param [String?] base The base branch the PR should target. If nil, PRs targeting any base are considered.
+      # @param [String] state The PR state to match (`open`, `closed`, or `all`). Defaults to `open`.
+      # @return [Sawyer::Resource, nil] The first matching Pull Request, or nil if none matches.
+      #
+      def find_pull_request(repository:, head:, base: nil, state: 'open')
+        qualified_head = head.include?(':') ? head : "#{repository.split('/').first}:#{head}"
+        options = { state: state, head: qualified_head }
+        options[:base] = base unless base.nil?
+
+        client.pull_requests(repository, options).first
+      end
+
       # Update a milestone for a repository
       #
       # @param [String] repository The repository name (including the organization)

data/lib/fastlane/plugin/wpmreleasetoolkit/helper/ios/ios_l10n_linter_helper.rb

@@ -14,7 +14,7 @@ module Fastlane
         attr_reader :install_path, :version
 
         # @param [String] install_path The path to install SwiftGen to. Usually something like "$PROJECT_DIR/vendor/swiftgen/#{SWIFTGEN_VERSION}".
-        #        It's recommended to provide an absolute path here rather than a relative one, to ensure it's not dependant on where the action is run from.
+        #        It's recommended to provide an absolute path here rather than a relative one, to ensure it's not dependent on where the action is run from.
         # @param [String] version The version of SwiftGen to use. This will be used both:
         #        - to check if the current version located in `install_path`, if it already exists, is the expected one
         #        - to know which version to download if there is not one installed in `install_path` yet

data/lib/fastlane/plugin/wpmreleasetoolkit/version.rb

@@ -3,6 +3,6 @@
 module Fastlane
   module Wpmreleasetoolkit
     NAME = 'fastlane-plugin-wpmreleasetoolkit'
-    VERSION = '14.6.0'
+    VERSION = '14.8.0'
   end
 end

data/lib/fastlane/plugin/wpmreleasetoolkit/versioning/formatters/continuous_build_code_formatter.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Fastlane
+  module Wpmreleasetoolkit
+    module Versioning
+      # Google Play Store's maximum allowed versionCode.
+      MAX_PLAY_STORE_VERSION_CODE = 2_100_000_000
+
+      # The `ContinuousBuildCodeFormatter` derives an Android Play Store `versionCode` for a
+      # "continuous trunk" release model, where the low-order term is a high-cardinality,
+      # monotonically increasing build number (e.g. a Buildkite build number).
+      #
+      # The build code is computed as:
+      #
+      #   versionCode = (major * 10 + minor) * 10^build_digits + build_number
+      #
+      # It takes `major`, `minor`, and `build_number` as explicit arguments rather than an
+      # `AppVersion`, because the inputs come from different sources and an `AppVersion` does not
+      # model them: the marketing `major`/`minor` come from the parsed version, while `build_number`
+      # is an independent CI counter (e.g. `BUILDKITE_BUILD_NUMBER`). Notably, `AppVersion#build_number`
+      # means something else in this domain (the RC/beta iteration counter, e.g. `-rc-1`), so taking an
+      # `AppVersion` here would invite reading the wrong field. There is also no `patch`: in a
+      # continuous-trunk model the build number strictly orders every build and subsumes patch's
+      # ordering role (hotfixes get a new build number, not a patch digit in the code).
+      #
+      # Because the build number is globally monotonic and the version prefix only ever increases,
+      # the resulting code is always strictly increasing — even if the build number eventually
+      # exceeds `10^build_digits` (which only costs human-readability, not ordering). The only hard
+      # correctness constraint is staying at or below the Play Store's max versionCode.
+      #
+      # Unlike `DerivedBuildCodeFormatter` (fixed-width string concatenation capped at 8 total digits
+      # and 3 digits per component, i.e. build <= 999), this formatter can hold a large build number.
+      # The two formatters target different release models; this one does not replace the other.
+      class ContinuousBuildCodeFormatter
+        # @param [Integer] build_digits Number of digits reserved for the build number, which sets the
+        # multiplier applied to the `major * 10 + minor` prefix (multiplier = 10^build_digits).
+        # Must be a positive integer. Defaults to 6 (multiplier = 1_000_000).
+        #
+        def initialize(build_digits: 6)
+          validate_build_digits!(build_digits)
+          @build_digits = build_digits
+        end
+
+        # Derive the build code (Android `versionCode`).
+        #
+        # @param [Integer] major The major (marketing) version number.
+        # @param [Integer] minor The minor (marketing) version number. Must be 9 or lower.
+        # @param [Integer] build_number A high-cardinality, monotonically increasing build number
+        # (e.g. a Buildkite build number). This is a CI counter, not `AppVersion#build_number`.
+        #
+        # @return [Integer] The derived `versionCode`.
+        #
+        def build_code(major:, minor:, build_number:)
+          # Validate up front so bad input (e.g. strings from env vars or file reads) raises a
+          # user-friendly error rather than an opaque `TypeError` from the arithmetic below.
+          validate_component!('major', major)
+          validate_component!('minor', minor)
+          validate_component!('build_number', build_number)
+
+          # `major * 10 + minor` is only unambiguous while minor is a single digit.
+          if minor > 9
+            UI.user_error!("Minor version (#{minor}) must be 9 or lower to derive an unambiguous build code with `#{self.class.name}`")
+          end
+
+          prefix = (major * 10) + minor
+          code = (prefix * (10**@build_digits)) + build_number
+
+          # Sanity check: Play Store versionCodes must be positive integers.
+          if code <= 0
+            UI.user_error!("Derived build code (#{code}) must be a positive integer")
+          end
+
+          if code > MAX_PLAY_STORE_VERSION_CODE
+            UI.user_error!("Derived build code (#{code}) exceeds the maximum allowed Play Store versionCode (#{MAX_PLAY_STORE_VERSION_CODE})")
+          end
+
+          code
+        end
+
+        private
+
+        # Validates that a version component is a non-negative integer.
+        #
+        # @param [String] name The component name, used in the error message
+        # @param [Integer] value The value to validate
+        #
+        # @raise [StandardError] If the value is not a non-negative integer
+        #
+        def validate_component!(name, value)
+          unless value.is_a?(Integer)
+            UI.user_error!("`#{name}` must be an integer, got: #{value.class}")
+          end
+
+          return unless value.negative?
+
+          UI.user_error!("`#{name}` must be a non-negative integer, got: #{value}")
+        end
+
+        # Validates that `build_digits` is a positive integer.
+        #
+        # @param [Integer] build_digits The build digit count to validate
+        #
+        # @raise [StandardError] If the value is not a positive integer
+        #
+        def validate_build_digits!(build_digits)
+          unless build_digits.is_a?(Integer)
+            UI.user_error!("`build_digits` must be an integer, got: #{build_digits.class}")
+          end
+
+          return if build_digits.positive?
+
+          UI.user_error!("`build_digits` must be a positive integer, got: #{build_digits}")
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-wpmreleasetoolkit
 version: !ruby/object:Gem::Version
-  version: 14.6.0
+  version: 14.8.0
 platform: ruby
 authors:
 - Automattic
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-05-13 00:00:00.000000000 Z
+date: 2026-06-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: buildkit
@@ -72,14 +72,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.231'
+        version: '2.235'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.231'
+        version: '2.235'
 - !ruby/object:Gem::Dependency
   name: gettext
   requirement: !ruby/object:Gem::Requirement
@@ -439,6 +439,7 @@ files:
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/common/create_new_milestone_action.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/common/create_release_backmerge_pull_request_action.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/common/extract_release_notes_for_version_action.rb
+- lib/fastlane/plugin/wpmreleasetoolkit/actions/common/find_or_create_pull_request_action.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/common/find_previous_tag.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/common/firebase_login.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/common/get_prs_between_tags.rb
@@ -451,6 +452,7 @@ files:
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/common/remove_branch_protection_action.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/common/set_branch_protection_action.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/common/set_milestone_frozen_marker_action.rb
+- lib/fastlane/plugin/wpmreleasetoolkit/actions/common/update_apps_cdn_build_metadata.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/common/update_assigned_milestone_action.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/common/upload_build_to_apps_cdn.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/actions/common/upload_to_s3.rb
@@ -479,6 +481,7 @@ files:
 - lib/fastlane/plugin/wpmreleasetoolkit/helper/android/android_tools_path_helper.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/helper/android/android_version_helper.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/helper/app_size_metrics_helper.rb
+- lib/fastlane/plugin/wpmreleasetoolkit/helper/apps_cdn_helper.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/helper/buildkite_aware_log_groups.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/helper/ci_helper.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/helper/configure_helper.rb
@@ -517,6 +520,7 @@ files:
 - lib/fastlane/plugin/wpmreleasetoolkit/versioning/files/android_version_file.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/versioning/files/ios_version_file.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/versioning/formatters/abstract_version_formatter.rb
+- lib/fastlane/plugin/wpmreleasetoolkit/versioning/formatters/continuous_build_code_formatter.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/versioning/formatters/derived_build_code_formatter.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/versioning/formatters/four_part_build_code_formatter.rb
 - lib/fastlane/plugin/wpmreleasetoolkit/versioning/formatters/four_part_version_formatter.rb