nvoi 0.1.6 → 0.1.8

data/lib/nvoi/config_api/actions/env.rb

@@ -6,26 +6,26 @@ module Nvoi
       class SetEnv < Base
         protected
 
-        def mutate(data, key:, value:)
-          raise ArgumentError, "key is required" if key.nil? || key.to_s.empty?
-          raise ArgumentError, "value is required" if value.nil?
+          def mutate(data, key:, value:)
+            raise ArgumentError, "key is required" if key.nil? || key.to_s.empty?
+            raise ArgumentError, "value is required" if value.nil?
 
-          app(data)["env"] ||= {}
-          app(data)["env"][key.to_s] = value.to_s
-        end
+            app(data)["env"] ||= {}
+            app(data)["env"][key.to_s] = value.to_s
+          end
       end
 
       class DeleteEnv < Base
         protected
 
-        def mutate(data, key:)
-          raise ArgumentError, "key is required" if key.nil? || key.to_s.empty?
+          def mutate(data, key:)
+            raise ArgumentError, "key is required" if key.nil? || key.to_s.empty?
 
-          env = app(data)["env"] || {}
-          raise Errors::ConfigValidationError, "env '#{key}' not found" unless env.key?(key.to_s)
+            env = app(data)["env"] || {}
+            raise Errors::ConfigValidationError, "env '#{key}' not found" unless env.key?(key.to_s)
 
-          env.delete(key.to_s)
-        end
+            env.delete(key.to_s)
+          end
       end
     end
   end

data/lib/nvoi/config_api/actions/init.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Nvoi
+  module ConfigApi
+    module Actions
+      class Init
+        def call(name:, environment: "production")
+          raise ArgumentError, "name is required" if name.nil? || name.to_s.empty?
+
+          # Generate master key
+          master_key = Utils::Crypto.generate_key
+
+          # Generate SSH keypair (reuse existing utility)
+          private_key, public_key = Utils::ConfigLoader.generate_keypair
+
+          # Build initial config
+          config_data = {
+            "application" => {
+              "name" => name.to_s,
+              "environment" => environment.to_s,
+              "domain_provider" => {},
+              "compute_provider" => {},
+              "servers" => {},
+              "app" => {},
+              "services" => {},
+              "env" => {},
+              "secrets" => {},
+              "ssh_keys" => {
+                "private_key" => private_key,
+                "public_key" => public_key
+              }
+            }
+          }
+
+          # Encrypt config
+          yaml = YAML.dump(config_data)
+          encrypted_config = Utils::Crypto.encrypt(yaml, master_key)
+
+          InitResult.new(
+            config: encrypted_config,
+            master_key:,
+            ssh_public_key: public_key
+          )
+        rescue ArgumentError => e
+          InitResult.new(error_type: :invalid_args, error_message: e.message)
+        rescue Errors::ConfigError => e
+          InitResult.new(error_type: :config_error, error_message: e.message)
+        end
+      end
+
+      class InitResult
+        attr_reader :config, :master_key, :ssh_public_key, :error_type, :error_message
+
+        def initialize(config: nil, master_key: nil, ssh_public_key: nil, error_type: nil, error_message: nil)
+          @config = config
+          @master_key = master_key
+          @ssh_public_key = ssh_public_key
+          @error_type = error_type
+          @error_message = error_message
+        end
+
+        def success? = @error_type.nil?
+        def failure? = !success?
+      end
+    end
+  end
+end

data/lib/nvoi/config_api/actions/secret.rb

@@ -6,26 +6,26 @@ module Nvoi
       class SetSecret < Base
         protected
 
-        def mutate(data, key:, value:)
-          raise ArgumentError, "key is required" if key.nil? || key.to_s.empty?
-          raise ArgumentError, "value is required" if value.nil?
+          def mutate(data, key:, value:)
+            raise ArgumentError, "key is required" if key.nil? || key.to_s.empty?
+            raise ArgumentError, "value is required" if value.nil?
 
-          app(data)["secrets"] ||= {}
-          app(data)["secrets"][key.to_s] = value.to_s
-        end
+            app(data)["secrets"] ||= {}
+            app(data)["secrets"][key.to_s] = value.to_s
+          end
       end
 
       class DeleteSecret < Base
         protected
 
-        def mutate(data, key:)
-          raise ArgumentError, "key is required" if key.nil? || key.to_s.empty?
+          def mutate(data, key:)
+            raise ArgumentError, "key is required" if key.nil? || key.to_s.empty?
 
-          secrets = app(data)["secrets"] || {}
-          raise Errors::ConfigValidationError, "secret '#{key}' not found" unless secrets.key?(key.to_s)
+            secrets = app(data)["secrets"] || {}
+            raise Errors::ConfigValidationError, "secret '#{key}' not found" unless secrets.key?(key.to_s)
 
-          secrets.delete(key.to_s)
-        end
+            secrets.delete(key.to_s)
+          end
       end
     end
   end

data/lib/nvoi/config_api/actions/server.rb

@@ -6,60 +6,60 @@ module Nvoi
       class SetServer < Base
         protected
 
-        def mutate(data, name:, master: false, type: nil, location: nil, count: 1)
-          raise ArgumentError, "name is required" if name.nil? || name.to_s.empty?
-          raise ArgumentError, "count must be positive" if count && count < 1
+          def mutate(data, name:, master: false, type: nil, location: nil, count: 1)
+            raise ArgumentError, "name is required" if name.nil? || name.to_s.empty?
+            raise ArgumentError, "count must be positive" if count && count < 1
 
-          app(data)["servers"] ||= {}
-          app(data)["servers"][name.to_s] = {
-            "master" => master,
-            "type" => type,
-            "location" => location,
-            "count" => count
-          }.compact
-        end
+            app(data)["servers"] ||= {}
+            app(data)["servers"][name.to_s] = {
+              "master" => master,
+              "type" => type,
+              "location" => location,
+              "count" => count
+            }.compact
+          end
       end
 
       class DeleteServer < Base
         protected
 
-        def mutate(data, name:)
-          raise ArgumentError, "name is required" if name.nil? || name.to_s.empty?
+          def mutate(data, name:)
+            raise ArgumentError, "name is required" if name.nil? || name.to_s.empty?
 
-          servers = app(data)["servers"] || {}
-          raise Errors::ConfigValidationError, "server '#{name}' not found" unless servers.key?(name.to_s)
+            servers = app(data)["servers"] || {}
+            raise Errors::ConfigValidationError, "server '#{name}' not found" unless servers.key?(name.to_s)
 
-          servers.delete(name.to_s)
-        end
+            servers.delete(name.to_s)
+          end
 
-        def validate(data)
-          check_orphaned_references(data)
-        end
+          def validate(data)
+            check_orphaned_references(data)
+          end
 
         private
 
-        def check_orphaned_references(data)
-          servers = (app(data)["servers"] || {}).keys
+          def check_orphaned_references(data)
+            servers = (app(data)["servers"] || {}).keys
 
-          (app(data)["app"] || {}).each do |svc_name, svc|
-            (svc["servers"] || []).each do |ref|
-              raise Errors::ConfigValidationError, "app.#{svc_name} references non-existent server '#{ref}'" unless servers.include?(ref)
+            (app(data)["app"] || {}).each do |svc_name, svc|
+              (svc["servers"] || []).each do |ref|
+                raise Errors::ConfigValidationError, "app.#{svc_name} references non-existent server '#{ref}'" unless servers.include?(ref)
+              end
             end
-          end
 
-          db = app(data)["database"]
-          if db
-            (db["servers"] || []).each do |ref|
-              raise Errors::ConfigValidationError, "database references non-existent server '#{ref}'" unless servers.include?(ref)
+            db = app(data)["database"]
+            if db
+              (db["servers"] || []).each do |ref|
+                raise Errors::ConfigValidationError, "database references non-existent server '#{ref}'" unless servers.include?(ref)
+              end
             end
-          end
 
-          (app(data)["services"] || {}).each do |svc_name, svc|
-            (svc["servers"] || []).each do |ref|
-              raise Errors::ConfigValidationError, "services.#{svc_name} references non-existent server '#{ref}'" unless servers.include?(ref)
+            (app(data)["services"] || {}).each do |svc_name, svc|
+              (svc["servers"] || []).each do |ref|
+                raise Errors::ConfigValidationError, "services.#{svc_name} references non-existent server '#{ref}'" unless servers.include?(ref)
+              end
             end
           end
-        end
       end
     end
   end

data/lib/nvoi/config_api/actions/service.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Nvoi
+  module ConfigApi
+    module Actions
+      class SetService < Base
+        protected
+
+          def mutate(data, name:, servers:, image:, port: nil, command: nil, env: nil, mount: nil)
+            raise ArgumentError, "name is required" if name.nil? || name.to_s.empty?
+            raise ArgumentError, "servers is required" if servers.nil? || servers.empty?
+            raise ArgumentError, "servers must be an array" unless servers.is_a?(Array)
+            raise ArgumentError, "image is required" if image.nil? || image.to_s.empty?
+
+            validate_server_refs(data, servers)
+
+            app(data)["services"] ||= {}
+            app(data)["services"][name.to_s] = {
+              "servers" => servers.map(&:to_s),
+              "image" => image.to_s,
+              "port" => port,
+              "command" => command,
+              "env" => env,
+              "mount" => mount
+            }.compact
+          end
+
+        private
+
+          def validate_server_refs(data, servers)
+            defined = (app(data)["servers"] || {}).keys
+            servers.each do |ref|
+              raise Errors::ConfigValidationError, "server '#{ref}' not found" unless defined.include?(ref.to_s)
+            end
+          end
+      end
+
+      class DeleteService < Base
+        protected
+
+          def mutate(data, name:)
+            raise ArgumentError, "name is required" if name.nil? || name.to_s.empty?
+
+            services = app(data)["services"] || {}
+            raise Errors::ConfigValidationError, "service '#{name}' not found" unless services.key?(name.to_s)
+
+            services.delete(name.to_s)
+          end
+      end
+    end
+  end
+end

data/lib/nvoi/config_api/actions/volume.rb

@@ -6,34 +6,34 @@ module Nvoi
       class SetVolume < Base
         protected
 
-        def mutate(data, server:, name:, size: 10)
-          raise ArgumentError, "server is required" if server.nil? || server.to_s.empty?
-          raise ArgumentError, "name is required" if name.nil? || name.to_s.empty?
-          raise ArgumentError, "size must be positive" if size && size < 1
+          def mutate(data, server:, name:, size: 10)
+            raise ArgumentError, "server is required" if server.nil? || server.to_s.empty?
+            raise ArgumentError, "name is required" if name.nil? || name.to_s.empty?
+            raise ArgumentError, "size must be positive" if size && size < 1
 
-          servers = app(data)["servers"] ||= {}
-          raise Errors::ConfigValidationError, "server '#{server}' not found" unless servers.key?(server.to_s)
+            servers = app(data)["servers"] ||= {}
+            raise Errors::ConfigValidationError, "server '#{server}' not found" unless servers.key?(server.to_s)
 
-          servers[server.to_s]["volumes"] ||= {}
-          servers[server.to_s]["volumes"][name.to_s] = { "size" => size }
-        end
+            servers[server.to_s]["volumes"] ||= {}
+            servers[server.to_s]["volumes"][name.to_s] = { "size" => size }
+          end
       end
 
       class DeleteVolume < Base
         protected
 
-        def mutate(data, server:, name:)
-          raise ArgumentError, "server is required" if server.nil? || server.to_s.empty?
-          raise ArgumentError, "name is required" if name.nil? || name.to_s.empty?
+          def mutate(data, server:, name:)
+            raise ArgumentError, "server is required" if server.nil? || server.to_s.empty?
+            raise ArgumentError, "name is required" if name.nil? || name.to_s.empty?
 
-          servers = app(data)["servers"] || {}
-          raise Errors::ConfigValidationError, "server '#{server}' not found" unless servers.key?(server.to_s)
+            servers = app(data)["servers"] || {}
+            raise Errors::ConfigValidationError, "server '#{server}' not found" unless servers.key?(server.to_s)
 
-          volumes = servers[server.to_s]["volumes"] || {}
-          raise Errors::ConfigValidationError, "volume '#{name}' not found on server '#{server}'" unless volumes.key?(name.to_s)
+            volumes = servers[server.to_s]["volumes"] || {}
+            raise Errors::ConfigValidationError, "volume '#{name}' not found on server '#{server}'" unless volumes.key?(name.to_s)
 
-          volumes.delete(name.to_s)
-        end
+            volumes.delete(name.to_s)
+          end
       end
     end
   end

data/lib/nvoi/config_api/base.rb

@@ -2,23 +2,17 @@
 
 module Nvoi
   module ConfigApi
+    # Base class for config transformations.
+    # Accepts a Hash, returns a Hash. No crypto - caller handles that.
     class Base
-      def initialize(encrypted_config, master_key)
-        @encrypted_config = encrypted_config
-        @master_key = master_key
+      def initialize(data)
+        @data = data
       end
 
       def call(**args)
-        yaml = Utils::Crypto.decrypt(@encrypted_config, @master_key)
-        @data = YAML.safe_load(yaml, permitted_classes: [Symbol])
-
         mutate(@data, **args)
         validate(@data)
-
-        new_yaml = YAML.dump(@data)
-        Result.success(Utils::Crypto.encrypt(new_yaml, @master_key))
-      rescue Errors::DecryptionError, Errors::InvalidKeyError => e
-        Result.failure(:decryption_error, e.message)
+        Result.success(@data)
       rescue Errors::ConfigValidationError => e
         Result.failure(:validation_error, e.message)
       rescue ArgumentError => e
@@ -27,18 +21,18 @@ module Nvoi
 
       protected
 
-      def mutate(_data, **_args)
-        raise NotImplementedError
-      end
+        def mutate(_data, **_args)
+          raise NotImplementedError
+        end
 
-      def validate(_data)
-        # Subclasses can override to add validation
-        # Default: no validation (lightweight actions like set_env don't need full config validation)
-      end
+        def validate(_data)
+          # Subclasses can override to add validation
+          # Default: no validation (lightweight actions like set_env don't need full config validation)
+        end
 
-      def app(data)
-        data["application"] ||= {}
-      end
+        def app(data)
+          data["application"] ||= {}
+        end
     end
   end
 end

data/lib/nvoi/config_api/result.rb

@@ -3,18 +3,18 @@
 module Nvoi
   module ConfigApi
     class Result
-      attr_reader :config, :error_type, :error_message
+      attr_reader :data, :error_type, :error_message
 
-      def self.success(config)
-        new(config: config)
+      def self.success(data)
+        new(data:)
       end
 
       def self.failure(type, message)
         new(error_type: type, error_message: message)
       end
 
-      def initialize(config: nil, error_type: nil, error_message: nil)
-        @config = config
+      def initialize(data: nil, error_type: nil, error_message: nil)
+        @data = data
         @error_type = error_type
         @error_message = error_message
       end

data/lib/nvoi/config_api.rb

@@ -3,67 +3,90 @@
 module Nvoi
   module ConfigApi
     class << self
+      # Init (creates new config - special case, handles crypto)
+      def init(**args)
+        Actions::Init.new.call(**args)
+      end
+
+      # Domain Provider
+      def set_domain_provider(data, **args)
+        Actions::SetDomainProvider.new(data).call(**args)
+      end
+
+      def delete_domain_provider(data)
+        Actions::DeleteDomainProvider.new(data).call
+      end
+
       # Compute Provider
-      def set_compute_provider(config, key, **args)
-        Actions::SetComputeProvider.new(config, key).call(**args)
+      def set_compute_provider(data, **args)
+        Actions::SetComputeProvider.new(data).call(**args)
       end
 
-      def delete_compute_provider(config, key)
-        Actions::DeleteComputeProvider.new(config, key).call
+      def delete_compute_provider(data)
+        Actions::DeleteComputeProvider.new(data).call
       end
 
       # Server
-      def set_server(config, key, **args)
-        Actions::SetServer.new(config, key).call(**args)
+      def set_server(data, **args)
+        Actions::SetServer.new(data).call(**args)
       end
 
-      def delete_server(config, key, **args)
-        Actions::DeleteServer.new(config, key).call(**args)
+      def delete_server(data, **args)
+        Actions::DeleteServer.new(data).call(**args)
       end
 
       # Volume
-      def set_volume(config, key, **args)
-        Actions::SetVolume.new(config, key).call(**args)
+      def set_volume(data, **args)
+        Actions::SetVolume.new(data).call(**args)
       end
 
-      def delete_volume(config, key, **args)
-        Actions::DeleteVolume.new(config, key).call(**args)
+      def delete_volume(data, **args)
+        Actions::DeleteVolume.new(data).call(**args)
       end
 
       # App
-      def set_app(config, key, **args)
-        Actions::SetApp.new(config, key).call(**args)
+      def set_app(data, **args)
+        Actions::SetApp.new(data).call(**args)
       end
 
-      def delete_app(config, key, **args)
-        Actions::DeleteApp.new(config, key).call(**args)
+      def delete_app(data, **args)
+        Actions::DeleteApp.new(data).call(**args)
       end
 
       # Database
-      def set_database(config, key, **args)
-        Actions::SetDatabase.new(config, key).call(**args)
+      def set_database(data, **args)
+        Actions::SetDatabase.new(data).call(**args)
       end
 
-      def delete_database(config, key)
-        Actions::DeleteDatabase.new(config, key).call
+      def delete_database(data)
+        Actions::DeleteDatabase.new(data).call
       end
 
       # Secret
-      def set_secret(config, key, **args)
-        Actions::SetSecret.new(config, key).call(**args)
+      def set_secret(data, **args)
+        Actions::SetSecret.new(data).call(**args)
       end
 
-      def delete_secret(config, key, **args)
-        Actions::DeleteSecret.new(config, key).call(**args)
+      def delete_secret(data, **args)
+        Actions::DeleteSecret.new(data).call(**args)
       end
 
       # Env
-      def set_env(config, key, **args)
-        Actions::SetEnv.new(config, key).call(**args)
+      def set_env(data, **args)
+        Actions::SetEnv.new(data).call(**args)
+      end
+
+      def delete_env(data, **args)
+        Actions::DeleteEnv.new(data).call(**args)
+      end
+
+      # Service
+      def set_service(data, **args)
+        Actions::SetService.new(data).call(**args)
       end
 
-      def delete_env(config, key, **args)
-        Actions::DeleteEnv.new(config, key).call(**args)
+      def delete_service(data, **args)
+        Actions::DeleteService.new(data).call(**args)
       end
     end
   end

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

@@ -229,7 +229,7 @@ module Nvoi
         end
 
         def wait_for_server(server_id, max_attempts)
-          server = Utils::Retry.poll(max_attempts: max_attempts, interval: 5) do
+          server = Utils::Retry.poll(max_attempts:, interval: 5) do
             resp = @client.describe_instances(instance_ids: [server_id])
 
             if resp.reservations.any? && resp.reservations[0].instances.any?
@@ -344,6 +344,31 @@ module Nvoi
           raise Errors::ValidationError, "aws credentials invalid: #{e.message}"
         end
 
+        # 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]
+          resp = @client.describe_instance_types(instance_types: common_types)
+          resp.instance_types.map do |t|
+            {
+              name: t.instance_type,
+              vcpus: t.v_cpu_info.default_v_cpus,
+              memory: t.memory_info.size_in_mi_b
+            }
+          end
+        rescue StandardError
+          # Fallback to static list if API fails
+          common_types.map { |t| { name: t, vcpus: nil, memory: nil } }
+        end
+
+        # List available regions for onboarding
+        def list_regions
+          resp = @client.describe_regions
+          resp.regions.map do |r|
+            { name: r.region_name, endpoint: r.endpoint }
+          end
+        end
+
         private
 
           def find_vpc_by_name(name)

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

@@ -136,7 +136,7 @@ module Nvoi
         end
 
         def wait_for_server(server_id, max_attempts)
-          server = Utils::Retry.poll(max_attempts: max_attempts, interval: Utils::Constants::SERVER_READY_INTERVAL) do
+          server = Utils::Retry.poll(max_attempts:, interval: Utils::Constants::SERVER_READY_INTERVAL) do
             s = get("/servers/#{server_id.to_i}")["server"]
             to_server(s) if s["status"] == "running"
           end
@@ -243,6 +243,32 @@ module Nvoi
           raise Errors::ValidationError, "hetzner credentials invalid: #{e.message}"
         end
 
+        # List available server types for onboarding
+        def list_server_types
+          get("/server_types")["server_types"].map do |t|
+            {
+              name: t["name"],
+              description: t["description"],
+              cores: t["cores"],
+              memory: t["memory"],
+              disk: t["disk"],
+              price: t.dig("prices", 0, "price_monthly", "gross")
+            }
+          end
+        end
+
+        # List available locations for onboarding
+        def list_locations
+          get("/locations")["locations"].map do |l|
+            {
+              name: l["name"],
+              city: l["city"],
+              country: l["country"],
+              description: l["description"]
+            }
+          end
+        end
+
         private
 
           def get(path)