fastlane-plugin-circle_ci 0.2.0 → 0.3.0

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

@@ -0,0 +1,160 @@
+require 'fastlane/action'
+require_relative '../helper/circle_ci_helper'
+
+module Fastlane
+  module Actions
+    module SharedValues
+      CIRCLECI_CREATED_SCHEDULE_ID = :CIRCLECI_CREATED_SCHEDULE_ID
+    end
+
+    class CircleciCreatePipelineScheduleAction < Action
+      def self.run(params)
+        UI.message("Creating CircleCI pipeline schedule via API v2...")
+        
+        api_token = params[:api_token]
+        project_slug = params[:project_slug]
+        name = params[:name]
+        description = params[:description]
+        attribution_actor = params[:attribution_actor]
+        parameters = params[:parameters] || {}
+        timetable = params[:timetable]
+        branch = params[:branch]
+
+        # Create request body
+        body = {
+          name: name,
+          description: description,
+          attribution_actor: attribution_actor,
+          parameters: parameters,
+          timetable: timetable
+        }
+
+        # Add branch if specified
+        body[:branch] = branch if branch
+        
+        # Make API request
+        result = Helper::CircleCiHelper.post_v2("project/#{project_slug}/schedule", api_token, body)
+        
+        # Store values in lane context
+        Actions.lane_context[SharedValues::CIRCLECI_CREATED_SCHEDULE_ID] = result["id"]
+        
+        UI.success("Successfully created pipeline schedule '#{name}' with ID #{result["id"]}")
+        
+        return result
+      end
+
+      def self.description
+        "Creates a new pipeline schedule for a CircleCI project using API v2"
+      end
+
+      def self.details
+        "This action creates a new pipeline schedule for a specific CircleCI project using the CircleCI API v2. The schedule determines when pipelines will be automatically triggered."
+      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: :name,
+                                       env_name: "CIRCLE_CI_SCHEDULE_NAME",
+                                       description: "Name of the schedule",
+                                       is_string: true,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :description,
+                                       env_name: "CIRCLE_CI_SCHEDULE_DESCRIPTION",
+                                       description: "Description of the schedule",
+                                       is_string: true,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :attribution_actor,
+                                       env_name: "CIRCLE_CI_ATTRIBUTION_ACTOR",
+                                       description: "The attribution actor who will run the scheduled pipeline (e.g., 'current' for the current user)",
+                                       is_string: true,
+                                       default_value: "current",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :parameters,
+                                       env_name: "CIRCLE_CI_SCHEDULE_PARAMETERS",
+                                       description: "Pipeline parameters, must match parameters defined in the pipeline configuration",
+                                       is_string: false,
+                                       default_value: {},
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :timetable,
+                                       env_name: "CIRCLE_CI_SCHEDULE_TIMETABLE",
+                                       description: "Timetable hash defining when the schedule should run (e.g., {per_hour: 1, hours_of_day: [0, 12], days_of_week: [1, 3, 5]})",
+                                       is_string: false,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :branch,
+                                       env_name: "CIRCLE_CI_SCHEDULE_BRANCH",
+                                       description: "The branch to trigger a pipeline on",
+                                       is_string: true,
+                                       optional: true)
+        ]
+      end
+
+      def self.output
+        [
+          ['CIRCLECI_CREATED_SCHEDULE_ID', 'The ID of the created pipeline schedule']
+        ]
+      end
+
+      def self.return_value
+        "Returns the full API response including the created schedule's details."
+      end
+
+      def self.authors
+        ["crazymanish", "copilot"]
+      end
+
+      def self.example_code
+        [
+          'circleci_create_pipeline_schedule(
+            project_slug: "github/myorg/myrepo",
+            name: "Nightly Build",
+            description: "Runs every night at midnight",
+            timetable: {
+              per_hour: 1,
+              hours_of_day: [0],
+              days_of_week: [1, 2, 3, 4, 5]
+            },
+            branch: "main",
+            parameters: {
+              "deploy_env" => "staging"
+            }
+          )',
+          'circleci_create_pipeline_schedule(
+            project_slug: "github/myorg/myrepo",
+            name: "Weekly Release",
+            description: "Runs every Friday at 2pm",
+            timetable: {
+              per_hour: 1,
+              hours_of_day: [14],
+              days_of_week: [5]
+            },
+            branch: "release"
+          )'
+        ]
+      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_project.rb

@@ -0,0 +1,105 @@
+require 'fastlane/action'
+require_relative '../helper/circle_ci_helper'
+
+module Fastlane
+  module Actions
+    module SharedValues
+      CIRCLECI_PROJECT = :CIRCLECI_PROJECT
+    end
+
+    class CircleciCreateProjectAction < Action
+      def self.run(params)
+        UI.message("Creating CircleCI project via API v2...")
+        
+        api_token = params[:api_token]
+        project_slug = params[:project_slug]
+        
+        # Make API request
+        result = Helper::CircleCiHelper.post_v2("project/#{project_slug}/follow", api_token)
+        
+        # Store values in lane context
+        Actions.lane_context[SharedValues::CIRCLECI_PROJECT] = result
+        
+        UI.success("Successfully created CircleCI project #{project_slug}")
+        
+        return result
+      end
+
+      def self.description
+        "Creates a new CircleCI project using API v2"
+      end
+
+      def self.details
+        "This action creates a new CircleCI project by following a repository using the CircleCI API v2. This makes the repository available for building on CircleCI."
+      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,
+                                       optional: false)
+        ]
+      end
+
+      def self.output
+        [
+          ['CIRCLECI_PROJECT', 'A hash containing the created project details']
+        ]
+      end
+
+      def self.return_value
+        "Returns a hash containing the created project details."
+      end
+
+      def self.authors
+        ["crazymanish", "copilot"]
+      end
+
+      def self.example_code
+        [
+          'circleci_create_project(
+            project_slug: "github/myorg/new-repo"
+          )',
+          '# Create a new CircleCI project and immediately trigger a build
+          project = circleci_create_project(
+            project_slug: "github/myorg/new-repo"
+          )
+          
+          # Trigger first pipeline
+          pipeline = circleci_trigger_pipeline(
+            project_slug: "github/myorg/new-repo",
+            branch: "main"
+          )
+          
+          UI.message("Started pipeline ##{pipeline["number"]} for the new project")
+          
+          # Wait for the pipeline to complete
+          circleci_wait_for_pipeline(
+            project_slug: "github/myorg/new-repo",
+            pipeline_id: pipeline["id"],
+            timeout: 1800 # 30 minutes
+          )'
+        ]
+      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_webhook.rb

@@ -0,0 +1,155 @@
+require 'fastlane/action'
+require_relative '../helper/circle_ci_helper'
+
+module Fastlane
+  module Actions
+    module SharedValues
+      CIRCLECI_CREATED_WEBHOOK_ID = :CIRCLECI_CREATED_WEBHOOK_ID
+    end
+
+    class CircleciCreateWebhookAction < Action
+      def self.run(params)
+        UI.message("Creating CircleCI webhook via API v2...")
+        
+        api_token = params[:api_token]
+        name = params[:name]
+        url = params[:url]
+        events = params[:events]
+        signing_secret = params[:signing_secret]
+        verify_tls = params[:verify_tls]
+        scope_id = params[:scope_id]
+        scope_type = params[:scope_type]
+        
+        # Create request body
+        body = {
+          name: name,
+          url: url,
+          events: events,
+          verify_tls: verify_tls,
+          "signing-secret": signing_secret,
+          scope: {
+            id: scope_id,
+            type: scope_type
+          }
+        }
+        
+        # Make API request
+        result = Helper::CircleCiHelper.post_v2("webhook", api_token, body)
+        
+        # Store values in lane context
+        Actions.lane_context[SharedValues::CIRCLECI_CREATED_WEBHOOK_ID] = result["id"]
+        
+        UI.success("Successfully created webhook '#{name}' with ID #{result["id"]}")
+        
+        return result
+      end
+
+      def self.description
+        "Creates a new webhook for a CircleCI project or organization using API v2"
+      end
+
+      def self.details
+        "This action creates a new webhook for a specific CircleCI project or organization using the CircleCI API v2. Webhooks allow external services to be notified of CircleCI 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: :name,
+                                       env_name: "CIRCLE_CI_WEBHOOK_NAME",
+                                       description: "Name of the webhook",
+                                       is_string: true,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :url,
+                                       env_name: "CIRCLE_CI_WEBHOOK_URL",
+                                       description: "URL to send the webhook to",
+                                       is_string: true,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :events,
+                                       env_name: "CIRCLE_CI_WEBHOOK_EVENTS",
+                                       description: "Array of event types to trigger the webhook (e.g., ['workflow-completed', 'job-completed'])",
+                                       is_string: false,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :signing_secret,
+                                       env_name: "CIRCLE_CI_WEBHOOK_SIGNING_SECRET",
+                                       description: "Secret used to verify webhook signatures",
+                                       is_string: true,
+                                       sensitive: true,
+                                       code_gen_sensitive: true,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :verify_tls,
+                                       env_name: "CIRCLE_CI_WEBHOOK_VERIFY_TLS",
+                                       description: "Whether to verify TLS certificates when sending webhooks",
+                                       is_string: false,
+                                       default_value: true,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :scope_id,
+                                       env_name: "CIRCLE_CI_WEBHOOK_SCOPE_ID",
+                                       description: "The ID of the project or organization to create the webhook 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_CREATED_WEBHOOK_ID', 'The ID of the created webhook']
+        ]
+      end
+
+      def self.return_value
+        "Returns the full API response including the created webhook's details."
+      end
+
+      def self.authors
+        ["crazymanish", "copilot"]
+      end
+
+      def self.example_code
+        [
+          'circleci_create_webhook(
+            name: "Slack Notification",
+            url: "https://hooks.slack.com/services/YOUR/SLACK/WEBHOOK",
+            events: ["workflow-completed", "job-failed"],
+            signing_secret: "your-secret-key",
+            scope_id: "project-uuid",
+            scope_type: "project"
+          )',
+          'circleci_create_webhook(
+            name: "Deployment Notification",
+            url: "https://example.com/deployment-webhook",
+            events: ["workflow-completed"],
+            signing_secret: "your-secret-key",
+            verify_tls: false,
+            scope_id: "organization-uuid",
+            scope_type: "organization"
+          )'
+        ]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.category
+        :ci
+      end
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+require 'fastlane/action'
+require_relative '../helper/circle_ci_helper'
+
+module Fastlane
+  module Actions
+    class CircleciDeleteCheckoutKeyAction < Action
+      def self.run(params)
+        UI.message("Deleting CircleCI project checkout key via API v2...")
+        
+        api_token = params[:api_token]
+        project_slug = params[:project_slug]
+        fingerprint = params[:fingerprint]
+        
+        # Make API request
+        result = Helper::CircleCiHelper.delete_v2("project/#{project_slug}/checkout-key/#{fingerprint}", api_token)
+        
+        UI.success("Successfully deleted checkout key with fingerprint #{fingerprint} from project #{project_slug}")
+        
+        return result
+      end
+
+      def self.description
+        "Deletes a checkout key from a CircleCI project using API v2"
+      end
+
+      def self.details
+        "This action deletes a specific checkout key from a CircleCI project using the CircleCI API v2. You need to provide the fingerprint of the key you want to delete."
+      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: :fingerprint,
+                                       description: "The fingerprint of the checkout key to delete",
+                                       is_string: true,
+                                       optional: false)
+        ]
+      end
+
+      def self.return_value
+        "Returns a hash with a 'message' key indicating success or failure."
+      end
+
+      def self.authors
+        ["crazymanish", "copilot"]
+      end
+
+      def self.example_code
+        [
+          'circleci_delete_checkout_key(
+            project_slug: "gh/MyOrg/my-project",
+            fingerprint: "c9:0b:1c:4f:d5:65:56:b9:ad:88:f9:81:2b:37:74:2f"
+          )',
+          '# Get keys first, then delete one
+          keys = circleci_get_checkout_keys(
+            project_slug: "gh/MyOrg/my-project"
+          )
+          
+          # Delete the first key
+          if keys["items"].any?
+            circleci_delete_checkout_key(
+              project_slug: "gh/MyOrg/my-project",
+              fingerprint: keys["items"].first["fingerprint"]
+            )
+          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_delete_context_env_var.rb

@@ -0,0 +1,110 @@
+require 'fastlane/action'
+require_relative '../helper/circle_ci_helper'
+
+module Fastlane
+  module Actions
+    class CircleciDeleteContextEnvVarAction < Action
+      def self.run(params)
+        UI.message("Deleting environment variable from CircleCI context via API v2...")
+        
+        api_token = params[:api_token]
+        context_id = params[:context_id]
+        env_var_name = params[:env_var_name]
+        
+        # Make API request
+        begin
+          Helper::CircleCiHelper.delete_v2("context/#{context_id}/environment-variable/#{env_var_name}", api_token)
+          UI.success("Successfully deleted environment variable '#{env_var_name}' from context #{context_id}")
+          return true
+        rescue => e
+          UI.error("Failed to delete environment variable: #{e.message}")
+          return false
+        end
+      end
+
+      def self.description
+        "Deletes an environment variable from a CircleCI context using API v2"
+      end
+
+      def self.details
+        "This action deletes an environment variable from a specific CircleCI context 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: :context_id,
+                                       env_name: "CIRCLE_CI_CONTEXT_ID",
+                                       description: "The ID of the context to delete the environment variable from",
+                                       is_string: true,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :env_var_name,
+                                       env_name: "CIRCLE_CI_ENV_VAR_NAME",
+                                       description: "The name of the environment variable to delete",
+                                       is_string: true,
+                                       optional: false)
+        ]
+      end
+
+      def self.return_value
+        "Returns true if the deletion was successful, false otherwise."
+      end
+
+      def self.authors
+        ["crazymanish", "copilot"]
+      end
+
+      def self.example_code
+        [
+          'circleci_delete_context_env_var(
+            context_id: "context-uuid",
+            env_var_name: "DEPRECATED_API_KEY"
+          )',
+          '# Clean up old environment variables from a context
+          contexts = circleci_list_contexts(
+            owner_slug: "github/myorg"
+          )
+          
+          # Find the development context
+          dev_context = contexts.find { |c| c["name"] == "development" }
+          
+          if dev_context
+            # Get current environment variables
+            env_vars = circleci_get_context_env_vars(
+              context_id: dev_context["id"]
+            )
+            
+            # Remove deprecated variables
+            deprecated_vars = ["OLD_API_URL", "LEGACY_TOKEN", "UNUSED_VAR"]
+            
+            deprecated_vars.each do |var_name|
+              if env_vars.any? { |var| var["variable"] == var_name }
+                circleci_delete_context_env_var(
+                  context_id: dev_context["id"],
+                  env_var_name: var_name
+                )
+                UI.important("Removed deprecated variable: #{var_name}")
+              end
+            end
+          end'
+        ]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.category
+        :ci
+      end
+    end
+  end
+end