rubino-agent 0.3.0

data/lib/rubino/api/operations/memory/stats_operation.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Rubino
+  module API
+    module Operations
+      module Memory
+        # GET /v1/memory/stats
+        # Returns the active backend's name and total fact count — the data the
+        # CLI /status line and the web dashboard's memory card need without
+        # paging the whole store.
+        class StatsOperation
+          def self.call(request)
+            new.call(request)
+          end
+
+          # Accepts an alternate backend for tests.
+          def initialize(backend: nil)
+            @backend = backend || ::Rubino::Memory::Backends.build
+          end
+
+          def call(_request)
+            [200, { backend: @backend.class.backend_name, count: @backend.count }]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubino/api/operations/metrics_operation.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Rubino
+  module API
+    module Operations
+      # GET /v1/metrics — Prometheus text exposition format (text/plain v0.0.4).
+      # No auth required (allowlisted in Middleware::Auth::SKIP_PATHS).
+      #
+      # @return [[Integer, Hash, Array<String>]] raw Rack triple with the rendered registry.
+      class MetricsOperation
+        def self.call(_request)
+          body = ::Rubino::Metrics.render
+          [200, { "content-type" => "text/plain; version=0.0.4" }, [body]]
+        end
+      end
+    end
+  end
+end

data/lib/rubino/api/operations/mode/show_operation.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Rubino
+  module API
+    module Operations
+      module Mode
+        # GET /v1/mode
+        # Returns the active mode and the list of valid modes so the web
+        # client can render a picker without hardcoding the set.
+        class ShowOperation
+          def self.call(request)
+            new.call(request)
+          end
+
+          def call(_request)
+            current = Rubino::Modes.current
+            [200, {
+              mode: current,
+              description: Rubino::Modes.description(current),
+              available: Rubino::Modes::ALL.map do |m|
+                { mode: m, description: Rubino::Modes.description(m) }
+              end
+            }]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubino/api/operations/mode/update_operation.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Rubino
+  module API
+    module Operations
+      module Mode
+        # PUT /v1/mode
+        # Body: { "mode": "default" | "plan" | "yolo" }
+        #
+        # Switches the active mode and emits the same `mode_changed` UI event
+        # the CLI fires on `/mode plan`, so any in-flight SSE stream notices.
+        #
+        # @raise [Rubino::ValidationError] on missing/typo'd mode
+        class UpdateOperation
+          def self.call(request)
+            new.call(request)
+          end
+
+          def call(request)
+            attrs    = request.validate!(Schemas::UpdateMode)
+            previous = Rubino::Modes.current
+
+            begin
+              Rubino::Modes.set(attrs[:mode])
+            rescue ArgumentError => e
+              # Modes.set already rejects unknowns; surface as a 422 the same
+              # way validation errors do. The dry-schema enum below normally
+              # catches this first; this is just defence in depth for an
+              # alternate caller.
+              raise ValidationError.new(e.message)
+            end
+
+            current = Rubino::Modes.current
+            Rubino.ui&.mode_changed(current, previous: previous)
+
+            [200, { mode: current, previous: previous, description: Rubino::Modes.description(current) }]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubino/api/operations/models/list_operation.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "ruby_llm"
+
+module Rubino
+  module API
+    module Operations
+      module Models
+        # GET /v1/models — returns the model catalog from ruby_llm.
+        # The source defaults to RubyLLM.models.all but accepts any callable
+        # returning an enumerable of model objects/hashes for tests.
+        class ListOperation
+          def self.call(request)
+            new.call(request)
+          end
+
+          # Accepts an alternate model source (callable) for tests.
+          def initialize(model_source: nil)
+            @model_source = model_source || -> { RubyLLM.models.all }
+          end
+
+          def call(_request)
+            models = @model_source.call.map do |m|
+              {
+                id: model_id(m),
+                provider: m.respond_to?(:provider) ? m.provider.to_s : nil,
+                context_window: m.respond_to?(:context_window) ? m.context_window : nil
+              }
+            end
+            [200, models]
+          end
+
+          private
+
+          def model_id(model)
+            return model.id if model.respond_to?(:id)
+            return model[:id] if model.is_a?(Hash)
+
+            model.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubino/api/operations/oauth/connections/disconnect_operation.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Rubino
+  module API
+    module Operations
+      module OAuth
+        module Connections
+          # DELETE /v1/oauth/connections/:id
+          # Removes a stored OAuth connection (encrypted tokens included) and
+          # asks the provider to revoke the underlying token, so a DB dump +
+          # encryption-key compromise no longer yields indefinite provider-side
+          # access.
+          #
+          # Provider revoke is best-effort: a failure (network, 4xx) is logged
+          # and the local row is still destroyed — leaving a stale local row is
+          # strictly worse than missing the revoke, since the user thinks the
+          # connection is gone and we'd keep using the encrypted tokens.
+          #
+          # @return [[Integer, nil]] 204 No Content.
+          # @raise [Rubino::NotFoundError] when the connection does not exist.
+          class DisconnectOperation
+            def self.call(request)
+              new.call(request)
+            end
+
+            # Accepts an alternate repository / registry / logger for tests.
+            def initialize(repository: nil, registry: ::Rubino::OAuth::Registry, logger: nil)
+              @repository = repository
+              @registry = registry
+              @logger = logger
+            end
+
+            def call(request)
+              id = request.params.fetch("id")
+              connection = repository.find(id)
+              raise NotFoundError.new("oauth_connection", id) unless connection
+
+              revoke_remote(connection)
+              repository.destroy!(id)
+              [204, nil]
+            end
+
+            private
+
+            def revoke_remote(connection)
+              provider = @registry.fetch_or_nil(connection[:provider])
+              return unless provider&.respond_to?(:revoke)
+
+              # Prefer refresh_token (Google revokes the whole grant) and fall
+              # back to access_token (GitHub only knows about user tokens).
+              token = connection[:refresh_token] || connection[:access_token]
+              return unless token && !token.empty?
+
+              provider.revoke(token)
+            rescue StandardError => e
+              logger.warn(
+                event: "oauth.disconnect.revoke_failed",
+                provider: connection[:provider],
+                connection_id: connection[:id],
+                error_class: e.class.name,
+                error_message: e.message
+              )
+            end
+
+            def repository
+              @repository ||= ::Rubino::OAuth::ConnectionRepository.new
+            end
+
+            def logger
+              @logger ||= ::Rubino.logger
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubino/api/operations/oauth/connections/list_operation.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Rubino
+  module API
+    module Operations
+      module OAuth
+        module Connections
+          # GET /v1/oauth/connections
+          # Lists stored OAuth connections through Serializer, which strips
+          # tokens and other secret fields before they leave the API.
+          class ListOperation
+            def self.call(request)
+              new.call(request)
+            end
+
+            # Accepts an alternate connection repository for tests.
+            def initialize(repository: nil)
+              @repository = repository
+            end
+
+            def call(_request)
+              connections = repository.list.map { |c| Serializer.call(c) }
+              [200, connections]
+            end
+
+            private
+
+            def repository
+              @repository ||= ::Rubino::OAuth::ConnectionRepository.new
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubino/api/operations/oauth/providers/callback_operation.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Rubino
+  module API
+    module Operations
+      module OAuth
+        module Providers
+          # POST /v1/oauth/providers/:id/callback
+          #
+          # Client posts back code + state + code_verifier (plus expected_state
+          # it kept from connect). We constant-time-compare state, exchange the
+          # code, fetch account info, upsert by (provider, account_id) with
+          # encrypted tokens, and return the connection. Exchange outcomes
+          # bump oauth_token_exchanges_total {ok|error}.
+          #
+          # @return [[Integer, Hash]] 201 + serialized connection (tokens stripped).
+          # @raise [Rubino::NotFoundError] when no provider is registered for +:id+.
+          # @raise [Rubino::ValidationError] when the body fails Schemas::CallbackProvider or state mismatches.
+          # @raise [Rubino::UpstreamError] when the provider's token exchange raises.
+          class CallbackOperation
+            def self.call(request)
+              new.call(request)
+            end
+
+            # Accepts an alternate provider registry and connection repository for tests.
+            def initialize(registry: ::Rubino::OAuth::Registry, repository: nil)
+              @registry = registry
+              @repository = repository
+            end
+
+            def call(request)
+              id = request.params.fetch("id")
+              provider = @registry.fetch(id)
+              attrs = request.validate!(Schemas::CallbackProvider)
+
+              unless Rack::Utils.secure_compare(attrs[:state], attrs[:expected_state])
+                raise ValidationError, "state mismatch"
+              end
+
+              token =
+                begin
+                  provider.exchange_code(
+                    code: attrs[:code],
+                    redirect_uri: attrs[:redirect_uri],
+                    code_verifier: attrs[:code_verifier]
+                  )
+                rescue StandardError => e
+                  ::Rubino::Metrics.counter(:oauth_token_exchanges_total,
+                                            provider: provider.id, outcome: "error").increment
+                  raise UpstreamError.new("token exchange failed: #{e.class.name}", service: provider.id)
+                end
+
+              ::Rubino::Metrics.counter(:oauth_token_exchanges_total,
+                                        provider: provider.id, outcome: "ok").increment
+
+              info = provider.fetch_account_info(token[:access_token])
+
+              connection = repository.upsert(
+                provider: provider.id,
+                account_id: info[:account_id],
+                account_email: info[:account_email],
+                access_token: token[:access_token],
+                refresh_token: token[:refresh_token],
+                expires_at: token[:expires_at],
+                scopes: token[:scopes],
+                metadata: info[:metadata] || {}
+              )
+
+              [201, Serializer.call(connection)]
+            end
+
+            private
+
+            def repository
+              @repository ||= ::Rubino::OAuth::ConnectionRepository.new
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubino/api/operations/oauth/providers/connect_operation.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Rubino
+  module API
+    module Operations
+      module OAuth
+        module Providers
+          # POST /v1/oauth/providers/:id/connect
+          #
+          # Builds a PKCE authorize request for the provider and returns
+          # { authorize_url, state, code_verifier, provider }. The client
+          # persists state + code_verifier between connect and callback;
+          # rubino stays stateless on the OAuth flow itself.
+          #
+          # @raise [Rubino::NotFoundError] when no provider is registered for +:id+.
+          # @raise [Rubino::ValidationError] when the body fails Schemas::ConnectProvider.
+          class ConnectOperation
+            def self.call(request)
+              new.call(request)
+            end
+
+            # Accepts an alternate provider registry for tests.
+            def initialize(registry: ::Rubino::OAuth::Registry)
+              @registry = registry
+            end
+
+            def call(request)
+              id = request.params.fetch("id")
+              provider = @registry.fetch(id)
+              attrs = request.validate!(Schemas::ConnectProvider)
+
+              flow = provider.build_authorize_request(
+                redirect_uri: attrs[:redirect_uri],
+                scopes: attrs[:scopes]
+              )
+
+              [200, flow.merge(provider: provider.id)]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubino/api/operations/oauth/providers/list_operation.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Rubino
+  module API
+    module Operations
+      module OAuth
+        module Providers
+          # GET /v1/oauth/providers
+          # Lists OAuth providers registered at boot, with their default scopes.
+          class ListOperation
+            def self.call(request)
+              new.call(request)
+            end
+
+            # Accepts an alternate provider registry for tests.
+            def initialize(registry: ::Rubino::OAuth::Registry)
+              @registry = registry
+            end
+
+            def call(_request)
+              providers = @registry.all.map do |p|
+                {
+                  id: p.id,
+                  display_name: p.class.display_name,
+                  scopes: p.scopes
+                }
+              end
+              [200, providers]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubino/api/operations/oauth/serializer.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Rubino
+  module API
+    module Operations
+      module OAuth
+        # Strips secret fields from connection rows before they leave the API.
+        # Tokens never go on the wire — clients use them implicitly through
+        # tools, not directly.
+        module Serializer
+          PUBLIC_FIELDS = %i[id provider account_id account_email expires_at scopes metadata created_at
+                             updated_at].freeze
+
+          def self.call(connection)
+            connection.slice(*PUBLIC_FIELDS)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubino/api/operations/runs/create_operation.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Rubino
+  module API
+    module Operations
+      module Runs
+        # POST /v1/sessions/:id/runs
+        # Persists a new run for the session and hands it to the executor.
+        # The run is reported as "running" immediately; clients tail
+        # /v1/runs/:id/events for state transitions.
+        #
+        # @return [[Integer, Hash]] 201 + run payload.
+        # @raise [Rubino::NotFoundError] when the parent session does not exist.
+        # @raise [Rubino::ValidationError] when the body fails Schemas::CreateRun.
+        class CreateOperation
+          def self.call(request)
+            new.call(request)
+          end
+
+          # Accepts alternate collaborators (session repo, run repo, executor) for tests.
+          def initialize(session_repository: nil, run_repository: nil, executor: nil)
+            @session_repo = session_repository || ::Rubino::Session::Repository.new
+            @run_repo = run_repository || ::Rubino::Run::Repository.new
+            @executor = executor || ::Rubino::Run::Executor.new
+          end
+
+          def call(request)
+            session_id = request.params.fetch("id")
+            raise NotFoundError.new("session", session_id) unless @session_repo.find(session_id)
+
+            attrs = request.validate!(Schemas::CreateRun)
+            ensure_input_or_attachments!(attrs)
+            run = @run_repo.create(
+              session_id: session_id,
+              input_text: attrs[:input],
+              attachments: attrs[:attachments] || [],
+              skills: attrs[:skills] || [],
+              model: attrs[:model],
+              provider: attrs[:provider]
+            )
+
+            @executor.start(run)
+
+            [201, serialize(run)]
+          end
+
+          private
+
+          # A run needs SOMETHING to act on: either text or at least one
+          # attachment (image-only runs are valid — the executor fills in a
+          # default prompt). The schema allows a blank/absent `input`, so this
+          # is where the "input present OR attachments present" rule lives.
+          # Reproduces the prior schema's 422 shape so an empty, attachment-less
+          # body still fails as `input: ["must be filled"]`.
+          def ensure_input_or_attachments!(attrs)
+            return if attrs[:input].to_s.strip != ""
+            return if Array(attrs[:attachments]).any?
+
+            raise ValidationError.new(
+              "invalid request body",
+              details: { errors: { input: ["must be filled"] } }
+            )
+          end
+
+          def serialize(run)
+            {
+              id: run[:id],
+              session_id: run[:session_id],
+              status: "running",
+              created_at: run[:created_at]
+            }
+          end
+        end
+      end
+    end
+  end
+end