relay.app 0.1.0

data/app/init/database.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Relay::Database
+  extend self
+
+  ##
+  # Loads the database config for the given environment.
+  # @param [String] env
+  # @return [Hash]
+  def load(env:)
+    erb = ERB.new(File.read(File.join(__dir__, "..", "..", "db", "config.yml")))
+    config = YAML.safe_load(erb.result, aliases: true)
+    config.fetch(env)
+  end
+
+  ##
+  # Establishes a Sequel connection for the configured environment.
+  # @param [String] env
+  # @return [Sequel::Database]
+  def connect!(env:)
+    settings = load(env:)
+    adapter = settings.fetch("adapter")
+    database = settings.fetch("database")
+    adapter = "sqlite" if adapter == "sqlite3"
+    database = File.expand_path(database, Relay.home) unless database.start_with?("/")
+    Sequel.connect(
+      adapter:,
+      database:,
+      max_connections: settings.fetch("pool", 5),
+      pool_timeout: settings.fetch("timeout", 5000) / 1000.0
+    )
+  end
+end
+
+Relay::DB = Relay::Database.connect!(env: Relay.environment)
+Sequel::Model.db = Relay::DB

data/app/init/env.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "securerandom"
+
+env = Relay.env_path
+if File.readable?(env)
+  data = File.read(env)
+  lines = data.each_line
+  lines.each do |line|
+    k, v = line.split("=")
+    ENV[k] = v.chomp
+  end
+end
+
+if ENV["SESSION_SECRET"].to_s.empty?
+  FileUtils.mkdir_p Relay.home
+  ENV["SESSION_SECRET"] = SecureRandom.hex(64)
+  File.write(env, "", mode: "a") unless File.exist?(env)
+  File.write(env, "SESSION_SECRET=#{ENV["SESSION_SECRET"]}\n", mode: "a")
+end

data/app/init/router.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module Relay
+  class Router < Roda
+    include Relay::Concerns::Attachment
+    include Relay::Concerns::Context
+    include Relay::Concerns::View
+
+    ##
+    # Plugins
+    plugin :common_logger
+
+    plugin :sessions,
+      key: "relay.session",
+      secret: ENV["SESSION_SECRET"]
+
+    plugin :partials,
+      assume_fixed_locals: Relay.production?,
+      check_template_mtime: !Relay.production?,
+      escape: true,
+      layout: "layout",
+      views: File.expand_path("../views", __dir__)
+
+    ##
+    # Routes
+    route do |r|
+      r.root do
+        Pages::Chat.new(self).call
+      end
+
+      r.is "sign-in" do
+        r.get do
+          Pages::SignIn.new(self).call
+        end
+
+        r.post do
+          Routes::SignIn.new(self).call
+        end
+      end
+
+      r.get true do
+        r.redirect "/"
+      end
+
+      r.is "mcps" do
+        r.get do
+          Routes::ListMCP.new(self).call
+        end
+
+        r.post do
+          Routes::MCP::Create.new(self).call
+        end
+      end
+
+      r.is "mcps", "new" do
+        r.get do
+          Routes::MCP::New.new(self).call
+        end
+      end
+
+      r.is "mcps", "form" do
+        r.post do
+          Routes::MCP::Form.new(self).call
+        end
+      end
+
+      r.on "mcps", Integer do |id|
+        r.get do
+          Routes::MCP::Show.new(self).call(id)
+        end
+
+        r.is "toggle" do
+          r.post do
+            Routes::MCP::Toggle.new(self).call(id)
+          end
+        end
+
+        r.is "delete" do
+          r.post do
+            Routes::MCP::Delete.new(self).call(id)
+          end
+        end
+
+        r.post do
+          Routes::MCP::Update.new(self).call(id)
+        end
+      end
+
+      r.on "settings" do
+        r.is "set-model" do
+          Routes::Settings::SetModel.new(self).call
+        end
+
+        r.is "set-context" do
+          Routes::Settings::SetContext.new(self).call
+        end
+
+        r.is "new-context" do
+          Routes::Settings::NewContext.new(self).call
+        end
+
+        r.is "set-provider" do
+          Routes::Settings::SetProvider.new(self).call
+        end
+      end
+
+      r.on "api" do
+        r.is "ws" do
+          throw :halt, Routes::Websocket.new(self).call
+        end
+      end
+
+      r.is "models" do
+        r.get do
+          Routes::ListModels.new(self).call
+        end
+      end
+
+      r.is "providers" do
+        r.get do
+          Routes::ListProviders.new(self).call
+        end
+      end
+
+      r.is "controls" do
+        r.get do
+          Routes::ListControls.new(self).call
+        end
+      end
+
+      r.is "chat" do
+        r.get do
+          Routes::ListChat.new(self).call
+        end
+      end
+
+      r.is "contexts" do
+        r.get do
+          Routes::ListContexts.new(self).call
+        end
+      end
+
+      r.is "tools" do
+        r.get do
+          Routes::ListTools.new(self).call
+        end
+      end
+
+      r.is "upload-attachment" do
+        r.post do
+          Routes::UploadAttachment.new(self).call
+        end
+      end
+
+      r.is "clear-attachment" do
+        r.post do
+          Routes::ClearAttachment.new(self).call
+        end
+      end
+
+    end
+
+  end
+end

data/app/models/context.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Relay::Models
+  ##
+  # The {Relay::Models::Context} model stores the accumulated model
+  # context for a user, provider, and model combination. It persists
+  # the underlying {LLM::Session} state as JSON in the "data" column
+  # so future turns can continue from the same context window.
+  class Context < Sequel::Model
+    include Relay::Model
+    plugin :llm, provider: :set_provider, context: :set_context, tracer: :set_tracer
+
+    set_dataset :contexts
+    many_to_one :user
+
+    ##
+    # @return [String, nil]
+    #  Returns the first persisted user message content.
+    def title
+      ctx.messages.find(&:user?)&.content
+    end
+
+    ##
+    # @return [Array<Relay::Models::MCP>]
+    #  Enabled MCP servers for this context's user.
+    def mcps
+      user ? user.mcps_dataset.where(enabled: true).all : []
+    end
+
+    ##
+    # @return [LLM::Compactor]
+    #  Returns the runtime compactor for the persisted context.
+    def compactor
+      ctx.compactor
+    end
+
+    ##
+    # @return [Boolean]
+    #  Returns true when the underlying llm.rb context is in a
+    #  post-compaction state.
+    def compacted?
+      ctx.compacted?
+    end
+
+    ##
+    # @note
+    #  This method excludes tool calls and system messages.
+    #  It is safe to render in the UI.
+    # @return [Array<Hash>]
+    #  Returns persisted user and assistant messages
+    def messages
+      ctx.messages.filter_map do |message|
+        next if message.tool_call? || message.compaction?
+        next unless message.user? || message.assistant?
+        {role: message.role.to_sym, content: message.content.to_s}
+      end
+    end
+
+    ##
+    # @return [Integer]
+    def context_window
+      super
+    rescue LLM::NoSuchModelError, LLM::NoSuchRegistryError
+      0
+    end
+
+    private
+
+    def set_provider
+      LLM.method(provider).call(key: ENV["#{provider.upcase}_SECRET"], persistent: true)
+    end
+
+    def set_context
+      { model: self[:model], compactor: { retention_window: 8, token_threshold: "95%" } }
+    end
+
+    def set_tracer
+      path = File.join(Relay.logs_dir, "#{provider}-#{Date.today.iso8601}.log")
+      LLM::Tracer::Logger.new(llm, path:)
+    end
+  end
+end

data/app/models/mcp/preset.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Relay::Models
+  ##
+  # The {Relay::Models::MCP::Preset} module defines the preset catalog
+  # and compilation rules for Relay MCP servers.
+  module MCP::Preset
+    extend self
+
+    PRESETS = {
+      "github" => {
+        id: "github",
+        title: "GitHub",
+        summary: "Connect GitHub with a single token.",
+        transport: "http",
+        data: {"preset" => "github", "url" => "https://api.githubcopilot.com/mcp/", "headers" => {}},
+        description: "Uses GitHub's hosted MCP endpoint with a Bearer token."
+      },
+      "forgejo" => {
+        id: "forgejo",
+        title: "Forgejo",
+        summary: "Connect a Forgejo instance with URL and token.",
+        transport: "stdio",
+        data: {"preset" => "forgejo", "argv" => ["forgejo-mcp"], "cwd" => "", "env" => {}},
+        description: "Requires Forgejo support to be installed on this Relay host."
+      }
+    }.freeze
+
+    ##
+    # @return [Array<Hash>]
+    #  Returns all visible MCP presets
+    def all
+      PRESETS.values
+    end
+
+    ##
+    # @param [String, Symbol] id
+    #  The MCP preset id
+    # @return [Hash, nil]
+    #  Returns the preset definition for the given id
+    def [](id)
+      PRESETS[id.to_s]
+    end
+
+    ##
+    # @param [Relay::Forms::MCP] form
+    #  The preset-specific MCP form
+    # @return [Hash]
+    #  The persisted MCP model attributes for the preset
+    def attributes_for(form)
+      preset = self[form.preset]
+      {
+        name: preset[:title],
+        description: "",
+        transport: preset[:transport],
+        data: preset[:data].merge(form.data)
+      }
+    end
+  end
+end

data/app/models/mcp.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+module Relay::Models
+  class MCP < Sequel::Model
+    include Relay::Model
+    plugin :validation_class_methods
+
+    set_dataset :mcps
+    many_to_one :user
+    validates_presence_of :user_id, :name, :transport
+    validates_inclusion_of :transport, in: %w[stdio http]
+
+    SUMMARY_COLUMNS = %i[
+      id
+      user_id
+      name
+      description
+      transport
+      enabled
+      created_at
+      updated_at
+    ].freeze
+
+    def self.dump_data(data)
+      JSON.generate(data)
+    end
+
+    def self.load_data(data)
+      case data
+      when String then JSON.parse(data)
+      when Hash, Array then data
+      else {}
+      end
+    rescue JSON::ParserError
+      {}
+    end
+
+    def self.summary_dataset(dataset = self.dataset)
+      dataset.select(*SUMMARY_COLUMNS)
+    end
+
+    def self.normalize_url(value)
+      url = value.to_s.strip
+      return "" if url.empty?
+      uri = URI.parse(url)
+      uri.path = "/" if uri.path.to_s.empty?
+      uri.to_s
+    rescue URI::InvalidURIError
+      url
+    end
+
+    ##
+    # @return [Hash]
+    #  Returns the parsed MCP transport data
+    def data
+      self.class.load_data(self[:data])
+    end
+
+    ##
+    # @group stdio
+
+    ##
+    # @return [Array<String>]
+    #  Returns the stdio command argv
+    def argv
+      transport == "stdio" ? data["argv"] || [] : []
+    end
+
+    ##
+    # @return [String]
+    #  Returns the stdio executable name
+    def command
+      argv.first.to_s
+    end
+
+    ##
+    # @return [Array<String>]
+    #  Returns the stdio command arguments
+    def arguments
+      argv.drop(1)
+    end
+
+    ##
+    # @return [Hash]
+    #  Returns the stdio environment variables
+    def env
+      transport == "stdio" ? data["env"] || {} : {}
+    end
+
+    ##
+    # @return [String]
+    #  Returns the stdio working directory
+    def cwd
+      transport == "stdio" ? data["cwd"].to_s : ""
+    end
+    # @endgroup
+
+    ##
+    # @group HTTP
+
+    ##
+    # @return [String]
+    #  Returns the MCP HTTP endpoint URL
+    def url
+      self.class.normalize_url(transport == "http" ? data["url"] : nil)
+    end
+
+    ##
+    # @return [Hash]
+    #  Returns the MCP HTTP headers
+    def headers
+      transport == "http" ? data["headers"] || {} : {}
+    end
+    # @endgroup
+
+    ##
+    # @return [Array<Class<LLM::Tool>>]
+    #  Returns the cached MCP tool classes
+    def tools
+      @tools ||= mcp.tools
+    end
+
+    ##
+    # @return [void]
+    #  Starts the MCP client
+    def start
+      mcp.start
+    end
+
+    ##
+    # @return [void]
+    #  Stops the MCP client
+    def stop
+      mcp.stop
+    end
+
+    private
+
+    def before_validation
+      super
+      self[:data] = self.class.dump_data(self[:data]) unless String === self[:data]
+    end
+
+    def validate
+      super
+      Relay::Validators::MCP.new(self).call
+    end
+
+    ##
+    # Builds an {LLM::MCP} instance from the persisted transport settings.
+    #
+    # For `http` transports this returns an HTTP-backed MCP client using
+    # {#url} and {#headers}. For `stdio` transports it returns a stdio-backed
+    # MCP client using {#argv}, {#env}, and {#cwd}.
+    #
+    # @return [LLM::MCP]
+    def mcp
+      @mcp ||= if transport == "http"
+        LLM::MCP.http(url:, headers:)
+      else
+        LLM::MCP.stdio(argv:, env:, cwd: cwd.empty? ? nil : cwd)
+      end
+    end
+  end
+end

data/app/models/model_record.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Relay::Models
+  class ModelRecord < Sequel::Model
+    include Relay::Model
+    plugin :validation_class_methods
+
+    set_dataset :model_records
+
+    validates_presence_of :provider
+    validates_presence_of :model_id
+    validates_presence_of :name
+    validates_presence_of :synced_at
+
+    ##
+    # Refreshes model records for every configured provider.
+    #
+    # Each provider builder is initialized and then passed through
+    # {refresh} to replace its persisted model rows.
+    #
+    # @return [void]
+    def self.refresh_all
+      Relay.providers.each do |_, provider|
+        provider = provider.call
+        refresh(provider)
+      rescue LLM::Error
+        next
+      end
+    end
+
+    ##
+    # Replaces all stored model metadata for a provider in one transaction.
+    #
+    # Existing rows for the provider are deleted before the new rows are
+    # inserted. An empty provider model list clears the provider's stored
+    # model metadata.
+    #
+    # @param [LLM::Provider] provider
+    # @return [void]
+    def self.refresh(provider)
+      now = Time.now.utc
+      name = provider.name.to_s
+      db.transaction do
+        where(provider: name).delete
+        models = provider.models.all.filter_map do
+          next unless _1.chat?
+          {
+            provider: name,
+            model_id: _1.id,
+            name: _1.name.to_s,
+            data: JSON.dump(_1.to_h),
+            synced_at: now,
+            created_at: now,
+            updated_at: now
+          }
+        end
+        multi_insert(models) unless models.empty?
+      end
+    end
+
+    ##
+    # @return [Hash]
+    #  Returns the parsed model metadata payload.
+    def data
+      @data ||= JSON.parse(self[:data])
+    rescue JSON::ParserError
+      {}
+    end
+  end
+end

data/app/models/song.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Relay::Models
+  class Song < Sequel::Model
+    include Relay::Model
+    plugin :validation_class_methods
+
+    set_dataset :songs
+    validates_presence_of :name, :title, :track
+  end
+end

data/app/models/user.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Relay::Models
+  class User < Sequel::Model
+    include Relay::Model
+
+    set_dataset :users
+    one_to_many :contexts
+    one_to_many :mcps, class: "Relay::Models::MCP"
+
+    ##
+    # Hashes and stores the given password.
+    # @param [String] value
+    def password=(value)
+      @password = value
+      self.password_digest = BCrypt::Password.create(value)
+    end
+
+    ##
+    # Authenticates the given plaintext password.
+    # @param [String] value
+    # @return [Relay::Models::User,false]
+    def authenticate(value)
+      return false if password_digest.to_s.empty?
+
+      BCrypt::Password.new(password_digest) == value && self
+    rescue BCrypt::Errors::InvalidHash
+      false
+    end
+  end
+end

data/app/pages/base.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Relay::Pages
+  ##
+  # Base class for full-page renderers.
+  class Base
+    include Relay::Models
+    include Relay::Concerns::Attachment
+    include Relay::Concerns::Context
+    include Relay::Concerns::Roda
+    include Relay::Concerns::View
+
+    private
+
+    ##
+    # Renders a page template with the shared layout.
+    # @param [String] name
+    # @param [Hash] locals
+    # @return [String]
+    def page(name, **locals)
+      view(File.join("pages", name), locals:, layout_opts: {locals:})
+    end
+
+  end
+end

data/app/pages/chat.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Relay::Pages
+  ##
+  # Renders the chat page.
+  class Chat < Base
+    prepend Relay::Hooks::RequireUser
+
+    ##
+    # @return [String]
+    def call
+      response["content-type"] = "text/html"
+      session["provider"] ||= "deepseek"
+      session["model"] ||= default_model
+      page("chat", title: "Relay", messages: ctx.messages)
+    end
+  end
+end

data/app/pages/mcp.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Relay::Pages
+  class MCP < Base
+    prepend Relay::Hooks::RequireUser
+
+    def call(form:, selected_id: nil)
+      response["content-type"] = "text/html"
+      page("mcps", title: "Relay MCP", form:, selected_id:)
+    end
+  end
+end