fastlane-plugin-apkgo 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 06e4b13ad0439c4a65ae89e321f246ef07902bd172173d5bd07008b066addce7
+  data.tar.gz: 6e6d3513f06c7ed5f398461333a788d11cf4d17659cdeb5f61bca30f37c864eb
+SHA512:
+  metadata.gz: 054a3b4bbf0d5ec0e442a3155060348160290fff57744b3c0ab8ee4042d027e29372733cf36da63296056cef913e18ea791acdcb358d3b010b6bf7824412372c
+  data.tar.gz: f5c23b0bca061ed1779ff2a62789a085352f8a7f3b828e9193e3312d78d4ae7087f6cf170381d1492019e3cb50b738e3cb10cbbd0237922ada1c3c0c08185d0e

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 KevinGong2013
+
+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,115 @@
+# fastlane-plugin-apkgo
+
+[![Gem](https://img.shields.io/gem/v/fastlane-plugin-apkgo.svg)](https://rubygems.org/gems/fastlane-plugin-apkgo)
+[![CI](https://github.com/KevinGong2013/fastlane-plugin-apkgo/actions/workflows/ci.yml/badge.svg)](https://github.com/KevinGong2013/fastlane-plugin-apkgo/actions)
+
+[fastlane](https://fastlane.tools) plugin to publish an APK to **all major
+Chinese Android app stores** in one step — via [**apkgo cloud**](https://apkgo.baici.tech).
+
+> 一行 lane,将 APK 发布到华为 / 小米 / OPPO / vivo / 荣耀 / 应用宝 / 三星 /
+> Google Play / 蒲公英 / fir 等所有主流安卓商店。凭证云端托管,发布历史可追溯。
+
+## Getting started
+
+Add the plugin to your project:
+
+```bash
+fastlane add_plugin apkgo
+```
+
+Or add to your `Pluginfile`:
+
+```ruby
+gem "fastlane-plugin-apkgo"
+```
+
+## Prerequisites
+
+This plugin drives the apkgo cloud **Open API**. Before using it:
+
+1. Sign up at [apkgo.baici.tech](https://apkgo.baici.tech).
+2. **Configure store credentials and bind them to your app** in the dashboard.
+   The plugin targets stores *by name* — it cannot create credentials.
+3. Create an **API key** (Settings → API Keys) with the `upload` permission and
+   put it in CI as `APKGO_API_KEY`.
+
+## Usage
+
+```ruby
+lane :release do
+  gradle(task: "assembleRelease")
+
+  upload_to_apkgo(
+    api_key: ENV["APKGO_API_KEY"],
+    apk: lane_context[SharedValues::GRADLE_APK_OUTPUT_PATH],
+    package_name: "com.example.myapp",
+    version_name: "1.2.3",
+    release_notes: "Bug fixes and improvements",
+    stores: ["huawei", "xiaomi", "oppo"] # omit = all stores bound to the app
+  )
+end
+```
+
+`apk` defaults to the output of the `gradle` action, so you can usually omit it.
+
+### Scheduled release (定时发布)
+
+```ruby
+upload_to_apkgo(
+  api_key: ENV["APKGO_API_KEY"],
+  package_name: "com.example.myapp",
+  release_time: "2026-06-20T10:00:00+08:00" # RFC3339, must be in the future
+)
+```
+
+Stores that support scheduling honor it; others release immediately after review.
+
+## Options
+
+| Option | Env | Default | Description |
+|---|---|---|---|
+| `api_key` | `APKGO_API_KEY` | — | Open API key (`apkgo_…`), needs `upload` permission |
+| `apk` | `APKGO_APK` | gradle output | Path to the APK |
+| `host` | `APKGO_HOST` | `https://apkgo.baici.tech` | apkgo cloud base URL (for self-hosted) |
+| `package_name` | `APKGO_PACKAGE_NAME` | — | Required unless `app_id` is set |
+| `app_id` | `APKGO_APP_ID` | — | apkgo cloud app UUID (alternative to package_name) |
+| `app_name` | `APKGO_APP_NAME` | — | Display name when auto-creating the app |
+| `version_code` | `APKGO_VERSION_CODE` | — | Informational; the worker re-parses the APK |
+| `version_name` | `APKGO_VERSION_NAME` | — | Informational |
+| `release_notes` | `APKGO_RELEASE_NOTES` | — | Update notes for each store |
+| `release_time` | `APKGO_RELEASE_TIME` | — | Scheduled release, RFC3339 in the future |
+| `stores` | `APKGO_STORES` | all bound | Target store names, e.g. `["huawei","xiaomi"]` |
+| `wait` | `APKGO_WAIT` | `true` | Poll until done; fail the lane if any store fails |
+| `poll_interval` | `APKGO_POLL_INTERVAL` | `5` | Seconds between status polls |
+| `timeout` | `APKGO_TIMEOUT` | `1800` | Max seconds to wait |
+
+## Output
+
+| Shared value | Description |
+|---|---|
+| `APKGO_JOB_ID` | The created upload job id |
+| `APKGO_JOB` | The full job object, including per-store results |
+
+## How it works
+
+The APK bytes never transit the apkgo cloud API server — the plugin:
+
+1. requests a direct-to-storage upload **ticket** (`POST /openapi/v1/uploads/tickets`);
+2. uploads the APK straight to object storage (七牛 Kodo);
+3. creates the job (`POST /openapi/v1/uploads`);
+4. polls (`GET /openapi/v1/uploads/{id}`) until every store finishes, surfacing
+   per-store success and store-side review (审核) state.
+
+See the [Open API reference](https://github.com/KevinGong2013/apkgo-cloud/blob/main/docs/openapi.md).
+
+## Development
+
+```bash
+bundle install
+bundle exec rspec      # tests
+bundle exec rubocop    # lint
+```
+
+## License
+
+MIT — see [LICENSE](./LICENSE).

data/lib/fastlane/plugin/apkgo/actions/upload_to_apkgo_action.rb

@@ -0,0 +1,251 @@
+require "fastlane/action"
+require_relative "../helper/apkgo_helper"
+
+module Fastlane
+  module Actions
+    module SharedValues
+      APKGO_JOB_ID = :APKGO_JOB_ID
+      APKGO_JOB = :APKGO_JOB
+    end
+
+    # upload_to_apkgo publishes an APK to Chinese app stores through the
+    # apkgo cloud Open API. Stores must be pre-configured (credentials + app
+    # bindings) in the apkgo cloud dashboard; this action targets them by name.
+    class UploadToApkgoAction < Action
+      DEFAULT_HOST = "https://apkgo.baici.tech".freeze
+
+      def self.run(params)
+        apk = params[:apk]
+        UI.user_error!("apkgo: 找不到 APK 文件: #{apk}") unless apk && File.exist?(apk)
+
+        client = Helper::ApkgoClient.new(host: params[:host], api_key: params[:api_key])
+
+        UI.message("apkgo: 申请上传凭证 …")
+        ticket = client.request_ticket(File.basename(apk))
+
+        UI.message("apkgo: 上传 APK 到对象存储 (provider=#{ticket['provider']}) …")
+        client.upload_to_storage(ticket, apk)
+
+        body = build_body(params, ticket, apk)
+        UI.message("apkgo: 创建上传任务 …")
+        job = client.create_job(body)
+        job_id = job["id"]
+
+        Actions.lane_context[SharedValues::APKGO_JOB_ID] = job_id
+        Actions.lane_context[SharedValues::APKGO_JOB] = job
+        UI.success("apkgo: 任务已创建 #{job_id} → 目标商店 #{target_names(job)}")
+
+        return job unless params[:wait]
+
+        poll(client, job_id, params)
+      end
+
+      def self.build_body(params, ticket, apk)
+        body = {
+          object_key: ticket["object_key"],
+          sha256: Helper::ApkgoHelper.sha256(apk)
+        }
+        body[:app_id] = params[:app_id] if params[:app_id]
+        body[:package_name] = params[:package_name] if params[:package_name]
+        body[:app_name] = params[:app_name] if params[:app_name]
+        body[:version_code] = params[:version_code] if params[:version_code]
+        body[:version_name] = params[:version_name] if params[:version_name]
+        body[:release_notes] = params[:release_notes] if params[:release_notes]
+        body[:release_time] = params[:release_time] if params[:release_time]
+        body[:target_stores] = params[:stores] if params[:stores] && !params[:stores].empty?
+        body
+      end
+
+      # poll waits for the job to reach a terminal state, surfacing per-store
+      # outcomes. Raises if any store failed so the lane fails loudly in CI.
+      def self.poll(client, job_id, params)
+        interval = params[:poll_interval]
+        deadline = Time.now + params[:timeout]
+        last_status = nil
+
+        loop do
+          job = client.get_job(job_id)
+          status = job["status"]
+          if status != last_status
+            UI.message("apkgo: 任务状态 #{status}")
+            last_status = status
+          end
+          log_progress(job)
+
+          if Helper::ApkgoClient::TERMINAL_STATUSES.include?(status)
+            Actions.lane_context[SharedValues::APKGO_JOB] = job
+            return finish(job)
+          end
+
+          UI.user_error!("apkgo: 轮询超时（#{params[:timeout]}s),任务 #{job_id} 仍未完成。可稍后用 dashboard 查看。") if Time.now > deadline
+          sleep(interval)
+        end
+      end
+
+      def self.log_progress(job)
+        (job["progress"] || {}).each do |store, p|
+          next unless p["bytes_total"].to_i.positive?
+
+          pct = (100.0 * p["bytes_done"].to_i / p["bytes_total"].to_i).round
+          UI.message("  #{store}: #{p['phase']} #{pct}%")
+        end
+      end
+
+      # finish reports each store result and fails the lane if any store failed.
+      def self.finish(job)
+        results = job["results"] || []
+        failed = []
+        results.each do |r|
+          if r["success"]
+            review = r["review_state"] ? " (审核: #{r['review_state']})" : ""
+            UI.success("  ✔ #{r['store_name']}#{review}")
+          else
+            failed << r
+            UI.error("  ✗ #{r['store_name']}: #{r['error']}")
+          end
+        end
+
+        if job["status"] != "completed" || !failed.empty?
+          names = failed.map { |r| r["store_name"] }.join(", ")
+          UI.user_error!("apkgo: 任务 #{job['status']}，失败商店: #{names.empty? ? job['status'] : names}")
+        end
+
+        UI.success("apkgo: 全部商店上传成功 🎉")
+        job
+      end
+
+      def self.target_names(job)
+        (job["target_stores"] || []).map { |t| t["store_name"] }.join(", ")
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Publish an APK to Chinese app stores via the apkgo cloud Open API"
+      end
+
+      def self.details
+        "Uploads an APK to apkgo cloud, which fans it out to the Android app " \
+          "stores you have configured (Huawei, Xiaomi, OPPO, vivo, Honor, " \
+          "Tencent, Samsung, Google Play, pgyer, fir …). Store credentials and " \
+          "app bindings are managed in the apkgo cloud dashboard; this action " \
+          "targets them by store name. See https://github.com/KevinGong2013/fastlane-plugin-apkgo"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :api_key,
+                                       env_name: "APKGO_API_KEY",
+                                       description: "apkgo cloud Open API key (apkgo_…), needs the `upload` permission",
+                                       sensitive: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("apkgo: api_key 不能为空") if value.to_s.empty?
+                                         UI.user_error!("apkgo: api_key 应以 apkgo_ 开头") unless value.start_with?("apkgo_")
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :apk,
+                                       env_name: "APKGO_APK",
+                                       description: "Path to the APK to upload",
+                                       default_value: Actions.lane_context[SharedValues::GRADLE_APK_OUTPUT_PATH],
+                                       default_value_dynamic: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("apkgo: 找不到 APK 文件: #{value}") unless File.exist?(value.to_s)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :host,
+                                       env_name: "APKGO_HOST",
+                                       description: "apkgo cloud base URL",
+                                       default_value: DEFAULT_HOST),
+          FastlaneCore::ConfigItem.new(key: :package_name,
+                                       env_name: "APKGO_PACKAGE_NAME",
+                                       description: "App package name (required unless app_id is set)",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :app_id,
+                                       env_name: "APKGO_APP_ID",
+                                       description: "apkgo cloud app UUID (alternative to package_name)",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :app_name,
+                                       env_name: "APKGO_APP_NAME",
+                                       description: "Display name when auto-creating the app",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :version_code,
+                                       env_name: "APKGO_VERSION_CODE",
+                                       description: "versionCode (informational; the worker re-parses the APK)",
+                                       optional: true,
+                                       type: Integer),
+          FastlaneCore::ConfigItem.new(key: :version_name,
+                                       env_name: "APKGO_VERSION_NAME",
+                                       description: "versionName (informational)",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :release_notes,
+                                       env_name: "APKGO_RELEASE_NOTES",
+                                       description: "Release notes / 更新日志 passed to each store",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :release_time,
+                                       env_name: "APKGO_RELEASE_TIME",
+                                       description: "Scheduled release time (定时发布), RFC3339 in the future e.g. 2026-06-20T10:00:00+08:00",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :stores,
+                                       env_name: "APKGO_STORES",
+                                       description: "Target store names, e.g. [\"huawei\",\"xiaomi\"]. Empty = all bound stores",
+                                       optional: true,
+                                       type: Array),
+          FastlaneCore::ConfigItem.new(key: :wait,
+                                       env_name: "APKGO_WAIT",
+                                       description: "Poll until the job finishes and fail the lane if any store fails",
+                                       optional: true,
+                                       default_value: true,
+                                       type: Boolean),
+          FastlaneCore::ConfigItem.new(key: :poll_interval,
+                                       env_name: "APKGO_POLL_INTERVAL",
+                                       description: "Seconds between status polls",
+                                       optional: true,
+                                       default_value: 5,
+                                       type: Integer),
+          FastlaneCore::ConfigItem.new(key: :timeout,
+                                       env_name: "APKGO_TIMEOUT",
+                                       description: "Max seconds to wait for the job to finish",
+                                       optional: true,
+                                       default_value: 1800,
+                                       type: Integer)
+        ]
+      end
+
+      def self.output
+        [
+          ["APKGO_JOB_ID", "The created upload job id"],
+          ["APKGO_JOB", "The full job object (with per-store results)"]
+        ]
+      end
+
+      def self.return_value
+        "The final job hash, including per-store results when `wait` is true"
+      end
+
+      def self.authors
+        ["KevinGong2013"]
+      end
+
+      def self.is_supported?(platform)
+        platform == :android
+      end
+
+      def self.example_code
+        [
+          'upload_to_apkgo(
+            api_key: ENV["APKGO_API_KEY"],
+            apk: lane_context[SharedValues::GRADLE_APK_OUTPUT_PATH],
+            package_name: "com.example.myapp",
+            version_name: "1.2.3",
+            release_notes: "Bug fixes and improvements",
+            stores: ["huawei", "xiaomi", "oppo"]
+          )'
+        ]
+      end
+
+      def self.category
+        :production
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/apkgo/helper/apkgo_helper.rb

@@ -0,0 +1,172 @@
+require "fastlane_core/ui/ui"
+require "net/http"
+require "uri"
+require "json"
+require "digest"
+require "securerandom"
+require "stringio"
+
+module Fastlane
+  UI = FastlaneCore::UI unless Fastlane.const_defined?(:UI)
+
+  module Helper
+    # ApkgoClient talks to the apkgo cloud Open API (`/openapi/v1`).
+    #
+    # The flow is deliberately three steps because the APK bytes never transit
+    # the apkgo cloud server — they go straight to object storage:
+    #   1. POST /uploads/tickets   → a direct-to-storage upload ticket
+    #   2. upload the APK to that storage (qiniu multipart, or dev PUT)
+    #   3. POST /uploads           → register the job around the stored object
+    #   4. GET  /uploads/{id}      → poll until terminal
+    class ApkgoClient
+      # Job lifecycle states (mirrors the backend's domain.UploadStatus).
+      TERMINAL_STATUSES = %w[completed failed cancelled].freeze
+
+      def initialize(host:, api_key:)
+        @host = host.to_s.sub(%r{/+\z}, "")
+        @api_key = api_key
+      end
+
+      # request_ticket asks the server for a direct-upload ticket for `file_name`.
+      # The server chooses the object key; we never get to.
+      def request_ticket(file_name)
+        api_post("/openapi/v1/uploads/tickets", { file_name: file_name })
+      end
+
+      # upload_to_storage places the APK bytes where the ticket points. Returns
+      # nothing; raises on any non-2xx.
+      def upload_to_storage(ticket, apk_path)
+        case ticket["provider"]
+        when "qiniu"
+          qiniu_form_upload(ticket, apk_path)
+        when "direct"
+          direct_put(ticket, apk_path)
+        else
+          UI.user_error!("apkgo: 未知的上传 provider: #{ticket['provider'].inspect}")
+        end
+      end
+
+      # create_job registers the upload job around an already-stored object.
+      def create_job(body)
+        api_post("/openapi/v1/uploads", body)
+      end
+
+      # get_job fetches a job with its per-store results and live progress.
+      def get_job(job_id)
+        api_get("/openapi/v1/uploads/#{job_id}")
+      end
+
+      private
+
+      # --- storage upload backends -----------------------------------------
+
+      # qiniu_form_upload does a multipart/form-data POST with the three fields
+      # the put-policy expects: token, key, file. No qiniu SDK needed — the
+      # token is already signed and scoped to exactly this key.
+      def qiniu_form_upload(ticket, apk_path)
+        uri = URI.parse(ticket["upload_url"])
+        boundary = "----apkgofastlane#{SecureRandom.hex(16)}"
+        body = build_multipart(boundary, {
+                                 "token" => ticket["token"],
+                                 "key" => ticket["object_key"]
+                               }, apk_path)
+
+        req = Net::HTTP::Post.new(uri)
+        req["Content-Type"] = "multipart/form-data; boundary=#{boundary}"
+        req.body = body
+
+        res = http_for(uri).request(req)
+        return if res.is_a?(Net::HTTPSuccess)
+
+        UI.user_error!("apkgo: 上传 APK 到对象存储失败 (#{res.code}): #{res.body}")
+      end
+
+      # direct_put streams the raw bytes with PUT — the dev/local-disk backend.
+      def direct_put(ticket, apk_path)
+        url = ticket["upload_url"]
+        # The dev backend returns a server-relative URL; resolve against host.
+        url = "#{@host}#{url}" if url.start_with?("/")
+        uri = URI.parse(url)
+
+        req = Net::HTTP::Put.new(uri)
+        req["Content-Type"] = "application/octet-stream"
+        req.body_stream = File.open(apk_path, "rb")
+        req["Content-Length"] = File.size(apk_path).to_s
+
+        res = http_for(uri).request(req)
+        return if res.is_a?(Net::HTTPSuccess)
+
+        UI.user_error!("apkgo: 上传 APK 到存储失败 (#{res.code}): #{res.body}")
+      end
+
+      # build_multipart assembles a multipart body, streaming the file part from
+      # disk so a 1–2GB APK doesn't all sit in a Ruby string at once.
+      def build_multipart(boundary, fields, file_path)
+        io = StringIO.new
+        fields.each do |name, value|
+          io << "--#{boundary}\r\n"
+          io << "Content-Disposition: form-data; name=\"#{name}\"\r\n\r\n"
+          io << "#{value}\r\n"
+        end
+        io << "--#{boundary}\r\n"
+        io << "Content-Disposition: form-data; name=\"file\"; filename=\"#{File.basename(file_path)}\"\r\n"
+        io << "Content-Type: application/octet-stream\r\n\r\n"
+        io << File.binread(file_path)
+        io << "\r\n--#{boundary}--\r\n"
+        io.string
+      end
+
+      # --- Open API plumbing -----------------------------------------------
+
+      def api_post(path, body)
+        uri = URI.parse("#{@host}#{path}")
+        req = Net::HTTP::Post.new(uri)
+        req["Content-Type"] = "application/json"
+        req["X-API-Key"] = @api_key
+        req.body = JSON.generate(body)
+        send_api(uri, req)
+      end
+
+      def api_get(path)
+        uri = URI.parse("#{@host}#{path}")
+        req = Net::HTTP::Get.new(uri)
+        req["X-API-Key"] = @api_key
+        send_api(uri, req)
+      end
+
+      # send_api executes the request and unwraps the `{data}` / `{error}`
+      # envelope every Open API endpoint returns.
+      def send_api(uri, req)
+        res = http_for(uri).request(req)
+        parsed = begin
+          res.body.to_s.empty? ? {} : JSON.parse(res.body)
+        rescue JSON::ParserError
+          UI.user_error!("apkgo: 服务器返回非 JSON 响应 (#{res.code}): #{res.body}")
+        end
+
+        unless res.is_a?(Net::HTTPSuccess)
+          msg = parsed["error"] || res.body
+          UI.user_error!("apkgo: 请求失败 (#{res.code}): #{msg}")
+        end
+        parsed["data"]
+      end
+
+      def http_for(uri)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = (uri.scheme == "https")
+        # APK uploads are large and store SDKs are slow — be generous.
+        http.read_timeout = 1800
+        http.open_timeout = 30
+        http
+      end
+    end
+
+    class ApkgoHelper
+      # show_env logs the resolved configuration (without the key) so failing CI
+      # runs are debuggable.
+      def self.sha256(path)
+        Digest::SHA256.file(path).hexdigest
+      end
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+module Fastlane
+  module Apkgo
+    VERSION = "0.1.0".freeze
+  end
+end

data/lib/fastlane/plugin/apkgo.rb

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

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: fastlane-plugin-apkgo
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- KevinGong2013
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-06-17 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.200.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.200.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: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.50.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.50.2
+- !ruby/object:Gem::Dependency
+  name: webmock
+  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'
+description:
+email: aoxianglele2010@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/fastlane/plugin/apkgo.rb
+- lib/fastlane/plugin/apkgo/actions/upload_to_apkgo_action.rb
+- lib/fastlane/plugin/apkgo/helper/apkgo_helper.rb
+- lib/fastlane/plugin/apkgo/version.rb
+homepage: https://github.com/KevinGong2013/fastlane-plugin-apkgo
+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.20
+signing_key:
+specification_version: 4
+summary: Publish an APK to Chinese app stores via the apkgo cloud Open API
+test_files: []