relay.app 0.1.0

data/lib/relay/markdown.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Relay
+  require "redcarpet"
+
+  ##
+  # Renders markdown to HTML
+  # @param [String] text
+  #  The markdown source
+  # @return [String]
+  def self.markdown(text)
+    renderer.render(text.to_s.gsub(/\r\n?/, "\n"))
+  end
+
+  ##
+  # @return [Redcarpet::Markdown]
+  #  Returns the shared markdown renderer
+  def self.renderer
+    Redcarpet::Markdown.new(
+      Markdown.new(filter_html: false, safe_links_only: true),
+      autolink: true,
+      fenced_code_blocks: true,
+      lax_spacing: true,
+      no_intra_emphasis: true,
+      tables: true
+    )
+  end
+
+  class Markdown < Redcarpet::Render::HTML
+    require "erb"
+    include ERB::Util
+    ##
+    # Renders fenced code blocks with a language class for highlight.js
+    # @param [String] code
+    #  The code block contents
+    # @param [String, nil] language
+    #  The fenced code language
+    # @return [String]
+    def block_code(code, language)
+      language = language.to_s.strip
+      language = "plaintext" if language.empty?
+      %(<pre><code class="language-#{h(language)}">#{h(code)}</code></pre>)
+    end
+  end
+end

data/lib/relay/model.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Relay
+  module Model
+    def self.included(model)
+      model.plugin :timestamps,
+        create: :created_at,
+        update: :updated_at,
+        update_on_create: true
+    end
+  end
+end

data/lib/relay/reloader.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Relay
+  ##
+  # Reloads Zeitwerk-managed application code on each request in
+  # development before passing control to the downstream Rack app.
+  class Reloader
+    ##
+    # @param [#call] app
+    # @return [Relay::Reloader]
+    def initialize(app)
+      @app = app
+    end
+
+    ##
+    # @param [Hash] env
+    # @return [Array(Integer, Hash, #each)]
+    def call(env)
+      reload!
+      @app.call(env)
+    end
+
+    private
+
+    def reload!
+      Relay.reload
+    end
+  end
+end

data/lib/relay/task.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+##
+# {Relay::Task} represents a Rake task that can be run
+# in a separate process. The process becomes a group leader,
+# so that if it spawns any child processes, they will be in
+# the same process group.
+#
+# A task provides its status through a channel, which can be
+# either "success" or "error" depending on whether the task
+# completed successfully or not.
+class Relay::Task
+  require "xchan"
+
+  ##
+  # @return [Chan::UNIXSocket]
+  attr_reader :ch
+
+  ##
+  # @return [Integer]
+  attr_reader :pid
+
+  ##
+  # @param [String] task
+  #  The name of the Rake task to run
+  # @return [void]
+  def initialize(task)
+    @task = task
+    @ch = xchan(:pure)
+    @pid = nil
+  end
+
+  ##
+  # Call the task in a separate process
+  # @return [Integer]
+  #  The PID of the child process
+  def call
+    @pid = fork do
+      become_group_leader
+      invoke_task
+      record_success
+    rescue
+      record_error
+    end
+  end
+
+  ##
+  # Read the status of a task (non-blocking)
+  # @raise [Chan::WaitReadable]
+  #   When the channel is not ready to be read
+  # @return [String]
+  #  Either "success" or "error"
+  def status
+    return @status if defined?(@status)
+    @status = ch.recv_nonblock
+  end
+
+  private
+
+  def become_group_leader = Process.setpgrp
+  def invoke_task = Rake::Task[@task].invoke
+
+  def record(status) = @ch.send(status)
+  def record_success = record("success")
+  def record_error = record("error")
+end

data/lib/relay/task_monitor.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+##
+# A task monitor that runs a list of tasks in parallel
+# and monitors them afterwards. When a task fails, the
+# monitor will exit and kill all other tasks.
+#
+# A {Relay::Task} becomes a process group leader, so killing
+# the process group will kill all processes in the group which
+# includes the task and all of its subprocesses.
+class Relay::TaskMonitor
+  ##
+  # @param [Array<String>] tasks
+  #  A list of task names
+  # @return [Relay::TaskMonitor]
+  def initialize(tasks:)
+    @tasks = tasks.map { Relay::Task.new(_1) }
+    @pids = []
+  end
+
+  ##
+  # Assign a block that is run before tasks are forked
+  # @return [void]
+  def prefork(&block)
+    @prefork = block
+  end
+
+  ##
+  # Start the task monitor
+  # @return [void]
+  def monitor
+    @prefork&.call
+    run
+    wait
+  rescue Interrupt
+    @pids.each { Process.kill("TERM", -_1) }
+    wait
+  end
+
+  private
+
+  ##
+  # Run all tasks in parallel and monitor their status
+  # @return [void]
+  def run
+    @pids = @tasks.map(&:call)
+    @tasks.each do |task|
+      if error?(task.status)
+        break(@tasks.size - 1)
+      end
+    rescue Chan::WaitReadable
+      sleep 0.05
+      retry
+    end
+  end
+
+  ##
+  # Wait for all tasks to finish
+  # @return [void]
+  def wait
+    @pids.each { Process.wait(_1) }
+  end
+
+  ##
+  # Read the status of a task
+  # @param [String] status
+  #   Either "success" or "error"
+  # @return [Boolean]
+  def error?(status)
+    case status
+    when "error"
+      @tasks.each do
+        Process.kill("TERM", -_1.pid)
+      rescue Errno::ESRCH
+      end
+      true
+    when "success" then false
+    end
+  end
+end

data/lib/relay/test.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Relay
+  class Test < Test::Unit::TestCase
+    include Rack::Test::Methods
+
+    def app
+      Relay::Router.freeze.app
+    end
+  end
+end

data/lib/relay/theme.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Relay
+  THEME = "dark"
+end

data/lib/relay/tool.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Relay
+  module Tool
+    ##
+    # Returns the root directory of the project
+    # @return [String]
+    def root
+      File.realpath File.join(__dir__, "..", "..")
+    end
+  end
+end

data/lib/relay/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Relay
+  VERSION = "0.1.0"
+end

data/lib/relay.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+module Relay
+  require_relative "relay/version"
+  require_relative "relay/cache"
+  require_relative "relay/attachment"
+  require_relative "relay/jukebox"
+  require_relative "relay/markdown"
+  require_relative "relay/theme"
+  require_relative "relay/task_monitor"
+  require_relative "relay/task"
+  require_relative "relay/tool"
+  require_relative "relay/model"
+  require_relative "relay/reloader"
+
+  PROVIDERS = {
+    "anthropic" => -> { LLM.anthropic(key: ENV["ANTHROPIC_SECRET"]) },
+    "deepseek" => -> { LLM.deepseek(key: ENV["DEEPSEEK_SECRET"]) },
+    "google" => -> { LLM.google(key: ENV["GOOGLE_SECRET"]) },
+    "openai" => -> { LLM.openai(key: ENV["OPENAI_SECRET"]) },
+    "xai" => -> { LLM.xai(key: ENV["XAI_SECRET"]) }
+  }.freeze
+  private_constant :PROVIDERS
+
+  ##
+  # @return [String]
+  def self.banner
+    " ____      _             \n" \
+    "|  _ \\ ___| | __ _ _   _ \n" \
+    "| |_) / _ \\ |/ _` | | | |\n" \
+    "|  _ <  __/ | (_| | |_| |\n" \
+    "|_| \\_\\___|_|\\__,_|\\__, |\n" \
+    "                   |___/ \n\n"
+  end
+
+  ##
+  # Returns all known providers
+  # @return [LLM::Object]
+  def self.providers
+    @providers ||= LLM::Object.from(PROVIDERS)
+  end
+
+  ##
+  # Returns the current Rack environment
+  # @return [String]
+  def self.environment
+    ENV["RACK_ENV"] || "development"
+  end
+
+  ##
+  # Returns true when running in development
+  # @return [Boolean]
+  def self.development?
+    environment == "development"
+  end
+
+  ##
+  # Returns true when running in production
+  # @return [Boolean]
+  def self.production?
+    environment == "production"
+  end
+
+  ##
+  # Returns an object that can be used to store application state
+  # that should persist between requests.
+  # @return [Relay::InMemoryCache]
+  def self.cache
+    @cache
+  end
+  @cache = Cache::InMemoryCache.new
+
+  ##
+  # Returns the root path of the application
+  # @return [String]
+  def self.root
+    @root ||= File.realpath File.join(__dir__, "..")
+  end
+
+  ##
+  # Returns the writable Relay home directory
+  # @return [String]
+  def self.home
+    @home ||= ENV["RELAY_HOME"] || File.join(Dir.home, ".relay")
+  end
+
+  ##
+  # Returns the path to the Relay env file
+  # @return [String]
+  def self.env_path
+    @env_path ||= File.join(home, "env")
+  end
+
+  ##
+  # @return [Array<String>]
+  #  Returns the tools directory
+  def self.tools_dir
+    @tools_dir ||= File.join(root, "app", "tools")
+  end
+
+  ##
+  # Returns the path to the public/ directory
+  # @return [String]
+  def self.public_dir
+    @public_dir ||= File.join(root, "public")
+  end
+
+  ##
+  # Returns the path to generated images
+  # @return [String]
+  def self.images_dir
+    @images_dir ||= File.join(home, "g")
+  end
+
+  ##
+  # Returns the path to the app/assets/ directory
+  # @return [String]
+  def self.assets_dir
+    @assets_dir ||= File.join(root, "app", "assets")
+  end
+
+  ##
+  # @return [String]
+  # Returns the path to the app/views/resources directory
+  def self.resources_dir
+    @resources_dir ||= File.join(root, "app", "resources")
+  end
+
+  ##
+  # Returns the path to the app/views/ directory
+  # @return [String]
+  def self.views_dir
+    @views_dir ||= File.join(root, "app", "views")
+  end
+
+  ##
+  # Returns the path to the db/migrate directory
+  # @return [String]
+  def self.migrations_dir
+    @migrations_dir ||= File.join(root, "db", "migrate")
+  end
+
+  ##
+  # Returns the path to the app/views/fragments directory
+  # @return [String]
+  def self.fragments_dir
+    @fragments_dir ||= File.join(views_dir, "fragments")
+  end
+
+  ##
+  # @return [String]
+  def self.logs_dir
+    @logs_dir ||= File.join(home, "tmp")
+  end
+
+  ##
+  # Renders an erb template
+  # @param [String] path
+  # @param [Hash] locals
+  # @return [String]
+  def self.erb(path, locals = {})
+    tmpl = File.read File.join(views_dir, path)
+    ERB.new(tmpl).result_with_hash(locals)
+  end
+
+  ##
+  # Reload Relay (useful in development enviroments)
+  # @param [Boolean] reload
+  # @return [Array<String>]
+  def self.reload
+    LLM::Tool.clear_registry!
+    Relay.loader.reload
+    paths = Dir[File.join(tools_dir, "*.rb")]
+    paths.concat Dir[File.join(home, "tools", "*.rb")]
+    paths.sort.each do
+      load(_1)
+    rescue => ex
+      warn "tool error\n"
+            "#{ex.class}: #{ex.message}\n"
+            "#{ex.backtrace.join("\n")}"
+    end
+  end
+end

data/libexec/relay/bootstrap

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "relay"
+require File.join(Relay.root, "app", "init")
+warn "relay: bootstrap the database"
+Sequel.extension :migration
+Sequel::Migrator.run(Relay::DB, Relay.migrations_dir)
+load File.join(Relay.root, "db", "seeds.rb")
+Relay::Models::ModelRecord.refresh_all

data/libexec/relay/configure

@@ -0,0 +1,100 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "relay"
+require "fileutils"
+require "io/console"
+
+PROVIDER_KEYS = {
+  "OPENAI_SECRET" => "OpenAI API key",
+  "GOOGLE_SECRET" => "Google API key",
+  "ANTHROPIC_SECRET" => "Anthropic API key",
+  "DEEPSEEK_SECRET" => "DeepSeek API key",
+  "XAI_SECRET" => "xAI API key"
+}.freeze
+
+##
+# utils
+def load_env
+  return {} unless File.readable?(Relay.env_path)
+  File.readlines(Relay.env_path, chomp: true).each_with_object({}) do |line, env|
+    next if line.empty? || line.start_with?("#")
+    key, value = line.split("=", 2)
+    env[key] = value.to_s
+  end
+end
+
+def write_env(env)
+  FileUtils.mkdir_p Relay.home
+  lines = env.sort.filter_map do |key, value|
+    next if value.to_s.empty?
+    "#{key}=#{value}"
+  end
+  File.write(Relay.env_path, "#{lines.join("\n")}\n")
+end
+
+def prompt(label, current: nil, secret: false)
+  suffix = current.to_s.empty? ? "" : " [configured]"
+  print "#{label}#{suffix}: "
+  value = secret ? STDIN.noecho(&:gets).to_s.chomp : STDIN.gets.to_s.chomp
+  puts if secret
+  value.empty? ? current.to_s : value
+end
+
+def prompt_required(label)
+  loop do
+    print "#{label}: "
+    value = STDIN.gets.to_s.strip
+    return value unless value.empty?
+    warn "#{label} is required."
+  end
+end
+
+def prompt_password
+  loop do
+    print "Password: "
+    password = STDIN.noecho(&:gets).to_s.chomp
+    puts
+    print "Confirm password: "
+    confirm = STDIN.noecho(&:gets).to_s.chomp
+    puts
+    return password unless password.empty? || password != confirm
+    warn "Passwords must match and cannot be empty."
+  end
+end
+
+##
+# main
+def main
+  unless STDIN.tty? && $stdout.tty?
+    warn "relay configure requires an interactive terminal"
+    throw(:exit, 1)
+  end
+  env = load_env
+  puts Relay.banner
+  puts "Relay configuration\n"
+  PROVIDER_KEYS.each do |key, label|
+    env[key] = prompt(label, current: env[key], secret: true)
+  end
+  name = prompt_required("Name")
+  email = prompt_required("Email")
+  password = prompt_password
+  write_env(env)
+  require File.join(Relay.root, "app", "init")
+  unless Relay::DB.table_exists?(:users)
+    warn "Relay has not been bootstrapped"
+    throw(:exit, 1)
+  end
+  user = Relay::Models::User.where(email:).first || Relay::Models::User.new(email:)
+  user.name = name
+  user.password = password
+  user.save
+  puts "\nConfigured Relay."
+  puts "Email: #{email}"
+end
+
+excode = catch(:exit) {
+  main
+  0
+}
+exit excode

data/libexec/relay/migrate

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "relay"
+require File.join(Relay.root, "app", "init")
+Sequel.extension :migration
+Sequel::Migrator.run(Relay::DB, Relay.migrations_dir)

data/libexec/relay/setup

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "relay"
+
+bootstrap = File.join(Relay.root, "libexec", "relay", "bootstrap")
+configure = File.join(Relay.root, "libexec", "relay", "configure")
+
+system(bootstrap) || exit(1)
+system(configure) || exit(1)

data/libexec/relay/start

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "relay"
+require "optparse"
+
+DEFAULT_BIND = "http://0.0.0.0:9292"
+
+##
+# utils
+def option_parser(bind)
+  OptionParser.new do |o|
+    o.banner = "Usage: relay start [OPTIONS] [URL]"
+    o.on("--bind URL", "Bind Falcon to a URL") { bind.replace(_1) }
+  end
+end
+
+##
+# main
+def main(argv)
+  bind = String.new(DEFAULT_BIND)
+  option_parser(bind).parse!(argv)
+  bind = argv.shift || bind
+  exec "falcon", "serve", "--bind", bind
+end
+
+excode = catch(:exit) {
+  main(ARGV)
+  0
+}
+exit excode