fastlane-plugin-circle_ci 0.2.0 → 0.3.0

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

@@ -0,0 +1,132 @@
+require 'fastlane/action'
+require_relative '../helper/circle_ci_helper'
+
+module Fastlane
+  module Actions
+    module SharedValues
+      CIRCLECI_CONTEXTS = :CIRCLECI_CONTEXTS
+    end
+
+    class CircleciListContextsAction < Action
+      def self.run(params)
+        UI.message("Listing CircleCI contexts via API v2...")
+        
+        api_token = params[:api_token]
+        owner_id = params[:owner_id]
+        owner_type = params[:owner_type]
+        owner_slug = params[:owner_slug]
+        
+        query_params = {}
+        
+        # Determine if we're using owner-id or owner-slug
+        if owner_id && owner_type
+          query_params["owner-id"] = owner_id
+          query_params["owner-type"] = owner_type
+          UI.verbose("Using owner-id: #{owner_id} and owner-type: #{owner_type}")
+        elsif owner_slug
+          query_params["owner-slug"] = owner_slug
+          UI.verbose("Using owner-slug: #{owner_slug}")
+        else
+          UI.user_error!("Either owner_id and owner_type, or owner_slug must be provided")
+        end
+        
+        # Make API request
+        result = Helper::CircleCiHelper.get_v2("context", api_token, query_params)
+        
+        # Store values in lane context
+        Actions.lane_context[SharedValues::CIRCLECI_CONTEXTS] = result["items"]
+        
+        UI.success("Successfully retrieved #{result["items"].count} contexts")
+        
+        return result["items"]
+      end
+
+      def self.description
+        "Lists CircleCI contexts using API v2"
+      end
+
+      def self.details
+        "This action lists all contexts for an organization or account using the CircleCI API v2. Contexts allow you to share environment variables across multiple projects."
+      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: :owner_id,
+                                       env_name: "CIRCLE_CI_CONTEXT_OWNER_ID",
+                                       description: "The ID of the context owner (organization or account)",
+                                       is_string: true,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :owner_type,
+                                       env_name: "CIRCLE_CI_CONTEXT_OWNER_TYPE",
+                                       description: "The type of the context owner (organization or account)",
+                                       is_string: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Owner type must be either 'organization' or 'account'") unless ['organization', 'account'].include?(value)
+                                       end,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :owner_slug,
+                                       env_name: "CIRCLE_CI_CONTEXT_OWNER_SLUG",
+                                       description: "The slug of the context owner (e.g., github/myorg)",
+                                       is_string: true,
+                                       optional: true)
+        ]
+      end
+
+      def self.output
+        [
+          ['CIRCLECI_CONTEXTS', 'An array of context data']
+        ]
+      end
+
+      def self.return_value
+        "Returns an array of context data including IDs, names, and creation timestamps."
+      end
+
+      def self.authors
+        ["crazymanish", "copilot"]
+      end
+
+      def self.example_code
+        [
+          'circleci_list_contexts(
+            owner_slug: "github/myorg"
+          )',
+          'circleci_list_contexts(
+            owner_id: "organization-uuid",
+            owner_type: "organization"
+          )',
+          'contexts = circleci_list_contexts(
+            owner_slug: "github/myorg"
+          )
+          
+          # Find a specific context
+          staging_context = contexts.find { |c| c["name"] == "staging" }
+          
+          if staging_context
+            # Get environment variables for this context
+            env_vars = circleci_get_context_env_vars(
+              context_id: staging_context["id"]
+            )
+          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_list_pipeline_definition_triggers.rb

@@ -0,0 +1,101 @@
+require 'fastlane/action'
+require_relative '../helper/circle_ci_helper'
+
+module Fastlane
+  module Actions
+    module SharedValues
+      CIRCLECI_PIPELINE_DEFINITION_TRIGGERS = :CIRCLECI_PIPELINE_DEFINITION_TRIGGERS
+    end
+
+    class CircleciListPipelineDefinitionTriggersAction < Action
+      def self.run(params)
+        UI.message("Getting CircleCI pipeline definition triggers via API v2...")
+        
+        api_token = params[:api_token]
+        project_id = params[:project_id]
+        pipeline_definition_id = params[:pipeline_definition_id]
+        
+        # Make API request
+        result = Helper::CircleCiHelper.get_v2("projects/#{project_id}/pipeline-definitions/#{pipeline_definition_id}/triggers", api_token)
+        
+        # Store values in lane context
+        Actions.lane_context[SharedValues::CIRCLECI_PIPELINE_DEFINITION_TRIGGERS] = result
+        
+        UI.success("Successfully retrieved pipeline definition triggers")
+        
+        return result
+      end
+
+      def self.description
+        "Gets all triggers for a pipeline definition using CircleCI API v2"
+      end
+
+      def self.details
+        "This action retrieves all triggers configured for a specific pipeline definition using the CircleCI API v2. Pipeline definition 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)
+        ]
+      end
+
+      def self.output
+        [
+          ['CIRCLECI_PIPELINE_DEFINITION_TRIGGERS', 'A hash containing triggers information']
+        ]
+      end
+
+      def self.return_value
+        "Returns a hash containing pipeline definition triggers information."
+      end
+
+      def self.authors
+        ["crazymanish", "copilot"]
+      end
+
+      def self.example_code
+        [
+          'circleci_list_pipeline_definition_triggers(
+            project_id: "01234567-89ab-cdef-0123-456789abcdef",
+            pipeline_definition_id: "fedcba98-7654-3210-fedc-ba9876543210"
+          )',
+          'triggers = circleci_list_pipeline_definition_triggers(
+            project_id: "01234567-89ab-cdef-0123-456789abcdef",
+            pipeline_definition_id: "fedcba98-7654-3210-fedc-ba9876543210"
+          )
+          
+          # Use the triggers information
+          triggers["items"].each do |trigger|
+            UI.message("Trigger ID: #{trigger["id"]}, Type: #{trigger["type"]}")
+          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_list_pipeline_schedules.rb

@@ -0,0 +1,99 @@
+require 'fastlane/action'
+require_relative '../helper/circle_ci_helper'
+
+module Fastlane
+  module Actions
+    module SharedValues
+      CIRCLECI_PIPELINE_SCHEDULES = :CIRCLECI_PIPELINE_SCHEDULES
+    end
+
+    class CircleciListPipelineSchedulesAction < Action
+      def self.run(params)
+        UI.message("Listing CircleCI pipeline schedules via API v2...")
+        
+        api_token = params[:api_token]
+        project_slug = params[:project_slug]
+        
+        # Make API request
+        result = Helper::CircleCiHelper.get_v2("project/#{project_slug}/schedule", api_token)
+        
+        # Store values in lane context
+        Actions.lane_context[SharedValues::CIRCLECI_PIPELINE_SCHEDULES] = result["items"]
+        
+        UI.success("Successfully retrieved #{result["items"].count} pipeline schedules for project #{project_slug}")
+        
+        return result["items"]
+      end
+
+      def self.description
+        "Lists pipeline schedules for a CircleCI project using API v2"
+      end
+
+      def self.details
+        "This action retrieves all pipeline schedules for a specific CircleCI project 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: :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)
+        ]
+      end
+
+      def self.output
+        [
+          ['CIRCLECI_PIPELINE_SCHEDULES', 'An array of pipeline schedule data for the project']
+        ]
+      end
+
+      def self.return_value
+        "Returns an array of pipeline schedule data including IDs, names, and schedule details."
+      end
+
+      def self.authors
+        ["crazymanish", "copilot"]
+      end
+
+      def self.example_code
+        [
+          'circleci_list_pipeline_schedules(
+            project_slug: "github/myorg/myrepo"
+          )',
+          'schedules = circleci_list_pipeline_schedules(
+            project_slug: "github/myorg/myrepo"
+          )
+          
+          # Find a specific schedule by name
+          nightly_build = schedules.find { |schedule| schedule["name"] == "Nightly Build" }
+          
+          if nightly_build
+            puts "Nightly build schedule ID: #{nightly_build["id"]}"
+            puts "Schedule: #{nightly_build["description"]}"
+          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_list_projects.rb

@@ -0,0 +1,89 @@
+require 'fastlane/action'
+require_relative '../helper/circle_ci_helper'
+
+module Fastlane
+  module Actions
+    module SharedValues
+      CIRCLECI_PROJECTS = :CIRCLECI_PROJECTS
+    end
+
+    class CircleciListProjectsAction < Action
+      def self.run(params)
+        UI.message("Listing CircleCI projects via API v2...")
+        
+        api_token = params[:api_token]
+        
+        # Make API request
+        result = Helper::CircleCiHelper.get_v2("projects", api_token)
+        
+        # Store values in lane context
+        Actions.lane_context[SharedValues::CIRCLECI_PROJECTS] = result["items"]
+        
+        UI.success("Successfully retrieved #{result["items"].count} projects")
+        
+        return result["items"]
+      end
+
+      def self.description
+        "Lists all CircleCI projects for the current user or organization using API v2"
+      end
+
+      def self.details
+        "This action retrieves all CircleCI projects that the current API token has access to 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)
+        ]
+      end
+
+      def self.output
+        [
+          ['CIRCLECI_PROJECTS', 'An array of project data']
+        ]
+      end
+
+      def self.return_value
+        "Returns an array of project data including names, slugs, and VCS information."
+      end
+
+      def self.authors
+        ["crazymanish", "copilot"]
+      end
+
+      def self.example_code
+        [
+          'circleci_list_projects',
+          'projects = circleci_list_projects
+          # Find a specific project by name
+          my_project = projects.find { |project| project["name"] == "my-repo-name" }
+          
+          # Use the project slug for other actions
+          if my_project
+            circleci_trigger_pipeline(
+              project_slug: my_project["slug"],
+              branch: "main"
+            )
+          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_list_webhooks.rb

@@ -0,0 +1,111 @@
+require 'fastlane/action'
+require_relative '../helper/circle_ci_helper'
+
+module Fastlane
+  module Actions
+    module SharedValues
+      CIRCLECI_WEBHOOKS = :CIRCLECI_WEBHOOKS
+    end
+
+    class CircleciListWebhooksAction < Action
+      def self.run(params)
+        UI.message("Listing CircleCI webhooks via API v2...")
+        
+        api_token = params[:api_token]
+        scope_id = params[:scope_id]
+        scope_type = params[:scope_type]
+        
+        # Make API request
+        result = Helper::CircleCiHelper.get_v2("webhook", api_token, {
+          "scope-id" => scope_id,
+          "scope-type" => scope_type
+        })
+        
+        # Store values in lane context
+        Actions.lane_context[SharedValues::CIRCLECI_WEBHOOKS] = result["items"]
+        
+        UI.success("Successfully retrieved #{result["items"].count} webhooks")
+        
+        return result["items"]
+      end
+
+      def self.description
+        "Lists webhooks for a CircleCI project or organization using API v2"
+      end
+
+      def self.details
+        "This action retrieves all webhooks defined for a specific CircleCI project or organization 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: :scope_id,
+                                       env_name: "CIRCLE_CI_WEBHOOK_SCOPE_ID",
+                                       description: "The ID of the project or organization to list webhooks for",
+                                       is_string: true,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :scope_type,
+                                       env_name: "CIRCLE_CI_WEBHOOK_SCOPE_TYPE",
+                                       description: "The type of scope (either 'project' or 'organization')",
+                                       is_string: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Scope type must be either 'project' or 'organization'") unless ['project', 'organization'].include?(value)
+                                       end,
+                                       optional: false)
+        ]
+      end
+
+      def self.output
+        [
+          ['CIRCLECI_WEBHOOKS', 'An array of webhook data']
+        ]
+      end
+
+      def self.return_value
+        "Returns an array of webhook data including IDs, URLs, and event types."
+      end
+
+      def self.authors
+        ["crazymanish", "copilot"]
+      end
+
+      def self.example_code
+        [
+          'circleci_list_webhooks(
+            scope_id: "project-uuid",
+            scope_type: "project"
+          )',
+          'circleci_list_webhooks(
+            scope_id: "organization-uuid",
+            scope_type: "organization"
+          )',
+          'webhooks = circleci_list_webhooks(
+            scope_id: "project-uuid",
+            scope_type: "project"
+          )
+          
+          # Check if a specific webhook exists
+          has_slack_webhook = webhooks.any? { |webhook| webhook["url"].include?("hooks.slack.com") }
+          puts "Slack webhook is #{has_slack_webhook ? "configured" : "not configured"}"'
+        ]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.category
+        :ci
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+require 'fastlane/action'
+require_relative '../helper/circle_ci_helper'
+
+module Fastlane
+  module Actions
+    class CircleciRerunWorkflowAction < Action
+      def self.run(params)
+        UI.message("Rerunning CircleCI workflow via API v2...")
+        
+        api_token = params[:api_token]
+        workflow_id = params[:workflow_id]
+        from_failed = params[:from_failed]
+        sparse_tree = params[:sparse_tree]
+        
+        # Create request body
+        body = {}
+        body[:from_failed] = from_failed unless from_failed.nil?
+        body[:sparse_tree] = sparse_tree unless sparse_tree.nil?
+        
+        # Make API request
+        result = Helper::CircleCiHelper.post_v2("workflow/#{workflow_id}/rerun", api_token, body)
+        
+        UI.success("Successfully reran workflow with ID #{workflow_id}")
+        
+        return result
+      end
+
+      def self.description
+        "Reruns a workflow in CircleCI using API v2"
+      end
+
+      def self.details
+        "This action reruns a specific workflow in CircleCI using the CircleCI API v2. You can choose to rerun the entire workflow or just the failed jobs."
+      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 rerun",
+                                       is_string: true,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :from_failed,
+                                       env_name: "CIRCLE_CI_WORKFLOW_FROM_FAILED",
+                                       description: "Whether to rerun just the failed jobs (true) or all jobs (false)",
+                                       is_string: false,
+                                       default_value: true,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :sparse_tree,
+                                       env_name: "CIRCLE_CI_WORKFLOW_SPARSE_TREE",
+                                       description: "If rerunning failed jobs, whether to rerun them as a sparse tree of only the failed jobs",
+                                       is_string: false,
+                                       default_value: false,
+                                       optional: true)
+        ]
+      end
+
+      def self.return_value
+        "Returns the API response with workflow rerun information."
+      end
+
+      def self.authors
+        ["crazymanish", "copilot"]
+      end
+
+      def self.example_code
+        [
+          'circleci_rerun_workflow(
+            workflow_id: "1234-5678-90ab-cdef"
+          )',
+          'circleci_rerun_workflow(
+            workflow_id: "1234-5678-90ab-cdef",
+            from_failed: false  # Rerun all jobs in the workflow
+          )',
+          'circleci_rerun_workflow(
+            workflow_id: "1234-5678-90ab-cdef",
+            from_failed: true,
+            sparse_tree: true  # Rerun only the failed jobs and their upstream dependencies
+          )'
+        ]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.category
+        :ci
+      end
+    end
+  end
+end