fastlane-plugin-appcircle_publish 0.1.0.beta.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d2a731169ee6e19ffa2c1faf2d552cf6464abff3ed839b4231d6de7ed6587897
+  data.tar.gz: 346b250fbba4003f3c0b22002eebffbc9b750cce16b2fbb1c9c1b7d2fcd4b89c
+SHA512:
+  metadata.gz: ec418da783e2feb28ff2cdf437bb8815523ae9476d78e823f1609290e684277f24af3e164775cc2eb3bc0695ed977f67a8d6e92f0d594974b316322683c12d2c
+  data.tar.gz: 2d4b73ea36345d73630c1d14318365627c768ff2dd4d5c8889e37f682f96fa4871199fb9c2ef3f26bbd5e7abd898dbd12d6e90bcd8a8802bbe8b4431c8254dc6

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Burak Yıldırım <buraky@appcircle.io>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,148 @@
+## Appcircle Publish
+
+[![fastlane Plugin Badge](https://rawcdn.githack.com/fastlane/fastlane/master/fastlane/assets/plugin-badge.svg)](https://rubygems.org/gems/fastlane-plugin-appcircle_publish)
+
+Upload an application binary to an Appcircle **Publish** profile and/or trigger
+its publish flow (app store publishing) directly from your Fastlane pipeline.
+
+Learn more about [Appcircle Publish](https://appcircle.io/publish-to-stores?utm_source=fastlane&utm_medium=plugin&utm_campaign=publish).
+
+## System Requirements
+
+**Compatible Agents:**
+
+- macOS 14.2, 14.5
+
+**Supported Version:**
+
+- Fastlane 2.222.0
+- Ruby 3.2.2
+
+Note: Both **Appcircle Cloud** and **self-hosted** Appcircle installations are supported. See [Self-Hosted Appcircle](#self-hosted-appcircle) below to configure custom endpoints.
+
+### Generating/Managing the Personal API Tokens
+
+To generate a Personal API Token:
+
+1. Go to the My Organization screen (second option at the bottom left).
+2. Find the Personal API Token section in the top right corner.
+3. Press the "Generate Token" button to generate your first token.
+
+![Token Generation](<https://cdn.appcircle.io/docs/assets/image%20(164).png>)
+
+## What the action does
+
+The action has two independent switches — `upload` and `publish` — both default
+to `false`. **You must enable at least one.** Create the Publish profile in
+Appcircle first; the action targets it by name (profile names are unique per
+platform).
+
+| `upload` | `publish` | Behavior |
+|:--------:|:---------:|----------|
+| `true`  | `false` | Upload `appPath` as a new app version on the profile. |
+| `false` | `true`  | Trigger the publish flow for the profile's **current release candidate**. |
+| `true`  | `true`  | Upload `appPath`, **mark the new version as release candidate**, then trigger the publish flow for it. |
+| `false` | `false` | Error — nothing to do. |
+
+**Rules:**
+
+- **In-progress guard:** if a publish is already running for the target profile, the action does **not** start a new one and fails fast.
+- **Release candidate:** when both `upload` and `publish` are `true`, the freshly uploaded version is automatically marked as the release candidate before it is published. In publish-only mode, the profile's existing release candidate is published.
+- **Progress:** while publishing, the action polls the publish status and prints step-by-step progress (with status icons) until the flow succeeds or fails.
+
+> **Manual-approval steps:** if the profile's publish flow contains a manual step (e.g. "Get Approval via Email"), the flow waits for that action and the plugin keeps polling until it completes or the poll times out. For CI use, prefer publish flows without manual gates.
+
+### Getting Started
+
+This project is a [_fastlane_](https://github.com/fastlane/fastlane) plugin. To get started with `appcircle_publish`, add it to your project by running:
+
+```bash
+fastlane add_plugin appcircle_publish
+```
+
+**Upload only:**
+
+```ruby
+  lane :upload_to_publish do
+    appcircle_publish(
+      personalAPIToken: "$(AC_PERSONAL_API_TOKEN)",
+      platform: "$(AC_PLATFORM)", # "ios" or "android"
+      publishProfile: "$(AC_PUBLISH_PROFILE)",
+      upload: true,
+      appPath: "$(AC_APP_PATH)"
+    )
+  end
+```
+
+**Publish only (publishes the profile's current release candidate):**
+
+```ruby
+  lane :trigger_publish do
+    appcircle_publish(
+      personalAPIToken: "$(AC_PERSONAL_API_TOKEN)",
+      platform: "$(AC_PLATFORM)",
+      publishProfile: "$(AC_PUBLISH_PROFILE)",
+      publish: true
+    )
+  end
+```
+
+**Upload and publish (uploads, marks it release candidate, then publishes):**
+
+```ruby
+  lane :upload_and_publish do
+    appcircle_publish(
+      personalAPIToken: "$(AC_PERSONAL_API_TOKEN)",
+      platform: "$(AC_PLATFORM)",
+      publishProfile: "$(AC_PUBLISH_PROFILE)",
+      upload: true,
+      publish: true,
+      appPath: "$(AC_APP_PATH)"
+    )
+  end
+```
+
+- `personalAPIToken` / `personalAccessKey`: Provide exactly one to authenticate Appcircle services.
+- `platform`: Target platform of the Publish profile — `ios` or `android`.
+- `publishProfile`: Name of the Publish profile to target.
+- `upload` (default `false`): Upload `appPath` as a new app version.
+- `publish` (default `false`): Trigger the profile's publish flow.
+- `appPath`: Path to the application file. Required when `upload` is `true`. For iOS use a `.ipa` file; for Android use a `.apk` or `.aab` file.
+
+### Self-Hosted Appcircle
+
+If you run a self-hosted Appcircle installation, point the action to your own endpoints with the optional `authEndpoint` and `apiEndpoint` parameters. Both default to the Appcircle cloud, so existing cloud users do not need to set them.
+
+- `authEndpoint` (optional): Authentication endpoint URL. Defaults to `https://auth.appcircle.io`.
+- `apiEndpoint` (optional): API endpoint URL. Defaults to `https://api.appcircle.io`.
+
+```ruby
+    appcircle_publish(
+      personalAPIToken: "$(AC_PERSONAL_API_TOKEN)",
+      platform: "$(AC_PLATFORM)",
+      publishProfile: "$(AC_PUBLISH_PROFILE)",
+      publish: true,
+      authEndpoint: "https://auth.my-appcircle.example.com",
+      apiEndpoint: "https://api.my-appcircle.example.com"
+    )
+```
+
+> **Self-signed or private CA certificates:** If your self-hosted Appcircle server uses a self-signed certificate (or one issued by a private/internal CA), requests will fail certificate validation. The plugin does not disable TLS verification. Trust the server's CA on the machine running Fastlane — add it to the system certificate store, or point the `SSL_CERT_FILE` environment variable at a PEM bundle that includes it.
+
+### Leveraging Environment Variables
+
+Utilize environment variables seamlessly by substituting the parameters with $(VARIABLE_NAME) in your task inputs. The plugin automatically retrieves values from the specified environment variables within your pipeline.
+
+If you would like to learn more about this plugin and how to utilize it in your projects, please [contact us](https://appcircle.io/contact?utm_source=fastlane&utm_medium=plugin&utm_campaign=publish)
+
+## Issues and Feedback
+
+For any other issues and feedback about this plugin, please submit it to this repository.
+
+## Troubleshooting
+
+If you have trouble using plugins, check out the [Plugins Troubleshooting](https://docs.fastlane.tools/plugins/plugins-troubleshooting/) guide.
+
+### Reference
+
+For more detailed instructions and support, visit the [Appcircle Publish documentation](https://docs.appcircle.io/publish-to-stores-module).

data/lib/fastlane/plugin/appcircle_publish/actions/appcircle_publish_action.rb

@@ -0,0 +1,290 @@
+require 'fastlane/action'
+require 'net/http'
+require 'uri'
+require 'json'
+
+require 'fastlane/action'
+require_relative '../helper/appcircle_publish_helper'
+
+require_relative '../helper/auth_service'
+require_relative '../helper/upload_service'
+
+module Fastlane
+  module Actions
+    class AppcirclePublishAction < Action
+      @@apiToken = nil
+      @@authEndpoint = "https://auth.appcircle.io"
+      @@apiEndpoint = "https://api.appcircle.io"
+
+      FLOW_STEP_STATUS = {
+        0 => 'Success', 1 => 'Failed', 2 => 'Cancelled', 3 => 'Timeout',
+        90 => 'Waiting', 91 => 'Running', 92 => 'Completing', 99 => 'Unknown',
+        100 => 'Skipped', 200 => 'Not Started', 201 => 'Stopped',
+        202 => 'In Progress', 203 => 'Awaiting Response'
+      }.freeze
+      TERMINAL_STEP_STATUSES = [0, 1, 2, 3, 100, 201].freeze
+      ACTIVE_STEP_STATUSES = [91, 92, 202].freeze
+
+      def self.run(params)
+        personalAPIToken = params[:personalAPIToken]
+        personalAccessKey = params[:personalAccessKey]
+        @@authEndpoint = params[:authEndpoint]
+        @@apiEndpoint = params[:apiEndpoint]
+        platform = params[:platform] && params[:platform].downcase
+        publishProfile = params[:publishProfile]
+        appPath = params[:appPath]
+        upload = params[:upload]
+        publish = params[:publish]
+
+        # --- Validation ---
+        if !upload && !publish
+          UI.user_error!("Nothing to do: set 'upload' and/or 'publish' to true.")
+        end
+
+        if personalAPIToken.nil? && personalAccessKey.nil?
+          UI.user_error!("Please provide either Personal API Token (personalAPIToken) or Personal Access Key (personalAccessKey) to authenticate connections to Appcircle services")
+        elsif !personalAPIToken.nil? && !personalAccessKey.nil?
+          UI.user_error!("Please provide only one authentication method: either Personal API Token (personalAPIToken) or Personal Access Key (personalAccessKey), not both")
+        end
+
+        if platform.nil? || (platform != "ios" && platform != "android")
+          UI.user_error!("Please provide a valid platform for the Publish profile: 'ios' or 'android'")
+        end
+
+        if publishProfile.nil?
+          UI.user_error!("Please provide the name of the Publish profile to target")
+        end
+
+        if upload
+          UI.user_error!("Please specify 'appPath' when 'upload' is true. For iOS use a .ipa file; for Android use a .apk or .aab file") if appPath.nil?
+          valid_extensions = ['.apk', '.aab', '.ipa']
+          file_extension = File.extname(appPath).downcase
+          unless valid_extensions.include?(file_extension)
+            raise "Invalid file extension: #{file_extension}. For Android, use .apk or .aab. For iOS, use .ipa."
+          end
+        end
+
+        # --- Auth + profile ---
+        if personalAPIToken.nil?
+          self.ac_login_with_pak(personalAccessKey)
+        else
+          self.ac_login_with_pat(personalAPIToken)
+        end
+
+        profileId = UploadService.get_publish_profile_id(auth_token: @@apiToken, platform: platform, profile_name: publishProfile, api_endpoint: @@apiEndpoint)
+
+        # Guard: never start a new publish if one is already running for the profile.
+        if publish
+          active = UploadService.get_active_publish_count_for_profile(auth_token: @@apiToken, publish_profile_id: profileId, api_endpoint: @@apiEndpoint)
+          if active > 0
+            UI.user_error!("A publish is already in progress for profile '#{publishProfile}'. Not starting a new one.")
+          end
+        end
+
+        appVersionId = nil
+
+        # --- Upload ---
+        if upload
+          response = UploadService.upload_artifact(token: @@apiToken, app: appPath, platform: platform, publish_profile_id: profileId, api_endpoint: @@apiEndpoint)
+          self.checkTaskStatus(response["taskId"])
+          appVersionId = UploadService.get_latest_app_version_id(auth_token: @@apiToken, platform: platform, publish_profile_id: profileId, api_endpoint: @@apiEndpoint)
+          UI.success("#{appPath} uploaded to the Appcircle Publish profile '#{publishProfile}' successfully")
+        end
+
+        # --- Publish ---
+        if publish
+          if upload && appVersionId
+            UploadService.mark_release_candidate(auth_token: @@apiToken, platform: platform, publish_profile_id: profileId, app_version_id: appVersionId, api_endpoint: @@apiEndpoint)
+            UI.message("Marked the uploaded version as release candidate.")
+          else
+            appVersionId = UploadService.get_release_candidate_version_id(auth_token: @@apiToken, platform: platform, publish_profile_id: profileId, api_endpoint: @@apiEndpoint)
+          end
+
+          publishId = UploadService.get_publish_id(auth_token: @@apiToken, platform: platform, publish_profile_id: profileId, app_version_id: appVersionId, api_endpoint: @@apiEndpoint)
+          UploadService.start_publish(auth_token: @@apiToken, platform: platform, publish_profile_id: profileId, publish_id: publishId, api_endpoint: @@apiEndpoint)
+          UI.success("Publish flow started for profile '#{publishProfile}'.")
+          success = self.poll_publish_status(platform, profileId, appVersionId)
+          UI.user_error!("Publish flow failed.") unless success
+        end
+      end
+
+      def self.ac_login_with_pat(accessToken)
+        user = AuthService.get_ac_token(pat: accessToken, auth_endpoint: @@authEndpoint)
+        UI.success("Login is successful.")
+        @@apiToken = user.accessToken
+      rescue StandardError => e
+        UI.error("Login failed: #{e.message}")
+        raise e
+      end
+
+      def self.ac_login_with_pak(personalAccessKey)
+        user = AuthService.get_ac_token_with_pak(personal_access_key: personalAccessKey, auth_endpoint: @@authEndpoint)
+        UI.success("Login is successful.")
+        @@apiToken = user.accessToken
+      rescue StandardError => e
+        UI.error("Login failed: #{e.message}")
+        raise e
+      end
+
+      def self.checkTaskStatus(taskId)
+        uri = URI.parse("#{@@apiEndpoint}/task/v1/tasks/#{taskId}")
+
+        response = self.send_request(uri, @@apiToken)
+        if response.kind_of?(Net::HTTPSuccess)
+          stateValue = JSON.parse(response.body)["stateValue"]
+          if stateValue == 1
+            sleep(1)
+            return checkTaskStatus(taskId)
+          end
+          if stateValue == 3
+            return true
+          else
+            taskStatus = { 0 => "Unknown", 1 => "Begin", 2 => "Canceled", 3 => 'Completed' }
+            UI.user_error!("#{taskId} id upload request failed with status #{taskStatus[stateValue]}.")
+          end
+        else
+          UI.user_error!("Upload failed with response code #{response.code} and message '#{response.message}'.")
+        end
+      end
+
+      # Poll the publish status until it terminates (status 0=success, 1=failed,
+      # anything else = running). Logs each step's start / await / terminal once,
+      # with status icons.
+      def self.poll_publish_status(platform, profileId, appVersionId, interval: 5, max_attempts: 240)
+        step_state = {}
+        max_attempts.times do
+          data = UploadService.get_publish_object(auth_token: @@apiToken, platform: platform, publish_profile_id: profileId, app_version_id: appVersionId, api_endpoint: @@apiEndpoint)
+          (data['steps'] || []).each do |step|
+            id = step['id'] || step['name']
+            next if id.nil?
+            st = (step_state[id] ||= {})
+            status = step['status']
+            if TERMINAL_STEP_STATUSES.include?(status) && !st[:done]
+              st[:done] = true
+              UI.message("#{step_icon(status)} #{step['name']} — #{step_status_name(status)}")
+            elsif status == 203 && !st[:awaiting] && !st[:done]
+              st[:awaiting] = true
+              UI.message("#{step_icon(status)} #{step['name']} — #{step_status_name(status)}")
+            elsif ACTIVE_STEP_STATUSES.include?(status) && !st[:started] && !st[:done]
+              st[:started] = true
+              UI.message("#{step_icon(status)} #{step['name']} — #{step_status_name(status)}")
+            end
+          end
+          status = data['status'].is_a?(Numeric) ? data['status'] : 99
+          return true if status == 0
+          return false if status == 1
+          sleep(interval)
+        end
+        UI.user_error!("Publish status polling timed out.")
+      end
+
+      def self.step_status_name(status)
+        FLOW_STEP_STATUS[status] || "Unknown (#{status})"
+      end
+
+      def self.step_icon(status)
+        case status
+        when 0 then '✅'
+        when 1 then '❌'
+        when 2 then '🚫'
+        when 3 then '⌛'
+        when 100 then '⏭️'
+        when 201 then '⏹️'
+        when 203 then '⏸️'
+        else '▶️'
+        end
+      end
+
+      def self.send_request(uri, access_token)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = (uri.scheme == "https")
+        request = Net::HTTP::Get.new(uri.request_uri)
+        request["Authorization"] = "Bearer #{access_token}"
+        http.request(request)
+      end
+
+      def self.description
+        "Upload a binary to an Appcircle Publish profile and/or trigger its publish flow"
+      end
+
+      def self.authors
+        ["Burak Yıldırım"]
+      end
+
+      def self.return_value
+      end
+
+      def self.details
+        "Uploads an application binary to an existing Appcircle Publish profile and/or triggers the profile's publish flow. Upload and publish are independent options: enable either or both. When both are enabled, the uploaded version is marked as release candidate and published; a new publish is never started if one is already in progress for the profile."
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :personalAPIToken,
+                                       env_name: "AC_PERSONAL_API_TOKEN",
+                                       description: "Provide Personal API Token to authenticate Appcircle services (use either personalAPIToken or personalAccessKey)",
+                                       optional: true,
+                                       type: String),
+
+          FastlaneCore::ConfigItem.new(key: :personalAccessKey,
+                                       env_name: "AC_PERSONAL_ACCESS_KEY",
+                                       description: "Provide Personal Access Key to authenticate Appcircle services (use either personalAPIToken or personalAccessKey)",
+                                       optional: true,
+                                       type: String),
+
+          FastlaneCore::ConfigItem.new(key: :authEndpoint,
+                                       env_name: "AC_AUTH_ENDPOINT",
+                                       description: "Optional: Authentication endpoint URL for self-hosted Appcircle installations. Defaults to the Appcircle cloud",
+                                       optional: true,
+                                       default_value: "https://auth.appcircle.io",
+                                       type: String),
+
+          FastlaneCore::ConfigItem.new(key: :apiEndpoint,
+                                       env_name: "AC_API_ENDPOINT",
+                                       description: "Optional: API endpoint URL for self-hosted Appcircle installations. Defaults to the Appcircle cloud",
+                                       optional: true,
+                                       default_value: "https://api.appcircle.io",
+                                       type: String),
+
+          FastlaneCore::ConfigItem.new(key: :platform,
+                                       env_name: "AC_PLATFORM",
+                                       description: "Target platform of the Publish profile: 'ios' or 'android'",
+                                       optional: false,
+                                       type: String),
+
+          FastlaneCore::ConfigItem.new(key: :publishProfile,
+                                       env_name: "AC_PUBLISH_PROFILE",
+                                       description: "Name of the Publish profile to target. Profile names are unique per platform",
+                                       optional: false,
+                                       type: String),
+
+          FastlaneCore::ConfigItem.new(key: :upload,
+                                       env_name: "AC_UPLOAD",
+                                       description: "Upload the binary at 'appPath' as a new app version. At least one of 'upload' or 'publish' must be true",
+                                       optional: true,
+                                       default_value: false,
+                                       is_string: false,
+                                       type: Boolean),
+
+          FastlaneCore::ConfigItem.new(key: :publish,
+                                       env_name: "AC_PUBLISH",
+                                       description: "Trigger the profile's publish flow. When combined with upload, the uploaded version is marked release candidate and published; otherwise the profile's current release candidate is published",
+                                       optional: true,
+                                       default_value: false,
+                                       is_string: false,
+                                       type: Boolean),
+
+          FastlaneCore::ConfigItem.new(key: :appPath,
+                                       env_name: "AC_APP_PATH",
+                                       description: "Path to the application file. Required when 'upload' is true. For iOS use a .ipa file; for Android use a .apk or .aab file",
+                                       optional: true,
+                                       type: String)
+        ]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/appcircle_publish/helper/appcircle_publish_helper.rb

@@ -0,0 +1,16 @@
+require 'fastlane_core/ui/ui'
+
+module Fastlane
+  UI = FastlaneCore::UI unless Fastlane.const_defined?(:UI)
+
+  module Helper
+    class AppcirclePublishHelper
+      # class methods that you define here become available in your action
+      # as `Helper::AppcirclePublishHelper.your_method`
+      #
+      def self.show_message
+        UI.message("Hello from the appcircle_publish plugin helper!")
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/appcircle_publish/helper/auth_service.rb

@@ -0,0 +1,78 @@
+require 'net/http'
+require 'uri'
+require 'cgi'
+require 'json'
+
+class UserResponse
+  attr_accessor :accessToken
+
+  def initialize(accessToken:)
+    @accessToken = accessToken
+  end
+end
+
+module AuthService
+  def self.get_ac_token(pat:, auth_endpoint: 'https://auth.appcircle.io')
+    endpoint_url = "#{auth_endpoint}/auth/v2/token"
+    uri = URI(endpoint_url)
+
+    # Create HTTP request
+    request = Net::HTTP::Post.new(uri)
+    request.content_type = 'application/x-www-form-urlencoded'
+    request['Accept'] = 'application/json'
+
+    # Encode parameters
+    params = { pat: pat }
+    request.body = URI.encode_www_form(params)
+
+    # Make the HTTP request
+    response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
+      http.request(request)
+    end
+
+    # Check response
+    if response.kind_of?(Net::HTTPSuccess)
+      response_data = JSON.parse(response.body)
+
+      user = UserResponse.new(
+        accessToken: response_data['access_token']
+      )
+
+      return user
+    else
+      raise "HTTP Request failed (#{response.code} #{response.message})"
+    end
+  end
+
+  def self.get_ac_token_with_pak(personal_access_key:, auth_endpoint: 'https://auth.appcircle.io')
+    endpoint_url = "#{auth_endpoint}/auth/v1/token"
+    uri = URI(endpoint_url)
+
+    # Create HTTP request
+    request = Net::HTTP::Post.new(uri)
+    request.content_type = 'application/x-www-form-urlencoded'
+    request['Accept'] = 'application/json'
+
+    # Encode parameters
+    params = { 'personal-access-key' => personal_access_key }
+    request.body = URI.encode_www_form(params)
+
+    # Make the HTTP request
+    response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
+      http.request(request)
+    end
+
+    # Check response
+    if response.kind_of?(Net::HTTPSuccess)
+      response_data = JSON.parse(response.body)
+
+      user = UserResponse.new(
+        accessToken: response_data['access_token']
+      )
+
+      return user
+    else
+      raise "HTTP Request failed (#{response.code} #{response.message})"
+    end
+  end
+end

data/lib/fastlane/plugin/appcircle_publish/helper/upload_service.rb

@@ -0,0 +1,149 @@
+require 'net/http'
+require 'uri'
+require 'json'
+require 'rest-client'
+
+BASE_URL = "https://api.appcircle.io"
+
+module UploadService
+  def self.put_with_retry(url, body, headers, max_retries: 5)
+    attempt = 0
+    delay = 1.0
+
+    begin
+      RestClient.put(url, body, headers)
+    rescue => e
+      status = e.respond_to?(:http_code) ? e.http_code : nil
+      retryable = status == 503 ||
+                  e.is_a?(RestClient::ServerBrokeConnection) ||
+                  e.is_a?(Errno::ECONNRESET) ||
+                  (defined?(RestClient::Exceptions::OpenTimeout) && e.is_a?(RestClient::Exceptions::OpenTimeout)) ||
+                  (defined?(RestClient::Exceptions::ReadTimeout) && e.is_a?(RestClient::Exceptions::ReadTimeout))
+
+      raise e if !retryable || attempt >= max_retries
+
+      attempt += 1
+      sleep(delay + rand(0.3)) # backoff + jitter (0-300ms)
+      delay *= 2
+      retry
+    end
+  end
+
+  # Resolve a publish profile id from its name for the given platform.
+  # Profile names are unique per (organization, platform), so the match is exact.
+  def self.get_publish_profile_id(auth_token:, platform:, profile_name:, api_endpoint: BASE_URL)
+    url = "#{api_endpoint}/publish/v2/profiles/#{platform}"
+    headers = { Authorization: "Bearer #{auth_token}", accept: 'application/json' }
+
+    profiles = JSON.parse(RestClient.get(url, headers).body)
+    profile = (profiles || []).find { |p| p['name'] == profile_name }
+    if profile.nil?
+      UI.user_error!("Publish profile '#{profile_name}' not found for platform '#{platform}'.")
+    end
+    profile['id']
+  rescue RestClient::ExceptionWithResponse => e
+    raise e
+  end
+
+  def self.upload_artifact(token:, app:, platform:, publish_profile_id:, api_endpoint: BASE_URL)
+    file_path = app
+    file_name = File.basename(file_path)
+    file_size = File.size(file_path)
+    auth_header = { Authorization: "Bearer #{token}", accept: 'application/json' }
+    # Profile listing is v2, but the signed-URL upload/commit actions live on v1.
+    base = "#{api_endpoint}/publish/v1/profiles/#{platform}/#{publish_profile_id}/app-versions"
+
+    begin
+      info_uri = URI(base)
+      info_uri.query = URI.encode_www_form({ action: 'uploadInformation', fileName: file_name, fileSize: file_size })
+      upload_info = JSON.parse(RestClient.get(info_uri.to_s, auth_header).body)
+      file_id = upload_info['fileId']
+      upload_url = upload_info['uploadUrl']
+      configuration = upload_info['configuration']
+      http_method = (configuration && configuration['httpMethod']) ? configuration['httpMethod'].to_s.upcase : 'PUT'
+
+      if http_method == 'POST'
+        sign_parameters = configuration['signParameters'] || {}
+        payload = {}
+        sign_parameters.each { |key, value| payload[key] = value }
+        payload['file'] = File.new(file_path, 'rb') # the 'file' field MUST be last
+        RestClient.post(upload_url, payload)
+      else
+        put_with_retry(upload_url, File.binread(file_path), { content_type: 'application/octet-stream' })
+      end
+
+      commit_uri = URI(base)
+      commit_uri.query = URI.encode_www_form({ action: 'commitFileUpload' })
+
+      commit_payload = { fileId: file_id, fileName: file_name }.to_json
+      commit_headers = { Authorization: "Bearer #{token}", content_type: :json, accept: 'application/json' }
+      JSON.parse(RestClient.post(commit_uri.to_s, commit_payload, commit_headers).body)
+    rescue RestClient::ExceptionWithResponse => e
+      raise e
+    rescue StandardError => e
+      raise e
+    end
+  end
+
+  def self.auth_headers(token)
+    { Authorization: "Bearer #{token}", accept: 'application/json' }
+  end
+
+  def self.get_app_versions(auth_token:, platform:, publish_profile_id:, api_endpoint: BASE_URL)
+    url = "#{api_endpoint}/publish/v2/profiles/#{platform}/#{publish_profile_id}/app-versions"
+    data = JSON.parse(RestClient.get(url, auth_headers(auth_token)).body)
+    data.is_a?(Array) ? data : (data['data'] || [])
+  end
+
+  # The most recently created app version (used after an upload).
+  def self.get_latest_app_version_id(auth_token:, platform:, publish_profile_id:, api_endpoint: BASE_URL)
+    versions = get_app_versions(auth_token: auth_token, platform: platform, publish_profile_id: publish_profile_id, api_endpoint: api_endpoint)
+    UI.user_error!("No app versions found on the publish profile after upload.") if versions.empty?
+    versions[0]['id']
+  end
+
+  # The profile's current release candidate (published in publish-only mode).
+  def self.get_release_candidate_version_id(auth_token:, platform:, publish_profile_id:, api_endpoint: BASE_URL)
+    versions = get_app_versions(auth_token: auth_token, platform: platform, publish_profile_id: publish_profile_id, api_endpoint: api_endpoint)
+    rc = versions.find { |v| v['releaseCandidate'] == true }
+    UI.user_error!("No release candidate app version found on the publish profile. Mark a version as release candidate (or enable upload) before publishing.") if rc.nil?
+    rc['id']
+  end
+
+  def self.mark_release_candidate(auth_token:, platform:, publish_profile_id:, app_version_id:, api_endpoint: BASE_URL)
+    uri = URI("#{api_endpoint}/publish/v2/profiles/#{platform}/#{publish_profile_id}/app-versions/#{app_version_id}")
+    uri.query = URI.encode_www_form({ action: 'releaseCandidate' })
+    headers = { Authorization: "Bearer #{auth_token}", content_type: :json, accept: 'application/json' }
+    RestClient.patch(uri.to_s, { ReleaseCandidate: true }.to_json, headers)
+  end
+
+  # In-progress publishes for the given profile (scope: target profile).
+  def self.get_active_publish_count_for_profile(auth_token:, publish_profile_id:, api_endpoint: BASE_URL)
+    url = "#{api_endpoint}/build/v1/queue/my-dashboard?page=1&size=1000"
+    data = JSON.parse(RestClient.get(url, auth_headers(auth_token)).body)
+    items = data['data'] || []
+    items.count { |p| p['publishId'] && p['profileId'] == publish_profile_id }
+  end
+
+  def self.get_publish_id(auth_token:, platform:, publish_profile_id:, app_version_id:, api_endpoint: BASE_URL)
+    url = "#{api_endpoint}/publish/v2/profiles/#{platform}/#{publish_profile_id}/app-versions/#{app_version_id}/publish"
+    data = JSON.parse(RestClient.get(url, auth_headers(auth_token)).body)
+    steps = data['steps'] || []
+    publish_id = steps[0] && steps[0]['publishId']
+    UI.user_error!("No publish flow steps found for the app version. Configure a publish flow on the profile first.") if publish_id.nil?
+    publish_id
+  end
+
+  def self.start_publish(auth_token:, platform:, publish_profile_id:, publish_id:, api_endpoint: BASE_URL)
+    uri = URI("#{api_endpoint}/publish/v2/profiles/#{platform}/#{publish_profile_id}/publish/#{publish_id}")
+    uri.query = URI.encode_www_form({ action: 'restart' })
+    headers = { Authorization: "Bearer #{auth_token}", content_type: :json, accept: 'application/json' }
+    RestClient.post(uri.to_s, "{}", headers)
+  end
+
+  # Single fetch of the publish object (status + steps). Polled by the action.
+  def self.get_publish_object(auth_token:, platform:, publish_profile_id:, app_version_id:, api_endpoint: BASE_URL)
+    url = "#{api_endpoint}/publish/v1/profiles/#{platform}/#{publish_profile_id}/app-versions/#{app_version_id}/publish"
+    JSON.parse(RestClient.get(url, auth_headers(auth_token)).body)
+  end
+end

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

@@ -0,0 +1,5 @@
+module Fastlane
+  module AppcirclePublish
+    VERSION = "0.1.0.beta.1"
+  end
+end

data/lib/fastlane/plugin/appcircle_publish.rb

@@ -0,0 +1,16 @@
+require 'fastlane/plugin/appcircle_publish/version'
+
+module Fastlane
+  module AppcirclePublish
+    # Return all .rb files inside the "actions" and "helper" directory
+    def self.all_classes
+      Dir[File.expand_path('**/{actions,helper}/*.rb', File.dirname(__FILE__))]
+    end
+  end
+end
+
+# By default we want to import all available actions and helpers
+# A plugin can contain any number of actions and plugins
+Fastlane::AppcirclePublish.all_classes.each do |current|
+  require current
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: fastlane-plugin-appcircle_publish
+version: !ruby/object:Gem::Version
+  version: 0.1.0.beta.1
+platform: ruby
+authors:
+- appcircleio
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-06-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description:
+email: cloud@appcircle.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/fastlane/plugin/appcircle_publish.rb
+- lib/fastlane/plugin/appcircle_publish/actions/appcircle_publish_action.rb
+- lib/fastlane/plugin/appcircle_publish/helper/appcircle_publish_helper.rb
+- lib/fastlane/plugin/appcircle_publish/helper/auth_service.rb
+- lib/fastlane/plugin/appcircle_publish/helper/upload_service.rb
+- lib/fastlane/plugin/appcircle_publish/version.rb
+homepage: https://github.com/appcircleio/fastlane-plugin-appcircle_publish
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.6'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubygems_version: 3.3.27
+signing_key:
+specification_version: 4
+summary: Upload an application binary to an Appcircle Publish profile
+test_files: []