runlight 0.1.1 → 0.1.3

data/lib/runlight/safefetch.rb

@@ -222,6 +222,103 @@ module Runlight
       end
     end
 
+    # Headers that describe a body, dropped with it when a redirect turns a request into a GET.
+    BODY_HEADERS = %w[content-type content-length content-encoding content-language content-location].freeze
+
+    # Fetches from a service someone set up, such as an AI model's API or a
+    # mail webhook, which may well be on this computer or a private network,
+    # but is never at a link-local or cloud metadata address. The address is
+    # checked, and so is every redirect's, up to "redirects" of them (default
+    # 5), each followed as fetch follows it: a 303, or a 301 or 302 answering a
+    # POST, goes on as a GET with no body. Only a redirect on the same origin is
+    # followed: the request carries a key, in whatever header the service names
+    # it, and a 307 or 308 would carry its body too, an email or a conversation, so
+    # a redirect to another origin, https to http among them, is refused before
+    # anything is sent there. A redirect past the last one comes back as it is.
+    # Raises a MetadataAddressError or a RedirectRefusedError for an address it refuses.
+    #
+    # init: a Hash with optionally "method", "headers" (a Hash), "body", "timeoutMs" (for every hop together),
+    # "redirects", and "maxBytes" and "truncate" for the fetcher.
+    def service_fetch(target, init, fetcher = nil)
+      fetcher ||= Http::NetFetcher.new
+      # A fetcher that reaches the network is held to the address checked. One a test or an app supplies is
+      # not, since a made-up host may not resolve anywhere.
+      strict = fetcher.is_a?(Http::NetFetcher)
+      redirects = init["redirects"] || 5
+      url = Http::Url.parse(target)
+      raise Http::FetchError, "Invalid URL" if url.nil?
+
+      method = (init["method"] || "GET").to_s.upcase
+      headers = (init["headers"] || {}).to_h
+      body = init["body"]
+      until_ns = init["timeoutMs"] && monotonic + (init["timeoutMs"] * 1_000_000)
+      hop = 0
+      loop do
+        host = url.hostname.sub(/\A\[/, "").sub(/\]\z/, "")
+        pin = service_pin(url, host, strict)
+
+        options = { "method" => method, "headers" => headers, "redirect" => "manual" }
+        options["resolve"] = pin unless pin.nil?
+        options["body"] = body unless body.nil?
+        %w[maxBytes truncate].each { |key| options[key] = init[key] unless init[key].nil? }
+        unless until_ns.nil?
+          # The whole limit for the first hop, and what is left of it for each redirect.
+          left = hop.zero? ? init["timeoutMs"] : (until_ns - monotonic).div(1_000_000)
+          raise timed_out if left <= 0
+
+          options["timeoutMs"] = left
+        end
+        answer = fetcher.fetch(url.href, options)
+        location = answer.headers.get("location")
+        return answer if answer.status < 300 || answer.status >= 400 || location.nil? || location == "" || hop >= redirects
+
+        following = Http::Url.parse(location, url.href)
+        raise Http::FetchError, "Invalid URL" if following.nil?
+
+        if following.origin != url.origin
+          there = following.hostname.sub(/\A\[/, "").sub(/\]\z/, "")
+          raise MetadataAddressError, there if metadata_host?(there)
+
+          raise RedirectRefusedError.new(url.host, %w[http: https:].include?(following.protocol) ? following.origin : following.protocol)
+        end
+        if answer.status == 303 || ([301, 302].include?(answer.status) && method == "POST")
+          method = "GET" unless method == "HEAD"
+          body = nil
+          headers = headers.reject { |name, _| BODY_HEADERS.include?(name.to_s.downcase) }
+        end
+        url = following
+        hop += 1
+      end
+    end
+
+    # The pin for one hop of a service fetch: the name is resolved here, every address it gives is checked, and
+    # the connection is pinned to them (the fetcher's "resolve", which also keeps it off any proxy from the
+    # environment), so a second lookup cannot hand back another. A private or local address is fine, since a
+    # model or a mail relay may be there; a link-local or metadata one is refused. A name that does not resolve
+    # is refused when strict, and let through to the fetcher otherwise.
+    def service_pin(url, host, strict)
+      name = Js.lower(Js.trim(host)).sub(/\.+\z/, "")
+      raise MetadataAddressError, host if METADATA_NAMES.include?(name) || metadata_address?(name)
+
+      literal = !v4(name).nil? || !v6(name).nil?
+      addresses = begin
+        literal ? [name] : Safefetch.resolver.call(name).map(&:to_s)
+      rescue StandardError
+        []
+      end
+      if addresses.empty?
+        raise Http::FetchError, "Could not look up #{host}" if strict
+
+        return nil
+      end
+      raise MetadataAddressError, host if addresses.any? { |address| metadata_address?(address) }
+
+      port = url.port == "" ? { "https:" => "443", "http:" => "80" }[url.protocol] : url.port
+      return nil if port.nil?
+
+      ["#{name}:#{port}:#{addresses.map { |a| a.include?(":") ? "[#{a}]" : a }.join(",")}"]
+    end
+
     # An install on this machine: http://localhost or http://127.0.0.1, with any port.
     LOCAL_INSTALL = %r{\Ahttp://(localhost|127\.0\.0\.1)(:\d+)?(/|\z)}
 
@@ -250,6 +347,6 @@ module Runlight
       Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond)
     end
 
-    private_class_method :v4, :public_v4?, :v6, :timed_out, :monotonic
+    private_class_method :v4, :public_v4?, :v6, :timed_out, :monotonic, :service_pin
   end
 end

data/lib/runlight/server/agents.rb

@@ -191,7 +191,7 @@ module Runlight
           raise SendError, e.message
         end
         if answer.status == 401
-          raise SendError, "Runlight refused the key. Use the site's key from Settings, Install, Key for CMS plugins."
+          raise SendError, "Runlight refused the key. Use the site's agents key from Settings, Install."
         end
         raise SendError, "Runlight answered #{answer.status}: #{Js.slice(Js.scrub(answer.text), 0, 200)}" unless answer.ok?
 

data/lib/runlight/server/cli.rb

@@ -42,7 +42,7 @@ module Runlight
 
           --log <file>    The access log, in nginx or Apache's combined format, or Caddy's JSON
           --to <url>      Your Runlight, as its dashboard address (or RUNLIGHT_URL)
-          --key <key>     The site's key from Settings, Install, Key for CMS plugins (or RUNLIGHT_OBSERVE_KEY)
+          --key <key>     The site's agents key from Settings, Install (or RUNLIGHT_OBSERVE_KEY)
           --site <url>    The site's address, such as https://example.com, when the log has no host in it
           --follow        Keep running and send fetches as they happen
           --state <file>  Remember where it stopped, so the next run, or a restarted --follow, starts there.

data/lib/runlight/server/config.rb

@@ -101,25 +101,7 @@ module Runlight
         given = get("RUNLIGHT_SECRET")
         return @secret = given unless given.nil?
 
-        file = "#{data_dir}/secret"
-        saved = read(file)
-        return @secret = saved if saved != ""
-
-        made = SecureRandom.hex(32)
-        # Made once: whoever writes the file first wins, and everyone else reads theirs.
-        begin
-          File.open(file, File::WRONLY | File::CREAT | File::EXCL, 0o600) { |out| out.write("#{made}\n") }
-        rescue SystemCallError
-          sleep(0.05)
-          saved = read(file)
-          if saved == ""
-            raise RuntimeError, "Runlight: could not write #{file}. Make the data folder writable, or set RUNLIGHT_SECRET."
-          end
-
-          return @secret = saved
-        end
-        File.chmod(0o600, file)
-        @secret = made
+        @secret = secret_in(data_dir)
       end
 
       # The dashboard's public address, such as https://stats.example.com, or nil.
@@ -234,6 +216,69 @@ module Runlight
       end
 
       # A file's text, trimmed unless asked not to, or "" when there is none.
+      # Shorter than any secret this file has ever been given, so a file caught half written is never used.
+      SHORTEST_SECRET = 32
+
+      # The secret kept in `dir`, made on first run, readable only by this user. Servers starting at once on one
+      # folder agree on it: the new secret is written whole to a file of its own, then linked into place, which
+      # refuses to replace a file already there, and the one that loses reads the winner's. A file read empty or
+      # short is read again for a moment, and then refused, never used.
+      def secret_in(dir)
+        file = "#{dir}/secret"
+        found = whole_secret(file)
+        return found unless found.nil?
+
+        made = SecureRandom.hex(32)
+        temp = "#{dir}/.secret-#{Process.pid}-#{SecureRandom.hex(6)}"
+        File.open(temp, File::WRONLY | File::CREAT | File::EXCL, 0o600) { |out| out.write("#{made}\n") }
+        begin
+          File.chmod(0o600, temp)
+          begin
+            File.link(temp, file)
+            made
+          rescue Errno::EEXIST
+            whole_secret(file) || refuse_secret(file)
+          rescue SystemCallError
+            # A file system with no hard links still creates the file only if it is not there; a reader that
+            # catches it before its contents land reads it again.
+            begin
+              File.open(file, File::WRONLY | File::CREAT | File::EXCL, 0o600) { |out| out.write("#{made}\n") }
+              File.chmod(0o600, file)
+              made
+            rescue Errno::EEXIST
+              whole_secret(file) || refuse_secret(file)
+            rescue SystemCallError
+              raise RuntimeError, "Runlight: could not write #{file}. Make the data folder writable, or set RUNLIGHT_SECRET."
+            end
+          end
+        ensure
+          begin
+            File.unlink(temp)
+          rescue SystemCallError
+            # Gone already.
+          end
+        end
+      end
+
+      # The secret in a file, waiting up to two seconds for one too short to be whole; nil when there is no file.
+      def whole_secret(file)
+        tries = 0
+        loop do
+          return nil unless File.exist?(file)
+
+          text = read(file)
+          return text if text.length >= SHORTEST_SECRET
+          refuse_secret(file) if tries >= 20
+
+          tries += 1
+          sleep(0.1)
+        end
+      end
+
+      def refuse_secret(file)
+        raise RuntimeError, "Runlight: #{file} holds no whole secret. Delete it to have a new one made, which signs everyone out, or set RUNLIGHT_SECRET."
+      end
+
       def read(file, strip: true)
         text = File.file?(file) ? File.read(file) : ""
         strip ? text.strip : text

data/lib/runlight/server/standalone.rb

@@ -17,7 +17,7 @@ module Runlight
     class Standalone
       # The server's own pages, which answer as the server on every name it is reached at, a link domain too.
       SERVER_PATHS = ["/login", "/logout", "/setup", "/invite", "/healthz", "/auth.css", "/auth.js", "/api", "/mcp",
-                      "/s.js", "/pick.js", "/e", "/embed"].freeze
+                      "/s.js", "/pick.js", "/pick-return", "/pick-return.js", "/e", "/embed"].freeze
 
       # The most names remembered as the server's own. The first ones stay and later ones are not learned, so
       # a server reached at more names than this needs RUNLIGHT_URL to keep the rest from becoming link domains.
@@ -135,8 +135,11 @@ module Runlight
         begin
           # A domain pointed at this server for short links answers at its root, with links one segment deep. The
           # server's own pages and its public address never answer as links, and "/" stays the dashboard for someone
-          # signed in, so a link domain added on the dashboard's own name can always be removed again.
-          linkable = path == Core::LINK_DOMAIN_CHECK ||
+          # signed in, so a link domain added on the dashboard's own name can always be removed again. /go/:slug is
+          # the server's own link path, which a link domain answers as a path with no link (a 404), as every adapter
+          # does.
+          own = request.method == "GET" && path.match?(%r{\A/go/[^/]+/?\z})
+          linkable = path == Core::LINK_DOMAIN_CHECK || own ||
                      (path.match?(%r{\A/[^/]*\z}) && !SERVER_PATHS.include?(path) &&
                       !(path == "/" && !@web.signed_in(request).nil?))
           if linkable && !(!@public_host.nil? && host_of(request) == @public_host)
@@ -146,9 +149,7 @@ module Runlight
           if path == "/healthz"
             return Http::Response.new("ok", status: 200, headers: { "content-type" => "text/plain", "cache-control" => "no-store" })
           end
-          if request.method == "GET" && path.match?(%r{\A/go/[^/]+/?\z})
-            return @runlight.link_handler.call(request, context)
-          end
+          return @runlight.link_handler.call(request, context) if own
 
           # Everything else, the sign-in pages and People included, is the routes'.
           @routes.handle(request, context)

data/lib/runlight/store/sql.rb

@@ -31,6 +31,16 @@ module Runlight
       # How long after a visit starts its events are looked for: far past any real visit.
       EVENT_TAIL_MS = 2 * 86_400_000
 
+      # What every table and index name starts with, unless a store is given another prefix in its place.
+      PREFIX = "rl_"
+
+      # Runlight's tables, after the prefix: the store's, and the sign-in accounts' two. An app dropping
+      # Runlight's tables drops these by name, never every table that starts with the prefix.
+      TABLES = %w[
+        meta sites salts sessions events links link_domains shares goals settings
+        reports tokens funnels rollup_days rollups users invites
+      ].freeze
+
       PIECE_MS = 86_400_000
 
       # Pageviews that can report engaged time: the tracker's, which carry a pageview id. Imported history has

data/lib/runlight/store/sql_store.rb

@@ -28,14 +28,33 @@ module Runlight
       EVENT_TAIL_MS = Sql::EVENT_TAIL_MS
       MYSQL_COLLATION = Sql::MYSQL_COLLATION
 
-      attr_reader :db
-
-      def initialize(db)
+      PREFIX = Sql::PREFIX
+      TABLES = Sql::TABLES
+
+      attr_reader :db,
+                  # What the store's table and index names start with: `rl_` unless it was given another.
+                  :prefix
+
+      # `prefix` takes the place of `rl_` at the start of every table and index name, so two apps can each keep
+      # Runlight's tables in one database. A database that is already prefixed keeps its own.
+      def initialize(db, prefix = PREFIX)
+        if db.is_a?(Db::Prefixed)
+          prefix = db.prefix
+        elsif prefix != PREFIX
+          db = Db::Prefixed.new(db, prefix)
+        end
         @db = db
+        @prefix = prefix
         @ready = false
         @checked_all = false
       end
 
+      # The store's tables as named in the database, for an app removing Runlight: each one by name, since
+      # another app's tables may well start with the same letters.
+      def tables
+        TABLES.map { |table| "#{@prefix}#{table}" }
+      end
+
       # Creates the tables on first use. Safe to call any number of times.
       #
       # When the database already records the current schema version, that is taken as done, so a store opened
@@ -619,13 +638,37 @@ module Runlight
         value = setting(key)
         return nil if value.nil?
 
-        sql = "DELETE FROM rl_settings WHERE \"key\" = ?"
-        gone = if @db.dialect == "mysql" && @db.respond_to?(:affected)
-                 @db.affected(sql, [key])
-               else
-                 @db.all("#{sql} RETURNING \"key\"", [key]).length
-               end
-        gone == 1 ? value : nil
+        setting_changed("DELETE FROM rl_settings WHERE \"key\" = ?", [key]) == 1 ? value : nil
+      end
+
+      # Writes a setting only if it is not there yet. Of two callers at once, only one gets true.
+      def add_setting(key, value)
+        # MySQL counts a row a duplicate key found as written, so it ignores the insert instead.
+        sql = if @db.dialect == "mysql"
+                "INSERT IGNORE INTO rl_settings (\"key\", value) VALUES (?, ?)"
+              else
+                Sql.upsert(@db.dialect, "rl_settings", ['"key"', "value"], ['"key"'], [])
+              end
+        setting_changed(sql, [key, value]) == 1
+      end
+
+      # Changes a setting only if it still holds `from`. Of two callers at once, only one gets true.
+      def swap_setting(key, from, to)
+        setting_changed("UPDATE rl_settings SET value = ? WHERE \"key\" = ? AND value = ?", [to, key, from]) == 1
+      end
+
+      # A setting, or the block's value written as it when there is none yet, such as a signing key made on first
+      # use. Of two callers at once, both get the value written first, so nothing signed with a key that lost is
+      # left invalid. An empty one counts as none.
+      def setting_or_add(key)
+        5.times do
+          saved = setting(key)
+          return saved if !saved.nil? && saved != ""
+
+          value = yield
+          return value if saved.nil? ? add_setting(key, value) : swap_setting(key, saved, value)
+        end
+        raise "Runlight: could not read or write the setting #{key}"
       end
 
       def set_setting(key, value)
@@ -1302,6 +1345,13 @@ module Runlight
 
       private
 
+      # How many settings a statement changed. MySQL has no RETURNING, so it asks the connection how many rows matched.
+      def setting_changed(sql, params)
+        return @db.affected(sql, params) if @db.dialect == "mysql" && @db.respond_to?(:affected)
+
+        @db.all("#{sql} RETURNING \"key\"", params).length
+      end
+
       # SQL for "a visit that started in one of these stretches".
       def within(rest)
         return { "sql" => "1 = 0", "params" => [] } if rest.empty?
@@ -1358,16 +1408,18 @@ module Runlight
           # A concurrent build that was stopped leaves its index unusable; it goes, and is built again below.
           broken = db.all(
             "SELECT c.relname AS name FROM pg_index i JOIN pg_class c ON c.oid = i.indexrelid
-           WHERE NOT i.indisvalid AND c.relname LIKE 'rl\\_%' AND c.relnamespace = current_schema()::regnamespace",
+           WHERE NOT i.indisvalid AND c.relname LIKE '#{@prefix.gsub("_", "\\\\_")}%' AND c.relnamespace = current_schema()::regnamespace",
           )
-          broken.each { |row| db.run("DROP INDEX IF EXISTS \"#{Sql.string(row["name"]).delete('"')}\"") }
+          # The name comes back as the database has it, so it goes back under rl_ before the prefix is put on
+          # again, which would otherwise be put on twice for a prefix that itself starts rl_, such as rl_wp_.
+          broken.each { |row| db.run("DROP INDEX IF EXISTS \"#{unnamed(Sql.string(row["name"])).delete('"')}\"") }
         end
         statements.each do |statement|
           index = statement.match(/\ACREATE (UNIQUE )?INDEX IF NOT EXISTS (\w+) ON (\w+)/)
           if db.dialect == "mysql" && index
             # MySQL has no CREATE INDEX IF NOT EXISTS, so it is looked for first.
             unique, name, table = index.captures
-            there = db.all("SELECT 1 AS there FROM information_schema.statistics WHERE table_schema = DATABASE() AND table_name = ? AND index_name = ? LIMIT 1", [table, name])
+            there = db.all("SELECT 1 AS there FROM information_schema.statistics WHERE table_schema = DATABASE() AND table_name = ? AND index_name = ? LIMIT 1", [named(table), named(name)])
             db.run(statement.sub(/\ACREATE (UNIQUE )?INDEX IF NOT EXISTS/, "CREATE #{unique}INDEX")) if there.empty?
           else
             db.run(postgres ? statement.sub(/\ACREATE (UNIQUE )?INDEX IF NOT EXISTS/) { "CREATE #{Regexp.last_match(1)}INDEX CONCURRENTLY IF NOT EXISTS" } : statement)
@@ -1390,6 +1442,16 @@ module Runlight
         db.run(Sql.upsert(db.dialect, "rl_meta", ['"key"', "value"], ['"key"'], ["value"]), ["schema", Sql::SCHEMA_VERSION.to_s])
       end
 
+      # A name as the database has it, under the store's prefix, as Runlight's SQL writes it, under rl_.
+      def unnamed(name)
+        name.start_with?(@prefix) ? "#{PREFIX}#{name[@prefix.length..]}" : name
+      end
+
+      # A table or index name as the database has it, under the store's prefix.
+      def named(name)
+        name.start_with?(PREFIX) ? "#{@prefix}#{name[PREFIX.length..]}" : name
+      end
+
       # When a site's oldest row at or after `from` is (nil for no lower bound), or nil when there is none.
       def oldest(table, col, site, from)
         row = @db.all("SELECT MIN(#{col}) AS t FROM #{table} WHERE site = ?#{from.nil? ? "" : " AND #{col} >= ?"}", from.nil? ? [site] : [site, from])[0]

data/lib/runlight/stores.rb

@@ -3,47 +3,51 @@
 module Runlight
   # The stores stores/sqlite.ts, stores/postgres.ts, and stores/mysql.ts make, over ActiveRecord. Tables are
   # prefixed `rl_`, so the database can be the app's own, and a database made by the TypeScript SDK opens here.
+  # Each takes `prefix:` in place of `rl_`: what every table and index name starts with, so two apps sharing
+  # one database each keep a set of their own, up to 32 letters, digits, and underscores, not starting with a
+  # digit.
   module Stores
     module_function
 
-    # Runlight's tables in a SQLite file (or ":memory:"), in WAL mode, as better-sqlite3 opens it there.
-    def sqlite(path)
-      Store::SqlStore.new(Db::Connect.sqlite(path))
+    # Runlight's tables in a SQLite file (or ":memory:"), in WAL mode, as better-sqlite3 opens it there. A
+    # file it makes is for its owner and group alone (0660).
+    def sqlite(path, prefix: Store::Sql::PREFIX)
+      Store::SqlStore.new(Db::Connect.sqlite(path), prefix)
     end
 
     # Runlight's tables in Postgres, from a connection string. statement_timeout is the longest one statement
     # may run, in milliseconds (default 120000, 0 for no limit); schema is the search path.
-    def postgres(url, statement_timeout: 120_000, schema: nil)
+    def postgres(url, statement_timeout: 120_000, schema: nil, prefix: Store::Sql::PREFIX)
       raise ArgumentError, "Runlight: postgres() needs a url" if url.to_s.empty?
 
-      Store::SqlStore.new(Db::Connect.postgres(url, statement_timeout: statement_timeout, schema: schema))
+      Store::SqlStore.new(Db::Connect.postgres(url, statement_timeout: statement_timeout, schema: schema), prefix)
     end
 
-    # Runlight's tables in MySQL 8.4 or MariaDB 11.4 and later, from a mysql:// or mariadb:// URL. Text is
+    # Runlight's tables in MySQL 8.0.20 or MariaDB 11.4 and later, from a mysql:// or mariadb:// URL. Text is
     # utf8mb4 with a binary collation, so it compares and sorts by code point, case and trailing spaces
     # included, as SQLite and Postgres do. statement_timeout is in milliseconds (default 120000, 0 for no
     # limit), which MySQL applies to reads only and MariaDB to every statement.
-    def mysql(url, statement_timeout: 120_000)
+    def mysql(url, statement_timeout: 120_000, prefix: Store::Sql::PREFIX)
       raise ArgumentError, "Runlight: mysql() needs a url" if url.to_s.empty?
 
-      Store::SqlStore.new(Db::Connect.mysql(url, statement_timeout: statement_timeout))
+      Store::SqlStore.new(Db::Connect.mysql(url, statement_timeout: statement_timeout), prefix)
     end
 
     # The store a DATABASE_URL names, as the standalone server picks one: postgres:// or postgresql:// for
     # Postgres, mysql:// or mariadb:// for MySQL, and sqlite: or file: followed by a path for SQLite.
-    def url(database_url)
-      Store::SqlStore.new(Db::Connect.url(database_url))
+    def url(database_url, prefix: Store::Sql::PREFIX)
+      Store::SqlStore.new(Db::Connect.url(database_url), prefix)
     end
 
     # Runlight's tables in the database an ActiveRecord class connects to: the app's own by default. Writes
     # join a transaction the app has open.
-    def active_record(connection_class = ::ActiveRecord::Base)
-      Store::SqlStore.new(Db::Database.new(connection_class))
+    def active_record(connection_class = ::ActiveRecord::Base, prefix: Store::Sql::PREFIX)
+      Store::SqlStore.new(Db::Database.new(connection_class), prefix)
     end
 
-    # A store over any Db::Database.
-    def from_db(db)
-      Store::SqlStore.new(db)
+    # A store over any Db::Database, with its tables under `prefix` in place of `rl_` when one is given.
+    def from_db(db, prefix: Store::Sql::PREFIX)
+      Store::SqlStore.new(db, prefix)
     end
   end
 end

data/lib/runlight/tables_busy_error.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Runlight
+  # Another process held the lock for creating tables past Db::Database::LOCK_WAIT_MS, such as one building an
+  # index on a big table after an upgrade. The request that waited fails with this, rather than waiting for good.
+  class TablesBusyError < RuntimeError
+    def initialize(waited = Db::Database::LOCK_WAIT_MS)
+      super("Runlight: another process is creating or upgrading the tables, and had not finished after #{(waited / 1000.0).round} seconds. Try again in a minute.")
+    end
+  end
+end

data/lib/runlight/version.rb

@@ -4,7 +4,7 @@ require "json"
 
 module Runlight
   # The gem's own version, which the release keeps equal to the npm package's.
-  GEM_VERSION = "0.1.1"
+  GEM_VERSION = "0.1.3"
 
   # The SDK's version and the HTTP API's, read from assets/build.json, which
   # scripts/ruby-assets.mts writes from the TypeScript SDK, so the two always

data/lib/runlight.rb

@@ -38,11 +38,13 @@ module Runlight
   autoload :Mcp, "runlight/mcp"
   autoload :McpError, "runlight/mcp_error"
   autoload :Messages, "runlight/messages"
+  autoload :MetadataAddressError, "runlight/metadata_address_error"
   autoload :Mmdb, "runlight/mmdb"
   autoload :OAuth, "runlight/oauth"
   autoload :Options, "runlight/options"
   autoload :Payload, "runlight/payload"
   autoload :PrivateAddressError, "runlight/private_address_error"
+  autoload :RedirectRefusedError, "runlight/redirect_refused_error"
   autoload :Query, "runlight/query"
   autoload :RackApp, "runlight/rack_app"
   autoload :RateLimit, "runlight/rate_limit"
@@ -51,6 +53,7 @@ module Runlight
   autoload :Safefetch, "runlight/safefetch"
   autoload :SettingsError, "runlight/settings_error"
   autoload :Sources, "runlight/sources"
+  autoload :TablesBusyError, "runlight/tables_busy_error"
   autoload :Ua, "runlight/ua"
   autoload :Zip, "runlight/zip"
 
@@ -73,6 +76,7 @@ module Runlight
     autoload :Connect, "runlight/db/connect"
     autoload :Database, "runlight/db/db"
     autoload :Pools, "runlight/db/connect"
+    autoload :Prefixed, "runlight/db/prefixed"
   end
 
   module Http

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: runlight
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Jon C. Phillips
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-10-11 00:00:00.000000000 Z
+date: 2026-10-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -46,6 +46,7 @@ files:
 - assets/dashboard.js
 - assets/intl.json
 - assets/locales.json
+- assets/pick-return.js
 - assets/picker.js
 - assets/tracker.js
 - assets/world.json
@@ -71,6 +72,7 @@ files:
 - lib/runlight/dates.rb
 - lib/runlight/db/connect.rb
 - lib/runlight/db/db.rb
+- lib/runlight/db/prefixed.rb
 - lib/runlight/env.rb
 - lib/runlight/funnel_error.rb
 - lib/runlight/funnels.rb
@@ -114,6 +116,7 @@ files:
 - lib/runlight/mcp.rb
 - lib/runlight/mcp_error.rb
 - lib/runlight/messages.rb
+- lib/runlight/metadata_address_error.rb
 - lib/runlight/mmdb.rb
 - lib/runlight/oauth.rb
 - lib/runlight/options.rb
@@ -123,6 +126,7 @@ files:
 - lib/runlight/rack_app.rb
 - lib/runlight/rails.rb
 - lib/runlight/rate_limit.rb
+- lib/runlight/redirect_refused_error.rb
 - lib/runlight/reports.rb
 - lib/runlight/routes.rb
 - lib/runlight/safefetch.rb
@@ -137,6 +141,7 @@ files:
 - lib/runlight/store/sql.rb
 - lib/runlight/store/sql_store.rb
 - lib/runlight/stores.rb
+- lib/runlight/tables_busy_error.rb
 - lib/runlight/ua.rb
 - lib/runlight/undefined.rb
 - lib/runlight/version.rb