rubino-agent 0.3.0

data/lib/rubino/api/operations/cron_jobs/delete_operation.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Rubino
+  module API
+    module Operations
+      module CronJobs
+        # DELETE /v1/jobs/:id
+        # Unschedules the cron job from the in-process scheduler before deleting
+        # the row, so no stray ticks fire post-delete.
+        #
+        # @return [[Integer, Hash]] 204 No Content.
+        # @raise [Rubino::NotFoundError] when the cron job does not exist.
+        class DeleteOperation
+          def self.call(request)
+            new.call(request)
+          end
+
+          # Accepts an alternate repository and scheduler for tests.
+          def initialize(repository: nil, scheduler: nil)
+            @repository = repository || ::Rubino::Jobs::CronJobRepository.new
+            @scheduler = scheduler || ::Rubino::Jobs::Scheduler.instance
+          end
+
+          def call(request)
+            id = request.params.fetch("id")
+            raise NotFoundError.new("cron_job", id) unless @repository.find(id)
+
+            @scheduler.unschedule(id)
+            @repository.destroy!(id)
+            Responses.no_content
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Rubino
+  module API
+    module Operations
+      module CronJobs
+        # GET /v1/jobs
+        # Lists cron jobs. Disabled jobs are included by default; pass
+        # ?include_disabled=false to hide them.
+        class ListOperation
+          def self.call(request)
+            new.call(request)
+          end
+
+          # Accepts an alternate repository for tests.
+          def initialize(repository: nil)
+            @repository = repository || ::Rubino::Jobs::CronJobRepository.new
+          end
+
+          def call(request)
+            include_disabled = request.query["include_disabled"] != "false"
+            jobs = @repository.list(include_disabled: include_disabled).map { |j| Serializer.call(j) }
+            [200, jobs]
+          end
+        end
+
+        # Shared serializer used by every CronJobs operation so the wire shape
+        # (and the JSON-decoded skills array) stays consistent.
+        module Serializer
+          module_function
+
+          def call(job)
+            {
+              id: job[:id],
+              name: job[:name],
+              schedule: job[:schedule],
+              prompt: job[:prompt],
+              skills: job[:skills_json] ? JSON.parse(job[:skills_json]) : [],
+              model: job[:model],
+              provider: job[:provider],
+              deliver: job[:deliver],
+              enabled: job[:enabled] == true,
+              last_run_at: job[:last_run_at],
+              last_run_id: job[:last_run_id],
+              created_at: job[:created_at],
+              updated_at: job[:updated_at]
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubino/api/operations/cron_jobs/pause_operation.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Rubino
+  module API
+    module Operations
+      module CronJobs
+        # POST /v1/jobs/:id/pause
+        # Flips enabled=false on the cron job and unschedules its tick. Idempotent.
+        #
+        # @raise [Rubino::NotFoundError] when the cron job does not exist.
+        class PauseOperation
+          def self.call(request)
+            new.call(request)
+          end
+
+          # Accepts an alternate repository and scheduler for tests.
+          def initialize(repository: nil, scheduler: nil)
+            @repository = repository || ::Rubino::Jobs::CronJobRepository.new
+            @scheduler = scheduler || ::Rubino::Jobs::Scheduler.instance
+          end
+
+          def call(request)
+            id = request.params.fetch("id")
+            raise NotFoundError.new("cron_job", id) unless @repository.find(id)
+
+            updated = @repository.set_enabled(id, enabled: false)
+            @scheduler.unschedule(id)
+            [200, Serializer.call(updated)]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubino/api/operations/cron_jobs/resume_operation.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Rubino
+  module API
+    module Operations
+      module CronJobs
+        # POST /v1/jobs/:id/resume
+        # Flips enabled=true on the cron job and (re)registers its tick. Idempotent.
+        #
+        # @raise [Rubino::NotFoundError] when the cron job does not exist.
+        class ResumeOperation
+          def self.call(request)
+            new.call(request)
+          end
+
+          # Accepts an alternate repository and scheduler for tests.
+          def initialize(repository: nil, scheduler: nil)
+            @repository = repository || ::Rubino::Jobs::CronJobRepository.new
+            @scheduler = scheduler || ::Rubino::Jobs::Scheduler.instance
+          end
+
+          def call(request)
+            id = request.params.fetch("id")
+            raise NotFoundError.new("cron_job", id) unless @repository.find(id)
+
+            updated = @repository.set_enabled(id, enabled: true)
+            @scheduler.schedule(updated)
+            [200, Serializer.call(updated)]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubino/api/operations/cron_jobs/schedule_validation.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "fugit"
+
+module Rubino
+  module API
+    module Operations
+      module CronJobs
+        # Pre-flight cron validation shared by Create/Update (#164). A schedule
+        # Fugit cannot parse must be rejected BEFORE the row is persisted: a
+        # committed bad row used to 500 the request AND poison the next boot
+        # (Scheduler#load_all! raised on it and the server never bound).
+        module ScheduleValidation
+          private
+
+          def validate_schedule!(schedule)
+            return if schedule.nil? || Fugit.parse_cron(schedule)
+
+            # Same envelope shape as Request#validate! so clients see one
+            # canonical 422 format: error.details.errors.<field> => [messages].
+            raise ValidationError.new(
+              "invalid request body",
+              details: { errors: { schedule: ["is not a valid cron expression"] } }
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Rubino
+  module API
+    module Operations
+      module CronJobs
+        # GET /v1/jobs/:id
+        # Fetches a single cron job by id.
+        #
+        # @raise [Rubino::NotFoundError] when the cron job does not exist.
+        class ShowOperation
+          def self.call(request)
+            new.call(request)
+          end
+
+          # Accepts an alternate repository for tests.
+          def initialize(repository: nil)
+            @repository = repository || ::Rubino::Jobs::CronJobRepository.new
+          end
+
+          def call(request)
+            id = request.params.fetch("id")
+            job = @repository.find(id)
+            raise NotFoundError.new("cron_job", id) unless job
+
+            [200, Serializer.call(job)]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubino/api/operations/cron_jobs/trigger_operation.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Rubino
+  module API
+    module Operations
+      module CronJobs
+        # POST /v1/jobs/:id/trigger
+        # Forces an off-cycle execution of the cron job through the scheduler
+        # and returns the new run/session ids.
+        #
+        # @return [[Integer, Hash]] 202 + { job_id, run_id, session_id }.
+        # @raise [Rubino::NotFoundError] when the cron job does not exist.
+        # @raise [Rubino::ConflictError] when the scheduler refuses to dispatch (returns nil).
+        class TriggerOperation
+          def self.call(request)
+            new.call(request)
+          end
+
+          # Accepts an alternate repository and scheduler for tests.
+          def initialize(repository: nil, scheduler: nil)
+            @repository = repository || ::Rubino::Jobs::CronJobRepository.new
+            @scheduler = scheduler || ::Rubino::Jobs::Scheduler.instance
+          end
+
+          def call(request)
+            id = request.params.fetch("id")
+            raise NotFoundError.new("cron_job", id) unless @repository.find(id)
+
+            run = @scheduler.trigger(id)
+            raise ConflictError, "trigger failed" if run.nil?
+
+            [202, { job_id: id, run_id: run[:id], session_id: run[:session_id] }]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Rubino
+  module API
+    module Operations
+      module CronJobs
+        # PATCH /v1/jobs/:id
+        # Applies a partial update and resyncs the scheduler: always unschedule,
+        # reschedule only when the resulting row is still enabled.
+        #
+        # @raise [Rubino::NotFoundError] when the cron job does not exist.
+        # @raise [Rubino::ValidationError] when the body fails Schemas::UpdateCronJob
+        #   or carries a cron schedule Fugit cannot parse (#164).
+        class UpdateOperation
+          include ScheduleValidation
+
+          def self.call(request)
+            new.call(request)
+          end
+
+          # Accepts an alternate repository and scheduler for tests.
+          def initialize(repository: nil, scheduler: nil)
+            @repository = repository || ::Rubino::Jobs::CronJobRepository.new
+            @scheduler = scheduler || ::Rubino::Jobs::Scheduler.instance
+          end
+
+          def call(request)
+            id = request.params.fetch("id")
+            raise NotFoundError.new("cron_job", id) unless @repository.find(id)
+
+            attrs = request.validate!(Schemas::UpdateCronJob)
+            validate_schedule!(attrs[:schedule])
+            updated = @repository.update(id, attrs)
+            @scheduler.unschedule(id)
+            @scheduler.schedule(updated) if updated[:enabled]
+            [200, Serializer.call(updated)]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubino/api/operations/files/read_operation.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Rubino
+  module API
+    module Operations
+      module Files
+        # GET /v1/files?path=relative/path
+        # Streams raw bytes from a path inside the sandboxed workspace as
+        # application/octet-stream. Path traversal is enforced by the workspace.
+        #
+        # @return [[Integer, Hash, Array<String>]] 200 + octet-stream Rack triple.
+        # @raise [Rubino::ValidationError] when the +path+ query parameter is missing or empty.
+        class ReadOperation
+          def self.call(request)
+            new.call(request)
+          end
+
+          # Accepts an alternate workspace for tests.
+          #
+          # Roots the workspace at the SAME directory the tools sandbox to
+          # (terminal.cwd || Dir.pwd), not config.paths_home. Tools and
+          # attach_file emit absolute paths under that root, so a produced
+          # artifact lives there — rooting at paths_home would make every
+          # such path look like a traversal escape and 422 the download.
+          def initialize(workspace: nil)
+            @workspace = workspace || ::Rubino::Files::Workspace.new(root: ::Rubino::Tools::Base.workspace_root)
+          end
+
+          def call(request)
+            path = request.query["path"]
+            raise ValidationError, "path query parameter is required" if path.nil? || path.empty?
+
+            content = @workspace.read(path)
+            [200, { "content-type" => "application/octet-stream" }, [content]]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubino/api/operations/files/upload_operation.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require "rack/multipart"
+
+module Rubino
+  module API
+    module Operations
+      module Files
+        # POST /v1/files (multipart/form-data, field "file")
+        # Persists a single uploaded file into the sandboxed workspace and
+        # returns its descriptor (id, filename, size).
+        #
+        # Multipart payload is capped at api.max_upload_bytes (default 50 MiB).
+        # The cap is enforced twice: first against the declared Content-Length
+        # (cheap reject before any IO), then by wrapping rack.input so a body
+        # that lies about its size — or omits Content-Length entirely — still
+        # aborts mid-stream before Rack::Multipart can fully buffer it to disk.
+        #
+        # @return [[Integer, Hash]] 201 + descriptor payload.
+        # @raise [Rubino::ValidationError] when the content-type is not multipart or the "file" field is missing.
+        # @raise [Rubino::PayloadTooLargeError] when the body exceeds the cap.
+        class UploadOperation
+          DEFAULT_MAX_UPLOAD_BYTES = 50 * 1024 * 1024
+
+          # Wraps a Rack input stream and raises PayloadTooLargeError once the
+          # cumulative bytes read pass +limit+. Rack::Multipart drives the read
+          # loop, so raising here unwinds straight out of parse_multipart and
+          # the partially-written tempfile is collected by the ensure block
+          # in #call.
+          class CappedInput
+            def initialize(io, limit)
+              @io = io
+              @limit = limit
+              @read = 0
+            end
+
+            def read(length = nil, buffer = nil)
+              chunk = buffer ? @io.read(length, buffer) : @io.read(length)
+              return chunk if chunk.nil?
+
+              @read += chunk.bytesize
+              if @read > @limit
+                raise Rubino::PayloadTooLargeError.new(
+                  "multipart upload exceeds #{@limit} bytes",
+                  details: { limit_bytes: @limit }
+                )
+              end
+
+              chunk
+            end
+
+            # Rack::Multipart::Parser interrogates rewind/eof?/gets on the input;
+            # delegate so the parser is unaware it's wrapped.
+            def rewind
+              @read = 0
+              @io.rewind
+            end
+
+            def eof?
+              @io.eof?
+            end
+
+            def gets(*)
+              line = @io.gets(*)
+              return line if line.nil?
+
+              @read += line.bytesize
+              if @read > @limit
+                raise Rubino::PayloadTooLargeError.new(
+                  "multipart upload exceeds #{@limit} bytes",
+                  details: { limit_bytes: @limit }
+                )
+              end
+
+              line
+            end
+
+            def respond_to_missing?(name, include_private = false)
+              @io.respond_to?(name, include_private) || super
+            end
+
+            def method_missing(name, *, &)
+              return @io.send(name, *, &) if @io.respond_to?(name)
+
+              super
+            end
+          end
+
+          def self.call(request)
+            new.call(request)
+          end
+
+          # Accepts an alternate workspace for tests.
+          #
+          # Roots at the tool workspace (terminal.cwd || Dir.pwd), the same
+          # root tools and attach_file use, so uploaded files land where the
+          # agent can read them back. See ReadOperation for the rationale.
+          def initialize(workspace: nil)
+            @workspace = workspace || ::Rubino::Files::Workspace.new(root: ::Rubino::Tools::Base.workspace_root)
+          end
+
+          def call(request)
+            content_type = request.env["CONTENT_TYPE"].to_s
+            unless content_type.start_with?("multipart/form-data")
+              raise ValidationError,
+                    "content-type must be multipart/form-data"
+            end
+
+            limit = max_upload_bytes
+            declared = request.env["CONTENT_LENGTH"].to_s
+            if !declared.empty? && declared.to_i > limit
+              raise PayloadTooLargeError.new(
+                "multipart upload exceeds #{limit} bytes",
+                details: { limit_bytes: limit }
+              )
+            end
+
+            params = parse_with_cap(request.env, limit)
+            upload = params["file"]
+            raise ValidationError, "missing 'file' field" if upload.nil? || !upload.is_a?(Hash)
+
+            descriptor = @workspace.upload(filename: upload[:filename], io: upload[:tempfile])
+            [201, { id: descriptor[:id], filename: descriptor[:filename], size: descriptor[:size] }]
+          end
+
+          private
+
+          # Wraps rack.input with CappedInput so a mid-stream overflow raises
+          # before Rack::Multipart fully drains the body. On overflow we also
+          # unlink any tempfile the parser already created for the partial
+          # part, so no orphan upload is left under /tmp.
+          def parse_with_cap(env, limit)
+            original = env["rack.input"]
+            return Rack::Multipart.parse_multipart(env) || {} if original.nil?
+
+            capped = CappedInput.new(original, limit)
+            env["rack.input"] = capped
+            begin
+              Rack::Multipart.parse_multipart(env) || {}
+            rescue PayloadTooLargeError
+              cleanup_partial_tempfiles(env)
+              raise
+            ensure
+              env["rack.input"] = original
+            end
+          end
+
+          # Rack::Multipart streams each part to a Tempfile created via
+          # Rack::Multipart::Parser::TEMPFILE_FACTORY. When we abort mid-read
+          # those tempfiles remain on disk because the parser never returned
+          # the descriptor to us. We do not have a handle to them either —
+          # but rack.tempfiles (set by Rack::Multipart::Parser since 2.2) is
+          # the canonical collection. Unlink everything in it.
+          def cleanup_partial_tempfiles(env)
+            tempfiles = env["rack.tempfiles"]
+            return unless tempfiles.is_a?(Array)
+
+            tempfiles.each do |tf|
+              tf.close unless tf.closed?
+              File.unlink(tf.path) if tf.respond_to?(:path) && tf.path && File.exist?(tf.path)
+            rescue StandardError
+              # Best-effort cleanup; we already failed the request.
+            end
+            tempfiles.clear
+          end
+
+          def max_upload_bytes
+            value = Rubino.configuration.dig("api", "max_upload_bytes")
+            value.is_a?(Integer) && value.positive? ? value : DEFAULT_MAX_UPLOAD_BYTES
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Rubino
+  module API
+    module Operations
+      # GET /v1/health — readiness probe.
+      # No auth required (allowlisted in Middleware::Auth::SKIP_PATHS).
+      #
+      # Pings the database and reports scheduler status alongside build info.
+      # Returns 503 if any critical dependency is degraded; never raises.
+      #
+      # @return [[Integer, Hash]] 200 when all deps are ok, 503 otherwise.
+      class HealthOperation
+        def self.call(_request)
+          new.call
+        end
+
+        def call
+          deps = { db: db_status, scheduler: scheduler_status }
+          status = deps.values.all? { |s| s[:status] == "ok" } ? 200 : 503
+          [status, {
+            status: status == 200 ? "ok" : "degraded",
+            version: Rubino::VERSION,
+            deps: deps
+          }]
+        end
+
+        private
+
+        def db_status
+          Rubino.database.db.test_connection
+          { status: "ok" }
+        rescue StandardError => e
+          { status: "down", error: e.class.name }
+        end
+
+        def scheduler_status
+          scheduler = ::Rubino::Jobs::Scheduler.instance
+          { status: "ok", scheduled_jobs: scheduler.scheduled_count }
+        rescue StandardError => e
+          { status: "down", error: e.class.name }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Rubino
+  module API
+    module Operations
+      module Memory
+        # DELETE /v1/memory/:id
+        # Forgets one fact by id (id-prefix match, mirroring the CLI).
+        #
+        # @return [[Integer, Hash]] 204 No Content.
+        # @raise [Rubino::NotFoundError] when no fact matches the id.
+        class DeleteOperation
+          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)
+            id = request.params.fetch("id")
+            raise NotFoundError.new("memory", id) unless @backend.delete(id)
+
+            Responses.no_content
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Rubino
+  module API
+    module Operations
+      module Memory
+        # GET /v1/memory
+        # Lists stored facts from the active memory backend, newest first.
+        #
+        # `?q=` filters to facts whose content matches the query (case-insensitive
+        # substring). The match is applied at the API layer over the backend's
+        # admin #list so it works identically for every backend — the backends'
+        # own #retrieve is session/turn-relevance scoped and char-budget capped,
+        # which is the wrong shape for a flat admin listing.
+        #
+        # `?limit=` / `?offset=` paginate the (optionally filtered) result.
+        class IndexOperation
+          DEFAULT_LIMIT = 50
+          MAX_LIMIT     = 200
+          # Window pulled from the backend before filter+paginate. Generous
+          # enough to page through a normal store; the backend keeps its own
+          # newest-first ordering.
+          WINDOW        = 1000
+
+          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)
+            limit  = clamp(request.query["limit"], DEFAULT_LIMIT, MAX_LIMIT)
+            offset = [request.query["offset"].to_i, 0].max
+            q      = request.query["q"].to_s.strip
+
+            rows = @backend.list(limit: WINDOW)
+            rows = filter(rows, q) unless q.empty?
+
+            page = rows.slice(offset, limit) || []
+            [200, { memory: page.map { |row| Serializer.call(row) } }]
+          end
+
+          private
+
+          def filter(rows, q)
+            needle = q.downcase
+            rows.select { |row| row[:content].to_s.downcase.include?(needle) }
+          end
+
+          def clamp(raw, default, max)
+            n = raw.to_i
+            return default if n <= 0
+
+            [n, max].min
+          end
+        end
+
+        # Shared serializer for the memory surface. Backends differ slightly in
+        # the rows they return (the sqlite backend omits :updated_at), so every
+        # field is read defensively and absent ones serialize to null.
+        module Serializer
+          module_function
+
+          def call(row)
+            {
+              id: row[:id],
+              kind: row[:kind],
+              content: row[:content],
+              created_at: row[:created_at],
+              updated_at: row[:updated_at]
+            }
+          end
+        end
+      end
+    end
+  end
+end