fastlane-plugin-appforshare 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: aee20a5b8c8408a2f2c378c1505861079a8d105a8b02349ef6b2eb5224825ed0
+  data.tar.gz: fc0dd2c5963ea01feadd098cc60f503e912d7204deeda3fb0d8ec6b1c5f1f53e
+SHA512:
+  metadata.gz: a5134d0a31ed40d12f0be48c44e9aa1ec79d77328a7d02dce515e64bb8b3317f5878a8f1ce367273075ec03bde8795080778b14c7c1f7dec3cb1b8f60cccef69
+  data.tar.gz: 00356bda06a9a8418525a13243de865d83ab7c32a1a92a53a67c6fe2d0bf68fd4a6699c0bc8965a78d6344336f53a5ed0a3af081168d24aeede6e13c9a52087a

data/LICENSE

@@ -0,0 +1,16 @@
+MIT License
+
+Copyright (c) 2026 AppForShare
+
+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,31 @@
+# fastlane-plugin-appforshare
+
+Upload iOS (.ipa) and Android (.apk) builds to [AppForShare](https://appforshare.io) from fastlane and get an
+install link and QR code page for your testers.
+
+```sh
+fastlane add_plugin appforshare
+```
+
+```ruby
+lane :beta do
+  gym(export_method: "ad-hoc")
+  appforshare(release_notes: "Fixes the login crash", fail_on: "blocked")
+  slack(message: "New build: #{lane_context[SharedValues::APPFORSHARE_URL]}")
+end
+```
+
+Set `APPFORSHARE_TOKEN` (Dashboard, Settings, API tokens; Pro and Team plans). Without `file:` the action takes
+the build from gym (`IPA_OUTPUT_PATH`) or gradle (`GRADLE_APK_OUTPUT_PATH`).
+
+| Option | Env | |
+|---|---|---|
+| `api_token` | `APPFORSHARE_TOKEN` | API token |
+| `file` | `APPFORSHARE_FILE` | .ipa or .apk |
+| `release_notes` | `APPFORSHARE_RELEASE_NOTES` | Shown to testers (Pro and Team) |
+| `fail_on` | `APPFORSHARE_FAIL_ON` | `blocked` or `review`: fail the lane on the store readiness check. The build stays uploaded. |
+
+Lane context after the action: `APPFORSHARE_URL`, `APPFORSHARE_SLUG`, `APPFORSHARE_READINESS`. The store readiness
+check is guidance about current App Store and Google Play rules, not a promise of approval.
+
+MIT license. Source: https://github.com/appforshare/fastlane-plugin-appforshare

data/lib/fastlane/plugin/appforshare/actions/appforshare_action.rb

@@ -0,0 +1,98 @@
+require 'fastlane/action'
+require_relative '../helper/client'
+
+module Fastlane
+  module Actions
+    module SharedValues
+      APPFORSHARE_URL = :APPFORSHARE_URL
+      APPFORSHARE_SLUG = :APPFORSHARE_SLUG
+      APPFORSHARE_READINESS = :APPFORSHARE_READINESS
+    end
+
+    class AppforshareAction < Action
+      def self.run(params)
+        file = params[:file]
+        UI.user_error!('No build to upload. Pass file: or run gym / gradle first.') unless file && File.exist?(file)
+        client = Helper::AppforshareClient.new(token: params[:api_token], api: params[:api_url], log: ->(m) { UI.message(m) })
+        status = client.upload(file, notes: params[:release_notes])
+        readiness = 'unknown'
+        findings = []
+        begin
+          detail = client.build(status['slug'])
+          readiness = detail.dig('readinessReport', 'status') || 'unknown'
+          findings = detail.dig('readinessReport', 'findings') || []
+        rescue Helper::AppforshareClient::Error => e
+          raise if params[:fail_on]
+
+          UI.important("Store readiness not read: #{e.message}")
+        end
+        Actions.lane_context[SharedValues::APPFORSHARE_URL] = status['url']
+        Actions.lane_context[SharedValues::APPFORSHARE_SLUG] = status['slug']
+        Actions.lane_context[SharedValues::APPFORSHARE_READINESS] = readiness
+        UI.success("Install link: #{status['url']}")
+        UI.message("Store readiness: #{readiness}")
+        findings.each { |f| UI.important("[#{f['level']}] #{f['title']}: #{f['fix']}") }
+        fail_on = params[:fail_on]
+        if (fail_on == 'blocked' && readiness == 'blocked') || (fail_on == 'review' && %w[blocked review].include?(readiness))
+          UI.user_error!("Store readiness is \"#{readiness}\" (fail_on: #{fail_on}). The build is uploaded and its link works: #{status['url']}")
+        end
+        status['url']
+      rescue Helper::AppforshareClient::Error => e
+        UI.user_error!(e.message)
+      end
+
+      def self.description
+        'Upload an .ipa or .apk to AppForShare and get an install link for testers'
+      end
+
+      def self.details
+        'Uploads in 32 MB chunks (resumes after a dropped connection), waits until the build is ready, returns the ' \
+          'install link and reads the store readiness check. Needs an AppForShare API token (Pro and Team plans).'
+      end
+
+      def self.authors
+        ['AppForShare']
+      end
+
+      def self.return_value
+        'The install link'
+      end
+
+      def self.output
+        [
+          ['APPFORSHARE_URL', 'Install link'],
+          ['APPFORSHARE_SLUG', 'Share code of the build'],
+          ['APPFORSHARE_READINESS', 'Store readiness status: ready, review, blocked or unknown']
+        ]
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :api_token, env_name: 'APPFORSHARE_TOKEN', description: 'AppForShare API token (Dashboard, Settings)', sensitive: true, optional: false),
+          FastlaneCore::ConfigItem.new(key: :file, env_name: 'APPFORSHARE_FILE', description: 'Path to the .ipa or .apk', optional: true,
+                                       default_value: Actions.lane_context[SharedValues::IPA_OUTPUT_PATH] || Actions.lane_context[SharedValues::GRADLE_APK_OUTPUT_PATH],
+                                       default_value_dynamic: true),
+          FastlaneCore::ConfigItem.new(key: :release_notes, env_name: 'APPFORSHARE_RELEASE_NOTES', description: 'Release notes shown to testers (Pro and Team)', optional: true),
+          FastlaneCore::ConfigItem.new(key: :fail_on, env_name: 'APPFORSHARE_FAIL_ON', description: 'Fail the lane when store readiness is "blocked", or "review"', optional: true,
+                                       verify_block: proc { |v| UI.user_error!('fail_on takes "blocked" or "review"') unless %w[blocked review].include?(v) }),
+          FastlaneCore::ConfigItem.new(key: :api_url, env_name: 'APPFORSHARE_API', description: 'API origin', optional: true, default_value: 'https://appforshare.io')
+        ]
+      end
+
+      def self.example_code
+        [
+          'appforshare(release_notes: "Fixes the login crash")',
+          'appforshare(file: "app/build/outputs/apk/release/app-release.apk", fail_on: "blocked")'
+        ]
+      end
+
+      def self.category
+        :beta
+      end
+
+      def self.is_supported?(platform)
+        %i[ios android].include?(platform)
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/appforshare/helper/client.rb

@@ -0,0 +1,84 @@
+require 'json'
+require 'net/http'
+require 'uri'
+
+module Fastlane
+  module Helper
+    # Same resumable upload API as the website and the npm CLI: create, PUT chunks at offsets, complete, poll.
+    class AppforshareClient
+      class Error < StandardError; end
+
+      def initialize(token:, api: 'https://appforshare.io', log: nil)
+        @token = token
+        @api = api.sub(%r{/+\z}, '')
+        @log = log || ->(_msg) {}
+      end
+
+      def upload(path, notes: nil)
+        size = File.size(path)
+        body = { fileName: File.basename(path), size: size }
+        body[:releaseNotes] = notes[0, 5000] if notes && !notes.empty?
+        created = request(:post, '/uploads', json: body)
+        @log.call("Uploading #{File.basename(path)} (#{format('%.1f', size / 1024.0 / 1024)} MB)")
+        offset = created['offset'] || 0
+        headers = { 'X-Upload-Token' => created['token'] }
+        File.open(path, 'rb') do |f|
+          while offset < size
+            f.seek(offset)
+            chunk = f.read([created['chunkBytes'], size - offset].min)
+            res = request(:put, "/uploads/#{created['id']}?offset=#{offset}", body: chunk, headers: headers)
+            offset = res['offset'].is_a?(Integer) ? res['offset'] : offset + chunk.bytesize
+          end
+        end
+        request(:post, "/uploads/#{created['id']}/complete", headers: headers)
+        deadline = Time.now + 20 * 60
+        loop do
+          s = request(:get, "/uploads/#{created['id']}", headers: headers)
+          raise Error, (s['error'] || 'The build could not be processed.') if s['status'] == 'FAILED'
+          return s if s['status'] == 'READY'
+          raise Error, 'Processing is taking too long. Check your dashboard.' if Time.now > deadline
+
+          sleep 2
+        end
+      end
+
+      def build(ref)
+        request(:get, "/ci/builds/#{URI.encode_www_form_component(ref)}")
+      end
+
+      def request(method, path, json: nil, body: nil, headers: {})
+        uri = URI("#{@api}/api#{path}")
+        attempt = 0
+        begin
+          attempt += 1
+          req = { get: Net::HTTP::Get, post: Net::HTTP::Post, put: Net::HTTP::Put, delete: Net::HTTP::Delete }[method].new(uri)
+          req['Authorization'] = "Bearer #{@token}"
+          req['User-Agent'] = "fastlane-plugin-appforshare/#{Fastlane::Appforshare::VERSION}"
+          headers.each { |k, v| req[k] = v }
+          if json
+            req['Content-Type'] = 'application/json'
+            req.body = JSON.generate(json)
+          elsif body
+            req['Content-Type'] = 'application/octet-stream'
+            req.body = body
+          end
+          res = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https', read_timeout: 300) { |http| http.request(req) }
+          data = res.body && !res.body.empty? ? (JSON.parse(res.body) rescue {}) : {}
+          code = res.code.to_i
+          raise IOError, "HTTP #{code}" if code >= 500 && attempt < 6
+          offset_reply = code == 400 && data['offset'].is_a?(Integer)
+          unless (200..299).cover?(code) || code == 409 || offset_reply
+            msg = data['message'].is_a?(Array) ? data['message'].first : data['message']
+            raise Error, (msg || "Request failed with #{code}")
+          end
+          data
+        rescue IOError, SystemCallError, Net::OpenTimeout, Net::ReadTimeout, OpenSSL::SSL::SSLError => e
+          raise Error, "Network error: #{e.message}" if attempt >= 6
+
+          sleep [30, 2**attempt].min
+          retry
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+module Fastlane
+  module Appforshare
+    VERSION = '1.0.0'
+  end
+end

data/lib/fastlane/plugin/appforshare.rb

@@ -0,0 +1,11 @@
+require 'fastlane/plugin/appforshare/version'
+
+module Fastlane
+  module Appforshare
+    def self.all_classes
+      Dir[File.expand_path('**/{actions,helper}/*.rb', File.dirname(__FILE__))]
+    end
+  end
+end
+
+Fastlane::Appforshare.all_classes.each { |current| require current }

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: fastlane-plugin-appforshare
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- AppForShare
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-10-31 00:00:00.000000000 Z
+dependencies: []
+description: Fastlane action that uploads an .ipa or .apk to AppForShare (appforshare.io),
+  waits for it to be ready, returns the install link and the store readiness status,
+  and can fail the lane on readiness blockers.
+email: support@appforshare.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/fastlane/plugin/appforshare.rb
+- lib/fastlane/plugin/appforshare/actions/appforshare_action.rb
+- lib/fastlane/plugin/appforshare/helper/client.rb
+- lib/fastlane/plugin/appforshare/version.rb
+homepage: https://appforshare.io/docs/ci
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://appforshare.io/docs/ci
+  source_code_uri: https://github.com/appforshare/fastlane-plugin-appforshare
+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.5.22
+signing_key:
+specification_version: 4
+summary: Upload iOS and Android builds to AppForShare and get an install link for
+  testers.
+test_files: []