fastlane-plugin-app_dropper 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 76c011d561432b70d2ec3994e11145fd34e8ade523503b8d2548f4b266fa43cd
+  data.tar.gz: c19756277bd79750da48a86bf2693ce372ff923be66447f185b29993e57f2eb1
+SHA512:
+  metadata.gz: c6f423e2b20583c66fc536c928960879929dc247bf80c63344faad52eb6b988a54f554144bb825460bda1af229b358a562f65df3d9ae2a43c4823b9f523c3139
+  data.tar.gz: ab27205510035b373d668fc31b4df2ccdb91e77729d65f21e2c920322d9450c9d98bff3e1e4da22d299105a450fc91c21a090bff14a22e1de7c202c162206992

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 App Dropper
+
+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,133 @@
+# fastlane-plugin-app_dropper
+
+[![fastlane Plugin Badge](https://rawcdn.githack.com/fastlane/fastlane/master/fastlane/assets/plugin-badge.svg)](https://rubygems.org/gems/fastlane-plugin-app_dropper)
+
+Upload the build your lane just produced to [App Dropper](https://appdropper.io) and get a shareable install link back.
+
+## Getting started
+
+```bash
+fastlane add_plugin app_dropper
+```
+
+Generate an API token under **Settings → API tokens** in your App Dropper dashboard, and export it:
+
+```bash
+export APPDROPPER_TOKEN="adp_…"
+```
+
+Each token is scoped to a single app and carries one scope, `upload:builds` — it cannot delete builds, manage testers, read billing, or reach another app.
+
+## Usage
+
+With no arguments, the action uploads whatever the lane most recently built — `IPA_OUTPUT_PATH`, falling back to `GRADLE_APK_OUTPUT_PATH`:
+
+```ruby
+lane :beta do
+  build_app(scheme: "MyApp", export_method: "ad-hoc")
+  app_dropper
+end
+```
+
+Or spell it out:
+
+```ruby
+lane :beta do
+  build_app(scheme: "MyApp", export_method: "ad-hoc")
+
+  app_dropper(
+    api_token: ENV["APPDROPPER_TOKEN"],
+    file: lane_context[SharedValues::IPA_OUTPUT_PATH],
+    release_notes: last_git_commit[:message],
+    tag: "adhoc"
+  )
+end
+```
+
+### Android
+
+```ruby
+lane :beta do
+  gradle(task: "assemble", build_type: "Release")
+
+  app_dropper(
+    file: lane_context[SharedValues::GRADLE_APK_OUTPUT_PATH],
+    release_notes: last_git_commit[:message]
+  )
+end
+```
+
+## Options
+
+| Option | Environment variable | Default |
+|---|---|---|
+| `api_token` | `APPDROPPER_TOKEN` | required |
+| `file` | `APPDROPPER_FILE` | the lane's `.ipa`, else its `.apk` |
+| `release_notes` | `APPDROPPER_RELEASE_NOTES` | empty |
+| `tag` | `APPDROPPER_TAG` | `beta` |
+| `timeout` | `APPDROPPER_TIMEOUT` | `600` seconds |
+| `api_url` | `APPDROPPER_API_URL` | `https://appdropper.io/api/v1` |
+
+`api_token` is declared sensitive, so fastlane redacts it from logs and from the run summary.
+
+## Return value and lane context
+
+The action returns the install link, and also sets:
+
+| Lane context key | Contains |
+|---|---|
+| `APP_DROPPER_INSTALL_URL` | Public install link |
+| `APP_DROPPER_BUILD_ID` | Identifier of the new build |
+| `APP_DROPPER_QR_URL` | PNG QR code for the install link |
+| `APP_DROPPER_VERSION` | Version string read out of the binary |
+
+```ruby
+url = app_dropper
+slack(message: "New iOS beta is up: #{url}")
+```
+
+## Switching from Diawi
+
+The action is deliberately shaped like the community `diawi` plugin, so the change is mechanical:
+
+```ruby
+# Before
+diawi(
+  token: ENV["DIAWI_TOKEN"],
+  file: lane_context[SharedValues::IPA_OUTPUT_PATH],
+  comment: last_git_commit[:message]
+)
+
+# After
+app_dropper(
+  api_token: ENV["APPDROPPER_TOKEN"],
+  file: lane_context[SharedValues::IPA_OUTPUT_PATH],
+  release_notes: last_git_commit[:message]
+)
+```
+
+Both block the lane until the build is processed and both return a link. App Dropper additionally groups builds into an app with full version history, notifies your registered testers by email and push, and keeps builds for 7 days on free or 30 on Pro (indefinitely if you pin one).
+
+## How it works
+
+The binary never passes through the API. The action reserves an upload (which is where every plan limit and quota is applied), streams the file straight to Google Cloud Storage, then waits for the server to parse it. That's what keeps a 500 MB `.ipa` clear of the request-size ceilings every HTTP API has.
+
+No runtime dependencies — everything uses Ruby's standard library, so installing this plugin can't drag a conflicting HTTP gem into your `Gemfile.lock`.
+
+## Development
+
+```bash
+bundle install
+bundle exec rspec
+bundle exec rubocop
+```
+
+## Docs
+
+- [Fastlane guide](https://appdropper.io/help/fastlane-plugin)
+- [CI/CD setup guide](https://appdropper.io/help/ci-cd-uploads)
+- [REST API reference](https://appdropper.io/help/api)
+
+## License
+
+MIT

data/lib/fastlane/plugin/app_dropper/actions/app_dropper_action.rb

@@ -0,0 +1,180 @@
+require 'fastlane/action'
+require_relative '../helper/app_dropper_helper'
+
+module Fastlane
+  module Actions
+    module SharedValues
+      APP_DROPPER_INSTALL_URL = :APP_DROPPER_INSTALL_URL
+      APP_DROPPER_BUILD_ID = :APP_DROPPER_BUILD_ID
+      APP_DROPPER_QR_URL = :APP_DROPPER_QR_URL
+      APP_DROPPER_VERSION = :APP_DROPPER_VERSION
+    end
+
+    class AppDropperAction < Action
+      def self.run(params)
+        path = File.expand_path(params[:file])
+        UI.user_error!("App Dropper: no such file — #{path}") unless File.exist?(path)
+
+        extension = File.extname(path).downcase
+        unless ['.apk', '.ipa'].include?(extension)
+          UI.user_error!("App Dropper: only .apk and .ipa builds can be uploaded (got '#{extension}').")
+        end
+
+        file_name = File.basename(path)
+        file_size = File.size(path)
+        helper = Helper::AppDropperHelper.new(
+          api_token: params[:api_token],
+          api_url: params[:api_url]
+        )
+
+        UI.message("Uploading #{file_name} (#{format_size(file_size)}) to App Dropper…")
+
+        ticket = helper.create_upload(
+          file_name: file_name,
+          file_size: file_size,
+          release_notes: params[:release_notes],
+          tag: params[:tag]
+        )
+
+        helper.send_binary(ticket['upload_url'], path, ticket['content_type'])
+        UI.message("Upload finished — waiting for App Dropper to process the build…")
+
+        result = helper.await_upload(ticket['upload_id'], timeout: params[:timeout])
+
+        if result['status'] == 'error'
+          UI.user_error!("App Dropper: #{result.dig('error', 'message') || 'the build could not be processed.'}")
+        end
+        unless result['status'] == 'ready'
+          UI.user_error!("App Dropper: the build is still processing after #{params[:timeout]}s. Nothing was lost — check your dashboard.")
+        end
+
+        install_url = result['install_url']
+        Actions.lane_context[SharedValues::APP_DROPPER_INSTALL_URL] = install_url
+        Actions.lane_context[SharedValues::APP_DROPPER_BUILD_ID] = result['build_id']
+        Actions.lane_context[SharedValues::APP_DROPPER_QR_URL] = result['qr_url']
+        Actions.lane_context[SharedValues::APP_DROPPER_VERSION] = result['version']
+
+        UI.success("#{result['app_name']} #{result['version']} is live: #{install_url}")
+        install_url
+      end
+
+      def self.format_size(bytes)
+        bytes >= 1024 * 1024 ? "#{(bytes / 1024.0 / 1024.0).round(1)} MB" : "#{(bytes / 1024.0).round} KB"
+      end
+
+      def self.description
+        "Upload an .apk or .ipa to App Dropper and get a shareable install link"
+      end
+
+      def self.details
+        [
+          "Sends a build to App Dropper and returns its public install link.",
+          "",
+          "The binary goes straight to storage on a resumable session rather than",
+          "through the API, so build size is bounded only by your plan.",
+          "",
+          "Generate a token under Settings → API tokens in your App Dropper",
+          "dashboard. Each token is scoped to one app and can only upload builds."
+        ].join("\n")
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(
+            key: :api_token,
+            env_name: "APPDROPPER_TOKEN",
+            description: "Your App Dropper API token",
+            sensitive: true,
+            verify_block: proc do |value|
+              UI.user_error!("No API token — set APPDROPPER_TOKEN or pass api_token:") if value.to_s.empty?
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :file,
+            env_name: "APPDROPPER_FILE",
+            description: "Path to the .apk or .ipa to upload",
+            # Whichever of the two the lane just produced. Both are set by the
+            # standard build actions, so the common case needs no `file:` at all.
+            default_value: Actions.lane_context[SharedValues::IPA_OUTPUT_PATH] ||
+                           Actions.lane_context[SharedValues::GRADLE_APK_OUTPUT_PATH],
+            default_value_dynamic: true,
+            verify_block: proc do |value|
+              UI.user_error!("Couldn't find a build to upload — pass file:") if value.to_s.empty?
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :release_notes,
+            env_name: "APPDROPPER_RELEASE_NOTES",
+            description: "Release notes shown to testers on the install page",
+            optional: true,
+            default_value: ""
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :tag,
+            env_name: "APPDROPPER_TAG",
+            description: "Label for this build, e.g. 'beta' or 'nightly'",
+            optional: true,
+            default_value: ""
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :timeout,
+            env_name: "APPDROPPER_TIMEOUT",
+            description: "Seconds to wait for the build to finish processing",
+            optional: true,
+            type: Integer,
+            default_value: Helper::AppDropperHelper::DEFAULT_TIMEOUT
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :api_url,
+            env_name: "APPDROPPER_API_URL",
+            description: "API base URL — only needed for a self-hosted deployment",
+            optional: true
+          )
+        ]
+      end
+
+      def self.output
+        [
+          ['APP_DROPPER_INSTALL_URL', 'Public install link for the uploaded build'],
+          ['APP_DROPPER_BUILD_ID', 'Identifier of the build that was created'],
+          ['APP_DROPPER_QR_URL', 'PNG QR code pointing at the install link'],
+          ['APP_DROPPER_VERSION', 'Version string parsed out of the binary']
+        ]
+      end
+
+      def self.return_value
+        "The public install link"
+      end
+
+      def self.authors
+        ["App Dropper"]
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :android].include?(platform)
+      end
+
+      def self.example_code
+        [
+          'app_dropper(
+            api_token: ENV["APPDROPPER_TOKEN"],
+            file: lane_context[SharedValues::IPA_OUTPUT_PATH]
+          )',
+          '# Android, with the last commit message as release notes
+          app_dropper(
+            file: lane_context[SharedValues::GRADLE_APK_OUTPUT_PATH],
+            release_notes: last_git_commit[:message],
+            tag: "nightly"
+          )',
+          '# The install link is both the return value and a lane_context entry
+          url = app_dropper
+          slack(message: "New build ready: #{url}")'
+        ]
+      end
+
+      def self.category
+        :beta
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/app_dropper/helper/app_dropper_helper.rb

@@ -0,0 +1,133 @@
+require 'fastlane_core/ui/ui'
+require 'net/http'
+require 'json'
+require 'uri'
+
+module Fastlane
+  UI = FastlaneCore::UI unless Fastlane.const_defined?(:UI)
+
+  module Helper
+    # Talks to the App Dropper REST API over Ruby's standard library only.
+    #
+    # Binaries never pass through the API: `create_upload` returns a Google
+    # Cloud Storage resumable session, `send_binary` streams the file straight
+    # there, and `await_upload` waits for the server to parse it. That is what
+    # keeps a 500 MB .ipa clear of the request-size ceilings every HTTP API has.
+    class AppDropperHelper
+      DEFAULT_API_URL = "https://appdropper.io/api/v1".freeze
+      # Matches the CLI: long enough for a large build to be parsed, short
+      # enough that a wedged lane eventually fails instead of hanging a CI job.
+      DEFAULT_TIMEOUT = 600
+
+      def initialize(api_token:, api_url: nil)
+        @api_token = api_token
+        @api_url = (api_url || ENV['APPDROPPER_API_URL'] || DEFAULT_API_URL).chomp('/')
+      end
+
+      def create_upload(file_name:, file_size:, release_notes:, tag:)
+        post('/uploads', {
+          file_name: file_name,
+          file_size: file_size,
+          release_notes: release_notes.to_s,
+          tag: tag.to_s
+        })
+      end
+
+      # A single PUT of the whole file. Net::HTTP streams from the IO rather
+      # than reading the build into memory, which matters when the build is
+      # bigger than the runner's RAM budget.
+      def send_binary(session_url, path, content_type)
+        uri = URI.parse(session_url)
+        size = File.size(path)
+
+        File.open(path, 'rb') do |io|
+          request = Net::HTTP::Put.new(uri)
+          request['Content-Type'] = content_type
+          request['Content-Length'] = size.to_s
+          request.body_stream = io
+
+          response = http_for(uri, read_timeout: 900).request(request)
+          unless response.is_a?(Net::HTTPSuccess)
+            UI.user_error!("App Dropper: storage rejected the upload (HTTP #{response.code}). #{response.body.to_s[0, 300]}")
+          end
+        end
+      end
+
+      # Long-polls the upload until it is parsed. The server holds the
+      # connection for `wait` seconds, so this is normally one request.
+      def await_upload(upload_id, timeout: DEFAULT_TIMEOUT)
+        deadline = Time.now + timeout
+        loop do
+          remaining = (deadline - Time.now).to_i
+          wait = [[remaining, 120].min, 0].max
+          result = get("/uploads/#{upload_id}?wait=#{wait}")
+          status = result['status']
+          return result if status == 'ready' || status == 'error'
+          return result if Time.now >= deadline
+        end
+      end
+
+      def whoami
+        get('/me')
+      end
+
+      private
+
+      def http_for(uri, read_timeout: 60)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == 'https'
+        http.open_timeout = 30
+        http.read_timeout = read_timeout
+        http
+      end
+
+      def get(path)
+        uri = URI.parse("#{@api_url}#{path}")
+        request = Net::HTTP::Get.new(uri)
+        apply_headers(request)
+        # Generously past the server's own hold, so the client isn't what gives
+        # up on a request the server is still honouring.
+        parse(http_for(uri, read_timeout: 180).request(request))
+      end
+
+      def post(path, body)
+        uri = URI.parse("#{@api_url}#{path}")
+        request = Net::HTTP::Post.new(uri)
+        apply_headers(request)
+        request['Content-Type'] = 'application/json'
+        request.body = body.to_json
+        parse(http_for(uri).request(request))
+      end
+
+      def apply_headers(request)
+        request['Authorization'] = "Bearer #{@api_token}"
+        request['Accept'] = 'application/json'
+        request['User-Agent'] = "fastlane-plugin-app_dropper/#{Fastlane::AppDropper::VERSION}"
+      end
+
+      def parse(response)
+        parsed = begin
+          response.body.to_s.empty? ? {} : JSON.parse(response.body)
+        rescue JSON::ParserError
+          {}
+        end
+
+        return parsed if response.is_a?(Net::HTTPSuccess)
+
+        message = parsed.dig('error', 'message') || "HTTP #{response.code}"
+        # The API answers 401/403 for a token problem; naming it here saves the
+        # usual round of "is the secret even set?" debugging.
+        case response.code.to_i
+        when 401, 403
+          UI.user_error!("App Dropper: #{message} Check that APPDROPPER_TOKEN is set and scoped to this app.")
+        when 402
+          UI.user_error!("App Dropper: #{message}")
+        when 429
+          UI.user_error!("App Dropper: #{message}")
+        else
+          UI.user_error!("App Dropper: #{message}")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+module Fastlane
+  module AppDropper
+    VERSION = "1.0.0"
+  end
+end

data/lib/fastlane/plugin/app_dropper.rb

@@ -0,0 +1,16 @@
+require 'fastlane/plugin/app_dropper/version'
+
+module Fastlane
+  module AppDropper
+    # Returns all .rb files inside the "actions" and "helper" directory, which
+    # is how fastlane discovers what a plugin provides.
+    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.
+Fastlane::AppDropper.all_classes.each do |current|
+  require current
+end

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: fastlane-plugin-app_dropper
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- App Dropper
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2026-08-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: fastlane
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.170.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.170.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.12.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.12.1
+description: A fastlane action that sends the build your lane just produced to App
+  Dropper, then returns a public install link and QR code for your testers.
+email: support@appdropper.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/fastlane/plugin/app_dropper.rb
+- lib/fastlane/plugin/app_dropper/actions/app_dropper_action.rb
+- lib/fastlane/plugin/app_dropper/helper/app_dropper_helper.rb
+- lib/fastlane/plugin/app_dropper/version.rb
+homepage: https://appdropper.io/help/fastlane-plugin
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://appdropper.io/help/fastlane-plugin
+  documentation_uri: https://appdropper.io/help/fastlane-plugin
+  source_code_uri: https://github.com/appdropper-io/fastlane-plugin-app_dropper
+  bug_tracker_uri: https://appdropper.io/contact
+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 .apk and .ipa builds to App Dropper and get a shareable install link
+test_files: []