fastlane-plugin-circle_ci 0.2.0 → 0.3.0

data/lib/fastlane/plugin/circle_ci/actions/circleci_cancel_job.rb

@@ -0,0 +1,96 @@
+require 'fastlane/action'
+require_relative '../helper/circle_ci_helper'
+
+module Fastlane
+  module Actions
+    class CircleciCancelJobAction < Action
+      def self.run(params)
+        UI.message("Canceling CircleCI job via API v2...")
+        
+        api_token = params[:api_token]
+        job_number = params[:job_number]
+        project_slug = params[:project_slug]
+        
+        # Make API request with empty body as required by the API
+        result = Helper::CircleCiHelper.post_v2("project/#{project_slug}/job/#{job_number}/cancel", api_token, {})
+        
+        UI.success("Successfully canceled job #{job_number} in project #{project_slug}")
+        
+        return { success: true, message: result["message"] }
+      end
+
+      def self.description
+        "Cancels a running job in CircleCI using API v2"
+      end
+
+      def self.details
+        "This action cancels a specific running job in CircleCI using the CircleCI API v2. This provides more granular control than canceling an entire workflow."
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :api_token,
+                                       env_name: "CIRCLE_CI_API_TOKEN",
+                                       description: "API Token for CircleCI API",
+                                       sensitive: true,
+                                       code_gen_sensitive: true,
+                                       is_string: true,
+                                       default_value: ENV["CIRCLE_CI_API_TOKEN"],
+                                       default_value_dynamic: true,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :project_slug,
+                                       env_name: "CIRCLE_CI_PROJECT_SLUG",
+                                       description: "Project slug in the form of :vcs-type/:org-name/:project-name (e.g. github/myorg/myrepo)",
+                                       is_string: true,
+                                       default_value: ENV["CIRCLE_CI_PROJECT_SLUG"],
+                                       default_value_dynamic: true,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :job_number,
+                                       env_name: "CIRCLE_CI_JOB_NUMBER",
+                                       description: "The number of the job to cancel",
+                                       is_string: true,
+                                       optional: false)
+        ]
+      end
+
+      def self.return_value
+        "Returns a hash with success status and the response message."
+      end
+
+      def self.authors
+        ["crazymanish", "copilot"]
+      end
+
+      def self.example_code
+        [
+          'circleci_cancel_job(
+            project_slug: "github/myorg/myrepo",
+            job_number: "123"
+          )',
+          '# First get jobs for a workflow, then cancel a specific one
+          jobs = circleci_get_workflow_jobs(
+            workflow_id: "workflow-id"
+          )
+          
+          # Find a job by name and cancel it if it\'s running
+          test_job = jobs.find { |job| job["name"] == "run-tests" && job["status"] == "running" }
+          
+          if test_job
+            circleci_cancel_job(
+              project_slug: "github/myorg/myrepo",
+              job_number: test_job["job_number"]
+            )
+          end'
+        ]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.category
+        :ci
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/circle_ci/actions/circleci_cancel_workflow.rb

@@ -0,0 +1,85 @@
+require 'fastlane/action'
+require_relative '../helper/circle_ci_helper'
+
+module Fastlane
+  module Actions
+    class CircleciCancelWorkflowAction < Action
+      def self.run(params)
+        UI.message("Canceling CircleCI workflow via API v2...")
+        
+        api_token = params[:api_token]
+        workflow_id = params[:workflow_id]
+        
+        # Make API request
+        result = Helper::CircleCiHelper.post_v2("workflow/#{workflow_id}/cancel", api_token)
+        
+        UI.success("Successfully canceled workflow with ID #{workflow_id}")
+        
+        return { success: true, message: result["message"] }
+      end
+
+      def self.description
+        "Cancels a running workflow in CircleCI using API v2"
+      end
+
+      def self.details
+        "This action cancels a specific running workflow in CircleCI using the CircleCI API v2."
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :api_token,
+                                       env_name: "CIRCLE_CI_API_TOKEN",
+                                       description: "API Token for CircleCI API",
+                                       sensitive: true,
+                                       code_gen_sensitive: true,
+                                       is_string: true,
+                                       default_value: ENV["CIRCLE_CI_API_TOKEN"],
+                                       default_value_dynamic: true,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :workflow_id,
+                                       env_name: "CIRCLE_CI_WORKFLOW_ID",
+                                       description: "The ID of the workflow to cancel",
+                                       is_string: true,
+                                       optional: false)
+        ]
+      end
+
+      def self.return_value
+        "Returns a hash with success status and the response message."
+      end
+
+      def self.authors
+        ["crazymanish", "copilot"]
+      end
+
+      def self.example_code
+        [
+          'circleci_cancel_workflow(
+            workflow_id: "1234-5678-90ab-cdef"
+          )',
+          '# First get workflows for a pipeline, then cancel a specific one
+          workflows = circleci_get_pipeline_workflows(
+            pipeline_id: "some-pipeline-id"
+          )
+          
+          workflows.each do |workflow|
+            if workflow["status"] == "running" && workflow["name"] == "build-and-test"
+              circleci_cancel_workflow(
+                workflow_id: workflow["id"]
+              )
+            end
+          end'
+        ]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.category
+        :ci
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/circle_ci/actions/circleci_continue_pipeline.rb

@@ -0,0 +1,104 @@
+require 'fastlane/action'
+require_relative '../helper/circle_ci_helper'
+
+module Fastlane
+  module Actions
+    module SharedValues
+      CIRCLECI_CONTINUED_PIPELINE = :CIRCLECI_CONTINUED_PIPELINE
+    end
+
+    class CircleciContinuePipelineAction < Action
+      def self.run(params)
+        UI.message("Continuing CircleCI pipeline via API v2...")
+        
+        api_token = params[:api_token]
+        pipeline_id = params[:pipeline_id]
+        parameters = params[:parameters]
+        
+        # Create the request body
+        body = {}
+        body["parameters"] = parameters if parameters
+        
+        # Make API request
+        result = Helper::CircleCiHelper.post_v2("pipeline/continue", api_token, {
+          "pipeline-id" => pipeline_id,
+          "parameters" => parameters
+        })
+        
+        # Store values in lane context
+        Actions.lane_context[SharedValues::CIRCLECI_CONTINUED_PIPELINE] = result
+        
+        UI.success("Successfully continued pipeline with ID #{pipeline_id}")
+        
+        return result
+      end
+
+      def self.description
+        "Continues a pipeline from the setup phase using CircleCI API v2"
+      end
+
+      def self.details
+        "This action continues a pipeline from the setup phase using the CircleCI API v2. This is useful for pipelines that require manual continuation or for dynamic configuration with parameters."
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :api_token,
+                                       env_name: "CIRCLE_CI_API_TOKEN",
+                                       description: "API Token for CircleCI API",
+                                       sensitive: true,
+                                       code_gen_sensitive: true,
+                                       is_string: true,
+                                       default_value: ENV["CIRCLE_CI_API_TOKEN"],
+                                       default_value_dynamic: true,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :pipeline_id,
+                                       description: "The ID of the pipeline to continue",
+                                       is_string: true,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :parameters,
+                                       description: "Parameters to pass to the pipeline continuation (for dynamic config)",
+                                       type: Hash,
+                                       optional: true)
+        ]
+      end
+
+      def self.output
+        [
+          ['CIRCLECI_CONTINUED_PIPELINE', 'A hash containing the continued pipeline information']
+        ]
+      end
+
+      def self.return_value
+        "Returns a hash containing information about the continued pipeline."
+      end
+
+      def self.authors
+        ["crazymanish", "copilot"]
+      end
+
+      def self.example_code
+        [
+          'circleci_continue_pipeline(
+            pipeline_id: "01234567-89ab-cdef-0123-456789abcdef"
+          )',
+          'continued_pipeline = circleci_continue_pipeline(
+            pipeline_id: "01234567-89ab-cdef-0123-456789abcdef",
+            parameters: {
+              "deploy_env" => "staging",
+              "version" => "1.2.3"
+            }
+          )'
+        ]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.category
+        :ci
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/circle_ci/actions/circleci_create_checkout_key.rb

@@ -0,0 +1,110 @@
+require 'fastlane/action'
+require_relative '../helper/circle_ci_helper'
+
+module Fastlane
+  module Actions
+    module SharedValues
+      CIRCLECI_CHECKOUT_KEY = :CIRCLECI_CHECKOUT_KEY
+    end
+
+    class CircleciCreateCheckoutKeyAction < Action
+      def self.run(params)
+        UI.message("Creating CircleCI project checkout key via API v2...")
+        
+        api_token = params[:api_token]
+        project_slug = params[:project_slug]
+        key_type = params[:key_type]
+        
+        # Create the request body
+        body = {
+          "type" => key_type
+        }
+        
+        # Make API request
+        result = Helper::CircleCiHelper.post_v2("project/#{project_slug}/checkout-key", api_token, body)
+        
+        # Store values in lane context
+        Actions.lane_context[SharedValues::CIRCLECI_CHECKOUT_KEY] = result
+        
+        UI.success("Successfully created checkout key (#{key_type}) for project #{project_slug}")
+        
+        return result
+      end
+
+      def self.description
+        "Creates a new checkout key for a CircleCI project using API v2"
+      end
+
+      def self.details
+        "This action creates a new checkout key for a specific CircleCI project using the CircleCI API v2. Checkout keys are used to check out code from your version control system. You can create either a 'deploy-key' or a 'github-user-key'."
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :api_token,
+                                       env_name: "CIRCLE_CI_API_TOKEN",
+                                       description: "API Token for CircleCI API",
+                                       sensitive: true,
+                                       code_gen_sensitive: true,
+                                       is_string: true,
+                                       default_value: ENV["CIRCLE_CI_API_TOKEN"],
+                                       default_value_dynamic: true,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :project_slug,
+                                       env_name: "CIRCLE_CI_PROJECT_SLUG",
+                                       description: "Project slug in the form of :vcs-type/:org-name/:project-name (e.g. github/myorg/myrepo)",
+                                       is_string: true,
+                                       default_value: ENV["CIRCLE_CI_PROJECT_SLUG"],
+                                       default_value_dynamic: true,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :key_type,
+                                       description: "The type of checkout key to create (deploy-key or github-user-key)",
+                                       is_string: true,
+                                       default_value: "deploy-key",
+                                       verify_block: proc do |value|
+                                         valid_types = ["deploy-key", "github-user-key"]
+                                         UI.user_error!("Key type must be one of: #{valid_types.join(', ')}") unless valid_types.include?(value)
+                                       end)
+        ]
+      end
+
+      def self.output
+        [
+          ['CIRCLECI_CHECKOUT_KEY', 'A hash containing the created checkout key information']
+        ]
+      end
+
+      def self.return_value
+        "Returns a hash containing the created checkout key information including type, fingerprint, and public key."
+      end
+
+      def self.authors
+        ["crazymanish", "copilot"]
+      end
+
+      def self.example_code
+        [
+          'circleci_create_checkout_key(
+            project_slug: "gh/MyOrg/my-project",
+            key_type: "deploy-key"
+          )',
+          'key = circleci_create_checkout_key(
+            project_slug: "gh/MyOrg/my-project",
+            key_type: "github-user-key"
+          )
+          
+          # Use the created key information
+          UI.message("Created key fingerprint: #{key["fingerprint"]}")'
+        ]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.category
+        :ci
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/circle_ci/actions/circleci_create_pipeline_definition.rb

@@ -0,0 +1,126 @@
+require 'fastlane/action'
+require_relative '../helper/circle_ci_helper'
+
+module Fastlane
+  module Actions
+    module SharedValues
+      CIRCLECI_CREATED_PIPELINE_DEFINITION = :CIRCLECI_CREATED_PIPELINE_DEFINITION
+    end
+
+    class CircleciCreatePipelineDefinitionAction < Action
+      def self.run(params)
+        UI.message("Creating CircleCI pipeline definition via API v2...")
+        
+        api_token = params[:api_token]
+        project_id = params[:project_id]
+        
+        # Build the request body
+        body = {
+          "name" => params[:name],
+          "config_source" => params[:config_source]
+        }
+        body["description"] = params[:description] if params[:description]
+        
+        # Make API request
+        result = Helper::CircleCiHelper.post_v2("projects/#{project_id}/pipeline-definitions", api_token, body)
+        
+        # Store values in lane context
+        Actions.lane_context[SharedValues::CIRCLECI_CREATED_PIPELINE_DEFINITION] = result
+        
+        UI.success("Successfully created pipeline definition '#{params[:name]}' for project #{project_id}")
+        
+        return result
+      end
+
+      def self.description
+        "Creates a pipeline definition for a CircleCI project using API v2"
+      end
+
+      def self.details
+        "This action creates a new pipeline definition for a specific CircleCI project using the CircleCI API v2. Pipeline definitions define how pipelines are configured for a project."
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :api_token,
+                                       env_name: "CIRCLE_CI_API_TOKEN",
+                                       description: "API Token for CircleCI API",
+                                       sensitive: true,
+                                       code_gen_sensitive: true,
+                                       is_string: true,
+                                       default_value: ENV["CIRCLE_CI_API_TOKEN"],
+                                       default_value_dynamic: true,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :project_id,
+                                       env_name: "CIRCLE_CI_PROJECT_ID",
+                                       description: "The ID of the CircleCI project",
+                                       is_string: true,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :name,
+                                       description: "The name of the pipeline definition",
+                                       is_string: true,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :description,
+                                       description: "Optional description for the pipeline definition",
+                                       is_string: true,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :config_source,
+                                       description: "Configuration source for the pipeline definition",
+                                       type: Hash,
+                                       optional: false,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("config_source must contain 'provider'") unless value["provider"]
+                                       end)
+        ]
+      end
+
+      def self.output
+        [
+          ['CIRCLECI_CREATED_PIPELINE_DEFINITION', 'A hash containing the created pipeline definition information']
+        ]
+      end
+
+      def self.return_value
+        "Returns a hash containing the created pipeline definition information."
+      end
+
+      def self.authors
+        ["crazymanish", "copilot"]
+      end
+
+      def self.example_code
+        [
+          'circleci_create_pipeline_definition(
+            project_id: "01234567-89ab-cdef-0123-456789abcdef",
+            name: "My Pipeline Definition",
+            description: "A pipeline definition for my project",
+            config_source: {
+              "provider" => "github_app",
+              "config_path" => ".circleci/config.yml"
+            }
+          )',
+          'definition = circleci_create_pipeline_definition(
+            project_id: "01234567-89ab-cdef-0123-456789abcdef",
+            name: "Bitbucket Pipeline Definition",
+            config_source: {
+              "provider" => "bitbucket_dc",
+              "config_path" => ".circleci/config.yml",
+              "branch" => "main"
+            }
+          )
+          
+          # Use the created pipeline definition
+          UI.message("Created definition ID: #{definition["id"]}")'
+        ]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.category
+        :ci
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/circle_ci/actions/circleci_create_pipeline_definition_trigger.rb

@@ -0,0 +1,133 @@
+require 'fastlane/action'
+require_relative '../helper/circle_ci_helper'
+
+module Fastlane
+  module Actions
+    module SharedValues
+      CIRCLECI_PIPELINE_DEFINITION_TRIGGER = :CIRCLECI_PIPELINE_DEFINITION_TRIGGER
+    end
+
+    class CircleciCreatePipelineDefinitionTriggerAction < Action
+      def self.run(params)
+        UI.message("Creating CircleCI pipeline definition trigger via API v2...")
+        
+        api_token = params[:api_token]
+        project_id = params[:project_id]
+        pipeline_definition_id = params[:pipeline_definition_id]
+        trigger_type = params[:trigger_type]
+        description = params[:description]
+        config = params[:config]
+        
+        # Create the request body
+        body = {
+          "type" => trigger_type,
+          "description" => description,
+          "config" => config
+        }
+        
+        # Make API request
+        result = Helper::CircleCiHelper.post_v2("projects/#{project_id}/pipeline-definitions/#{pipeline_definition_id}/triggers", api_token, body)
+        
+        # Store values in lane context
+        Actions.lane_context[SharedValues::CIRCLECI_PIPELINE_DEFINITION_TRIGGER] = result
+        
+        UI.success("Successfully created pipeline definition trigger")
+        
+        return result
+      end
+
+      def self.description
+        "Creates a trigger for a pipeline definition using CircleCI API v2"
+      end
+
+      def self.details
+        "This action creates a new trigger for a specific pipeline definition using the CircleCI API v2. Triggers allow you to automatically start pipelines based on events."
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :api_token,
+                                       env_name: "CIRCLE_CI_API_TOKEN",
+                                       description: "API Token for CircleCI API",
+                                       sensitive: true,
+                                       code_gen_sensitive: true,
+                                       is_string: true,
+                                       default_value: ENV["CIRCLE_CI_API_TOKEN"],
+                                       default_value_dynamic: true,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :project_id,
+                                       env_name: "CIRCLE_CI_PROJECT_ID",
+                                       description: "The ID of the CircleCI project",
+                                       is_string: true,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :pipeline_definition_id,
+                                       description: "The ID of the pipeline definition",
+                                       is_string: true,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :trigger_type,
+                                       description: "The type of trigger to create (e.g., 'webhook', 'github', etc.)",
+                                       is_string: true,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :description,
+                                       description: "A description for the trigger",
+                                       is_string: true,
+                                       optional: true,
+                                       default_value: ""),
+          FastlaneCore::ConfigItem.new(key: :config,
+                                       description: "Configuration for the trigger (varies by trigger type)",
+                                       type: Hash,
+                                       optional: false)
+        ]
+      end
+
+      def self.output
+        [
+          ['CIRCLECI_PIPELINE_DEFINITION_TRIGGER', 'A hash containing the created trigger information']
+        ]
+      end
+
+      def self.return_value
+        "Returns a hash containing the created trigger information."
+      end
+
+      def self.authors
+        ["crazymanish", "copilot"]
+      end
+
+      def self.example_code
+        [
+          'circleci_create_pipeline_definition_trigger(
+            project_id: "01234567-89ab-cdef-0123-456789abcdef",
+            pipeline_definition_id: "fedcba98-7654-3210-fedc-ba9876543210",
+            trigger_type: "webhook",
+            description: "My webhook trigger",
+            config: {
+              "authType" => "NONE"
+            }
+          )',
+          'trigger = circleci_create_pipeline_definition_trigger(
+            project_id: "01234567-89ab-cdef-0123-456789abcdef",
+            pipeline_definition_id: "fedcba98-7654-3210-fedc-ba9876543210",
+            trigger_type: "github",
+            description: "GitHub Push Trigger",
+            config: {
+              "pushEventType" => "BRANCHES",
+              "targetBranchMatchers" => ["main", "develop/*"]
+            }
+          )
+          
+          # Use the created trigger information
+          UI.message("Created trigger ID: #{trigger["id"]}")'
+        ]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.category
+        :ci
+      end
+    end
+  end
+end