fastlane-plugin-pcloudy 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 31b41a535d0d2a935e7bd9df3d37c97260491f3bcbc758cc62d473e762f34969
-  data.tar.gz: e8861e28863669b33b4a52049fa738014412db6aed0839b8df268c0ea77a7a46
+  metadata.gz: 5beb8f759d9c8483fbb1d9185edc83e0d09c6d22e900c4e848ff635adff4f1e7
+  data.tar.gz: 4c21078f470ecbf008c417c60a6afac259b84750850b9c6d489048715d8311cd
 SHA512:
-  metadata.gz: 2edbd581c9ada9dba62432426856447ba32173489260fb97767a8007365e992a21ec316c7b917ed5906f8745317df8cab3687793a8092f89cd84f8a4fa161fa5
-  data.tar.gz: 6d92f4f62758cf0745779161f70e88c520b07ef63be2da5632002c26dcfd43b43872b75d42ca519d4130770d1c8a0e5c7a0c689882c7ab92b38c4e16ea2eb9c3
+  metadata.gz: baa15536e27dc025e5e56845f256fc35d4c4d4f37b2781a7e8052f946b9649d817caccd2adfaebe233e718d172f812433c103b81419ba51251a5639c9f06e696
+  data.tar.gz: 07a4aceb6833f999a52be92af8cd1aaf1b02c6f94ec2408768c70f18576c2b10014ad761c1caac714b55e4e66517f99e94526bf576ed8744fd669a1ae018f472

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 0.2.0
+
+- New `pcloudy_upload_app`: uploads an `.ipa` or `.apk` to pCloudy My Apps. Picks up the output of
+  `build_app` / `gradle` automatically, waits until pCloudy has registered the file, and returns the
+  name pCloudy stored it under (pCloudy adds a timestamp when the name already exists).
+  `resign: true` re-signs an `.ipa` in the same step.
+- New `pcloudy_resign_app`: re-signs an uploaded `.ipa` with pCloudy's certificate and waits for it to finish.
+- New shared values: `PCLOUDY_UPLOADED_FILE`, `PCLOUDY_RESIGNED_FILE`, `PCLOUDY_APP_FILE`.
+
 ## 0.1.0
 
 First release.

data/README.md

@@ -5,8 +5,8 @@ A [fastlane](https://fastlane.tools) plugin for [pCloudy](https://www.pcloudy.co
 | Action | Status |
 |---|---|
 | `pcloudy_list_devices`: list available devices | ✅ Available |
-| `pcloudy_upload_app`: upload an `.ipa` / `.apk` | Planned |
-| `pcloudy_resign_app`: resign an `.ipa` for pCloudy devices | Planned |
+| `pcloudy_upload_app`: upload an `.ipa` / `.apk` | ✅ Available |
+| `pcloudy_resign_app`: re-sign an `.ipa` for pCloudy devices | ✅ Available |
 | `pcloudy_book_device` / `pcloudy_release_device` | Planned |
 | `pcloudy_install_app`: install and launch on a booked device | Planned |
 
@@ -28,6 +28,70 @@ PCLOUDY_API_KEY=your-api-key        # pCloudy > Settings > API Key
 # PCLOUDY_CLOUD_URL=https://device.pcloudy.com   # optional, for private clouds
 ```
 
+## Quick start
+
+```ruby
+# iOS: build, upload and re-sign with pCloudy's certificate
+lane :pcloudy_ios do
+  build_app(scheme: "MyApp", export_method: "development")
+  pcloudy_upload_app(resign: true)
+end
+
+# Android: build and upload
+lane :pcloudy_android do
+  gradle(task: "assembleDebug")
+  pcloudy_upload_app
+end
+```
+
+The app then appears in **pCloudy → My Apps**, ready to install on real devices.
+
+## `pcloudy_upload_app`
+
+Uploads an `.ipa` or `.apk` to pCloudy My Apps. If you don't pass `file:`, it uses the `.ipa` from `build_app` or the `.apk` from `gradle`.
+
+When a file with the same name already exists, pCloudy saves the upload under a new, timestamped name (e.g. `MyApp-1794551836.ipa`). The action returns that name, so always use the return value or `PCLOUDY_UPLOADED_FILE`, never the local file name.
+
+```ruby
+pcloudy_upload_app                                  # output of build_app / gradle
+pcloudy_upload_app(resign: true)                    # iOS: upload + re-sign in one step
+name = pcloudy_upload_app(file: "./build/MyApp.apk")
+```
+
+| Option | Env var | Default | Description |
+|---|---|---|---|
+| `file` | `PCLOUDY_APP_PATH` | output of `build_app` / `gradle` | Path to the `.ipa` or `.apk` |
+| `resign` | `PCLOUDY_RESIGN` | `false` | Re-sign the `.ipa` after uploading (iOS only) |
+| `wait_for_processing` | `PCLOUDY_WAIT_FOR_PROCESSING` | `true` | Wait until the file appears in My Apps |
+| `upload_timeout` | `PCLOUDY_UPLOAD_TIMEOUT` | `600` | Seconds allowed for the upload |
+| `processing_timeout` | `PCLOUDY_PROCESSING_TIMEOUT` | `120` | Seconds to wait for the file to appear in My Apps |
+| `resign_timeout` | `PCLOUDY_RESIGN_TIMEOUT` | `600` | Seconds to wait for re-signing (with `resign: true`) |
+
+Plus `username`, `api_key` and `cloud_url`, as for every action.
+
+**Returns:** the file name in My Apps (the re-signed copy when `resign: true`).
+**Sets:** `PCLOUDY_UPLOADED_FILE`, `PCLOUDY_APP_FILE`, and with `resign: true`, `PCLOUDY_RESIGNED_FILE`.
+
+## `pcloudy_resign_app`
+
+Re-signs an `.ipa` that's already in pCloudy My Apps with pCloudy's certificate, so it installs on pCloudy iPhones and iPads. If you don't pass `file:`, it uses the last `pcloudy_upload_app` upload.
+
+```ruby
+pcloudy_upload_app
+pcloudy_resign_app
+
+pcloudy_resign_app(file: "MyApp-1794551836.ipa")    # a file already in My Apps
+```
+
+| Option | Env var | Default | Description |
+|---|---|---|---|
+| `file` | `PCLOUDY_RESIGN_FILE` | last upload | File name in pCloudy My Apps |
+| `timeout` | `PCLOUDY_RESIGN_TIMEOUT` | `600` | Seconds to wait for re-signing to finish |
+| `poll_interval` | — | `5` | Seconds between progress checks |
+
+**Returns:** the re-signed file name, e.g. `MyApp-1794551836_Resigned1794551854668.ipa`.
+**Sets:** `PCLOUDY_RESIGNED_FILE` and `PCLOUDY_APP_FILE`.
+
 ## `pcloudy_list_devices`
 
 ```ruby
@@ -59,5 +123,7 @@ The action returns an array of device hashes (`id`, `full_name`, `display_name`,
 ```bash
 bundle install
 bundle exec rspec                                    # unit tests (HTTP is stubbed)
-bundle exec fastlane list_devices platform:ios       # live run, needs fastlane/.env
+bundle exec fastlane list_devices platform:ios       # live runs, need fastlane/.env
+bundle exec fastlane upload file:/path/App.ipa resign:true
+bundle exec fastlane resign file:App-1794551836.ipa
 ```

data/lib/fastlane/plugin/pcloudy/actions/pcloudy_list_devices_action.rb

@@ -1,6 +1,6 @@
 require "fastlane/action"
 require "terminal-table"
-require_relative "../helper/pcloudy_client"
+require_relative "../helper/pcloudy_options"
 
 module Fastlane
   module Actions
@@ -12,9 +12,7 @@ module Fastlane
       PLATFORMS = %w(ios android all).freeze
 
       def self.run(params)
-        client = Helper::PcloudyClient.new(username: params[:username],
-                                           api_key: params[:api_key],
-                                           cloud_url: params[:cloud_url])
+        client = Helper::PcloudyOptions.client(params)
 
         platforms = params[:platform] == "all" ? %w(ios android) : [params[:platform]]
         devices = platforms.flat_map do |platform|
@@ -104,24 +102,7 @@ module Fastlane
       end
 
       def self.available_options
-        [
-          FastlaneCore::ConfigItem.new(key: :username,
-                                       env_name: "PCLOUDY_USERNAME",
-                                       description: "pCloudy account email",
-                                       optional: false,
-                                       type: String),
-          FastlaneCore::ConfigItem.new(key: :api_key,
-                                       env_name: "PCLOUDY_API_KEY",
-                                       description: "pCloudy API key (Settings > API Key)",
-                                       optional: false,
-                                       sensitive: true,
-                                       code_gen_sensitive: true,
-                                       type: String),
-          FastlaneCore::ConfigItem.new(key: :cloud_url,
-                                       env_name: "PCLOUDY_CLOUD_URL",
-                                       description: "pCloudy cloud URL (change for private clouds)",
-                                       default_value: Helper::PcloudyClient::DEFAULT_CLOUD_URL,
-                                       type: String),
+        Helper::PcloudyOptions.auth + [
           FastlaneCore::ConfigItem.new(key: :platform,
                                        env_name: "PCLOUDY_PLATFORM",
                                        description: "Device platform: ios, android or all",

data/lib/fastlane/plugin/pcloudy/actions/pcloudy_resign_app_action.rb

@@ -0,0 +1,86 @@
+require "fastlane/action"
+require_relative "../helper/pcloudy_options"
+require_relative "pcloudy_upload_app_action"
+
+module Fastlane
+  module Actions
+    class PcloudyResignAppAction < Action
+      def self.run(params)
+        filename = params[:file] || Actions.lane_context[SharedValues::PCLOUDY_UPLOADED_FILE]
+        UI.user_error!("No app to re-sign. Run pcloudy_upload_app first or pass file: (a file name in pCloudy My Apps)") if filename.to_s.empty?
+
+        client = Helper::PcloudyOptions.client(params)
+        signed = Helper::PcloudyOptions.resign(client, filename, timeout: params[:timeout], interval: params[:poll_interval])
+
+        Actions.lane_context[SharedValues::PCLOUDY_RESIGNED_FILE] = signed
+        Actions.lane_context[SharedValues::PCLOUDY_APP_FILE] = signed
+        signed
+      rescue Helper::PcloudyClient::Error => e
+        UI.user_error!(e.message)
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Re-signs an uploaded .ipa with pCloudy's certificate so it installs on pCloudy iOS devices"
+      end
+
+      def self.details
+        "Starts re-signing on pCloudy, waits for it to reach 100% and returns the re-signed file name in My Apps. " \
+          "Uses the file from the last pcloudy_upload_app unless you pass file:."
+      end
+
+      def self.authors
+        ["bikee1235"]
+      end
+
+      def self.return_value
+        "The re-signed file name in pCloudy My Apps, e.g. MyApp-1794551836_Resigned1794551854668.ipa"
+      end
+
+      def self.output
+        [
+          ["PCLOUDY_RESIGNED_FILE", "Re-signed file name in pCloudy My Apps"],
+          ["PCLOUDY_APP_FILE", "Set to the re-signed file, for installing on devices"]
+        ]
+      end
+
+      def self.available_options
+        Helper::PcloudyOptions.auth + [
+          FastlaneCore::ConfigItem.new(key: :file,
+                                       env_name: "PCLOUDY_RESIGN_FILE",
+                                       description: "File name in pCloudy My Apps. Defaults to the last pcloudy_upload_app upload",
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :timeout,
+                                       env_name: "PCLOUDY_RESIGN_TIMEOUT",
+                                       description: "Seconds to wait for re-signing to finish",
+                                       default_value: 600,
+                                       type: Integer),
+          FastlaneCore::ConfigItem.new(key: :poll_interval,
+                                       description: "Seconds between progress checks",
+                                       default_value: 5,
+                                       type: Integer)
+        ]
+      end
+
+      def self.example_code
+        [
+          'pcloudy_upload_app
+          pcloudy_resign_app',
+          'pcloudy_resign_app(file: "MyApp-1794551836.ipa")'
+        ]
+      end
+
+      def self.category
+        :testing
+      end
+
+      def self.is_supported?(platform)
+        platform == :ios
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/pcloudy/actions/pcloudy_upload_app_action.rb

@@ -0,0 +1,144 @@
+require "fastlane/action"
+require_relative "../helper/pcloudy_options"
+
+module Fastlane
+  module Actions
+    module SharedValues
+      PCLOUDY_UPLOADED_FILE = :PCLOUDY_UPLOADED_FILE
+      PCLOUDY_RESIGNED_FILE = :PCLOUDY_RESIGNED_FILE
+      PCLOUDY_APP_FILE = :PCLOUDY_APP_FILE
+    end
+
+    class PcloudyUploadAppAction < Action
+      EXTENSIONS = %w(.ipa .apk).freeze
+
+      def self.run(params)
+        path = params[:file] || default_file
+        UI.user_error!("No app to upload. Pass file: or run build_app (iOS) / gradle (Android) first") if path.to_s.empty?
+
+        path = File.expand_path(path)
+        UI.user_error!("File not found: #{path}") unless File.file?(path)
+        ext = File.extname(path).downcase
+        UI.user_error!("Unsupported file type '#{ext}'. pCloudy apps must be #{EXTENSIONS.join(' or ')}") unless EXTENSIONS.include?(ext)
+        UI.user_error!("resign: true only works for iOS apps (.ipa); #{File.basename(path)} is #{ext}") if params[:resign] && ext != ".ipa"
+
+        client = Helper::PcloudyOptions.client(params)
+
+        UI.message("Uploading #{File.basename(path)} (#{format_size(File.size(path))}) to pCloudy...")
+        name = client.upload(path, timeout: params[:upload_timeout])
+        UI.success("Uploaded as #{name}")
+
+        if params[:wait_for_processing]
+          UI.message("Waiting for pCloudy to register #{name}...")
+          client.wait_for_file(name, timeout: params[:processing_timeout])
+        end
+
+        Actions.lane_context[SharedValues::PCLOUDY_UPLOADED_FILE] = name
+        Actions.lane_context[SharedValues::PCLOUDY_APP_FILE] = name
+
+        if params[:resign]
+          name = Helper::PcloudyOptions.resign(client, name, timeout: params[:resign_timeout], interval: 5)
+          Actions.lane_context[SharedValues::PCLOUDY_RESIGNED_FILE] = name
+          Actions.lane_context[SharedValues::PCLOUDY_APP_FILE] = name
+        end
+
+        name
+      rescue Helper::PcloudyClient::Error => e
+        UI.user_error!(e.message)
+      end
+
+      # The .ipa from build_app/gym, or else the .apk from gradle.
+      def self.default_file
+        context = Actions.lane_context
+        [context[:IPA_OUTPUT_PATH], context[:GRADLE_APK_OUTPUT_PATH]].find { |value| !value.to_s.empty? }
+      end
+
+      def self.format_size(bytes)
+        bytes >= 1024 * 1024 ? format("%.1f MB", bytes / 1024.0 / 1024) : format("%.0f KB", bytes / 1024.0)
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Uploads an .ipa or .apk to pCloudy (My Apps), optionally re-signing the .ipa"
+      end
+
+      def self.details
+        "Uploads the app built by build_app or gradle (or any file you pass) to pCloudy, waits until pCloudy has " \
+          "registered it, and returns the name pCloudy stored it under. pCloudy adds a timestamp to the name when " \
+          "a file with the same name already exists, so always use the returned name or PCLOUDY_UPLOADED_FILE."
+      end
+
+      def self.authors
+        ["bikee1235"]
+      end
+
+      def self.return_value
+        "The file name in pCloudy My Apps (the re-signed copy when resign: true)"
+      end
+
+      def self.output
+        [
+          ["PCLOUDY_UPLOADED_FILE", "File name pCloudy stored the upload under"],
+          ["PCLOUDY_RESIGNED_FILE", "Re-signed file name (when resign: true)"],
+          ["PCLOUDY_APP_FILE", "The file to install on devices: re-signed copy if any, otherwise the upload"]
+        ]
+      end
+
+      def self.available_options
+        Helper::PcloudyOptions.auth + [
+          FastlaneCore::ConfigItem.new(key: :file,
+                                       env_name: "PCLOUDY_APP_PATH",
+                                       description: "Path to the .ipa or .apk. Defaults to the output of build_app or gradle",
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :resign,
+                                       env_name: "PCLOUDY_RESIGN",
+                                       description: "Re-sign the uploaded .ipa with pCloudy's certificate (iOS only)",
+                                       default_value: false,
+                                       type: Boolean),
+          FastlaneCore::ConfigItem.new(key: :wait_for_processing,
+                                       env_name: "PCLOUDY_WAIT_FOR_PROCESSING",
+                                       description: "Wait until the upload appears in pCloudy My Apps",
+                                       default_value: true,
+                                       type: Boolean),
+          FastlaneCore::ConfigItem.new(key: :upload_timeout,
+                                       env_name: "PCLOUDY_UPLOAD_TIMEOUT",
+                                       description: "Seconds to allow for the upload request",
+                                       default_value: 600,
+                                       type: Integer),
+          FastlaneCore::ConfigItem.new(key: :processing_timeout,
+                                       env_name: "PCLOUDY_PROCESSING_TIMEOUT",
+                                       description: "Seconds to wait for the upload to appear in My Apps",
+                                       default_value: 120,
+                                       type: Integer),
+          FastlaneCore::ConfigItem.new(key: :resign_timeout,
+                                       env_name: "PCLOUDY_RESIGN_TIMEOUT",
+                                       description: "Seconds to wait for re-signing to finish (when resign: true)",
+                                       default_value: 600,
+                                       type: Integer)
+        ]
+      end
+
+      def self.example_code
+        [
+          'build_app(scheme: "MyApp", export_method: "development")
+          pcloudy_upload_app(resign: true)',
+          'gradle(task: "assembleDebug")
+          pcloudy_upload_app',
+          'name = pcloudy_upload_app(file: "./build/MyApp.ipa")'
+        ]
+      end
+
+      def self.category
+        :testing
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :android].include?(platform)
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/pcloudy/helper/pcloudy_client.rb

@@ -39,19 +39,93 @@ module Fastlane
         result["models"] || []
       end
 
+      # POST /api/upload_file (multipart). Returns the file name pCloudy stored the app under.
+      # pCloudy renames the upload (adds a timestamp) when a file with the same name already exists,
+      # so callers must use this return value, never the local file name.
+      def upload(path, filter: "all", timeout: 600)
+        request = Net::HTTP::Post.new(endpoint("/api/upload_file"))
+        result = File.open(path, "rb") do |io|
+          request.set_form([["file", io, { filename: File.basename(path) }],
+                            ["source_type", "raw"],
+                            ["token", token],
+                            ["filter", filter]],
+                           "multipart/form-data")
+          perform(request, timeout: timeout)
+        end
+        name = result["file"].to_s
+        raise(Error, "pCloudy upload succeeded but returned no file name") if name.empty?
+
+        name
+      end
+
+      # POST /api/drive. Returns the files in "My Apps" as hashes ({"file" => "...", "size_KB" => ..., ...}).
+      def files(filter: "all")
+        post_json("/api/drive", token: token, limit: 0, filter: filter)["files"] || []
+      end
+
+      # Waits until an uploaded file shows up in "My Apps". Raises Error after timeout seconds.
+      def wait_for_file(name, timeout: 120, interval: 3)
+        deadline = monotonic_now + timeout
+        loop do
+          return true if files.any? { |f| f["file"] == name }
+          raise(Error, "#{name} did not appear in pCloudy My Apps within #{timeout}s") if monotonic_now >= deadline
+
+          sleep(interval)
+        end
+      end
+
+      # Re-signs an uploaded .ipa with pCloudy's certificate: resign/initiate -> resign/progress -> resign/download.
+      # Yields the progress percentage while waiting. Returns the re-signed file name in "My Apps".
+      def resign(filename, timeout: 600, interval: 5)
+        deadline = monotonic_now + timeout
+        resign_token = with_retry_until(deadline, interval, /does not exist/i) do
+          post_json("/api/resign/initiate", token: token, filename: filename)["resign_token"]
+        end
+        raise(Error, "pCloudy resign/initiate returned no resign_token") if resign_token.to_s.empty?
+
+        loop do
+          status = post_json("/api/resign/progress", token: token, resign_token: resign_token, filename: filename)["resign_status"].to_i
+          yield(status) if block_given?
+          break if status >= 100
+          raise(Error, "Re-signing #{filename} did not finish within #{timeout}s (last progress #{status}%)") if monotonic_now >= deadline
+
+          sleep(interval)
+        end
+
+        signed = post_json("/api/resign/download", token: token, resign_token: resign_token, filename: filename)["resign_file"].to_s
+        raise(Error, "pCloudy resign/download returned no file name") if signed.empty?
+
+        signed
+      end
+
       private
 
+      # Runs the block, retrying while it raises an Error whose message matches `pattern`, until `deadline`.
+      def with_retry_until(deadline, interval, pattern)
+        yield
+      rescue Error => e
+        raise if e.message !~ pattern || monotonic_now >= deadline
+
+        sleep(interval)
+        retry
+      end
+
+      def monotonic_now
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
       def post_json(path, payload)
         request = Net::HTTP::Post.new(endpoint(path), "Content-Type" => "application/json")
         request.body = JSON.generate(payload)
         perform(request)
       end
 
-      def perform(request)
+      def perform(request, timeout: @timeout)
         response = Net::HTTP.start(@base.host, @base.port,
                                    use_ssl: @base.scheme == "https",
                                    open_timeout: @timeout,
-                                   read_timeout: @timeout) do |http|
+                                   read_timeout: timeout,
+                                   write_timeout: timeout) do |http|
           http.request(request)
         end
 
@@ -61,9 +135,10 @@ module Fastlane
         result = JSON.parse(response.body.to_s)["result"]
         raise(Error, "pCloudy #{path} returned an unexpected response") unless result.kind_of?(Hash)
 
-        unless result["code"].to_i == 200
+        # Some endpoints (e.g. upload_file) omit "code"; treat an explicit error or a non-200 code as failure.
+        if result["error"] || (result.key?("code") && result["code"].to_i != 200)
           message = result["error"] || result["msg"] || result["message"] || "unknown error"
-          raise(Error, "pCloudy #{path} failed (code #{result['code']}): #{message}")
+          raise(Error, "pCloudy #{path} failed (code #{result['code'] || 'n/a'}): #{message}")
         end
 
         result

data/lib/fastlane/plugin/pcloudy/helper/pcloudy_options.rb

@@ -0,0 +1,53 @@
+require "fastlane_core/configuration/config_item"
+require_relative "pcloudy_client"
+
+module Fastlane
+  module Helper
+    # Options and client setup shared by every pcloudy_* action.
+    module PcloudyOptions
+      def self.auth
+        [
+          FastlaneCore::ConfigItem.new(key: :username,
+                                       env_name: "PCLOUDY_USERNAME",
+                                       description: "pCloudy account email",
+                                       optional: false,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :api_key,
+                                       env_name: "PCLOUDY_API_KEY",
+                                       description: "pCloudy API key (Settings > API Key)",
+                                       optional: false,
+                                       sensitive: true,
+                                       code_gen_sensitive: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :cloud_url,
+                                       env_name: "PCLOUDY_CLOUD_URL",
+                                       description: "pCloudy cloud URL (change for private clouds)",
+                                       default_value: PcloudyClient::DEFAULT_CLOUD_URL,
+                                       type: String)
+        ]
+      end
+
+      def self.client(params)
+        PcloudyClient.new(username: params[:username],
+                          api_key: params[:api_key],
+                          cloud_url: params[:cloud_url])
+      end
+
+      # Re-signs `filename` in pCloudy, logging progress. Shared by pcloudy_resign_app and pcloudy_upload_app(resign: true).
+      def self.resign(client, filename, timeout:, interval:)
+        unless File.extname(filename).casecmp?(".ipa")
+          UI.user_error!("Only iOS apps (.ipa) can be re-signed on pCloudy; got #{filename}")
+        end
+
+        UI.message("Re-signing #{filename} on pCloudy...")
+        last = nil
+        signed = client.resign(filename, timeout: timeout, interval: interval) do |progress|
+          UI.message("Re-sign progress: #{progress}%") unless progress == last
+          last = progress
+        end
+        UI.success("Re-signed app in pCloudy: #{signed}")
+        signed
+      end
+    end
+  end
+end

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

@@ -1,5 +1,5 @@
 module Fastlane
   module Pcloudy
-    VERSION = "0.1.0"
+    VERSION = "0.2.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-pcloudy
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - bikee1235
@@ -91,9 +91,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
-description: Lists available real iOS and Android devices on pCloudy (device.pcloudy.com
-  or a private cloud) from your fastlane lanes, with filters for platform, OS version,
-  manufacturer and device name.
+description: 'Use pCloudy (device.pcloudy.com or a private cloud) from your fastlane
+  lanes: list available real iOS and Android devices, upload the .ipa or .apk you
+  just built, and re-sign iOS apps with pCloudy''s certificate.'
 email:
 - bikee.bihari@sstsinc.com
 executables: []
@@ -105,7 +105,10 @@ files:
 - README.md
 - lib/fastlane/plugin/pcloudy.rb
 - lib/fastlane/plugin/pcloudy/actions/pcloudy_list_devices_action.rb
+- lib/fastlane/plugin/pcloudy/actions/pcloudy_resign_app_action.rb
+- lib/fastlane/plugin/pcloudy/actions/pcloudy_upload_app_action.rb
 - lib/fastlane/plugin/pcloudy/helper/pcloudy_client.rb
+- lib/fastlane/plugin/pcloudy/helper/pcloudy_options.rb
 - lib/fastlane/plugin/pcloudy/version.rb
 homepage: https://github.com/Smart-Software-Testing-Solutions-Opkey/fastlane-plugin-pcloudy
 licenses: