cpflow 4.2.0 → 5.0.0.rc.1

data/docs/releasing.md

@@ -0,0 +1,153 @@
+# Releasing the Gem
+
+This project follows a changelog-first Ruby gem release process, modeled after
+the React on Rails release flow but without any npm publishing steps.
+
+## Release Process
+
+### 1. Update the Changelog
+
+Always update `CHANGELOG.md` before running the release task.
+
+1. Ensure all desired changes are merged to `main`.
+2. Run `/update-changelog release` to find merged PRs, add entries under the
+   right headings, compute the next version, stamp the version header, update
+   compare links, and open a changelog PR. Use `/update-changelog rc`,
+   `/update-changelog beta`, or an explicit version like
+   `/update-changelog 4.2.0.rc.1` when preparing a prerelease or fixed target
+   version.
+3. Review the generated changelog PR and verify the version number matches the
+   intended release level:
+   - Breaking changes: major
+   - Added features or enhancements: minor
+   - Fixes, improvements, deprecations, removals, or security updates: patch
+4. Merge the changelog PR before releasing.
+
+If updating the changelog manually, move the relevant `Unreleased` entries into
+a versioned header:
+
+   ```markdown
+   ## [4.2.0] - 2026-05-05
+   ```
+
+Then update the compare links at the bottom of `CHANGELOG.md`, including the
+`Unreleased` link and the new version link, and merge those changelog changes
+before releasing.
+
+The release task reads the latest versioned `CHANGELOG.md` header and can create
+the GitHub release from that section automatically.
+
+### 2. Run the Release Task
+
+The recommended command has no arguments:
+
+```bash
+bundle exec rake release
+```
+
+With no arguments, `rake release`:
+
+1. Reads the first versioned `CHANGELOG.md` header, such as `## [4.2.0]`.
+2. Uses that version when it is newer than the current gem version.
+3. Uses the current version if the changelog version matches the gem version
+   but has not been tagged yet.
+4. Falls back to a patch bump if no new changelog version is found.
+
+Other supported forms:
+
+```bash
+bundle exec rake "release[patch]"
+bundle exec rake "release[minor]"
+bundle exec rake "release[major]"
+bundle exec rake "release[4.2.0]"
+bundle exec rake "release[4.2.0.rc.1]"
+bundle exec rake "release[4.2.0,true]"
+```
+
+Use RubyGems version format for prereleases: `4.2.0.rc.1`, not
+`4.2.0-rc.1`.
+
+Full argument list:
+
+```bash
+bundle exec rake "release[version,dry_run,override_version_policy]"
+```
+
+Environment variables:
+
+```bash
+VERBOSE=1
+RUBYGEMS_OTP=<code>
+RELEASE_VERSION_POLICY_OVERRIDE=true
+GEM_RELEASE_MAX_RETRIES=<n>
+```
+
+### 3. What the Task Does
+
+`bundle exec rake release` performs the gem-only release:
+
+1. Requires a clean working tree.
+2. Verifies `gem-release` is available through Bundler.
+3. For real releases, verifies GitHub CLI authentication and write access.
+4. Pulls the latest changes with `git pull --rebase`.
+5. Resolves the target version from the changelog or explicit argument.
+6. Requires stable releases to run from `main`; prereleases may run from another
+   branch.
+7. Validates the target version is newer than the latest tag and is consistent
+   with the changelog section when the section indicates a bump level.
+8. Bumps `lib/cpflow/version.rb` and updates `Gemfile.lock`.
+9. Commits the version bump, tags `vX.Y.Z`, and pushes the commit and tags.
+10. Publishes the `cpflow` gem to RubyGems.org.
+11. Creates or updates the GitHub release from the matching changelog section.
+
+The older `bundle exec rake "create_release[4.2.0,false]"` task name remains as
+a compatibility alias, but new releases should use `bundle exec rake release`.
+
+### 4. Sync GitHub Release Notes Manually
+
+If the GitHub release was not created automatically, update and commit the
+matching changelog section, then run:
+
+```bash
+bundle exec rake "sync_github_release[4.2.0]"
+bundle exec rake "sync_github_release[4.2.0,true]"
+```
+
+`sync_github_release` reads notes from `CHANGELOG.md` and creates or updates the
+GitHub release for the corresponding `vX.Y.Z` tag.
+
+## Pre-Release Checklist
+
+Before running the release:
+
+1. `git checkout main`
+2. `git pull --rebase`
+3. `bundle install`
+4. `gh auth status`
+5. Confirm RubyGems credentials can publish `cpflow`.
+6. Confirm `CHANGELOG.md` has a committed section for the target version.
+7. Run a dry run:
+
+   ```bash
+   bundle exec rake "release[4.2.0,true]"
+   ```
+
+## If a Release Fails
+
+Check what was published before retrying:
+
+```bash
+gem list cpflow -r -a
+gh release view v4.2.0
+git tag -l v4.2.0
+```
+
+If the gem was published but GitHub release creation failed, fix GitHub CLI
+authentication or permissions and run:
+
+```bash
+bundle exec rake "sync_github_release[4.2.0]"
+```
+
+If the tag was pushed but the gem was not published, delete or correct the tag
+and version commit intentionally before trying again.

data/lib/command/ai_github_flow_prompt.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "../core/repo_introspection"
+
+module Command
+  class AiGithubFlowPrompt < Base
+    NAME = "ai-github-flow-prompt"
+    DESCRIPTION = "Prints the recommended AI prompt for adding the Control Plane GitHub Flow to a repo"
+    LONG_DESCRIPTION = <<~DESC
+      Prints a copy-paste prompt for an AI agent to roll out the reusable Control Plane GitHub Flow:
+      - verifies the repo is deployable from a clean clone before generating files
+      - scaffolds `.controlplane/` and `cpflow-*` GitHub Actions files when the repo qualifies
+      - stops on external blockers or product decisions instead of forcing a broken rollout
+    DESC
+    EXAMPLES = <<~EX
+      ```sh
+      # Prints the recommended AI rollout prompt for the current repo
+      cpflow ai-github-flow-prompt
+      ```
+    EX
+    WITH_INFO_HEADER = false
+    VALIDATIONS = [].freeze
+    REQUIRES_STARTUP_CHECKS = false
+
+    def call
+      puts prompt
+    end
+
+    private
+
+    def prompt
+      <<~PROMPT
+        Set up Control Plane GitHub Flow for this repo. Start with `cpflow github-flow-readiness` and stop on any reported blockers. The repo must be deployable from a clean clone: published package versions, complete runtime scaffold, and a production Dockerfile that can build the app. If any package version is unpublished, inaccessible from CI, or requires credentials that are not already modeled in the repo or GitHub settings, stop and report the blocker instead of generating workflow files. If the repo is a legacy sample pinned to an obsolete Ruby or Bundler toolchain, if it does not even have a production Dockerfile yet, or if it is a monorepo without an already-decided single app boundary for this flow, stop and report that as a prerequisite instead of forcing the rollout.
+
+        If `.controlplane/` is missing, run `cpflow generate`. Treat the generated app names as the repo-name default (`#{inferred_app_prefix}`) and rename them only if the project needs a different prefix. Then run `cpflow generate-github-actions` (or `cpflow generate-github-actions --staging-branch BRANCH` when staging should deploy from a branch other than `main`/`master`), keep review apps opt-in via `+review-app-deploy`, make sure any `STAGING_APP_BRANCH` repository variable is also present in the generated staging workflow's `on.push.branches` filter, and list the GitHub secrets and variables that must be configured.
+
+        Keep Node available in the final image if asset compilation or SSR depends on ExecJS, Yarn, `pnpm`, or npm after the main install layer. Make sure the generated Dockerfile uses a Ruby base image compatible with the app's declared Ruby requirement. Preserve repo-defined frontend build hooks: if `config/shakapacker.yml` defines a `precompile_hook`, or React on Rails enables `config.auto_load_bundle = true`, confirm the generated Dockerfile runs that codegen step before `rails assets:precompile`. If `config/database.yml` shows SQLite in production, confirm that the generated scaffold uses persistent `db` and `storage` volumes plus a release script that runs `rails db:prepare`; otherwise keep the default Postgres workload. If the public workload is not named `rails`, set `PRIMARY_WORKLOAD` or adjust the generated workflows. Inspect the Dockerfile and package sources for private GitHub dependencies or `RUN --mount=type=ssh`; if present, wire `DOCKER_BUILD_SSH_KEY`, optionally set `DOCKER_BUILD_SSH_KNOWN_HOSTS` for non-GitHub SSH hosts, and keep `DOCKER_BUILD_EXTRA_ARGS` to newline-delimited single tokens such as `--build-arg=FOO=bar`.
+
+        Run the real local validations you can: Docker build if feasible, repo tests or smoke checks, YAML validation, and any CI-equivalent build steps. Push the branch and check the GitHub Actions results. Only stop early for a real external blocker or a product decision that changes scope.
+      PROMPT
+    end
+
+    def inferred_app_prefix
+      RepoIntrospection.inferred_app_prefix(Dir.pwd)
+    end
+  end
+end

data/lib/command/base.rb

@@ -40,6 +40,8 @@ module Command
     WITH_INFO_HEADER = true
     # Which validations to run before the command
     VALIDATIONS = %w[config].freeze
+    # Whether or not to run CLI startup checks such as cpln availability and update checks
+    REQUIRES_STARTUP_CHECKS = true
 
     def initialize(config)
       @config = config
@@ -316,6 +318,18 @@ module Command
       }
     end
 
+    def self.staging_branch_option(required: false)
+      {
+        name: :staging_branch,
+        params: {
+          banner: "BRANCH",
+          desc: "Branch that should auto-deploy staging; defaults to main/master",
+          type: :string,
+          required: required
+        }
+      }
+    end
+
     def self.logs_limit_option(required: false)
       {
         name: :limit,
@@ -477,6 +491,17 @@ module Command
         }
       }
     end
+
+    def self.use_digest_image_ref_option(required: false)
+      {
+        name: :use_digest_image_ref,
+        params: {
+          desc: "Uses the image's digest (SHA256 value) for referencing the Docker image",
+          type: :boolean,
+          required: required
+        }
+      }
+    end
     # rubocop:enable Metrics/MethodLength
 
     def self.all_options

data/lib/command/cleanup_images.rb

@@ -26,7 +26,7 @@ module Command
 
       progress.puts("Images to delete:")
       images_to_delete.each do |image|
-        created = Shell.color((image[:created]).to_s, :red)
+        created = Shell.color(image[:created].to_s, :red)
         reason = Shell.color(image[:reason], :red)
         progress.puts("  - #{image[:name]} (#{created} - #{reason})")
       end

data/lib/command/cleanup_stale_apps.rb

@@ -22,7 +22,7 @@ module Command
 
       progress.puts("Stale apps:")
       stale_apps.each do |app|
-        progress.puts("  - #{app[:name]} (#{Shell.color((app[:date]).to_s, :red)})")
+        progress.puts("  - #{app[:name]} (#{Shell.color(app[:date].to_s, :red)})")
       end
 
       return unless confirm_delete

data/lib/command/copy_image_from_upstream.rb

@@ -5,14 +5,14 @@ module Command
     NAME = "copy-image-from-upstream"
     OPTIONS = [
       app_option(required: true),
-      upstream_token_option(required: true),
+      upstream_token_option,
       image_option
     ].freeze
     DESCRIPTION = "Copies an image (by default the latest) from a source org to the current org"
     LONG_DESCRIPTION = <<~DESC
       - Copies an image (by default the latest) from a source org to the current org
       - The source app must be specified either through the `CPLN_UPSTREAM` env var or `upstream` in the `.controlplane/controlplane.yml` file
-      - Additionally, the token for the source org must be provided through `--upstream-token` or `-t`
+      - The token for the source org must be provided through `--upstream-token`/`-t` or the `CPLN_UPSTREAM_TOKEN` env var
       - A `cpln` profile will be temporarily created to pull the image from the source org
     DESC
     EXAMPLES = <<~EX
@@ -20,6 +20,9 @@ module Command
       # Copies the latest image from the source org to the current org.
       cpflow copy-image-from-upstream -a $APP_NAME --upstream-token $UPSTREAM_TOKEN
 
+      # Equivalent call using an env var (avoids exposing the token via the OS process table).
+      CPLN_UPSTREAM_TOKEN=$UPSTREAM_TOKEN cpflow copy-image-from-upstream -a $APP_NAME
+
       # Copies a specific image from the source org to the current org.
       cpflow copy-image-from-upstream -a $APP_NAME --upstream-token $UPSTREAM_TOKEN --image appimage:123
       ```
@@ -30,7 +33,9 @@ module Command
 
       @upstream = ENV.fetch("CPLN_UPSTREAM", nil) || config[:upstream]
       @upstream_org = ENV.fetch("CPLN_ORG_UPSTREAM", nil) || config.find_app_config(@upstream)&.dig(:cpln_org)
+      @upstream_token = config.options[:upstream_token] || ENV.fetch("CPLN_UPSTREAM_TOKEN", nil)
       ensure_upstream_org!
+      ensure_upstream_token!
 
       create_upstream_profile
       fetch_upstream_image_url
@@ -51,6 +56,12 @@ module Command
             "and CPLN_ORG_UPSTREAM env var is not set."
     end
 
+    def ensure_upstream_token!
+      return if @upstream_token && !@upstream_token.strip.empty?
+
+      raise "Missing upstream token. Pass `--upstream-token`/`-t` or set the `CPLN_UPSTREAM_TOKEN` env var."
+    end
+
     def create_upstream_profile
       step("Creating upstream profile") do
         loop do
@@ -58,7 +69,7 @@ module Command
           break unless cp.profile_exists?(@upstream_profile)
         end
 
-        cp.profile_create(@upstream_profile, config.options[:upstream_token])
+        cp.profile_create(@upstream_profile, @upstream_token)
       end
     end
 

data/lib/command/deploy_image.rb

@@ -7,7 +7,8 @@ module Command
     NAME = "deploy-image"
     OPTIONS = [
       app_option(required: true),
-      run_release_phase_option
+      run_release_phase_option,
+      use_digest_image_ref_option
     ].freeze
     DESCRIPTION = "Deploys the latest image to app workloads, and runs a release script (optional)"
     LONG_DESCRIPTION = <<~DESC
@@ -15,24 +16,19 @@ module Command
       - Runs a release script before deploying if `release_script` is specified in the `.controlplane/controlplane.yml` file and `--run-release-phase` is provided
       - The release script is run in the context of `cpflow run` with the latest image
       - If the release script exits with a non-zero code, the command will stop executing and also exit with a non-zero code
+      - If `use_digest_image_ref` is `true` in the `.controlplane/controlplane.yml` file or `--use-digest-image-ref` option is provided, deployed image's reference will include its digest
     DESC
 
     def call # rubocop:disable Metrics/MethodLength
       run_release_script if config.options[:run_release_phase]
 
       deployed_endpoints = {}
-
-      image = cp.latest_image
-      if cp.fetch_image_details(image).nil?
-        raise "Image '#{image}' does not exist in the Docker repository on Control Plane " \
-              "(see https://console.cpln.io/console/org/#{config.org}/repository/#{config.app}). " \
-              "Use `cpflow build-image` first."
-      end
+      image = resolve_image_to_deploy
 
       config[:app_workloads].each do |workload|
         workload_data = cp.fetch_workload!(workload)
         workload_data.dig("spec", "containers").each do |container|
-          next unless container["image"].match?(%r{^/org/#{config.org}/image/#{config.app}:})
+          next unless container["image"].match?(%r{^/org/#{config.org}/image/#{config.app}[:@]})
 
           container_name = container["name"]
           step("Deploying image '#{image}' for workload '#{container_name}'") do
@@ -50,6 +46,41 @@ module Command
 
     private
 
+    def resolve_image_to_deploy
+      image = cp.latest_image
+      # Preserve the pre-existing fail-fast check so missing images are reported
+      # before workloads are touched.
+      image_details = fetch_image_details!(image)
+
+      return image unless config.use_digest_image_ref?
+
+      # Control Plane accepts the tagged digest form returned here; latest_image currently returns app:N.
+      "#{image}@#{image_digest!(image, image_details)}"
+    end
+
+    def fetch_image_details!(image)
+      image_details = cp.fetch_image_details(image)
+      raise image_not_found_message(image) if image_details.nil?
+
+      image_details
+    end
+
+    def image_digest!(image, image_details)
+      digest = image_details["digest"]
+      raise "Image '#{image}' does not have a digest available." if digest.nil? || digest.empty?
+      # SHA-256 only; expand the regex if Control Plane ever returns sha512 or other digest algorithms.
+      # OCI digests are always lowercase hex per the OCI image spec.
+      raise "Unexpected digest format for image '#{image}'." unless digest.match?(/\Asha256:[a-f0-9]{64}\z/)
+
+      digest
+    end
+
+    def image_not_found_message(image)
+      "Image '#{image}' does not exist in the Docker repository on Control Plane " \
+        "(see https://console.cpln.io/console/org/#{config.org}/repository/#{config.app}). " \
+        "Use `cpflow build-image` first."
+    end
+
     def endpoint_for_workload(workload_data)
       endpoint = workload_data.dig("status", "endpoint")
       Resolv.getaddress(endpoint.split("/").last)

data/lib/command/exists.rb

@@ -9,15 +9,26 @@ module Command
     DESCRIPTION = "Shell-checks if an application (GVC) exists, useful in scripts"
     LONG_DESCRIPTION = <<~DESC
       - Shell-checks if an application (GVC) exists, useful in scripts, e.g.:
+      - Exits 0 when the app exists, 3 when it does not exist, and 64 for other errors.
     DESC
     EXAMPLES = <<~EX
       ```sh
-      if [ cpflow exists -a $APP_NAME ]; ...
+      cpflow exists -a "$APP_NAME"
+      status=$?
+      if [ "$status" -eq 0 ]; then
+        echo "exists"
+      elif [ "$status" -eq 3 ]; then
+        echo "not found"
+      else
+        echo "error: cpflow exists exited $status"
+      fi
       ```
     EX
 
     def call
-      exit(cp.fetch_gvc.nil? ? ExitCode::ERROR_DEFAULT : ExitCode::SUCCESS)
+      exit(cp.fetch_gvc.nil? ? ExitCode::NOT_FOUND : ExitCode::SUCCESS)
+    rescue StandardError => e
+      Shell.abort(e.message)
     end
   end
 end

data/lib/command/generate.rb

@@ -1,32 +1,181 @@
 # frozen_string_literal: true
 
+require "yaml"
+
+require_relative "generator_helpers"
+require_relative "../core/repo_introspection"
+
 module Command
-  class Generator < Thor::Group
+  class Generator < Thor::Group # rubocop:disable Metrics/ClassLength
     include Thor::Actions
+    include GeneratorHelpers
+
+    COMMON_TEMPLATE_FILES = %w[
+      Dockerfile
+      entrypoint.sh
+    ].freeze
+    POSTGRES_TEMPLATE_FILES = %w[
+      controlplane.yml
+      templates/app.yml
+      templates/postgres.yml
+      templates/rails.yml
+      release_script.sh
+    ].freeze
+    SQLITE_TEMPLATE_FILES = %w[
+      controlplane.yml
+      release_script.sh
+      templates/app.yml
+      templates/db.yml
+      templates/rails.yml
+      templates/storage.yml
+    ].freeze
+
+    # Fallback Ruby version when the repo doesn't pin one via `.ruby-version`,
+    # `.tool-versions`, or the `Gemfile`. Keep this on a supported release line
+    # (https://www.ruby-lang.org/en/downloads/branches/).
+    DEFAULT_RUBY_VERSION = "3.3"
 
     def copy_files
-      directory("generator_templates", ".controlplane", verbose: ENV.fetch("HIDE_COMMAND_OUTPUT", nil) != "true")
+      generated_paths = copy_template_files("generator_templates", base_template_files)
+      generated_paths += copy_template_files("generator_templates_sqlite", SQLITE_TEMPLATE_FILES) if sqlite_project?
+      substitute_template_variables(generated_paths)
+      make_shell_scripts_executable(generated_paths)
     end
 
     def self.source_root
       Cpflow.root_path.join("lib")
     end
+
+    private
+
+    def copy_template_files(root_dir, relative_paths)
+      relative_paths.map { |relative_path| copy_template_file(root_dir, relative_path) }
+    end
+
+    def copy_template_file(root_dir, relative_path)
+      destination_path = File.join(".controlplane", relative_path)
+      empty_directory(File.dirname(destination_path), verbose: false)
+      copy_file(
+        File.join(root_dir, relative_path),
+        destination_path,
+        force: true,
+        verbose: ENV.fetch("HIDE_COMMAND_OUTPUT", nil) != "true"
+      )
+      destination_path
+    end
+
+    def base_template_files
+      COMMON_TEMPLATE_FILES + (sqlite_project? ? [] : POSTGRES_TEMPLATE_FILES)
+    end
+
+    def template_variables
+      {
+        "__APP_PREFIX__" => inferred_app_prefix,
+        "__RUBY_VERSION__" => inferred_ruby_version,
+        "__ASSET_PRECOMPILE_HOOK_RUN__" => asset_precompile_hook_run
+      }
+    end
+
+    def inferred_app_prefix
+      RepoIntrospection.inferred_app_prefix(Dir.pwd)
+    end
+
+    def inferred_ruby_version
+      RepoIntrospection.inferred_ruby_version_string(Dir.pwd) || DEFAULT_RUBY_VERSION
+    end
+
+    def sqlite_project?
+      return @sqlite_project if instance_variable_defined?(:@sqlite_project)
+
+      @sqlite_project = sqlite_database_in_production?
+    end
+
+    def asset_precompile_hook_run
+      command = normalized_asset_precompile_hook_command
+      return "" unless command
+      return "" unless single_line_asset_precompile_hook?(command)
+
+      "RUN #{command}\n\n"
+    end
+
+    def single_line_asset_precompile_hook?(command)
+      return true unless command.match?(/[\r\n]/)
+
+      Shell.warn("Skipping asset precompile hook: value must be a single line: #{command.inspect}")
+      false
+    end
+
+    def sqlite_database_in_production?
+      RepoIntrospection.sqlite_database_in_production?(Dir.pwd)
+    end
+
+    def normalized_asset_precompile_hook_command
+      command = shakapacker_precompile_hook || react_on_rails_auto_bundle_hook
+      return unless command
+
+      command.start_with?("rake ") ? "bundle exec #{command}" : command
+    end
+
+    def shakapacker_precompile_hook
+      return unless File.file?("config/shakapacker.yml")
+
+      # Parse rather than regex-match: Shakapacker emits an environment-keyed YAML file
+      # (the hook usually lives under `default:` or `production:`), and folded or quoted
+      # multi-line values would also defeat a single-line regex.
+      config = YAML.safe_load(File.read("config/shakapacker.yml"), aliases: true)
+      hook = extract_shakapacker_precompile_hook(config)
+      hook unless hook.nil? || hook.empty?
+    rescue Psych::SyntaxError
+      nil
+    end
+
+    SHAKAPACKER_HOOK_SCOPES = %w[production default].freeze
+    private_constant :SHAKAPACKER_HOOK_SCOPES
+
+    def extract_shakapacker_precompile_hook(config)
+      return nil unless config.is_a?(Hash)
+
+      scoped = SHAKAPACKER_HOOK_SCOPES.filter_map do |key|
+        section = config[key]
+        section["precompile_hook"] if section.is_a?(Hash) && section["precompile_hook"].is_a?(String)
+      end.first
+      scoped || (config["precompile_hook"] if config["precompile_hook"].is_a?(String))
+    end
+
+    def react_on_rails_auto_bundle_hook
+      return unless react_on_rails_auto_load_bundle?
+
+      "bundle exec rake react_on_rails:generate_packs"
+    end
+
+    def react_on_rails_auto_load_bundle?
+      return false unless File.file?("config/initializers/react_on_rails.rb")
+
+      File.readlines("config/initializers/react_on_rails.rb")
+          .reject { |line| line.lstrip.start_with?("#") }
+          .any? { |line| line.match?(/config\.auto_load_bundle\s*=\s*true\b/) }
+    end
   end
 
   class Generate < Base
     NAME = "generate"
     DESCRIPTION = "Creates base Control Plane config and template files"
     LONG_DESCRIPTION = <<~DESC
-      Creates base Control Plane config and template files
+      Creates base Control Plane config and template files for a Rails project:
+      - infers the app prefix from the current directory and wires staging, review, and production entries
+      - infers the Docker base Ruby version from `.ruby-version`, `.tool-versions`, or the app's `Gemfile`
+      - preserves repo-defined asset precompile hooks, including React on Rails auto bundle generation
+      - detects SQLite in `config/database.yml` and generates persistent `db` and `storage` volume templates instead of the default Postgres workload
     DESC
     EXAMPLES = <<~EX
       ```sh
-      # Creates .controlplane directory with Control Plane config and other templates
+      # Creates .controlplane directory with Control Plane config and starter templates
       cpflow generate
       ```
     EX
     WITH_INFO_HEADER = false
     VALIDATIONS = [].freeze
+    REQUIRES_STARTUP_CHECKS = false
 
     def call
       if controlplane_directory_exists?