fastlane-plugin-rustore_connect 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 101ef7fb018be635bc16dc3b8fe5babbac0a3317337b519cd4d686007f08bc92
+  data.tar.gz: 658ca30d1e25afc890fbb848d6604ce127bcf6cafa7dda0c3388741d410df7a8
+SHA512:
+  metadata.gz: e3094f839faf30dcf8288cb54c2673204e447441f5b2e151ebe569ed444cd4f668fcc1ba7447a5e923b0fedc81a104053a48e54599e14bc2ed5993085215b403
+  data.tar.gz: 763bcd8362dbc47f8cc0cd1b1ae9fd2d7cd54a587b2a02f8a2439729e84dc9f78b1d7457eea7381b3b5cf01552f72d8b9c8886126e3a1268af6b4dbd8f0f11b8

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Mikhail Matsera <mmatsera@gmail.com>
+
+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,108 @@
+# rustore_connect plugin
+
+[![fastlane Plugin Badge](https://rawcdn.githack.com/fastlane/fastlane/master/fastlane/assets/plugin-badge.svg)](https://rubygems.org/gems/fastlane-plugin-rustore_connect)
+
+## Getting Started
+This project is a [_fastlane_](https://github.com/fastlane/fastlane) plugin. To get started with `fastlane-plugin-rustore_connect`, add it to your project by running:
+```bash
+fastlane add_plugin huawei_appgallery_connect
+```
+
+## About Fastlane Rustore Connect Plugin
+**Fastlane plugin for publishing Android applications to RuStore.**
+This plugin provides seamless integration with RuStore, allowing you to easily upload and manage your Android application releases directly from your CI/CD pipeline.
+
+## Features
+
+* Create new draft versions or reuse existing drafts
+* Upload APK or AAB files
+* Submit applications for review automatically
+* Supports partial and delayed publication
+* Handles draft strategies: DELETE, REUSE, FAIL
+
+## Usage
+
+```ruby
+rustore_connect(
+  key_id: "YOUR_KEY_ID",
+  private_key: "YOUR_PRIVATE_KEY",
+  package_name: "com.example.app",
+  app_name: "My App",
+  app_type: "GAMES",
+  categories: "health, news",
+  age_legal: "6+",
+  short_description: "Brief app description",
+  full_description: "Full app description",
+  whats_new: "What's new in this version",
+  moder_info: "Comment for moderator",
+  price_value: "8799",
+  seo_tag_ids: "tag1,tag2",
+  publish_type: "INSTANTLY",
+  publish_date_time: "2025-09-10T12:00:00+03:00",
+  partial_value: "50",
+  services_type: "Unknown",
+  is_main_apk: true,
+  apk_path: "./app-release.apk",
+  is_aab: false,
+  draft_strategy: "FAIL",
+  submit_for_review: true
+)
+```
+
+## Available Options
+
+| Option              | Description                                         | Type    | Default     | Required |
+| ------------------- | --------------------------------------------------- | ------- | ----------- | -------- |
+| `key_id`            | Key ID for RuStore API                              | String  | —           | ✅        |
+| `private_key`       | Private key for RuStore API                         | String  | —           | ✅        |
+| `package_name`      | App package name (example: `com.example.app`)       | String  | —           | ✅        |
+| `app_name`          | Application name                                    | String  | —           | ❌        |
+| `app_type`          | Type of application (example: `GAMES`)              | String  | —           | ❌        |
+| `categories`        | Version categories (example: `"health, news"`)      | String  | —           | ❌        |
+| `age_legal`         | Age rating (example: `6+`)                          | String  | —           | ❌        |
+| `short_description` | Brief description (max 80 chars)                    | String  | —           | ❌        |
+| `full_description`  | Full description (max 4000 chars)                   | String  | —           | ❌        |
+| `whats_new`         | What's new                                          | String  | —           | ❌        |
+| `moder_info`        | Comment for moderator (max 180 chars)               | String  | —           | ❌        |
+| `price_value`       | App price in kopecks (example: `8799`)              | String  | —           | ❌        |
+| `seo_tag_ids`       | SEO tags                                            | String  | —           | ❌        |
+| `publish_type`      | Publication type: `MANUAL`, `INSTANTLY`, `DELAYED`  | String  | `INSTANTLY` | ❌        |
+| `publish_date_time` | Scheduled publication date (for delayed type)       | String  | —           | ❌        |
+| `partial_value`     | Percentage for partial release                      | String  | —           | ❌        |
+| `services_type`     | Service type: `HMS` or `Unknown`                    | String  | `Unknown`   | ❌        |
+| `is_main_apk`       | Is main APK                                         | Boolean | `false`     | ❌        |
+| `apk_path`          | Path to APK or AAB                                  | String  | —           | ✅        |
+| `is_aab`            | Upload AAB instead of APK                           | Boolean | `false`     | ❌        |
+| `draft_strategy`    | Strategy if draft exists: `DELETE`, `REUSE`, `FAIL` | String  | `FAIL`      | ❌        |
+| `submit_for_review` | Should submit for review automatically              | Boolean | `true`      | ❌        |
+
+## Draft Strategies
+
+* `DELETE` – Delete existing draft and create a new one
+* `REUSE` – Reuse the existing draft
+* `FAIL` – Fail if a draft already exists
+
+## Run tests for this plugin
+
+To run both the tests, and code style validation, run
+
+```
+rake
+```
+
+To automatically fix many of the styling issues, use
+```
+rubocop -a
+```
+
+## Issues and Feedback
+For any other issues and feedback about this plugin, please submit it to this repository.
+
+## Troubleshooting
+If you have trouble using plugins, check out the [Plugins Troubleshooting](https://docs.fastlane.tools/plugins/plugins-troubleshooting/) guide.
+
+## Using _fastlane_ Plugins
+For more information about how the `fastlane` plugin system works, check out the [Plugins documentation](https://docs.fastlane.tools/plugins/create-plugin/).
+
+## About _fastlane_
+_fastlane_ is the easiest way to automate beta deployments and releases for your iOS and Android apps. To learn more, check out [fastlane.tools](https://fastlane.tools).

data/lib/fastlane/plugin/rustore_connect/actions/rustore_connect_action.rb

@@ -0,0 +1,283 @@
+require 'fastlane/action'
+require_relative '../helper/rustore_connect_helper'
+require_relative '../lib/rustore_connect_draft_strategy'
+
+module Fastlane
+  module Actions
+    class RustoreConnectAction < Action
+      def self.run(params)
+        token = Helper::RustoreConnectHelper.get_token(params[:key_id], params[:private_key])
+
+        if token.nil?
+          UI.message("Cannot retrieve token, please check your Key ID and private key")
+        else
+          version_id = Helper::RustoreConnectHelper.get_app_versions(
+            token,
+            params[:package_name],
+            version_statuses: 'DRAFT'
+          )
+
+          UI.message("Debug: version_id before strategy check: #{version_id}")
+          UI.message("Debug: strategy check: #{params[:draft_strategy]}")
+
+          if version_id.nil?
+            # No draft exists → create a new one
+            UI.message("No existing draft found. Creating a new draft...")
+            version_id = Helper::RustoreConnectHelper.create_draft(
+              token,
+              params[:package_name],
+              params[:app_name],
+              params[:app_type],
+              params[:categories],
+              params[:age_legal],
+              params[:short_description],
+              params[:full_description],
+              params[:whats_new],
+              params[:moder_info],
+              params[:price_value],
+              params[:seo_tag_ids],
+              params[:publish_type],
+              params[:publish_date_time],
+              params[:partial_value]
+            )
+
+          else
+            # Draft exists → handle based on draft_strategy
+            case params[:draft_strategy]
+            when RustoreConnectDraftStrategy::DELETE
+              UI.message("Draft exists (ID=#{version_id}). Deleting and creating a new one...")
+
+              Helper::RustoreConnectHelper.delete_draft(
+                token,
+                params[:package_name],
+                version_id
+              )
+
+              version_id = Helper::RustoreConnectHelper.create_draft(
+                token,
+                params[:package_name],
+                params[:app_name],
+                params[:app_type],
+                params[:categories],
+                params[:age_legal],
+                params[:short_description],
+                params[:full_description],
+                params[:whats_new],
+                params[:moder_info],
+                params[:price_value],
+                params[:seo_tag_ids],
+                params[:publish_type],
+                params[:publish_date_time],
+                params[:partial_value]
+              )
+
+            when RustoreConnectDraftStrategy::REUSE
+              UI.message("Draft exists (ID=#{version_id}). Reusing existing draft.")
+
+            when RustoreConnectDraftStrategy::FAIL
+              UI.user_error!("Draft already exists (ID=#{version_id}) and draft_strategy is set to 'FAIL'")
+
+            else
+              UI.user_error!("Unknown draft_strategy: #{params[:draft_strategy]}. Allowed values: delete_and_create, reuse_existing, fail_if_exists")
+            end
+          end
+
+          UI.message("Using version_id=#{version_id} for upload...")
+
+          # Upload APK or AAB file
+          Helper::RustoreConnectHelper.upload(token, params[:package_name], version_id, params[:is_aab], params[:apk_path], params[:services_type], params[:is_main_apk])
+
+          if params[:submit_for_review] === true
+            Helper::RustoreConnectHelper::commit_version(token, params[:package_name], version_id)
+          end
+
+        end
+      end
+
+      def self.description
+        "Fastlane plugin for publishing Android applications to RuStore."
+      end
+
+      def self.authors
+        ["Mikhail Matsera"]
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+      end
+
+      def self.details
+        # Optional:
+        "This Fastlane plugin provides seamless integration with RuStore, allowing you to easily upload and manage your Android application releases directly from your CI/CD pipeline."
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :key_id,
+                                       env_name: "RUSTORE_CONNECT_KEY_ID",
+                                       description: "Key id",
+                                       optional: false,
+                                       type: String,
+                                       ),
+
+          FastlaneCore::ConfigItem.new(key: :private_key,
+                                       env_name: "RUSTORE_CONNECT_PRIVATE_KEY",
+                                       description: "Private key",
+                                       optional: false,
+                                       type: String,
+                                       ),
+
+          FastlaneCore::ConfigItem.new(key: :package_name,
+                                       env_name: "RUSTORE_CONNECT_PACKAGE_NAME",
+                                       description: "Наименование пакета приложения (example: `com.example.example`)",
+                                       optional: false,
+                                       type: String,
+                                       ),
+
+          FastlaneCore::ConfigItem.new(key: :app_name,
+                                       env_name: "RUSTORE_CONNECT_APP_NAME",
+                                       description: "App name (example `My App`)",
+                                       optional: true,
+                                       type: String,
+                                       ),
+
+          FastlaneCore::ConfigItem.new(key: :app_type,
+                                       env_name: "RUSTORE_CONNECT_APP_TYPE",
+                                       description: "Тип приложения (example `GAMES`)",
+                                       optional: true,
+                                       type: String,
+                                       ),
+
+          FastlaneCore::ConfigItem.new(key: :categories,
+                                       env_name: "RUSTORE_CONNECT_CATEGORIES",
+                                       description: "Категории версии. (example `\"health\", \"news\"`)",
+                                       optional: true,
+                                       type: String,
+                                       ),
+
+          FastlaneCore::ConfigItem.new(key: :age_legal,
+                                       env_name: "RUSTORE_CONNECT_AGE_LEGAL",
+                                       description: "Возрастная категория. (example `6+`)",
+                                       optional: true,
+                                       type: String,
+                                       ),
+
+          FastlaneCore::ConfigItem.new(key: :short_description,
+                                       env_name: "RUSTORE_CONNECT_SHORT_DESCRIPTION",
+                                       description: "Brief app release description. Maximum length: 80 characters",
+                                       optional: true,
+                                       type: String,
+                                       ),
+
+          FastlaneCore::ConfigItem.new(key: :full_description,
+                                       env_name: "RUSTORE_CONNECT_FULL_DESCRIPTION",
+                                       description: "Full description. Maximum length: 4000 characters",
+                                       optional: true,
+                                       type: String,
+                                       ),
+
+          FastlaneCore::ConfigItem.new(key: :whats_new,
+                                       env_name: "RUSTORE_CONNECT_WHATS_NEW",
+                                       description: "What's New",
+                                       optional: true,
+                                       type: String,
+                                       ),
+
+          FastlaneCore::ConfigItem.new(key: :moder_info,
+                                       env_name: "RUSTORE_CONNECT_MODER_INFO",
+                                       description: "Developer comment for moderator. Maximum length: 180 characters",
+                                       optional: true,
+                                       type: String,
+                                       ),
+
+          FastlaneCore::ConfigItem.new(key: :price_value,
+                                       env_name: "RUSTORE_CONNECT_PRICE_VALUE",
+                                       description: "App price in minimum currency units (in kopecks), for example, `87.99 rubles.` = 8799. Value should be >0",
+                                       optional: true,
+                                       type: String,
+                                       ),
+
+          FastlaneCore::ConfigItem.new(key: :seo_tag_ids,
+                                       env_name: "RUSTORE_CONNECT_SEO_TAG_IDS",
+                                       description: "Package name, for example `com.example.example`",
+                                       optional: true,
+                                       type: String,
+                                       ),
+
+          FastlaneCore::ConfigItem.new(key: :publish_type,
+                                       env_name: "RUSTORE_CONNECT_PUBLISH_TYPE",
+                                       description: "Publication type. Publication type: MANUAL — manual publication; INSTANTLY — automatic publication immediately after review; DELAYED — delayed publication. Note: if this parameter is not specified, then it is taken asINSTANTLY by default",
+                                       optional: true,
+                                       default_value: "INSTANTLY",
+                                       type: String,
+                                       ),
+
+          FastlaneCore::ConfigItem.new(key: :publish_date_time,
+                                       env_name: "RUSTORE_CONNECT_PUBLISH_DATE_TIME",
+                                       description: "Date and time for delayed publication: format: yyyy-MM-dd'T'HH:mm:ssXXX. The specified date must be no earlier than 24 hours and no later than 60 days from the planned submission date. The delayed publication date can be changed. Note: if publishType is MANUAL или INSTANTLY, this parameter can be anything and will not be taken into account",
+                                       optional: true,
+                                       type: String,
+                                       ),
+
+          FastlaneCore::ConfigItem.new(key: :partial_value,
+                                       env_name: "RUSTORE_CONNECT_PARTIAL_VALUE",
+                                       description: "Percentage for partial publication",
+                                       optional: true,
+                                       type: String,
+                                       ),
+
+          FastlaneCore::ConfigItem.new(key: :services_type,
+                                       env_name: "RUSTORE_CONNECT_SERVICES_TYPE",
+                                       description: "Type of service used by the app. Possible options: • `HMS` — for APK files with Huawei Mobile Services; • `Unknown` is set by default if the field is empty",
+                                       optional: true,
+                                       default_value: "Unknown",
+                                       type: String,
+                                       ),
+
+          FastlaneCore::ConfigItem.new(key: :is_main_apk,
+                                       env_name: "RUSTORE_CONNECT_IS_MAIN_APK",
+                                       description: "Attribute that is assigned to the main apk file. Values: • `true` — main APK file; • `false` — by default",
+                                       optional: true,
+                                       default_value: false,
+                                       type: Boolean,
+                                       ),
+
+          FastlaneCore::ConfigItem.new(key: :apk_path,
+                                       env_name: "RUSTORE_CONNECT_APK_PATH",
+                                       description: "Path to APK file for upload",
+                                       optional: false,
+                                       type: String,
+                                       ),
+
+          FastlaneCore::ConfigItem.new(key: :is_aab,
+                                       env_name: "RUSTORE_CONNECT_IS_AAB",
+                                       description: "Specify this to be true if you're uploading aab instead of apk",
+                                       optional: true,
+                                       type: Boolean,
+                                       ),
+
+          FastlaneCore::ConfigItem.new(key: :draft_strategy,
+                                       env_name: "RUSTORE_CONNECT_DRAFT_STRATEGY",
+                                       description: "Strategy if draft existing. DELETE, REUSE, FAIL",
+                                       optional: true,
+                                       type: String,
+                                       default_value: RustoreConnectDraftStrategy::FAIL,
+                                       ),
+
+          FastlaneCore::ConfigItem.new(key: :submit_for_review,
+                                       env_name: "RUSTORE_CONNECT_SUBMIT_FOR_REVIEW",
+                                       description: "Should submit the app for review. The default value is true. If set false will only upload the app, and you can submit for review from the console",
+                                       optional: true,
+                                       type: Boolean,
+                                       default_value: true,
+                                       )
+        ]
+      end
+
+      def self.is_supported?(platform)
+        [:android].include?(platform)
+        true
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/rustore_connect/helper/rustore_connect_helper.rb

@@ -0,0 +1,257 @@
+require 'fastlane_core/ui/ui'
+require 'net/http'
+require 'uri'
+require 'json'
+require 'net/http/post/multipart'
+
+module Fastlane
+  UI = FastlaneCore::UI unless Fastlane.const_defined?(:UI)
+
+  module Helper
+    class RustoreConnectHelper
+      def self.rsa_sign(timestamp, key_id, private_key)
+        key = OpenSSL::PKey::RSA.new("-----BEGIN RSA PRIVATE KEY-----\n#{private_key}\n-----END RSA PRIVATE KEY-----")
+        signature = key.sign(OpenSSL::Digest.new('SHA512'), key_id + timestamp)
+        Base64.encode64(signature)
+      end
+
+      def self.get_token(key_id, private_key)
+        UI.important("Fetching app access token")
+
+        uri = URI.parse('https://public-api.rustore.ru/public/auth')
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        request = Net::HTTP::Post.new(uri.path)
+
+        request["Content-Type"] = "application/json"
+
+        timestamp = DateTime.now.iso8601(3)
+        signature = rsa_sign(timestamp, key_id, private_key)
+
+        request.body = { keyId: key_id, timestamp: timestamp, signature: signature }.to_json
+        response = http.request(request)
+
+        UI.message("Debug: response #{response.body}")
+
+        # Если не 200 — возвращаем nil
+        return nil unless response.is_a?(Net::HTTPSuccess)
+
+        result_json = JSON.parse(response.body) rescue nil
+        return nil unless result_json && result_json["body"]
+
+        return result_json["body"]["jwe"]
+      end
+
+      def self.get_app_versions(token, package_name, ids: nil, version_statuses: nil, filter_testing_type: nil, page: nil, size: nil)
+        uri = URI.parse("https://public-api.rustore.ru/public/v1/application/#{package_name}/version")
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+
+        uri.query = URI.encode_www_form(
+          {
+            ids: ids,
+            versionStatuses: version_statuses,
+            filterTestingType: filter_testing_type,
+            page: page,
+            size: size
+          }.compact
+        )
+
+        request = Net::HTTP::Get.new(uri)
+
+        request["Content-Type"] = "application/json"
+        request["Public-Token"] = token
+
+        response = http.request(request)
+
+        result_json = JSON.parse(response.body)
+
+        UI.message("Debug: response #{response.body}")
+        if result_json["code"] == 'OK'
+          body = result_json["body"]
+          content = body["content"]
+
+          # Check that content is an array
+          unless content.is_a?(Array)
+            raise "Invalid RuStore response format: 'content' array is missing"
+          end
+
+          # If there are no elements — return nil
+          return nil if content.empty?
+
+          # If there are more than one element — raise an error
+          if content.size > 1
+            raise "Expected a single element in 'content', but found: #{content.size}"
+          end
+
+          # Return the id of the first element
+          return content.first["versionId"]
+        else
+          raise "Couldn't get draftId from RuStore: #{result_json['message'] || 'Unknown error'}"
+        end
+
+      end
+
+      def self.create_draft(
+        token,
+        package_name,
+        app_name,
+        app_type,
+        categories,
+        age_legal,
+        short_description,
+        full_description,
+        whats_new,
+        moder_info,
+        price_value,
+        seo_tag_ids,
+        publish_type,
+        publish_date_time,
+        partial_value
+      )
+        uri = URI.parse("https://public-api.rustore.ru/public/v1/application/#{package_name}/version")
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        request = Net::HTTP::Post.new(uri)
+
+        request["Content-Type"] = "application/json"
+        request["Public-Token"] = token
+
+        request.body = {
+          appName: app_name,
+          appType: app_type,
+          categories: categories,
+          ageLegal: age_legal,
+          shortDescription: short_description,
+          fullDescription: full_description,
+          whatsNew: whats_new,
+          moderInfo: moder_info,
+          priceValue: price_value,
+          seoTagIds: seo_tag_ids,
+          publishType: publish_type,
+          publishDateTime: publish_date_time,
+          partialValue: partial_value
+        }.to_json
+
+        response = http.request(request)
+
+        result_json = JSON.parse(response.body)
+
+        UI.message("Debug: response #{response.body}")
+
+        if result_json["code"] == "OK"
+          version_id = result_json["body"]
+          if version_id
+            return version_id
+          else
+            raise "Missing versionId in response body"
+          end
+        else
+          message = result_json["message"] || "Couldn't create draft on RuStore"
+          raise message
+        end
+      end
+
+      def self.delete_draft(
+        token,
+        package_name,
+        version_id
+      )
+        uri = URI.parse("https://public-api.rustore.ru/public/v1/application/#{package_name}/version/#{version_id}")
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        request = Net::HTTP::Delete.new(uri)
+
+        request["Content-Type"] = "application/json"
+        request["Public-Token"] = token
+
+        response = http.request(request)
+        result_json = JSON.parse(response.body)
+
+        UI.message("Debug: response #{response.body}")
+
+        if result_json["code"] == "OK"
+          UI.message("Draft version #{version_id} deleted successfully.")
+          return true
+        else
+          message = result_json["message"] || "Failed to delete draft version #{version_id}"
+          raise message
+        end
+      end
+
+      def self.commit_version(token, package_name, version_id)
+        uri = URI.parse("https://public-api.rustore.ru/public/v1/application/#{package_name}/version/#{version_id}/commit")
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+
+        request = Net::HTTP::Post.new(uri)
+        request["Content-Type"] = "application/json"
+        request["Public-Token"] = token
+
+        response = http.request(request)
+        result_json = JSON.parse(response.body)
+
+        UI.message("Debug: response #{response.body}") if ENV['DEBUG']
+
+        if result_json["code"] == "OK"
+          UI.message("Draft version #{version_id} committed successfully.")
+          return true
+        else
+          message = result_json["message"] || "Failed to commit draft version #{version_id}"
+          raise message
+        end
+      end
+
+      def self.upload(token, package_name, version_id, is_aab, file_path, services_type = nil, is_main_apk = nil)
+        file_path = File.expand_path(file_path, Dir.pwd)
+        raise "File not found: #{file_path}" unless File.exist?(file_path)
+
+        file_name = File.basename(file_path)
+
+        if is_aab
+          # Загрузка AAB
+          uri = URI.parse("https://public-api.rustore.ru/public/v1/application/#{package_name}/version/#{version_id}/aab")
+          payload = { "file" => UploadIO.new(file_path, "application/vnd.android.package-archive", file_name) }
+        else
+          # Загрузка APK
+          raise ArgumentError, "is_main_apk is required for APK upload" if is_main_apk.nil?
+
+          services_type ||= "Unknown"
+          uri = URI.parse("https://public-api.rustore.ru/public/v1/application/#{package_name}/version/#{version_id}/apk")
+          uri.query = URI.encode_www_form({ isMainApk: is_main_apk, servicesType: services_type })
+          payload = { "file" => UploadIO.new(file_path, "application/vnd.android.package-archive", file_name) }
+        end
+
+        request = Net::HTTP::Post::Multipart.new(uri, payload)
+        request["Public-Token"] = token
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        http.open_timeout = 60      # время на открытие соединения
+        http.read_timeout = 600     # время на чтение ответа (подойдет для больших файлов)
+        http.write_timeout = 600    # время на отправку файла
+
+        response = http.request(request)
+        result_json = JSON.parse(response.body)
+
+        UI.message("Debug: response #{response.body}")
+
+        if result_json["code"] == "OK"
+          UI.message("#{file_name} uploaded successfully.")
+          true
+        else
+          message = result_json["message"] || "Failed to upload file"
+          if message.include?("The code of this version must be larger")
+            raise "Build with this version code was already uploaded earlier"
+          else
+            raise message
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/fastlane/plugin/rustore_connect/lib/rustore_connect_draft_strategy.rb

@@ -0,0 +1,15 @@
+module RustoreConnectDraftStrategy
+  DELETE = 'DELETE'
+  REUSE = 'REUSE'
+  FAIL = 'FAIL'
+
+  ALL = [
+    DELETE,
+    REUSE,
+    FAIL
+  ].freeze
+
+  def self.valid?(value)
+    ALL.include?(value)
+  end
+end

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

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

data/lib/fastlane/plugin/rustore_connect.rb

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

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: fastlane-plugin-rustore_connect
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Mikhail Matsera
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-09-03 00:00:00.000000000 Z
+dependencies: []
+description:
+email: mmatsera@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/fastlane/plugin/rustore_connect.rb
+- lib/fastlane/plugin/rustore_connect/actions/rustore_connect_action.rb
+- lib/fastlane/plugin/rustore_connect/helper/rustore_connect_helper.rb
+- lib/fastlane/plugin/rustore_connect/lib/rustore_connect_draft_strategy.rb
+- lib/fastlane/plugin/rustore_connect/version.rb
+homepage:
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.6'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: Fastlane plugin for publishing Android applications to RuStore.
+test_files: []