fastlane-plugin-betadrop 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8ce7c339c0a0073c167fda130b72ccd3bab1565ec12866aac66d6343b7b429f7
+  data.tar.gz: 9d13fdd00f6549f200e5f93ca30a3de75316757a69bb20dce441e8d3ca7545cf
+SHA512:
+  metadata.gz: 5ec6c7a516786704d3c2dada1e775334949059f0550d5a0570e680c07dbafe285c69532426db556cec3bac521d3f4dc15096ee289cecd03f69153224acc52212
+  data.tar.gz: 69c1fac304243b36d47c3039ddaaf36756399c7d18a29d25c00c8184788f5794f737bd860dc65b3ec161255fb5cf31dc33744bdc40d14f65a933d05b097700cb

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 BetaDrop
+
+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,58 @@
+# fastlane-plugin-betadrop
+
+Upload the `.ipa` or `.apk` your lane just built to [BetaDrop](https://betadrop.app) and get an
+over-the-air install link — no TestFlight review, no Play track, no tester accounts.
+
+```bash
+fastlane add_plugin betadrop
+```
+
+## Usage
+
+```ruby
+lane :beta do
+  gym(export_method: "ad-hoc")
+  betadrop(
+    notes: last_git_commit[:message],
+    standing_link: "acmebeta",   # optional: one URL testers keep (free: 1, Pro/Studio: up to 50)
+    inspect: true                # refuse to upload a build that will not install from a link
+  )
+  slack(message: "New build: #{lane_context[SharedValues::BETADROP_INSTALL_URL]}")
+end
+```
+
+Set `BETADROP_TOKEN` in your CI secrets (create one at betadrop.app → Settings → Developer → API
+tokens, or with `npx @betadrop/cli tokens create ci`). With no `file:`, the action uploads what
+`gym` or `gradle` produced.
+
+## Actions
+
+### `betadrop`
+
+| Option | Env | Description |
+| --- | --- | --- |
+| `api_token` | `BETADROP_TOKEN` | API token. Required. |
+| `file` | `BETADROP_FILE` | Path to the build. Defaults to `IPA_OUTPUT_PATH` / `GRADLE_APK_OUTPUT_PATH`. |
+| `name` | | Override the build name. |
+| `notes` | `BETADROP_NOTES` | Release notes shown on the install page. |
+| `standing_link` | `BETADROP_STANDING_LINK` | Standing link slug to point at the build. Fails the lane if it could not be moved. |
+| `expires_in_days` · `max_downloads` · `max_devices` | | Limits on the install link; with more than one, it stops at whichever comes first. |
+| `no_expiry` | | Keep the link until the build is deleted (paid plans). |
+| `app_version` · `build_number` · `bundle_id` | | Override what is read from the build. |
+| `inspect` | | Check the build first and fail, with nothing uploaded, if it will not install from a link. |
+| `api_url` | `BETADROP_API_URL` | API host. Default `https://api.betadrop.app`. |
+
+Sets `BETADROP_INSTALL_URL`, `BETADROP_BUILD_ID` and `BETADROP_STANDING_LINK_URL` in
+`lane_context`, and returns the install URL.
+
+### `betadrop_inspect`
+
+Checks a build without uploading it to your account: provisioning profile type and expiry, a
+profile issued for another bundle ID, unsigned or `testOnly` APKs, v1-only signatures on apps
+targeting Android 11+. A read-only token is enough. `strict: true` fails on warnings too;
+`fail_on_error: false` only reports. The report is in `BETADROP_INSPECT_REPORT`.
+
+## Also
+
+- Webhooks to Slack, Discord or your own service: <https://betadrop.app/docs/webhooks/>
+- The CLI the GitHub Action uses: <https://betadrop.app/docs/cli/>

data/lib/fastlane/plugin/betadrop/actions/betadrop_action.rb

@@ -0,0 +1,154 @@
+require 'fastlane/action'
+require_relative '../helper/betadrop_helper'
+
+module Fastlane
+  module Actions
+    module SharedValues
+      BETADROP_INSTALL_URL = :BETADROP_INSTALL_URL
+      BETADROP_BUILD_ID = :BETADROP_BUILD_ID
+      BETADROP_STANDING_LINK_URL = :BETADROP_STANDING_LINK_URL
+    end
+
+    class BetadropAction < Action
+      def self.run(params)
+        file = params[:file] ||
+               Actions.lane_context[SharedValues::IPA_OUTPUT_PATH] ||
+               Actions.lane_context[SharedValues::GRADLE_APK_OUTPUT_PATH]
+        UI.user_error!('No build to upload. Pass file:, or run gym / gradle first.') if file.to_s.empty?
+
+        client = Helper::BetadropHelper.new(api_token: params[:api_token], api_url: params[:api_url])
+
+        if params[:inspect]
+          UI.message("Checking #{File.basename(file)} will install from a link…")
+          report = client.inspect_build(file)
+          (report['checks'] || []).each do |check|
+            case check['level']
+            when 'error' then UI.error(check['message'])
+            when 'warning' then UI.important(check['message'])
+            else UI.success(check['message'])
+            end
+          end
+          unless report['installableFromLink']
+            UI.user_error!("#{File.basename(file)} will not install from a link, so it was not uploaded. Fix the errors above.")
+          end
+        end
+
+        fields = {
+          'name' => params[:name],
+          'notes' => params[:notes],
+          'version' => params[:app_version],
+          'buildNumber' => params[:build_number],
+          'bundleId' => params[:bundle_id],
+          'channel' => params[:standing_link]
+        }.merge(Helper::BetadropHelper.expiry_fields(
+                  days: params[:expires_in_days],
+                  downloads: params[:max_downloads],
+                  devices: params[:max_devices],
+                  permanent: params[:no_expiry]
+                ))
+
+        UI.message("Uploading #{File.basename(file)} to BetaDrop…")
+        result = client.publish(file, fields)
+
+        app_url = (ENV['BETADROP_APP_URL'] || 'https://betadrop.app').sub(%r{/+\z}, '')
+        install_url = "#{app_url}/install/?i=#{result['shortId']}"
+        Actions.lane_context[SharedValues::BETADROP_INSTALL_URL] = install_url
+        Actions.lane_context[SharedValues::BETADROP_BUILD_ID] = result['id']
+
+        UI.important(result['retentionClamp']['message']) if result['retentionClamp']
+        UI.important("#{result['duplicateOf']['message']} (#{result['duplicateOf']['url']})") if result['duplicateOf']
+
+        if result['channel']
+          Actions.lane_context[SharedValues::BETADROP_STANDING_LINK_URL] = result['channel']['url']
+          UI.success("Standing link #{result['channel']['slug']} now serves this build: #{result['channel']['url']}")
+        end
+        UI.success("Install link: #{install_url}")
+        # A standing link that was asked for and did not move is a failed release, even though the
+        # build itself is live — the same rule the CLI and the GitHub Action apply.
+        UI.user_error!(result['channelWarning']) if result['channelWarning']
+
+        install_url
+      rescue Helper::BetadropHelper::Error => e
+        UI.user_error!(e.message)
+      end
+
+      def self.description
+        'Upload an .ipa or .apk to BetaDrop and get an over-the-air install link'
+      end
+
+      def self.details
+        'Publishes the build gym or gradle just produced. Optionally checks it will install from a ' \
+          'link first, points a standing link at it, and limits how long or how widely the link works.'
+      end
+
+      def self.authors
+        ['BetaDrop']
+      end
+
+      def self.return_value
+        'The install URL'
+      end
+
+      def self.output
+        [
+          ['BETADROP_INSTALL_URL', 'Install link for the uploaded build'],
+          ['BETADROP_BUILD_ID', 'BetaDrop build id'],
+          ['BETADROP_STANDING_LINK_URL', 'The standing link URL, when standing_link was set']
+        ]
+      end
+
+      def self.available_options
+        positive = proc do |name|
+          proc do |value|
+            UI.user_error!("#{name} must be a whole number of 1 or more") unless value.to_s =~ /\A[1-9]\d*\z/
+          end
+        end
+        [
+          FastlaneCore::ConfigItem.new(key: :api_token, env_name: 'BETADROP_TOKEN', sensitive: true,
+                                       description: 'BetaDrop API token (bd_live_…)', optional: false),
+          FastlaneCore::ConfigItem.new(key: :file, env_name: 'BETADROP_FILE', optional: true,
+                                       description: 'Path to the .ipa or .apk. Defaults to the output of gym or gradle'),
+          FastlaneCore::ConfigItem.new(key: :name, optional: true, description: 'Override the build name'),
+          FastlaneCore::ConfigItem.new(key: :notes, env_name: 'BETADROP_NOTES', optional: true,
+                                       description: 'Release notes shown on the install page'),
+          FastlaneCore::ConfigItem.new(key: :standing_link, env_name: 'BETADROP_STANDING_LINK', optional: true,
+                                       description: 'Standing link slug to point at this build (must already be claimed)'),
+          FastlaneCore::ConfigItem.new(key: :expires_in_days, optional: true, type: Integer,
+                                       verify_block: positive.call('expires_in_days'),
+                                       description: 'Stop the install link working after this many days'),
+          FastlaneCore::ConfigItem.new(key: :max_downloads, optional: true, type: Integer,
+                                       verify_block: positive.call('max_downloads'),
+                                       description: 'Stop the install link after this many downloads'),
+          FastlaneCore::ConfigItem.new(key: :max_devices, optional: true, type: Integer,
+                                       verify_block: positive.call('max_devices'),
+                                       description: 'Stop the install link after this many devices'),
+          FastlaneCore::ConfigItem.new(key: :no_expiry, optional: true, type: Boolean, default_value: false,
+                                       description: 'Keep the link working until the build is deleted (paid plans)'),
+          FastlaneCore::ConfigItem.new(key: :app_version, optional: true, description: 'Override the version string'),
+          FastlaneCore::ConfigItem.new(key: :build_number, optional: true, description: 'Override the build number'),
+          FastlaneCore::ConfigItem.new(key: :bundle_id, optional: true, description: 'Override the bundle / package id'),
+          FastlaneCore::ConfigItem.new(key: :inspect, optional: true, type: Boolean, default_value: false,
+                                       description: 'Check the build will install from a link before uploading, and fail if not'),
+          FastlaneCore::ConfigItem.new(key: :api_url, env_name: 'BETADROP_API_URL', optional: true,
+                                       default_value: 'https://api.betadrop.app', description: 'API host')
+        ]
+      end
+
+      def self.is_supported?(platform)
+        %i[ios android].include?(platform)
+      end
+
+      def self.example_code
+        [
+          'betadrop',
+          'betadrop(notes: last_git_commit[:message], standing_link: "acmebeta", inspect: true)',
+          'betadrop(file: "app/build/outputs/apk/release/app-release.apk", max_devices: 25)'
+        ]
+      end
+
+      def self.category
+        :beta
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/betadrop/actions/betadrop_inspect_action.rb

@@ -0,0 +1,78 @@
+require 'fastlane/action'
+require_relative '../helper/betadrop_helper'
+
+module Fastlane
+  module Actions
+    module SharedValues
+      BETADROP_INSPECT_REPORT = :BETADROP_INSPECT_REPORT
+    end
+
+    # Check a build will install from a link without uploading it to the account — the step to put
+    # between gym and the rest of a release lane.
+    class BetadropInspectAction < Action
+      def self.run(params)
+        file = params[:file] || Actions.lane_context[SharedValues::IPA_OUTPUT_PATH] ||
+               Actions.lane_context[SharedValues::GRADLE_APK_OUTPUT_PATH]
+        UI.user_error!('No build to inspect. Pass file:, or run gym / gradle first.') if file.to_s.empty?
+
+        report = Helper::BetadropHelper.new(api_token: params[:api_token], api_url: params[:api_url]).inspect_build(file)
+        Actions.lane_context[SharedValues::BETADROP_INSPECT_REPORT] = report
+
+        (report['checks'] || []).each do |check|
+          case check['level']
+          when 'error' then UI.error(check['message'])
+          when 'warning' then UI.important(check['message'])
+          else UI.success(check['message'])
+          end
+        end
+
+        failed = (report['checks'] || []).any? do |c|
+          c['level'] == 'error' || (params[:strict] && c['level'] == 'warning')
+        end
+        UI.user_error!("#{File.basename(file)} failed the install check.") if failed && params[:fail_on_error]
+        UI.success('Installable from a link.') unless failed
+        report
+      rescue Helper::BetadropHelper::Error => e
+        UI.user_error!(e.message)
+      end
+
+      def self.description
+        'Check an .ipa or .apk will install from a link: profile type and expiry, signing, testOnly'
+      end
+
+      def self.authors
+        ['BetaDrop']
+      end
+
+      def self.return_value
+        'The inspection report (a Hash)'
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :api_token, env_name: 'BETADROP_TOKEN', sensitive: true,
+                                       description: 'BetaDrop API token; a read-only token is enough', optional: false),
+          FastlaneCore::ConfigItem.new(key: :file, optional: true, description: 'Path to the .ipa or .apk'),
+          FastlaneCore::ConfigItem.new(key: :strict, optional: true, type: Boolean, default_value: false,
+                                       description: 'Treat warnings as failures'),
+          FastlaneCore::ConfigItem.new(key: :fail_on_error, optional: true, type: Boolean, default_value: true,
+                                       description: 'Fail the lane when a check fails'),
+          FastlaneCore::ConfigItem.new(key: :api_url, env_name: 'BETADROP_API_URL', optional: true,
+                                       default_value: 'https://api.betadrop.app', description: 'API host')
+        ]
+      end
+
+      def self.is_supported?(platform)
+        %i[ios android].include?(platform)
+      end
+
+      def self.example_code
+        ['betadrop_inspect', 'betadrop_inspect(strict: true)']
+      end
+
+      def self.category
+        :beta
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/betadrop/helper/betadrop_helper.rb

@@ -0,0 +1,143 @@
+require 'json'
+require 'net/http'
+require 'securerandom'
+require 'stringio'
+require 'uri'
+require_relative '../version'
+
+module Fastlane
+  module Helper
+    # The HTTP half of the plugin, kept free of fastlane so it can be tested with plain Ruby.
+    #
+    # Uploads stream from disk: a build can be hundreds of megabytes, and reading it into memory
+    # to build a multipart body is how a CI runner with a small heap falls over.
+    class BetadropHelper
+      DEFAULT_API_URL = 'https://api.betadrop.app'.freeze
+
+      class Error < StandardError
+        attr_reader :status, :reason
+
+        def initialize(message, status: nil, reason: nil)
+          super(message)
+          @status = status
+          @reason = reason
+        end
+      end
+
+      # An IO that reads several IOs one after another, so Net::HTTP can stream the multipart
+      # preamble, the file and the epilogue as one body with a known length.
+      class ChainIO
+        def initialize(*parts)
+          @parts = parts
+        end
+
+        def read(length = nil, outbuf = nil)
+          outbuf ||= +''
+          outbuf.clear
+          until @parts.empty?
+            chunk = @parts.first.read(length ? length - outbuf.bytesize : nil)
+            if chunk.nil? || chunk.empty?
+              @parts.shift
+              next
+            end
+            outbuf << chunk
+            break if length && outbuf.bytesize >= length
+          end
+          outbuf.empty? && length ? nil : outbuf
+        end
+      end
+
+      def initialize(api_token:, api_url: nil, user_agent: nil)
+        raise Error, 'A BetaDrop API token is required (api_token, or BETADROP_TOKEN).' if api_token.to_s.strip.empty?
+
+        @token = api_token.strip
+        @base = (api_url.to_s.strip.empty? ? DEFAULT_API_URL : api_url.strip).sub(%r{/+\z}, '')
+        @user_agent = user_agent || "fastlane-plugin-betadrop/#{Fastlane::Betadrop::VERSION}"
+      end
+
+      # POST /api/cli/publish. `fields` values that are nil or empty are not sent.
+      def publish(file, fields = {})
+        multipart('/api/cli/publish', file, fields)
+      end
+
+      # POST /api/inspect. Stores nothing on the account.
+      def inspect_build(file)
+        multipart('/api/inspect', file, {})
+      end
+
+      # Turn the three limit options into the API's expiry fields — the same rule the CLI uses:
+      # one limit is that kind, more than one is `combined`, none sends nothing.
+      def self.expiry_fields(days: nil, downloads: nil, devices: nil, permanent: false)
+        return { 'expiry_type' => 'none' } if permanent
+
+        set = { 'expiry_time_days' => days, 'expiry_download_limit' => downloads, 'expiry_device_limit' => devices }
+              .reject { |_, v| v.nil? || v.to_s.strip.empty? }
+        return {} if set.empty?
+
+        type = if set.size > 1 then 'combined'
+               elsif set.key?('expiry_time_days') then 'time'
+               elsif set.key?('expiry_download_limit') then 'downloads'
+               else 'devices'
+               end
+        set.merge('expiry_type' => type)
+      end
+
+      private
+
+      def multipart(path, file, fields)
+        raise Error, "No build found at #{file}" unless file && File.file?(file)
+
+        boundary = "----betadropfastlane#{SecureRandom.hex(16)}"
+        preamble = +''
+        fields.each do |key, value|
+          next if value.nil? || value.to_s.empty?
+
+          preamble << "--#{boundary}\r\nContent-Disposition: form-data; name=\"#{key}\"\r\n\r\n#{value}\r\n"
+        end
+        filename = File.basename(file).gsub(/["\\\r\n]/, '_')
+        preamble << "--#{boundary}\r\nContent-Disposition: form-data; name=\"file\"; filename=\"#{filename}\"\r\n" \
+                    "Content-Type: application/octet-stream\r\n\r\n"
+        epilogue = "\r\n--#{boundary}--\r\n"
+
+        uri = URI("#{@base}#{path}")
+        File.open(file, 'rb') do |io|
+          request = Net::HTTP::Post.new(uri)
+          request['Authorization'] = "Bearer #{@token}"
+          request['Accept'] = 'application/json'
+          request['User-Agent'] = @user_agent
+          request['Content-Type'] = "multipart/form-data; boundary=#{boundary}"
+          request['Content-Length'] = (preamble.bytesize + File.size(file) + epilogue.bytesize).to_s
+          request.body_stream = ChainIO.new(StringIO.new(preamble), io, StringIO.new(epilogue))
+          send_request(uri, request)
+        end
+      end
+
+      def send_request(uri, request)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == 'https'
+        http.open_timeout = 30
+        # A large upload on a slow runner. The server answers once the file is stored and parsed.
+        http.read_timeout = 900
+        http.write_timeout = 900 if http.respond_to?(:write_timeout=)
+        response = http.request(request)
+        body = begin
+          JSON.parse(response.body.to_s)
+        rescue JSON::ParserError
+          nil
+        end
+        status = response.code.to_i
+        if status == 401
+          raise Error.new('BetaDrop rejected the API token: it is invalid, expired or revoked.', status: status)
+        end
+        if body.nil?
+          raise Error.new("Unexpected response from BetaDrop (HTTP #{status}).", status: status)
+        end
+        unless status.between?(200, 299) && body['success'] != false
+          raise Error.new(body['error'] || body['message'] || "Request failed (HTTP #{status}).",
+                          status: status, reason: body['reason'])
+        end
+        body['data']
+      end
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+module Fastlane
+  module Betadrop
+    VERSION = "0.1.0"
+  end
+end

data/lib/fastlane/plugin/betadrop.rb

@@ -0,0 +1,14 @@
+require 'fastlane/plugin/betadrop/version'
+
+module Fastlane
+  module Betadrop
+    # Loads every action and helper in this plugin, the way fastlane's plugin loader expects.
+    def self.all_classes
+      Dir[File.expand_path('**/{actions,helper}/*.rb', File.dirname(__FILE__))]
+    end
+  end
+end
+
+Fastlane::Betadrop.all_classes.each do |current|
+  require current
+end

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: fastlane-plugin-betadrop
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- BetaDrop
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2026-11-15 00:00:00.000000000 Z
+dependencies: []
+description: Publishes the .ipa or .apk your lane built to BetaDrop, optionally checks
+  it will install from a link first, and can point a standing link at it.
+email: support@betadrop.app
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/fastlane/plugin/betadrop.rb
+- lib/fastlane/plugin/betadrop/actions/betadrop_action.rb
+- lib/fastlane/plugin/betadrop/actions/betadrop_inspect_action.rb
+- lib/fastlane/plugin/betadrop/helper/betadrop_helper.rb
+- lib/fastlane/plugin/betadrop/version.rb
+homepage: https://betadrop.app/integrations/fastlane/
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/betadrop-app/fastlane-plugin-betadrop
+  documentation_uri: https://betadrop.app/integrations/fastlane/
+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: '0'
+requirements: []
+rubygems_version: 3.0.3.1
+signing_key: 
+specification_version: 4
+summary: Upload iOS and Android builds to BetaDrop and get an over-the-air install
+  link.
+test_files: []