fastlane-plugin-firebase 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9361331c59d149a7f719386d1c08c25c82a403f8
+  data.tar.gz: 2016b089727e3a4ee85587b44eeada1b4b174893
+SHA512:
+  metadata.gz: 7081d6fc6f890e1d0ae24d906113655e98e0f22b6a07aa061338923a688f789afb67d15397d36612e8297b7959cd20639eb84696a974463a7ffc9a0dbf7cfcae
+  data.tar.gz: 135af776a81c32012398322b829f7d810d28114ce2490e8da0dc7d42237255d09d43165eed4e2bed65886feaf0f8fa1f3017078d0ea3f59ba65ac3cb5ca4622b

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Tomas Kohout <email@tomaskohout.cz>
+
+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,101 @@
+# firebase plugin
+
+[![fastlane Plugin Badge](https://rawcdn.githack.com/fastlane/fastlane/master/fastlane/assets/plugin-badge.svg)](https://rubygems.org/gems/fastlane-plugin-firebase)
+
+## Getting Started
+
+This project is a [fastlane](https://github.com/fastlane/fastlane) plugin. To get started with `fastlane-plugin-firebase`, add it to your project by running:
+
+```bash
+fastlane add_plugin firebase
+```
+
+## About firebase
+
+An unofficial tool to access Firebase project settings. It allows you to create new clients (apps) and delete existing ones. It also allows to download config files (GoogleInfo.plist for ios and google-services.json for android) and upload push notification certificates (ios).
+
+## Disclaimer
+**!! Important !!**
+
+This tool uses internal firebase api and logs-in through google login using web scrapper tool. Until firebase provides official api, this is all we got. The use of web-based google login might result in email warnings from google about new login from unknown device. We recommend creating an extra account for the use of the firebase plugin and set it with limited permissions. We give no warranties whatsoever.
+
+
+### Actions
+
+
+List all projects and clients 
+
+```
+firebase_list
+```
+
+
+Add client to a project and download config file
+
+```
+firebase_add_client
+```
+
+
+Remove existing client from a project 
+
+```
+firebase_delete_client
+```
+
+Upload push certificate to a client
+
+```
+firebase_upload_certificate
+```
+
+Download config file for a client
+
+```
+firebase_download_config
+```
+
+
+## Example
+
+Check out the [example `Fastfile`](fastlane/Fastfile) to see how to use this plugin. Try it by cloning the repo, running `fastlane install_plugins` and `bundle exec fastlane test`.
+
+
+## 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).
+
+## Warning
+
+DISCLAIMER OF WARRANTIES AND LIMITATION OF LIABILITY.
+
+UNLESS OTHERWISE SEPARATELY UNDERTAKEN BY THE LICENSOR, TO THE EXTENT POSSIBLE, THE LICENSOR OFFERS THE LICENSED MATERIAL AS-IS AND AS-AVAILABLE, AND MAKES NO REPRESENTATIONS OR WARRANTIES OF ANY KIND CONCERNING THE LICENSED MATERIAL, WHETHER EXPRESS, IMPLIED, STATUTORY, OR OTHER. THIS INCLUDES, WITHOUT LIMITATION, WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, ABSENCE OF LATENT OR OTHER DEFECTS, ACCURACY, OR THE PRESENCE OR ABSENCE OF ERRORS, WHETHER OR NOT KNOWN OR DISCOVERABLE. WHERE DISCLAIMERS OF WARRANTIES ARE NOT ALLOWED IN FULL OR IN PART, THIS DISCLAIMER MAY NOT APPLY TO YOU.
+
+TO THE EXTENT POSSIBLE, IN NO EVENT WILL THE LICENSOR BE LIABLE TO YOU ON ANY LEGAL THEORY (INCLUDING, WITHOUT LIMITATION, NEGLIGENCE) OR OTHERWISE FOR ANY DIRECT, SPECIAL, INDIRECT, INCIDENTAL, CONSEQUENTIAL, PUNITIVE, EXEMPLARY, OR OTHER LOSSES, COSTS, EXPENSES, OR DAMAGES ARISING OUT OF THIS PUBLIC LICENSE OR USE OF THE LICENSED MATERIAL, EVEN IF THE LICENSOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH LOSSES, COSTS, EXPENSES, OR DAMAGES. WHERE A LIMITATION OF LIABILITY IS NOT ALLOWED IN FULL OR IN PART, THIS LIMITATION MAY NOT APPLY TO YOU.
+
+THE DISCLAIMER OF WARRANTIES AND LIMITATION OF LIABILITY PROVIDED ABOVE SHALL BE INTERPRETED IN A MANNER THAT, TO THE EXTENT POSSIBLE, MOST CLOSELY APPROXIMATES AN ABSOLUTE DISCLAIMER AND WAIVER OF ALL LIABILITY.

data/lib/fastlane/plugin/firebase.rb

@@ -0,0 +1,16 @@
+require 'fastlane/plugin/firebase/version'
+
+module Fastlane
+  module Firebase
+    # Return all .rb files inside the "actions" and "helper" directory
+    def self.all_classes
+      Dir[File.expand_path('**/{actions,helper,lib}/*.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::Firebase.all_classes.each do |current|
+  require current
+end

data/lib/fastlane/plugin/firebase/actions/firebase_add_client_action.rb

@@ -0,0 +1,107 @@
+module Fastlane
+  module Actions
+    class FirebaseAddClientAction < Action
+      
+      def self.run(params)
+        manager = Firebase::Manager.new
+        #Login
+        api = manager.login(params[:username])
+
+        #Select project
+        project = manager.select_project(params[:project_number])
+
+        # Client input
+        type = params[:type].to_sym
+
+        bundle_id = params[:bundle_id]
+        name = params[:name]
+        appstore_id = params[:appstore_id]
+
+        # Add client
+        client = api.add_client(project["projectNumber"], type, bundle_id, name, appstore_id)
+        
+        if params[:download_config] then
+          #Download config
+          config = api.download_config_file(project["projectNumber"], client["clientId"])
+          path = File.join(params[:output_path], params[:output_name] || config.filename)
+          config.save(path)
+
+          UI.success "Successfuly saved config at #{path}"
+        end
+
+      end
+
+      def self.description
+        "An unofficial tool to access Firebase"
+      end
+
+      def self.authors
+        ["Tomas Kohout"]
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+      end
+
+      def self.details
+        # Optional:
+        "Firebase helps you list your projects, create applications, download configuration files and more..."
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :username,
+                                  env_name: "FIREBASE_USERNAME",
+                               description: "Username for your google account",
+                                  optional: false),
+          FastlaneCore::ConfigItem.new(key: :project_number,
+                                  env_name: "FIREBASE_PROJECT_NUMBER",
+                               description: "Project number",
+                                  optional: true),
+          FastlaneCore::ConfigItem.new(key: :download_config,
+                                  env_name: "FIREBASE_DOWNLOAD_CONFIG",
+                               description: "Should download config for created client",
+                                  optional: false,
+                                  default_value: true),
+          FastlaneCore::ConfigItem.new(key: :type,
+                                  env_name: "FIREBASE_TYPE",
+                                  description: "Type of client (ios, android)",
+                                  verify_block: proc do |value|
+                                    types = [:ios, :android]
+                                    UI.user_error!("Type must be in #{types}") unless types.include?(value.to_sym)
+                                  end
+                               ),
+          FastlaneCore::ConfigItem.new(key: :bundle_id,
+                                  env_name: "FIREBASE_BUNDLE_ID",
+                               description: "Bundle ID (package name)",
+                                  optional: false),
+          FastlaneCore::ConfigItem.new(key: :name,
+                                  env_name: "FIREBASE_BUNDLE_ID",
+                               description: "Display name",
+                                  optional: true),
+          FastlaneCore::ConfigItem.new(key: :appstore_id,
+                                  env_name: "FIREBASE_APPSTORE_ID",
+                               description: "AppStore ID",
+                                  optional: true),
+          FastlaneCore::ConfigItem.new(key: :output_path,
+                                  env_name: "FIREBASE_OUTPUT_PATH",
+                               description: "Path for the downloaded config",
+                                  optional: false,
+                                  default_value: "./"),
+          FastlaneCore::ConfigItem.new(key: :output_name,
+                                  env_name: "FIREBASE_OUTPUT_NAME",
+                               description: "Name of the downloaded file",
+                                  optional: true)
+        ]
+      end
+
+      def self.is_supported?(platform)
+        # Adjust this if your plugin only works for a particular platform (iOS vs. Android, for example)
+        # See: https://github.com/fastlane/fastlane/blob/master/fastlane/docs/Platforms.md
+        #
+        # [:ios, :mac, :android].include?(platform)
+        true
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/firebase/actions/firebase_delete_client_action.rb

@@ -0,0 +1,75 @@
+module Fastlane
+  module Actions
+    class FirebaseDeleteClientAction < Action
+      
+      def self.run(params)
+        manager = Firebase::Manager.new
+        #Login
+        api = manager.login(params[:username])
+
+        #Select project
+        project = manager.select_project(params[:project_number])
+
+        #Select project
+        client = manager.select_client(project, params[:client_id])
+
+        #Confirm
+        if !params[:force] then
+          UI.error "Caution, this is a permanent action. Deleting your app will delete the corresponding Analytics data, but not your app's API keys or OAuth clients."
+          UI.confirm "Are you sure to delete #{client["clientId"]} (#{client["displayName"]})?"
+        end
+
+        #Delete
+        api.delete_client(project["projectNumber"], client["clientId"])
+
+        UI.success "Successfuly deleted #{client["clientId"]}"
+      end
+
+      def self.description
+        "An unofficial tool to access Firebase"
+      end
+
+      def self.authors
+        ["Tomas Kohout"]
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+      end
+
+      def self.details
+        # Optional:
+        "Firebase helps you list your projects, create applications, download configuration files and more..."
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :username,
+                                  env_name: "FIREBASE_USERNAME",
+                               description: "Username for your google account",
+                                  optional: false),
+          FastlaneCore::ConfigItem.new(key: :project_number,
+                                  env_name: "FIREBASE_PROJECT_NUMBER",
+                               description: "Project number",
+                                  optional: true),
+          FastlaneCore::ConfigItem.new(key: :client_id,
+                                  env_name: "FIREBASE_CLIENT_ID",
+                               description: "Client ID to be deleted",
+                                  optional: true),
+          FastlaneCore::ConfigItem.new(key: :force,
+                                  env_name: "FIREBASE_FORCE",
+                               description: "Force delete",
+                                  default_value: false)
+        ]
+      end
+
+      def self.is_supported?(platform)
+        # Adjust this if your plugin only works for a particular platform (iOS vs. Android, for example)
+        # See: https://github.com/fastlane/fastlane/blob/master/fastlane/docs/Platforms.md
+        #
+        # [:ios, :mac, :android].include?(platform)
+        true
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/firebase/actions/firebase_download_config_action.rb

@@ -0,0 +1,79 @@
+module Fastlane
+  module Actions
+    class FirebaseDownloadConfigAction < Action
+      
+      def self.run(params)
+        manager = Firebase::Manager.new
+        
+        # Login
+        api = manager.login(params[:username])
+
+        #Select project
+        project = manager.select_project(params[:project_number])
+        project_number = project["projectNumber"]
+
+        #Select client
+        client = manager.select_client(project, params[:client_id])
+        client_id = client["clientId"]
+
+        #Download
+        config = api.download_config_file(project_number, client_id)
+        path = File.join(params[:output_path], params[:output_name] || config.filename)
+        config.save(path)
+
+        UI.success "Successfuly saved config at #{path}"
+      end
+
+      def self.description
+        "An unofficial tool to access Firebase"
+      end
+
+      def self.authors
+        ["Tomas Kohout"]
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+      end
+
+      def self.details
+        # Optional:
+        "Firebase helps you list your projects, create applications, download configuration files and more..."
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :username,
+                                  env_name: "FIREBASE_USERNAME",
+                               description: "Username for your google account",
+                                  optional: false),
+          FastlaneCore::ConfigItem.new(key: :project_number,
+                                  env_name: "FIREBASE_PROJECT_NUMBER",
+                               description: "Project number",
+                                  optional: true),
+          FastlaneCore::ConfigItem.new(key: :client_id,
+                                  env_name: "FIREBASE_CLIENT_ID",
+                               description: "Project client id",
+                                  optional: true),
+          FastlaneCore::ConfigItem.new(key: :output_path,
+                                  env_name: "FIREBASE_OUTPUT_PATH",
+                               description: "Path for the downloaded config",
+                                  optional: false,
+                                  default_value: "./"),
+          FastlaneCore::ConfigItem.new(key: :output_name,
+                                  env_name: "FIREBASE_OUTPUT_NAME",
+                               description: "Name of the downloaded file",
+                                  optional: true)
+        ]
+      end
+
+      def self.is_supported?(platform)
+        # Adjust this if your plugin only works for a particular platform (iOS vs. Android, for example)
+        # See: https://github.com/fastlane/fastlane/blob/master/fastlane/docs/Platforms.md
+        #
+        # [:ios, :mac, :android].include?(platform)
+        true
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/firebase/actions/firebase_list_action.rb

@@ -0,0 +1,60 @@
+module Fastlane
+  module Actions
+    class FirebaseListAction < Action
+      require 'security'
+      
+      def self.run(params)
+        manager = Firebase::Manager.new
+        # Login
+        api = manager.login(params[:username])
+
+        # List projects
+        projects = api.project_list()
+        projects.each_with_index { |p, i| 
+          UI.message "#{i+1}. #{p["displayName"]}" 
+          p["clientSummary"].sort {|left, right| left["clientId"] <=> right["clientId"] }.each_with_index { |client, j|
+            UI.message "  - #{client["clientId"]} (#{client["displayName"]})" 
+          } 
+        }
+      end
+
+      def self.description
+        "An unofficial tool to access Firebase"
+      end
+
+      def self.authors
+        ["Tomas Kohout"]
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+      end
+
+      def self.details
+        # Optional:
+        "Firebase helps you list your projects, create applications, download configuration files and more..."
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :username,
+                                  env_name: "FIREBASE_USERNAME",
+                               description: "Username for your google account",
+                                  optional: false),
+          FastlaneCore::ConfigItem.new(key: :project_number,
+                                  env_name: "FIREBASE_PROJECT_NUMBER",
+                               description: "Project number",
+                                  optional: true)
+        ]
+      end
+
+      def self.is_supported?(platform)
+        # Adjust this if your plugin only works for a particular platform (iOS vs. Android, for example)
+        # See: https://github.com/fastlane/fastlane/blob/master/fastlane/docs/Platforms.md
+        #
+        # [:ios, :mac, :android].include?(platform)
+        true
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/firebase/actions/firebase_upload_certificate_action.rb

@@ -0,0 +1,104 @@
+module Fastlane
+  module Actions
+    class FirebaseUploadCertificateAction < Action
+      require 'security'
+      
+      def self.server_name
+        "firebase.google.com"
+      end
+
+      def self.run(params)
+        manager = Firebase::Manager.new
+        
+        # Login
+        api = manager.login(params[:username])
+
+        p12_path = params[:p12_path]
+
+        #Select project
+        project = manager.select_project(params[:project_number])
+        project_number = project["projectNumber"]
+
+        #Select client
+        client = manager.select_client(project, params[:client_id])
+        client_id = client["clientId"]
+
+        #Select certificate type
+        type = UI.select("Select type:", [:development, :production])
+
+        #Base64 certificate
+        certificate_value = Base64.encode64(File.open(p12_path, "rb").read).delete!("\n")
+
+        UI.message "Uploading certificate ..."
+        cert_password = params[:p12_password]
+
+        begin 
+          api.upload_certificate(project_number, client_id, type, certificate_value, cert_password)
+        rescue Firebase::Api::BadRequestError => e
+          if e.message.start_with? "3000" then
+            UI.error e.message
+            cert_password = UI.password("Password for certificate")
+            retry
+          elsif e.message.start_with? "3003" then
+            UI.user_error! "The Bundle ID in the certificate does not match the Bundle ID you entered."
+            return
+          end
+          UI.crash! e.message
+        end
+
+        UI.success "Successfully uploaded certificate"
+      end
+
+
+      def self.description
+        "An unofficial tool to access Firebase"
+      end
+
+      def self.authors
+        ["Tomas Kohout"]
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+      end
+
+      def self.details
+        # Optional:
+        "Firebase helps you list your projects, create applications, download configuration files and more..."
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :username,
+                                  env_name: "FIREBASE_USERNAME",
+                               description: "Username for your google account",
+                                  optional: false),
+          FastlaneCore::ConfigItem.new(key: :p12_path,
+                                  env_name: "FIREBASE_P12PATH",
+                               description: "Path to certificate",
+                                  optional: false),
+          FastlaneCore::ConfigItem.new(key: :p12_password,
+                                  env_name: "FIREBASE_PASSWORD",
+                               description: "Password to the certicate",
+                                  optional: true),
+          FastlaneCore::ConfigItem.new(key: :project_number,
+                                  env_name: "FIREBASE_PROJECT_NUMBER",
+                               description: "Project number",
+                                  optional: true),
+          FastlaneCore::ConfigItem.new(key: :client_id,
+                                  env_name: "FIREBASE_CLIENT_ID",
+                               description: "Project client id",
+                                  optional: true)
+        ]
+      end
+
+      def self.is_supported?(platform)
+        # Adjust this if your plugin only works for a particular platform (iOS vs. Android, for example)
+        # See: https://github.com/fastlane/fastlane/blob/master/fastlane/docs/Platforms.md
+        #
+        # [:ios, :mac, :android].include?(platform)
+        true
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/firebase/helper/firebase_helper.rb

@@ -0,0 +1,12 @@
+module Fastlane
+  module Helper
+    class FirebaseHelper
+      # class methods that you define here become available in your action
+      # as `Helper::FirebaseHelper.your_method`
+      #
+      def self.show_message
+        UI.message("Hello from the firebase plugin helper!")
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/firebase/lib/api.rb

@@ -0,0 +1,186 @@
+module Fastlane
+  module Firebase
+  	
+		class Api 
+			class LoginError < StandardError 
+			end
+
+			class BadRequestError < StandardError
+			end
+
+			require 'mechanize'
+			require 'digest/sha1'
+			require 'json'
+			require 'cgi'
+
+			def initialize(email, password)
+				@agent = Mechanize.new
+				@base_url = "https://console.firebase.google.com"
+				@sdk_url = "https://mobilesdk-pa.clients6.google.com/"
+				@login_url = "https://accounts.google.com/ServiceLogin"
+
+				login(email, password)
+			end
+
+			def login(email, password)
+				UI.message "Logging in to Google account #{email}"
+
+				page = @agent.get("#{@login_url}?passive=1209600&osid=1&continue=#{@base_url}/&followup=#{@base_url}/")
+				
+				#First step - email
+				google_form = page.form()
+				google_form.Email = email
+
+				#Send
+				page = @agent.submit(google_form, google_form.buttons.first)
+				
+				#Second step - password
+				google_form = page.form()
+				google_form.Passwd = password
+
+				#Send
+				page = @agent.submit(google_form, google_form.buttons.first)
+				match = page.search("script").text.scan(/\\x22api-key\\x22:\\x22(.*?)\\x22/)
+				
+				if match.count == 1 then
+					@api_key = match[0][0]
+					@authorization_headers = create_authorization_headers()
+					UI.success "Successfuly logged in"
+					true
+				else
+					if error = page.at("#errormsg_0_Passwd") then
+						message = error.text.strip
+					else
+						message = "Unknown error"
+					end
+					raise LoginError, "Login failed: #{message}"
+				end 
+			end
+
+			def generate_sapisid_hash(time, sapisid, origin) 
+				to_hash = time.to_s + " " + sapisid + " " + origin.to_s
+				
+				hash = Digest::SHA1.hexdigest(to_hash)
+				sapisid_hash = time.to_s + "_" + hash
+
+				sapisid_hash
+			end
+
+			def create_authorization_headers 
+				cookie = @agent.cookie_jar.jar["google.com"]["/"]["SAPISID"]
+				sapisid = cookie.value
+				origin = @base_url
+				time = Time.now.to_i
+
+				sapisid_hash = generate_sapisid_hash(time, sapisid, origin)
+
+				cookies = @agent.cookie_jar.jar["google.com"]["/"].merge(@agent.cookie_jar.jar["console.firebase.google.com"]["/"])
+				cookie_header = cookies.map { |el, cookie| "#{el}=#{cookie.value}" }.join(";")
+
+				sapisid_hash = generate_sapisid_hash(time, sapisid, origin)
+				sapisid_header = "SAPISIDHASH #{sapisid_hash}"
+
+				json_headers = {
+					'Authorization' => sapisid_header,
+					'Cookie' => cookie_header,
+					'X-Origin' => origin
+				}
+
+				json_headers
+			end
+
+			def request_json(path, method = :get, parameters = Hash.new, headers = Hash.new)
+					begin
+					if method == :get then
+						parameters["key"] = @api_key
+						page = @agent.get("#{@sdk_url}#{path}", parameters, nil, headers.merge(@authorization_headers))
+					elsif method == :post then
+						headers['Content-Type'] = 'application/json'
+						page = @agent.post("#{@sdk_url}#{path}?key=#{@api_key}", parameters.to_json, headers.merge(@authorization_headers))
+					elsif method == :delete then
+						page = @agent.delete("#{@sdk_url}#{path}?key=#{@api_key}", parameters, headers.merge(@authorization_headers))
+					end
+
+					JSON.parse(page.body)
+
+					rescue Mechanize::ResponseCodeError => e
+						code = e.response_code.to_i
+						if code >= 400 && code < 500 then
+							if body = JSON.parse(e.page.body) then
+								raise BadRequestError, body["error"]["message"]
+							end
+						end
+						UI.crash! e.page.body
+					end
+			end
+
+			def project_list
+				UI.message "Retrieving project list"
+				json = request_json("v1/projects")
+				projects = json["project"]
+				UI.success "Found #{projects.count} projects"
+				projects
+			end
+
+			def add_client(project_number, type, bundle_id, app_name, ios_appstore_id )
+				parameters = {
+					"requestHeader" => { "clientVersion" => "FIREBASE" },
+					"displayName" => app_name || ""
+				}
+
+				case type
+					when :ios
+						parameters["iosData"] = {
+							"bundleId" => bundle_id,
+							"iosAppStoreId" => ios_appstore_id || ""
+						}
+					when :android
+						parameters["androidData"] = {
+							"packageName" => bundle_id
+						}
+				end
+
+				json = request_json("v1/projects/#{project_number}/clients", :post, parameters)
+				if client = json["client"] then
+					UI.success "Successfuly added client #{bundle_id}"
+					client
+				else
+					UI.error "Client could not be added"
+				end
+			end
+
+			def delete_client(project_number, client_id)
+				json = request_json("v1/projects/#{project_number}/clients/#{client_id}", :delete)
+			end
+
+			def upload_certificate(project_number, client_id, type, certificate_value, certificate_password)
+				
+				prefix = type == :development ? "debug" : "prod"
+
+				parameters = {
+					"#{prefix}ApnsCertificate" => { 
+						"certificateValue" => certificate_value,
+						"apnsPassword" => certificate_password 
+					}
+				}
+
+				json = request_json("v1/projects/#{project_number}/clients/#{client_id}:setApnsCertificate", :post, parameters)
+			end
+
+			def download_config_file(project_number, client_id)
+				
+				request = "[\"getArtifactRequest\",null,\"#{client_id}\",\"1\",\"#{project_number}\"]"
+				code = (client_id.start_with? "ios") ? "1" : "2"
+				url = @base_url + "/m/mobilesdk/projects/" + project_number + "/clients/" + CGI.escape(client_id) + "/artifacts/#{code}?param=" + CGI.escape(request)
+				UI.message "Downloading config file"
+				begin
+					config = @agent.get url
+					UI.success "Successfuly downloaded #{config.filename}"
+					config
+				rescue Mechanize::ResponseCodeError => e
+					UI.crash! e.page.body
+				end
+			end
+		end
+	end
+end

data/lib/fastlane/plugin/firebase/lib/commands_generator.rb

@@ -0,0 +1,41 @@
+require 'commander'
+require 'fastlane/version'
+
+
+module Firebase
+  class CommandsGenerator
+    include Commander::Methods
+
+    def self.start
+      self.new.run
+    end
+
+    def run
+      program :name, 'firebase'
+      program :version, Fastlane::VERSION
+      program :description, 'CLI for \'PEM\' - Automatically generate and renew your push notification profiles'
+      program :help, 'Author', 'Felix Krause <pem@krausefx.com>'
+      program :help, 'Website', 'https://fastlane.tools'
+      program :help, 'GitHub', 'https://github.com/fastlane/PEM'
+      program :help_formatter, :compact
+
+      global_option('--verbose') { FastlaneCore::Globals.verbose = true }
+
+      command :list do |c|
+        c.syntax = 'fastlane firebase list'
+        c.description = 'Lists all projects in your firebase'
+
+        FastlaneCore::CommanderGenerator.new.generate(Firebase::Options.available_options, command: c)
+
+        c.action do |args, options|
+          Firebase.config = FastlaneCore::Configuration.create(Firebase::Options.available_options, options.__hash__)
+          #Firebase::Manager.start
+        end
+      end
+
+      default_command :list
+
+      run!
+    end
+  end
+end

data/lib/fastlane/plugin/firebase/lib/manager.rb

@@ -0,0 +1,61 @@
+module Fastlane
+  module Firebase
+  	
+		class Manager
+			def server_name
+        "firebase.google.com"
+      end
+
+
+
+			def login(username)
+				item = Security::InternetPassword.find(server: server_name(), account: username)
+        password = item.password if item
+
+        begin 
+          password = UI.input("Password for #{username}") unless password
+          
+          #Api instance
+          @api = Firebase::Api.new(username, password)
+          
+          #Store password
+          Security::InternetPassword.add(server_name(), username, password) unless item.password == password
+
+          @api
+        rescue Firebase::Api::LoginError => e
+          password = nil
+          UI.error e.message
+          retry
+        end
+			end
+
+			def select_project(project_number)
+				projects = @api.project_list()
+				if project = projects.select {|p| p["projectNumber"] == project_number }.first then
+					project
+				else 
+        	options = projects.map { |p| p["displayName"] }
+        	index = select_index("Select project:", options)
+        	projects[index]
+        end
+      end
+
+      def select_client(project, client_id)
+      	clients = project["clientSummary"].sort {|left, right| left["clientId"] <=> right["clientId"] }
+
+      	if client = clients.select {|c| c["clientId"] == client_id }.first then
+      		client
+      	else
+      		options = clients.map { |p| "#{p["clientId"]} (#{p["displayName"]})" }
+      		index = select_index("Select client:", options)
+      		clients[index]
+	      end
+      end
+
+      def select_index(text, options)
+				selected = UI.select(text, options)
+				return options.index(selected)
+			end 
+		end
+	end
+end 

data/lib/fastlane/plugin/firebase/lib/options.rb

@@ -0,0 +1,14 @@
+require 'fastlane_core'
+require 'credentials_manager'
+
+module Firebase
+  class Options
+    def self.available_options
+      [
+        FastlaneCore::ConfigItem.new(key: :username,
+                                     env_name: "FIREBASE_USERNAME",
+                                     description: "Username for the google account"),
+      ]
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+module Fastlane
+  module Firebase
+    VERSION = "0.1.1"
+  end
+end

metadata

@@ -0,0 +1,141 @@
+--- !ruby/object:Gem::Specification
+name: fastlane-plugin-firebase
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Tomas Kohout
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-04-20 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: 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: 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: rubocop
+  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.5.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.5.0
+- !ruby/object:Gem::Dependency
+  name: mechanize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email: email@tomaskohout.cz
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/fastlane/plugin/firebase.rb
+- lib/fastlane/plugin/firebase/actions/firebase_add_client_action.rb
+- lib/fastlane/plugin/firebase/actions/firebase_delete_client_action.rb
+- lib/fastlane/plugin/firebase/actions/firebase_download_config_action.rb
+- lib/fastlane/plugin/firebase/actions/firebase_list_action.rb
+- lib/fastlane/plugin/firebase/actions/firebase_upload_certificate_action.rb
+- lib/fastlane/plugin/firebase/helper/firebase_helper.rb
+- lib/fastlane/plugin/firebase/lib/api.rb
+- lib/fastlane/plugin/firebase/lib/commands_generator.rb
+- lib/fastlane/plugin/firebase/lib/manager.rb
+- lib/fastlane/plugin/firebase/lib/options.rb
+- lib/fastlane/plugin/firebase/version.rb
+homepage: https://github.com/tkohout/fastlane-firebase-plugin
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.11
+signing_key: 
+specification_version: 4
+summary: Unofficial tool to access Firebase project settings
+test_files: []