nvoi 0.1.7 → 0.2.0

data/lib/nvoi/cli/onboard/steps/app.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Nvoi
+  class Cli
+    module Onboard
+      module Steps
+        # Single app form - used for add and edit
+        class App
+          include Onboard::Ui
+
+          def initialize(prompt, test_mode: false)
+            @prompt = prompt
+            @test_mode = test_mode
+          end
+
+          # Returns [name, config] tuple
+          def call(existing_name: nil, existing: nil, zones: [], cloudflare_client: nil)
+            @zones = zones
+            @cloudflare_client = cloudflare_client
+
+            name = @prompt.ask("App name:", default: existing_name) { |q| q.required true }
+
+            command = prompt_optional("Run command", existing&.dig("command"),
+              placeholder: "leave blank for Docker entrypoint")
+
+            port = prompt_optional("Port", existing&.dig("port")&.to_s,
+              placeholder: "leave blank for background workers")
+            port = port.to_i if port && !port.blank?
+
+            config = { "servers" => existing&.dig("servers") || ["main"] }
+            config["command"] = command unless command.blank?
+            config["port"] = port if port && port.to_i > 0
+
+            # Domain selection only if port is set and cloudflare configured
+            if port && port.to_i > 0 && @zones.any?
+              domain, subdomain = prompt_domain_selection
+              if domain
+                config["domain"] = domain
+                config["subdomain"] = subdomain unless subdomain.blank?
+              end
+            end
+
+            pre_run = prompt_optional("Pre-run command", existing&.dig("pre_run_command"),
+              placeholder: "e.g. migrations")
+            config["pre_run_command"] = pre_run unless pre_run.blank?
+
+            [name, config]
+          end
+
+          private
+
+            def prompt_optional(label, default, placeholder: nil)
+              hint = placeholder ? " (#{placeholder})" : ""
+              if default
+                @prompt.ask("#{label}#{hint}:", default:)
+              else
+                @prompt.ask("#{label}#{hint}:")
+              end
+            end
+
+            def prompt_domain_selection
+              domain_choices = @zones.map { |z| { name: z[:name], value: z } }
+              domain_choices << { name: "Skip (no domain)", value: nil }
+
+              selected = @prompt.select("Domain:", domain_choices)
+              return [nil, nil] unless selected
+
+              zone_id = selected[:id]
+              domain = selected[:name]
+              subdomain = prompt_subdomain(zone_id, domain)
+
+              [domain, subdomain]
+            end
+
+            def prompt_subdomain(zone_id, domain)
+              loop do
+                subdomain = @prompt.ask("Subdomain (leave blank for #{domain} + *.#{domain}):")
+                subdomain = subdomain.to_s.strip.downcase
+
+                if !subdomain.empty? && !subdomain.match?(/\A[a-z0-9]([a-z0-9-]*[a-z0-9])?\z/)
+                  error("Invalid subdomain format. Use lowercase letters, numbers, and hyphens.")
+                  next
+                end
+
+                hostnames = Utils::Namer.build_hostnames(subdomain.empty? ? nil : subdomain, domain)
+                all_available = true
+
+                hostnames.each do |hostname|
+                  available = with_spinner("Checking #{hostname}...") do
+                    check_subdomain = hostname == domain ? "" : hostname.sub(".#{domain}", "")
+                    @cloudflare_client.subdomain_available?(zone_id, check_subdomain, domain)
+                  end
+
+                  unless available
+                    error("#{hostname} already has a DNS record. Choose a different subdomain.")
+                    all_available = false
+                    break
+                  end
+                end
+
+                return subdomain if all_available
+              end
+            end
+        end
+      end
+    end
+  end
+end

data/lib/nvoi/cli/onboard/steps/app_name.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Nvoi
+  class Cli
+    module Onboard
+      module Steps
+        # Collects application name
+        class AppName
+          include Onboard::Ui
+
+          def initialize(prompt, test_mode: false)
+            @prompt = prompt
+            @test_mode = test_mode
+          end
+
+          def call(existing: nil)
+            @prompt.ask("Application name:", default: existing) do |q|
+              q.required true
+              q.validate(/\A[a-z0-9_-]+\z/i, "Only letters, numbers, dashes, underscores")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nvoi/cli/onboard/steps/compute.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module Nvoi
+  class Cli
+    module Onboard
+      module Steps
+        # Collects compute provider configuration
+        class Compute
+          include Onboard::Ui
+
+          PROVIDERS = [
+            { name: "Hetzner (recommended)", value: :hetzner },
+            { name: "AWS", value: :aws },
+            { name: "Scaleway", value: :scaleway }
+          ].freeze
+
+          def initialize(prompt, test_mode: false)
+            @prompt = prompt
+            @test_mode = test_mode
+          end
+
+          def call(existing: nil)
+            section "Compute Provider"
+
+            provider = @prompt.select("Select provider:", PROVIDERS)
+
+            case provider
+            when :hetzner  then setup_hetzner
+            when :aws      then setup_aws
+            when :scaleway then setup_scaleway
+            end
+          end
+
+          private
+
+            def setup_hetzner
+              token = prompt_with_retry("Hetzner API Token:", mask: true) do |t|
+                client = External::Cloud::Hetzner.new(t)
+                client.validate_credentials
+                @client = client
+              end
+
+              types, locations = with_spinner("Fetching options...") do
+                [@client.list_server_types, @client.list_locations]
+              end
+
+              type_choices = types.sort_by { |t| t[:name] }.map do |t|
+                price = t[:price] ? " - #{t[:price]}/mo" : ""
+                { name: "#{t[:name]} (#{t[:cores]} vCPU, #{t[:memory] / 1024}GB#{price})", value: t[:name] }
+              end
+
+              location_choices = locations.map do |l|
+                { name: "#{l[:name]} (#{l[:city]}, #{l[:country]})", value: l[:name] }
+              end
+
+              server_type = @prompt.select("Server type:", type_choices, per_page: 10)
+              location = @prompt.select("Location:", location_choices)
+
+              {
+                "hetzner" => {
+                  "api_token" => token,
+                  "server_type" => server_type,
+                  "server_location" => location
+                }
+              }
+            end
+
+            def setup_aws
+              access_key = prompt_with_retry("AWS Access Key ID:") do |k|
+                raise Errors::ValidationError, "Invalid format" unless k.match?(/\AAKIA/)
+              end
+
+              secret_key = @prompt.mask("AWS Secret Access Key:")
+
+              temp_client = External::Cloud::Aws.new(access_key, secret_key, "us-east-1")
+              regions = with_spinner("Validating credentials...") do
+                temp_client.validate_credentials
+                temp_client.list_regions
+              end
+
+              region_choices = regions.map { |r| r[:name] }.sort
+              region = @prompt.select("Region:", region_choices, per_page: 10, filter: true)
+
+              client = External::Cloud::Aws.new(access_key, secret_key, region)
+              types = client.list_instance_types
+
+              type_choices = types.map do |t|
+                mem = t[:memory] ? " #{t[:memory] / 1024}GB" : ""
+                { name: "#{t[:name]} (#{t[:vcpus]} vCPU#{mem})", value: t[:name] }
+              end
+
+              instance_type = @prompt.select("Instance type:", type_choices)
+
+              {
+                "aws" => {
+                  "access_key_id" => access_key,
+                  "secret_access_key" => secret_key,
+                  "region" => region,
+                  "instance_type" => instance_type
+                }
+              }
+            end
+
+            def setup_scaleway
+              secret_key = prompt_with_retry("Scaleway Secret Key:", mask: true)
+              project_id = @prompt.ask("Scaleway Project ID:") { |q| q.required true }
+
+              temp_client = External::Cloud::Scaleway.new(secret_key, project_id)
+              zones = temp_client.list_zones
+
+              zone_choices = zones.map { |z| { name: "#{z[:name]} (#{z[:city]})", value: z[:name] } }
+              zone = @prompt.select("Zone:", zone_choices)
+
+              client = External::Cloud::Scaleway.new(secret_key, project_id, zone:)
+              types = with_spinner("Validating credentials...") do
+                client.validate_credentials
+                client.list_server_types
+              end
+
+              type_choices = types.map do |t|
+                { name: "#{t[:name]} (#{t[:cores]} cores)", value: t[:name] }
+              end
+
+              server_type = @prompt.select("Server type:", type_choices, per_page: 10, filter: true)
+
+              {
+                "scaleway" => {
+                  "secret_key" => secret_key,
+                  "project_id" => project_id,
+                  "zone" => zone,
+                  "server_type" => server_type
+                }
+              }
+            end
+        end
+      end
+    end
+  end
+end

data/lib/nvoi/cli/onboard/steps/database.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Nvoi
+  class Cli
+    module Onboard
+      module Steps
+        # Collects database configuration
+        class Database
+          include Onboard::Ui
+
+          ADAPTERS = [
+            { name: "PostgreSQL", value: "postgres" },
+            { name: "MySQL", value: "mysql" },
+            { name: "SQLite", value: "sqlite3" },
+            { name: "None (skip)", value: nil }
+          ].freeze
+
+          def initialize(prompt, test_mode: false)
+            @prompt = prompt
+            @test_mode = test_mode
+          end
+
+          # Returns [db_config, volume_config] tuple
+          def call(app_name:, existing: nil)
+            section "Database"
+
+            adapter = @prompt.select("Database:", ADAPTERS)
+            return [nil, nil] unless adapter
+
+            case adapter
+            when "postgres" then setup_postgres(app_name)
+            when "mysql"    then setup_mysql(app_name)
+            when "sqlite3"  then setup_sqlite
+            end
+          end
+
+          private
+
+            def setup_postgres(app_name)
+              db_name = @prompt.ask("Database name:", default: "#{app_name}_production")
+              user = @prompt.ask("Database user:", default: app_name)
+              password = @prompt.mask("Database password:") { |q| q.required true }
+
+              config = {
+                "servers" => ["main"],
+                "adapter" => "postgres",
+                "secrets" => {
+                  "POSTGRES_DB" => db_name,
+                  "POSTGRES_USER" => user,
+                  "POSTGRES_PASSWORD" => password
+                }
+              }
+
+              volume = { "postgres_data" => { "size" => 10 } }
+
+              [config, volume]
+            end
+
+            def setup_mysql(app_name)
+              db_name = @prompt.ask("Database name:", default: "#{app_name}_production")
+              user = @prompt.ask("Database user:", default: app_name)
+              password = @prompt.mask("Database password:") { |q| q.required true }
+
+              config = {
+                "servers" => ["main"],
+                "adapter" => "mysql",
+                "secrets" => {
+                  "MYSQL_DATABASE" => db_name,
+                  "MYSQL_USER" => user,
+                  "MYSQL_PASSWORD" => password
+                }
+              }
+
+              volume = { "mysql_data" => { "size" => 10 } }
+
+              [config, volume]
+            end
+
+            def setup_sqlite
+              path = @prompt.ask("Database path:", default: "/app/data/production.sqlite3")
+
+              config = {
+                "servers" => ["main"],
+                "adapter" => "sqlite3",
+                "path" => path,
+                "mount" => { "data" => "/app/data" }
+              }
+
+              volume = { "sqlite_data" => { "size" => 10 } }
+
+              [config, volume]
+            end
+        end
+      end
+    end
+  end
+end

data/lib/nvoi/cli/onboard/steps/domain.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Nvoi
+  class Cli
+    module Onboard
+      module Steps
+        # Collects domain provider (Cloudflare) configuration
+        class Domain
+          include Onboard::Ui
+
+          attr_reader :client, :zones
+
+          def initialize(prompt, test_mode: false)
+            @prompt = prompt
+            @test_mode = test_mode
+            @client = nil
+            @zones = []
+          end
+
+          def call(existing: nil)
+            section "Domain Provider"
+
+            return nil unless @prompt.yes?("Configure Cloudflare for domains/tunnels?")
+
+            token = prompt_with_retry("Cloudflare API Token:", mask: true)
+            account_id = @prompt.ask("Cloudflare Account ID:") { |q| q.required true }
+
+            @client = External::Dns::Cloudflare.new(token, account_id)
+
+            @zones = with_spinner("Fetching domains...") do
+              @client.validate_credentials
+              @client.list_zones.select { |z| z[:status] == "active" }
+            end
+
+            output.puts "No active domains found in Cloudflare account" if @zones.empty?
+
+            {
+              "cloudflare" => {
+                "api_token" => token,
+                "account_id" => account_id
+              }
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nvoi/cli/onboard/steps/env.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Nvoi
+  class Cli
+    module Onboard
+      module Steps
+        # Collects environment variables and secrets
+        class Env
+          include Onboard::Ui
+
+          ACTIONS = [
+            { name: "Add variable", value: :add },
+            { name: "Add secret (masked)", value: :secret },
+            { name: "Done", value: :done }
+          ].freeze
+
+          def initialize(prompt, test_mode: false)
+            @prompt = prompt
+            @test_mode = test_mode
+          end
+
+          # Returns [env, secrets] tuple
+          def call(existing_env: nil, existing_secrets: nil)
+            section "Environment Variables"
+
+            env = (existing_env || {}).dup
+            secrets = (existing_secrets || {}).dup
+
+            # Add default
+            env["RAILS_ENV"] ||= "production"
+
+            loop do
+              show_table(env, secrets) unless env.empty? && secrets.empty?
+
+              case @prompt.select("Action:", ACTIONS)
+              when :add
+                key = @prompt.ask("Variable name:") { |q| q.required true }
+                value = @prompt.ask("Value:") { |q| q.required true }
+                env[key] = value
+
+              when :secret
+                key = @prompt.ask("Secret name:") { |q| q.required true }
+                value = @prompt.mask("Value:") { |q| q.required true }
+                secrets[key] = value
+
+              when :done
+                break
+              end
+            end
+
+            [env, secrets]
+          end
+
+          private
+
+            def show_table(env, secrets)
+              rows = []
+              env.each { |k, v| rows << [k, v] }
+              secrets.each { |k, _| rows << [k, "********"] }
+
+              table(rows:, header: %w[Key Value])
+            end
+        end
+      end
+    end
+  end
+end

data/lib/nvoi/cli/onboard/ui.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "pastel"
+require "tty-spinner"
+require "tty-table"
+require "tty-box"
+
+module Nvoi
+  class Cli
+    module Onboard
+      # Shared UI helpers for onboard steps
+      module Ui
+        MAX_RETRIES = 3
+
+        def section(title)
+          output.puts
+          output.puts pastel.bold("─── #{title} ───")
+        end
+
+        def success(msg)
+          output.puts "#{pastel.green("✓")} #{msg}"
+        end
+
+        def error(msg)
+          output.puts "#{pastel.red("✗")} #{msg}"
+        end
+
+        def with_spinner(message)
+          return yield if @test_mode
+
+          spinner = TTY::Spinner.new("[:spinner] #{message}", format: :dots)
+          spinner.auto_spin
+          begin
+            result = yield
+            spinner.success("done")
+            result
+          rescue StandardError => e
+            spinner.error("failed")
+            raise
+          end
+        end
+
+        def prompt_with_retry(message, mask: false, max: MAX_RETRIES)
+          retries = 0
+          loop do
+            value = mask ? @prompt.mask(message) : @prompt.ask(message) { |q| q.required true }
+            begin
+              yield(value) if block_given?
+              return value
+            rescue Errors::ValidationError, Errors::AuthenticationError => e
+              retries += 1
+              if retries >= max
+                error("Failed after #{max} attempts: #{e.message}")
+                raise
+              end
+              output.puts("#{e.message}. Please try again. (#{retries}/#{max})")
+            end
+          end
+        end
+
+        def table(rows:, header: nil)
+          t = TTY::Table.new(header:, rows:)
+          output.puts t.render(:unicode, padding: [0, 1])
+          output.puts
+        end
+
+        def box(text)
+          output.puts TTY::Box.frame(text, padding: [0, 2], align: :center, border: :light)
+          output.puts
+        end
+
+        def output
+          @prompt.output
+        end
+
+        private
+
+          def pastel
+            @pastel ||= Pastel.new
+          end
+      end
+    end
+  end
+end

data/lib/nvoi/cli/unlock/command.rb

@@ -61,9 +61,9 @@ module Nvoi
 
           def apply_branch_override
             branch = @options[:branch]
-            return if branch.nil? || branch.empty?
+            return if branch.blank?
 
-            override = Objects::ConfigOverride.new(branch:)
+            override = Configuration::Override.new(branch:)
             override.apply(@config)
           end
       end