nvoi 0.2.0 → 0.2.1

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

@@ -40,31 +40,66 @@ module Nvoi
                 @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] }
+              locations = with_spinner("Fetching datacenters...") do
+                @client.list_locations
               end
 
+              # Step 1: Pick datacenter first
               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)
+              location = @prompt.select("Datacenter:", location_choices)
+
+              # Step 2: Fetch server types available at selected datacenter
+              available_types = with_spinner("Fetching available server types...") do
+                @client.list_server_types(location: location)
+              end
+
+              type_choices = available_types.sort_by { |t| t[:name] }.map do |t|
+                price = price_for_datacenter(t[:prices], location)
+                price_str = price ? " - €#{price}/mo" : ""
+                memory_gb = t[:memory].to_f.round(1)
+                cpu_info = cpu_label(t[:cpu_type], t[:architecture])
+                { name: "#{t[:name]} (#{t[:cores]} vCPU, #{memory_gb}GB, #{cpu_info}#{price_str})", value: t[:name] }
+              end
+
+              server_type = @prompt.select("Server type:", type_choices, per_page: 10, filter: true)
+
+              # Get architecture for selected server type
+              selected_type = available_types.find { |t| t[:name] == server_type }
+              arch = selected_type&.dig(:architecture) || "x86"
 
               {
                 "hetzner" => {
                   "api_token" => token,
                   "server_type" => server_type,
-                  "server_location" => location
+                  "server_location" => location,
+                  "architecture" => arch
                 }
               }
             end
 
+            def price_for_datacenter(prices, datacenter)
+              return nil unless prices
+
+              # Datacenter name is like "fsn1-dc14", location in prices is "fsn1"
+              location = datacenter.split("-").first
+              price_entry = prices.find { |p| p["location"] == location }
+              return nil unless price_entry
+
+              gross = price_entry.dig("price_monthly", "gross")
+              return nil unless gross
+
+              gross.to_f.round(2)
+            end
+
+            def cpu_label(cpu_type, architecture)
+              arch = architecture == "arm" ? "ARM" : "x86"
+              type = cpu_type == "dedicated" ? "dedicated" : "shared"
+              "#{arch}/#{type}"
+            end
+
             def setup_aws
               access_key = prompt_with_retry("AWS Access Key ID:") do |k|
                 raise Errors::ValidationError, "Invalid format" unless k.match?(/\AAKIA/)
@@ -86,17 +121,23 @@ module Nvoi
 
               type_choices = types.map do |t|
                 mem = t[:memory] ? " #{t[:memory] / 1024}GB" : ""
-                { name: "#{t[:name]} (#{t[:vcpus]} vCPU#{mem})", value: t[:name] }
+                arch_label = t[:architecture] == "arm64" ? " ARM" : ""
+                { name: "#{t[:name]} (#{t[:vcpus]} vCPU#{mem}#{arch_label})", value: t[:name] }
               end
 
               instance_type = @prompt.select("Instance type:", type_choices)
 
+              # Get architecture for selected instance type
+              selected_type = types.find { |t| t[:name] == instance_type }
+              arch = selected_type&.dig(:architecture) || "x86"
+
               {
                 "aws" => {
                   "access_key_id" => access_key,
                   "secret_access_key" => secret_key,
                   "region" => region,
-                  "instance_type" => instance_type
+                  "instance_type" => instance_type,
+                  "architecture" => arch
                 }
               }
             end
@@ -118,17 +159,23 @@ module Nvoi
               end
 
               type_choices = types.map do |t|
-                { name: "#{t[:name]} (#{t[:cores]} cores)", value: t[:name] }
+                arch_label = t[:architecture] == "arm64" ? " ARM" : ""
+                { name: "#{t[:name]} (#{t[:cores]} cores#{arch_label})", value: t[:name] }
               end
 
               server_type = @prompt.select("Server type:", type_choices, per_page: 10, filter: true)
 
+              # Get architecture for selected server type
+              selected_type = types.find { |t| t[:name] == server_type }
+              arch = selected_type&.dig(:architecture) || "x86"
+
               {
                 "scaleway" => {
                   "secret_key" => secret_key,
                   "project_id" => project_id,
                   "zone" => zone,
-                  "server_type" => server_type
+                  "server_type" => server_type,
+                  "architecture" => arch
                 }
               }
             end

data/lib/nvoi/cli.rb

@@ -114,6 +114,7 @@ module Nvoi
         option :api_token, desc: "API token (hetzner)"
         option :server_type, desc: "Server type (cx22, etc)"
         option :server_location, desc: "Location (fsn1, etc)"
+        option :architecture, desc: "CPU architecture (x86, arm64)"
         option :access_key_id, desc: "AWS access key ID"
         option :secret_access_key, desc: "AWS secret access key"
         option :region, desc: "AWS region"
@@ -123,7 +124,7 @@ module Nvoi
         option :zone, desc: "Scaleway zone"
         def set(provider)
           Nvoi::Cli::Config::Command.new(options).provider_set(provider, **options.slice(
-            :api_token, :server_type, :server_location,
+            :api_token, :server_type, :server_location, :architecture,
             :access_key_id, :secret_access_key, :region, :instance_type,
             :secret_key, :project_id, :zone
           ).transform_keys(&:to_sym).compact)

data/lib/nvoi/configuration/builder.rb

@@ -357,21 +357,24 @@ module Nvoi
             {
               "api_token" => opts[:api_token],
               "server_type" => opts[:server_type],
-              "server_location" => opts[:server_location]
+              "server_location" => opts[:server_location],
+              "architecture" => opts[:architecture]
             }.compact
           when "aws"
             {
               "access_key_id" => opts[:access_key_id],
               "secret_access_key" => opts[:secret_access_key],
               "region" => opts[:region],
-              "instance_type" => opts[:instance_type]
+              "instance_type" => opts[:instance_type],
+              "architecture" => opts[:architecture]
             }.compact
           when "scaleway"
             {
               "secret_key" => opts[:secret_key],
               "project_id" => opts[:project_id],
               "zone" => opts[:zone],
-              "server_type" => opts[:server_type]
+              "server_type" => opts[:server_type],
+              "architecture" => opts[:architecture]
             }.compact
           end
         end

data/lib/nvoi/configuration/providers.rb

@@ -38,19 +38,20 @@ module Nvoi
 
       # Hetzner contains Hetzner-specific configuration
       class Hetzner
-        attr_accessor :api_token, :server_type, :server_location
+        attr_accessor :api_token, :server_type, :server_location, :architecture
 
         def initialize(data = nil)
           data ||= {}
           @api_token = data["api_token"]
           @server_type = data["server_type"]
           @server_location = data["server_location"]
+          @architecture = data["architecture"]
         end
       end
 
       # AwsCfg contains AWS-specific configuration
       class AwsCfg
-        attr_accessor :access_key_id, :secret_access_key, :region, :instance_type
+        attr_accessor :access_key_id, :secret_access_key, :region, :instance_type, :architecture
 
         def initialize(data = nil)
           data ||= {}
@@ -58,12 +59,13 @@ module Nvoi
           @secret_access_key = data["secret_access_key"]
           @region = data["region"]
           @instance_type = data["instance_type"]
+          @architecture = data["architecture"]
         end
       end
 
       # Scaleway contains Scaleway-specific configuration
       class Scaleway
-        attr_accessor :secret_key, :project_id, :zone, :server_type
+        attr_accessor :secret_key, :project_id, :zone, :server_type, :architecture
 
         def initialize(data = nil)
           data ||= {}
@@ -71,6 +73,7 @@ module Nvoi
           @project_id = data["project_id"]
           @zone = data["zone"] || "fr-par-1"
           @server_type = data["server_type"]
+          @architecture = data["architecture"]
         end
       end
     end

data/lib/nvoi/configuration/root.rb

@@ -53,6 +53,21 @@ module Nvoi
         @deploy.application.domain_provider.cloudflare
       end
 
+      def architecture
+        case provider_name
+        when "hetzner" then hetzner&.architecture
+        when "aws" then aws&.architecture
+        when "scaleway" then scaleway&.architecture
+        end
+      end
+
+      def docker_platform
+        case architecture
+        when "arm", "arm64" then "linux/arm64"
+        else "linux/amd64"
+        end
+      end
+
       def keep_count_value
         count = @deploy.application.keep_count
         count && count.positive? ? count : 2
@@ -144,6 +159,7 @@ module Nvoi
             raise Errors::ConfigValidationError, "hetzner api_token is required" if h.api_token.blank?
             raise Errors::ConfigValidationError, "hetzner server_type is required" if h.server_type.blank?
             raise Errors::ConfigValidationError, "hetzner server_location is required" if h.server_location.blank?
+            raise Errors::ConfigValidationError, "hetzner architecture is required" if h.architecture.blank?
           end
 
           if app.compute_provider.aws
@@ -153,6 +169,7 @@ module Nvoi
             raise Errors::ConfigValidationError, "aws secret_access_key is required" if a.secret_access_key.blank?
             raise Errors::ConfigValidationError, "aws region is required" if a.region.blank?
             raise Errors::ConfigValidationError, "aws instance_type is required" if a.instance_type.blank?
+            raise Errors::ConfigValidationError, "aws architecture is required" if a.architecture.blank?
           end
 
           if app.compute_provider.scaleway
@@ -161,6 +178,7 @@ module Nvoi
             raise Errors::ConfigValidationError, "scaleway secret_key is required" if s.secret_key.blank?
             raise Errors::ConfigValidationError, "scaleway project_id is required" if s.project_id.blank?
             raise Errors::ConfigValidationError, "scaleway server_type is required" if s.server_type.blank?
+            raise Errors::ConfigValidationError, "scaleway architecture is required" if s.architecture.blank?
           end
 
           raise Errors::ConfigValidationError, "compute provider required: hetzner, aws, or scaleway must be configured" unless has_provider

data/lib/nvoi/configuration/service.rb

@@ -47,16 +47,5 @@ module Nvoi
           end
         end
     end
-
-    # SshKey defines SSH key content (stored in encrypted config)
-    class SshKey
-      attr_accessor :private_key, :public_key
-
-      def initialize(data = nil)
-        data ||= {}
-        @private_key = data["private_key"]
-        @public_key = data["public_key"]
-      end
-    end
   end
 end

data/lib/nvoi/configuration/ssh_key.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Nvoi
+  module Configuration
+    # SshKey defines SSH key content (stored in encrypted config)
+    class SshKey
+      attr_accessor :private_key, :public_key
+
+      def initialize(data = nil)
+        data ||= {}
+        @private_key = data["private_key"]
+        @public_key = data["public_key"]
+      end
+    end
+  end
+end

data/lib/nvoi/external/cloud/aws.rb

@@ -346,19 +346,29 @@ module Nvoi
 
         # List available instance types for onboarding
         def list_instance_types
-          # Common instance types (full list is huge)
-          common_types = %w[t3.micro t3.small t3.medium t3.large t3.xlarge m5.large m5.xlarge c5.large c5.xlarge]
+          # Common instance types including ARM (Graviton)
+          common_types = %w[
+            t3.micro t3.small t3.medium t3.large t3.xlarge
+            t4g.micro t4g.small t4g.medium t4g.large t4g.xlarge
+            m5.large m5.xlarge m6g.large m6g.xlarge
+            c5.large c5.xlarge c6g.large c6g.xlarge
+          ]
           resp = @client.describe_instance_types(instance_types: common_types)
           resp.instance_types.map do |t|
+            arch = t.processor_info&.supported_architectures&.first || "x86_64"
             {
               name: t.instance_type,
               vcpus: t.v_cpu_info.default_v_cpus,
-              memory: t.memory_info.size_in_mi_b
+              memory: t.memory_info.size_in_mi_b,
+              architecture: arch.include?("arm") ? "arm64" : "x86"
             }
           end
         rescue StandardError
           # Fallback to static list if API fails
-          common_types.map { |t| { name: t, vcpus: nil, memory: nil } }
+          common_types.map do |t|
+            arch = t.include?("g.") ? "arm64" : "x86"  # Graviton types have 'g' suffix
+            { name: t, vcpus: nil, memory: nil, architecture: arch }
+          end
         end
 
         # List available regions for onboarding

data/lib/nvoi/external/cloud/hetzner.rb

@@ -109,14 +109,11 @@ module Nvoi
           image = find_image(opts.image)
           raise Errors::ValidationError, "invalid image: #{opts.image}" unless image
 
-          location = find_location(opts.location)
-          raise Errors::ValidationError, "invalid location: #{opts.location}" unless location
-
           create_opts = {
             name: opts.name,
             server_type: server_type["name"],
             image: image["name"],
-            location: location["name"],
+            datacenter: opts.location,
             user_data: opts.user_data,
             start_after_create: true
           }
@@ -230,8 +227,8 @@ module Nvoi
         end
 
         def validate_region(region)
-          location = find_location(region)
-          raise Errors::ValidationError, "invalid hetzner location: #{region}" unless location
+          datacenter = find_datacenter(region)
+          raise Errors::ValidationError, "invalid hetzner datacenter: #{region}" unless datacenter
 
           true
         end
@@ -244,27 +241,45 @@ module Nvoi
         end
 
         # List available server types for onboarding
-        def list_server_types
-          get("/server_types")["server_types"].map do |t|
-            {
+        # When location (datacenter) is provided, filters to only actually available types
+        def list_server_types(location: nil)
+          all_types = get("/server_types")["server_types"]
+
+          # If no location specified, return all with basic info
+          types_hash = all_types.each_with_object({}) do |t, h|
+            h[t["id"]] = {
+              id: t["id"],
               name: t["name"],
               description: t["description"],
               cores: t["cores"],
               memory: t["memory"],
               disk: t["disk"],
-              price: t.dig("prices", 0, "price_monthly", "gross")
+              cpu_type: t["cpu_type"],
+              architecture: t["architecture"],
+              prices: t["prices"]
             }
           end
+
+          if location
+            # Filter by datacenter's actually available server types
+            datacenter = get("/datacenters")["datacenters"].find { |d| d["name"] == location }
+            return [] unless datacenter
+
+            available_ids = datacenter.dig("server_types", "available") || []
+            types_hash.values_at(*available_ids).compact
+          else
+            types_hash.values
+          end
         end
 
-        # List available locations for onboarding
+        # List available datacenters for onboarding (returns datacenter-level granularity)
         def list_locations
-          get("/locations")["locations"].map do |l|
+          get("/datacenters")["datacenters"].map do |d|
             {
-              name: l["name"],
-              city: l["city"],
-              country: l["country"],
-              description: l["description"]
+              name: d["name"],
+              city: d.dig("location", "city"),
+              country: d.dig("location", "country"),
+              description: d["description"]
             }
           end
         end
@@ -331,8 +346,8 @@ module Nvoi
             response["images"]&.first
           end
 
-          def find_location(name)
-            get("/locations")["locations"].find { |l| l["name"] == name }
+          def find_datacenter(name)
+            get("/datacenters")["datacenters"].find { |d| d["name"] == name }
           end
 
           def create_network_api(payload)

data/lib/nvoi/external/cloud/scaleway.rb

@@ -313,11 +313,13 @@ module Nvoi
         # List available server types for onboarding
         def list_server_types
           list_server_types_api.map do |name, info|
+            arch = info.dig("arch") || "x86_64"
             {
               name:,
               cores: info.dig("ncpus"),
               ram: info.dig("ram"),
-              hourly_price: info.dig("hourly_price")
+              hourly_price: info.dig("hourly_price"),
+              architecture: arch.include?("arm") ? "arm64" : "x86"
             }
           end
         end

data/lib/nvoi/external/dns/cloudflare.rb

@@ -69,11 +69,11 @@ module Nvoi
           url = "accounts/#{@account_id}/cfd_tunnel/#{tunnel_id}/configurations"
 
           ingress_rules = hostnames.map do |hostname|
-            {
-              hostname:,
-              service: service_url,
-              originRequest: { httpHostHeader: hostname.sub(/^\*\./, "") } # Use apex for wildcard
-            }
+            rule = { hostname:, service: service_url }
+            # Only set httpHostHeader for non-wildcard hostnames
+            # Wildcards should pass through the original Host header
+            rule[:originRequest] = { httpHostHeader: hostname } unless hostname.start_with?("*.")
+            rule
           end
           ingress_rules << { service: "http_status:404" }
 

data/lib/nvoi/utils/namer.rb

@@ -33,7 +33,7 @@ module Nvoi
 
       # ServerName returns the server name for a given group and index
       def server_name(group, index)
-        "#{@config.deploy.application.name}-#{group}-#{index}"
+        "#{sanitize_name(@config.deploy.application.name)}-#{group}-#{index}"
       end
 
       def firewall_name
@@ -196,6 +196,11 @@ module Nvoi
 
       private
 
+        # Sanitize name for cloud provider compatibility (no underscores, lowercase, etc.)
+        def sanitize_name(name)
+          name.to_s.gsub("_", "-").downcase
+        end
+
         def hash_string(str)
           Digest::SHA256.hexdigest(str)[0, 16]
         end

data/lib/nvoi/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Nvoi
-  VERSION = "0.2.0"
+  VERSION = "0.2.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nvoi
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - NVOI
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-12-13 00:00:00.000000000 Z
+date: 2025-12-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: zeitwerk
@@ -246,8 +246,9 @@ files:
 - ".rubocop.yml"
 - Gemfile
 - Gemfile.lock
-- Makefile
 - Rakefile
+- _TODO-rails-example.md
+- _TODO-rails-optimization.md
 - doc/config-schema.yaml
 - examples/apex-wildcard/deploy.yml
 - examples/golang-postgres-multi/.gitignore
@@ -412,6 +413,7 @@ files:
 - lib/nvoi/configuration/root.rb
 - lib/nvoi/configuration/server.rb
 - lib/nvoi/configuration/service.rb
+- lib/nvoi/configuration/ssh_key.rb
 - lib/nvoi/errors.rb
 - lib/nvoi/external/cloud.rb
 - lib/nvoi/external/cloud/aws.rb

data/Makefile

@@ -1,26 +0,0 @@
-NVOI = ruby -I$(PWD)/lib $(PWD)/exe/nvoi
-EXAMPLES = $(PWD)/examples
-
-deploy-golang:
-	cd $(EXAMPLES)/golang && $(NVOI) deploy
-
-exec-golang:
-	cd $(EXAMPLES)/golang && $(NVOI) exec -i
-
-show-golang:
-	cd $(EXAMPLES)/golang && $(NVOI) credentials show
-
-delete-golang:
-	cd $(EXAMPLES)/golang && $(NVOI) delete
-
-deploy-rails:
-	cd $(EXAMPLES)/rails-single && $(NVOI) deploy
-
-delete-rails:
-	cd $(EXAMPLES)/rails-single && $(NVOI) delete
-
-test:
-	bundle exec rake test
-
-lint:
-	bundle exec rubocop