fastlane-plugin-buildstash 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 62cba9cd5be4ef6fb4a9b5dac48500b080449a60a8cf0791c17e3bdf2444721c
+  data.tar.gz: 749f043fdb116a03536e9702ee1cd902681c7f47699ce1207eb93e6f13824cfa
+SHA512:
+  metadata.gz: 2291b1f0b91c5aed6563d98875b2419c0ffe97c832c5444a6b614b11580cc7ae0c6262a355acbbfc6ccbffc156185488241a0056a6d5f0acab7ad64ec38a925f
+  data.tar.gz: 592499bfd9c1a466dd43680dddf0ee1e71d3432c9b3da17f44201c923051ec9f6ab82da786d4e38092e5a706cccca21f111a4dfb8c83e9f8522aa71cc6b8fbd2

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Buildstash, and contributors
+
+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,165 @@
+# Fastlane Buildstash Plugin
+
+## Overview
+The `fastlane-plugin-buildstash` plugin allows you to upload build artifacts to Buildstash seamlessly as part of your Fastlane workflow. This plugin ensures that your builds are efficiently stored and accessible for further processing.
+
+## Installation
+You can install this plugin to your project running:
+
+```sh
+fastlane add_plugin buildstash
+```
+
+Or, to use a copy of this plugin locally, add it to your `Pluginfile`:
+
+```ruby
+gem 'fastlane-plugin-buildstash', path: '/path/to/fastlane-plugin-buildstash'
+```
+
+Then run:
+
+```sh
+bundle install
+```
+
+## Usage
+To upload an artifact to Buildstash, use the `buildstash_upload` action in your `Fastfile`.
+
+With base required parameters:
+
+```ruby
+buildstash_upload(
+  api_key: 'BUILDSTASH_APP_API_KEY',
+  primary_file_path: './path/to/file.apk',
+  platform: 'android',
+  stream: 'default',
+  version_component_1_major: 0,
+  version_component_2_minor: 0,
+  version_component_3_patch: 1
+)
+```
+
+or with all input parameters:
+
+```ruby
+lane :run_buildstash_upload do |options|
+  buildstash_upload(
+    api_key: options[:api_key],
+    structure: 'file',
+    primary_file_path: './path/to/file.apk',
+    platform: 'android',
+    stream: 'default',
+    version_component_1_major: 0,
+    version_component_2_minor: 0,
+    version_component_3_patch: 1,
+    version_component_extra: 'rc',
+    version_component_meta: '2024.12.01',
+    custom_build_number: '12345',
+    notes: '<AppChangelog>',
+    source: 'ghactions',
+    ci_pipeline: options[:ci_pipeline],
+    ci_run_id: options[:ci_run_id],
+    ci_run_url: options[:ci_run_url],
+    vc_host_type: 'git',
+    vc_host: 'github',
+    vc_repo_name: options[:vc_repo_name],
+    vc_repo_url: options[:vc_repo_url],
+    vc_branch: options[:vc_branch],
+    vc_commit_sha: options[:vc_commit_sha],
+    vc_commit_url: options[:vc_commit_url]
+  )
+end
+```
+
+## Parameters
+| Parameter      | Description                                                                                                  | Required |
+|--------------|--------------------------------------------------------------------------------------------------------------|----------|
+| `api_key`     | The API key for authentication                                                                               | ✅       |
+| `structure`     | 'file' for single file, 'file+expansion' to include Android expansion file. will default to 'file'           | ✖       |
+| `primary_file_path`     | './path/to/file.apk'                                                                                         | ✅       |
+| `platform`     | 'android' or 'ios' (see [Buildstash docs for full list](https://docs.buildstash.com/integrations/platforms)) | ✅       |
+| `stream`     | Exact name of a build stream in your app                                                                     | ✅       |
+| `version_component_1_major`     | Semantic version (major component)                                                                           | ✅       |
+| `version_component_2_minor`     | Semantic version (minor component)                                                                           | ✅       |
+| `version_component_3_patch`     | Semantic version (patch component)                                                                           | ✅       |
+| `version_component_extra`     | Optional pre-release label (beta, rc1, etc)                                                                  | ✖       |
+| `version_component_meta`     | Optional release metadata                                                                                    | ✖       |
+| `custom_build_number`     | Optional custom build number in any format                                                                   | ✖       |
+| `notes`     | Changelog or additional notes                                                                                | ✖️       |
+| `source`     | Where build was produced (`ghactions`, `jenkins`, etc) defaults to cli-upload                                | ✖️       |
+| `ci_pipeline`     | CI pipeline name                                                                                             | ✖️       |
+| `ci_run_id`     | CI run ID                                                                                                    | ✖️       |
+| `ci_run_url`     | CI run URL                                                                                                   | ✖️       |
+| `vc_host_type`     | Version control host type (git, svn, hg, perforce, etc)                                                      | ✖️       |
+| `vc_host`     | Version control host (github, gitlab, etc)                                                                   | ✖️       |
+| `vc_repo_name`     | Repository name                                                                                              | ✖️       |
+| `vc_repo_url`     | Repository URL                                                                                               | ✖️       |
+| `vc_branch`     | Branch name (if applicable)                                                                                  | ✖️       |
+| `vc_commit_sha`     | Commit SHA (if applicable)                                                                                   | ✖️       |
+| `vc_commit_url`     | Commit URL                                                                                                   | ✖️       |
+
+
+## Example Output
+When the upload is successful, you will see:
+
+```sh
+[✔] Upload to Buildstash successful!
+```
+
+If the file does not exist, an error will be raised:
+
+```sh
+[✗] File not found at path: non_existent_file.apk
+```
+
+
+## Outputs
+The buildstash_upload action stores the following outputs in lane_context for in subsequent actions:
+
+| Key | Description |
+|-----|-------------|
+| `BUILDSTASH_BUILD_ID` | The build ID in Buildstash for the uploaded build |
+| `BUILDSTASH_INFO_URL` | Link to view uploaded build within Buildstash workspace |
+| `BUILDSTASH_DOWNLOAD_URL` | Link to download the build uploaded to Buildstash (requires login) |
+
+For example, to see these values output:
+
+```ruby
+lane :test_plugin do |options|
+  buildstash_upload(
+    api_key: options[:api_key],
+    primary_file_path: "ponderpad.ipa",
+    platform: "ios",
+    stream: "default",
+    version_component_1_major: 1,
+    version_component_2_minor: 0,
+    version_component_3_patch: 1
+  )
+  
+  # Output to terminal
+  UI.message("🔧 Buildstash Build ID: #{lane_context[:BUILDSTASH_BUILD_ID]}")
+  UI.message("🔗 Build Info URL: #{lane_context[:BUILDSTASH_INFO_URL]}")
+  UI.message("📦 Download URL: #{lane_context[:BUILDSTASH_DOWNLOAD_URL]}")
+end
+```
+
+## Testing
+To run tests:
+
+```sh
+bundle exec rspec
+```
+
+## Contributing
+1. Fork the repository.
+2. Create a new branch (`feature/my-feature`).
+3. Commit your changes.
+4. Push to the branch and create a Merge Request.
+
+Contributions are welcome.
+
+## Support
+For issues and feature requests, please contact the internal development team or submit an issue on GitLab.
+
+## Thanks
+Credit to [Yann Miecielica](https://github.com/yMiecie) and the team at [Gimbal Cube](https://us.gimbalcube.com/) for contributions to this plugin.

data/lib/fastlane/plugin/buildstash/actions/buildstash_upload_action.rb

@@ -0,0 +1,465 @@
+require 'fastlane/action'
+require_relative '../helper/buildstash_helper'
+require 'net/http'
+require 'json'
+
+module Fastlane
+  module Actions
+    class BuildstashUploadAction < Action
+      def self.run(params)
+        api_key = params[:api_key]
+        structure = params[:structure]
+        primary_file_path = params[:primary_file_path]
+        version_component_1_major = params[:version_component_1_major]
+        version_component_2_minor = params[:version_component_2_minor]
+        version_component_3_patch = params[:version_component_3_patch]
+        version_component_extra = params[:version_component_extra]
+        version_component_meta = params[:version_component_meta]
+        custom_build_number = params[:custom_build_number]
+        platform = params[:platform]
+        stream = params[:stream]
+        notes = params[:notes]
+
+        source = params[:source]
+
+        ci_pipeline = params[:ci_pipeline]
+        ci_run_id = params[:ci_run_id]
+        ci_run_url = params[:ci_run_url]
+
+        vc_host_type = params[:vc_host_type]
+        vc_host = params[:vc_host]
+        vc_repo_name = params[:vc_repo_name]
+        vc_repo_url = params[:vc_repo_url]
+        vc_branch = params[:vc_branch]
+        vc_commit_sha = params[:vc_commit_sha]
+        vc_commit_url = params[:vc_commit_url]
+
+        if !structure
+          structure = "file"
+        end
+
+        if !source
+          source = "cli-upload"
+        end
+
+        UI.user_error!("File path must be provided.") if primary_file_path.to_s.strip.empty?
+        UI.user_error!("File not found at path: #{primary_file_path}") unless File.exist?(primary_file_path)
+
+
+        UI.message("Send upload request...")
+
+        file_size = File.size(primary_file_path)
+        file_name = File.basename(primary_file_path)
+
+        request_body = {
+          structure: structure,
+          primary_file: {
+            filename: file_name,
+            size_bytes: file_size
+          },
+          version_component_1_major: version_component_1_major,
+          version_component_2_minor: version_component_2_minor,
+          version_component_3_patch: version_component_3_patch,
+          version_component_extra: version_component_extra,
+          version_component_meta: version_component_meta,
+          custom_build_number: custom_build_number,
+          platform: platform,
+          stream: stream,
+          notes: notes,
+          source: source,
+          ci_pipeline: ci_pipeline,
+          ci_run_id: ci_run_id,
+          ci_run_url: ci_run_url,
+          vc_host_type: vc_host_type,
+          vc_host: vc_host,
+          vc_repo_name: vc_repo_name,
+          vc_repo_url: vc_repo_url,
+          vc_branch: vc_branch,
+          vc_commit_sha: vc_commit_sha,
+          vc_commit_url: vc_commit_url
+        }
+
+        expansion_file_path = params[:expansion_file_path]
+        # Add expansion file info if structure is file+expansion and expansion file path provided
+        if structure == 'file+expansion' && expansion_file_path
+            
+          # Verify expansion file exists
+          unless File.exist?(expansion_file_path)
+            UI.user_error!("Expansion file not found at path: #{expansion_file_path}")
+          end
+
+          # Get expansion file stats
+          expansion_filename = File.basename(expansion_file_path)
+          expansion_file_size = File.size(expansion_file_path)
+
+          request_body[:expansion_files] = [{
+            filename: expansion_filename,
+            size_bytes: expansion_file_size
+          }]
+        end
+
+        response = Helper::BuildstashHelper.post_json(
+          url: "https://app.buildstash.com/api/v1/upload/request",
+          body: request_body,
+          headers: {
+            "Authorization" => "Bearer #{api_key}",
+            "Content-Type" => "application/json",
+            "Accept" => "application/json"
+          }
+        )
+
+        unless response.is_a?(Net::HTTPSuccess)
+          UI.error("Buildstash API returned #{response.code}: #{response.body}")
+          UI.user_error!("Buildstash API request failed")
+        end
+
+        if response.content_type && response.content_type != "application/json"
+          UI.user_error!("Upload request failed due to unexpected response type: #{response.content_type} - Response: #{response.code}: #{response.body}")
+        end
+
+        response_data = JSON.parse(response.body)
+        
+        UI.verbose("Response data: #{response_data.inspect}")
+        
+        # Verify if the response contains an error
+        if response_data["errors"]
+          UI.user_error!("Buildstash API Error: #{response_data["message"]} - Response: #{response.code}: #{response.body}")
+        end
+
+        pending_upload_id = response_data["pending_upload_id"]
+        primary_file = response_data["primary_file"]
+        expansion_files = response_data["expansion_files"]
+
+        # Handle primary file upload
+        if primary_file["chunked_upload"]
+          UI.message('Uploading primary file using chunked upload...');
+          primary_file_parts = Helper::BuildstashHelper.upload_chunked_file(
+            file_path: primary_file_path,
+            filesize: file_size,
+            pending_upload_id: pending_upload_id,
+            chunk_count: primary_file["chunked_number_parts"],
+            chunk_size_mb: primary_file["chunked_part_size_mb"],
+            api_key: api_key,
+            is_expansion: false
+          )
+
+          UI.verbose("primary_file_parts=#{primary_file_parts}");
+        else
+          UI.message("Uploading primary file using direct upload...")
+
+          response = Helper::BuildstashHelper.upload_file(
+            url: primary_file["presigned_data"]["url"],
+            file_path: primary_file_path,
+            headers: {
+              "Content-Disposition" => primary_file["presigned_data"]["headers"]["Content-Disposition"],
+              "x-amz-acl": "private",
+              "Content-Type" => primary_file["presigned_data"]["headers"]["Content-Type"],
+              "Content-Length" => file_size.to_s
+            }
+          )
+
+          unless response.is_a?(Net::HTTPSuccess)
+            UI.user_error!("Upload failed #{response.code}: #{response.body}")
+          end
+
+          UI.message("Upload done! Response code: #{response.code}")
+          UI.message("Response body: #{response.body}")
+        end
+
+        if pending_upload_id.nil? || pending_upload_id.empty?
+          UI.user_error!("Invalid pending_upload_id received from Buildstash.")
+        end
+
+        if expansion_file_path && response_data["expansion_files"] && response_data["expansion_files"][0]
+          expansion_info = response_data["expansion_files"][0]
+          expansion_file_size = File.size(expansion_file_path)
+
+          if expansion_info["chunked_upload"]
+            UI.message("Uploading expansion file using chunked upload...")
+
+            expansion_parts = Helper::BuildstashHelper.upload_chunked_file(
+              file_path: expansion_file_path,
+              filesize: expansion_file_size,
+              pending_upload_id: response_data["pending_upload_id"],
+              chunk_count: expansion_info["chunked_number_parts"],
+              chunk_size_mb: expansion_info["chunked_part_size_mb"],
+              api_key: params[:api_key],
+              is_expansion: true
+            )
+
+            # Store this info for later if needed
+            # e.g. for upload/complete or logs
+            UI.success("Expansion file uploaded in #{expansion_parts.size} parts.")
+            UI.message("Expansion parts: #{expansion_parts.map { |p| p[:PartNumber] }.join(', ')}")
+          else
+            UI.message("Uploading expansion file using direct upload...")
+
+            response = Helper::BuildstashHelper.upload_file(
+              url: expansion_info["presigned_data"]["url"],
+              file_path: expansion_file_path,
+              headers: {
+                "Content-Type" => expansion_info["presigned_data"]["headers"]["Content-Type"],
+                "Content-Length" => expansion_info["presigned_data"]["headers"]["Content-Length"].to_s,
+                "Content-Disposition" => expansion_info["presigned_data"]["headers"]["Content-Disposition"],
+                "x-amz-acl" => "private"
+              }
+            )
+
+            unless response.is_a?(Net::HTTPSuccess)
+              UI.user_error!("Expansion file upload failed: #{response.code} #{response.body}")
+            end
+
+            UI.success("Expansion file uploaded successfully.")
+          end
+        end
+
+        UI.message("Verifying upload...")
+
+        verify_body = {
+          pending_upload_id: pending_upload_id
+        }
+
+        if defined?(primary_file_parts) && primary_file_parts && !primary_file_parts.empty?
+          verify_body[:multipart_chunks] = primary_file_parts
+        end
+
+        # add expansion parts to the verify payload if they exist
+        if defined?(expansion_parts) && expansion_parts && !expansion_parts.empty?
+          verify_body[:multipart_chunks] ||= []
+          verify_body[:multipart_chunks].concat(expansion_parts)
+        end
+
+        response = Helper::BuildstashHelper.post_json(
+          url: "https://app.buildstash.com/api/v1/upload/verify",
+          body: verify_body,
+          headers: { 
+            "Authorization" => "Bearer #{api_key}",
+            "Content-Type" => "application/json",
+            "Accept" => "application/json"
+          })
+
+        unless response.is_a?(Net::HTTPSuccess)
+          UI.error("Buildstash API returned #{response.code}: #{response.body}")
+          UI.user_error!("Buildstash API request failed")
+        end
+
+        if response.content_type && response.content_type != "application/json"
+          UI.user_error!("Verification failed due to unexpected response type: #{response.content_type} - Response: #{response.code}: #{response.body}")
+        end
+
+        response_data = JSON.parse(response.body)
+
+        # Set outputs
+        Actions.lane_context[:BUILDSTASH_BUILD_ID] = response_data["build_id"]
+        Actions.lane_context[:BUILDSTASH_INFO_URL] = response_data["build_info_url"]
+        Actions.lane_context[:BUILDSTASH_DOWNLOAD_URL] = response_data["download_url"]
+
+        if response_data["build_info_url"] && response_data&.dig("pending_processing") == true
+          UI.success("✅ Upload complete! Build now being processed. Once ready, view it at: #{response_data["build_info_url"]}")
+        elsif response_data["build_info_url"]
+          UI.success("✅ Upload complete! View it at: #{response_data["build_info_url"]}")
+        else
+          UI.success("✅ Upload to Buildstash successful!")
+        end
+      end
+
+      def self.description
+        "Upload build artifacts to Buildstash"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(
+            key: :api_key,
+            description: "Buildstash API key",
+            optional: false,
+            type: String
+          ),
+
+          FastlaneCore::ConfigItem.new(
+            key: :structure,
+            description: "Upload structure: 'file' or 'file+expansion'",
+            optional: true,
+            type: String,
+            default_value: "file"
+          ),
+
+          FastlaneCore::ConfigItem.new(
+            key: :primary_file_path,
+            description: "Path to the primary file to upload",
+            optional: false,
+            type: String,
+            verify_block: proc do |value|
+              UI.user_error!("File not found: #{value}") unless File.exist?(value)
+            end
+          ),
+
+          FastlaneCore::ConfigItem.new(
+            key: :platform,
+            description: "Platform of the build",
+            optional: false,
+            type: String
+          ),
+
+          FastlaneCore::ConfigItem.new(
+            key: :stream,
+            description: "Buildstash stream",
+            optional: false,
+            type: String
+          ),
+
+          FastlaneCore::ConfigItem.new(
+            key: :version_component_1_major,
+            description: "Semantic version (major component)",
+            optional: false,
+            type: Integer
+          ),
+
+          FastlaneCore::ConfigItem.new(
+            key: :version_component_2_minor,
+            description: "Semantic version (minor component)",
+            optional: false,
+            type: Integer
+          ),
+
+          FastlaneCore::ConfigItem.new(
+            key: :version_component_3_patch,
+            description: "Semantic version (patch component)",
+            optional: false,
+            type: Integer
+          ),
+
+          FastlaneCore::ConfigItem.new(
+            key: :version_component_extra,
+            description: "Additional version identifier (e.g., `rc`)",
+            optional: true,
+            type: String
+          ),
+
+          FastlaneCore::ConfigItem.new(
+            key: :version_component_meta,
+            description: "Metadata related to the version",
+            optional: true,
+            type: String
+          ),
+
+          FastlaneCore::ConfigItem.new(
+            key: :custom_build_number,
+            description: "Custom build number",
+            optional: true,
+            type: String
+          ),
+
+          FastlaneCore::ConfigItem.new(
+            key: :notes,
+            description: "Changelog or additional notes",
+            optional: true,
+            type: String
+          ),
+
+          FastlaneCore::ConfigItem.new(
+            key: :expansion_file_path,
+            description: "Path to the expansion file (if there is one)",
+            optional: true,
+            type: String
+          ),
+
+          FastlaneCore::ConfigItem.new(
+            key: :source,
+            description: "Where build was produced (e.g., `ghactions`, `jenkins`, etc.)",
+            optional: true,
+            type: String,
+          ),
+
+          FastlaneCore::ConfigItem.new(
+            key: :ci_pipeline,
+            description: "CI pipeline name",
+            optional: true,
+            type: String,
+          ),
+
+          FastlaneCore::ConfigItem.new(
+            key: :ci_run_id,
+            description: "CI run ID",
+            optional: true,
+            type: String,
+          ),
+
+          FastlaneCore::ConfigItem.new(
+            key: :ci_run_url,
+            description: "CI run URL",
+            optional: true,
+            type: String,
+          ),
+
+          FastlaneCore::ConfigItem.new(
+            key: :vc_host_type,
+            description: "Version control host type (git, svn, hg, perforce, etc)",
+            optional: true,
+            type: String,
+          ),
+
+          FastlaneCore::ConfigItem.new(
+            key: :vc_host,
+            description: "Version control host (github, gitlab, etc)",
+            optional: true,
+            type: String,
+          ),
+
+          FastlaneCore::ConfigItem.new(
+            key: :vc_repo_name,
+            description: "Repository name",
+            optional: true,
+            type: String,
+          ),
+
+          FastlaneCore::ConfigItem.new(
+            key: :vc_repo_url,
+            description: "Repository URL",
+            optional: true,
+            type: String,
+          ),
+
+          FastlaneCore::ConfigItem.new(
+            key: :vc_branch,
+            description: "Branch name (if applicable)",
+            optional: true,
+            type: String,
+          ),
+
+          FastlaneCore::ConfigItem.new(
+            key: :vc_commit_sha,
+            description: "Commit SHA (if applicable)",
+            optional: true,
+            type: String,
+          ),
+
+          FastlaneCore::ConfigItem.new(
+            key: :vc_commit_url,
+            description: "Commit URL",
+            optional: true,
+            type: String,
+          ),
+
+        ]
+      end
+
+      def self.output
+        [
+          ['BUILDSTASH_BUILD_ID', 'The build ID in Buildstash for the uploaded build'],
+          ['BUILDSTASH_INFO_URL', 'Link to view uploaded build within Buildstash workspace'],
+          ['BUILDSTASH_DOWNLOAD_URL', 'Link to download the build uploaded to Buildstash (requires login)']
+        ]
+      end
+
+      def self.author
+        'Buildstash'
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+    end
+  end
+end

data/lib/fastlane/plugin/buildstash/helper/buildstash_helper.rb

@@ -0,0 +1,109 @@
+require 'fastlane_core/ui/ui'
+
+module Fastlane
+  UI = FastlaneCore::UI unless Fastlane.const_defined?("UI")
+
+  module Helper
+    class BuildstashHelper
+      # class methods that you define here become available in your action
+      # as `Helper::BuildstashHelper.your_method`
+      #
+      def self.show_message
+        UI.message("Hello from the buildstash plugin helper!")
+      end
+
+      def self.post_json(url:, body:, headers:)
+        uri = URI(url)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = (uri.scheme == "https")
+        request = Net::HTTP::Post.new(uri.path, headers)
+        request.body = body.to_json
+        http.request(request)
+      end
+
+      def self.upload_file(url:, file_path:, headers:)
+        uri = URI(url)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = (uri.scheme == "https")
+        request = Net::HTTP::Put.new(uri.request_uri, headers)
+        request.body = File.binread(file_path)
+        http.request(request)
+      end
+
+      def self.upload_chunked_file(file_path:, filesize:, pending_upload_id:, chunk_count:, chunk_size_mb:, api_key:, is_expansion: false)
+        parts = []
+        chunk_size = chunk_size_mb * 1024 * 1024
+        endpoint = is_expansion ?
+          "https://app.buildstash.com/api/v1/upload/request/multipart/expansion" :
+          "https://app.buildstash.com/api/v1/upload/request/multipart"
+
+        File.open(file_path, 'rb') do |file|
+          chunk_count.times do |i|
+            chunk_start = i * chunk_size
+            chunk_end = [((i + 1) * chunk_size) - 1, filesize - 1].min
+            content_length = chunk_end - chunk_start + 1
+            part_number = i + 1
+
+            puts "Uploading chunked upload, part: #{part_number} of #{chunk_count}"
+
+            # Request for signed URL for the part
+            uri = URI(endpoint)
+            http = Net::HTTP.new(uri.host, uri.port)
+            http.use_ssl = true
+            req = Net::HTTP::Post.new(uri.path, {
+              "Authorization" => "Bearer #{api_key}",
+              "Content-Type" => "application/json",
+              "Accept" => "application/json"
+            })
+            req.body = {
+              pending_upload_id: pending_upload_id,
+              part_number: part_number,
+              content_length: content_length
+            }.to_json
+
+            response = http.request(req)
+            unless response.is_a?(Net::HTTPSuccess)
+              raise "Failed to get presigned URL for part #{part_number}: #{response.code} #{response.body}"
+            end
+
+            data = JSON.parse(response.body)
+            presigned_url = data["part_presigned_url"]
+
+            # Read the chunk data from the file
+            file.seek(chunk_start)
+            chunk_data = file.read(content_length)
+
+            # Upload the chunk to the presigned URL
+            uri = URI(presigned_url)
+            http = Net::HTTP.new(uri.host, uri.port)
+            http.use_ssl = true
+
+            upload = Net::HTTP::Put.new(uri.request_uri, {
+              "Content-Type" => "application/octet-stream",
+              "Content-Length" => content_length.to_s
+            })
+            upload.body = chunk_data
+
+            upload_response = http.request(upload)
+
+            unless upload_response.is_a?(Net::HTTPSuccess)
+              raise "Upload failed for part #{part_number}: #{upload_response.code} #{upload_response.body}"
+            end
+
+            etag = upload_response["ETag"]
+            if etag.nil?
+              puts "⚠️ No ETag returned for part #{part_number}"
+            end
+
+            parts << {
+              PartNumber: part_number,
+              ETag: etag&.gsub('"', '')
+            }
+          end
+        end
+
+        parts
+      end
+    end
+  end
+end

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

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

data/lib/fastlane/plugin/buildstash.rb

@@ -0,0 +1,16 @@
+require 'fastlane/plugin/buildstash/version'
+
+module Fastlane
+  module Buildstash
+    # 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::Buildstash.all_classes.each do |current|
+  require current
+end

metadata

@@ -0,0 +1,185 @@
+--- !ruby/object:Gem::Specification
+name: fastlane-plugin-buildstash
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Buildstash
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fastlane
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.205.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.205.2
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec_junit_formatter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !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
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-require_tools
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+email: hello@buildstash.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/fastlane/plugin/buildstash.rb
+- lib/fastlane/plugin/buildstash/actions/buildstash_upload_action.rb
+- lib/fastlane/plugin/buildstash/helper/buildstash_helper.rb
+- lib/fastlane/plugin/buildstash/version.rb
+homepage: https://github.com/buildstash/fastlane-plugin-buildstash
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: Fastlane plugin to upload built apps to Buildstash - store, organize, and
+  distribute your builds.
+test_files: []