talk_to_your_app 0.1.0.pre.1

data/lib/talk_to_your_app/plugins/custom_tools/plugin.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "../../plugin"
+require_relative "../../custom_tool"
+
+module TalkToYourApp
+  module Plugins
+    module CustomTools
+      # Exposes every TalkToYourApp::CustomTool subclass over MCP. Unlike the
+      # bundled plugins, its tool list is dynamic — whatever subclasses of
+      # CustomTool the host app has defined. Tools generated by
+      # `rails g talk_to_your_app:custom_tool` live in
+      # app/talk_to_your_app/custom_tools/ and are loaded automatically here.
+      class Plugin < TalkToYourApp::Plugin
+        def self.tools
+          TalkToYourApp.require_app_dir("custom_tools")
+          # Dedup by MCP name (last wins) in case two files declare the same
+          # tool_name, or a class is registered more than once in a process.
+          TalkToYourApp::CustomTool.registry.each_with_object({}) { |t, acc| acc[t.tool_name] = t }.values
+        end
+      end
+    end
+  end
+end
+
+TalkToYourApp.register_plugin(:custom_tools, TalkToYourApp::Plugins::CustomTools::Plugin)

data/lib/talk_to_your_app/plugins/db/plugin.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative "../../plugin"
+require_relative "tools/query"
+require_relative "tools/tables"
+require_relative "tools/schema"
+
+module TalkToYourApp
+  module Plugins
+    module Db
+      # Default cap on rows returned by db.query. Override per app with
+      # `config.plugin :db, max_rows: 5000`, or disable the cap entirely with
+      # `max_rows: nil` (also accepts false or :unlimited).
+      DEFAULT_MAX_ROWS = 2000
+      UNLIMITED = [nil, false, :unlimited].freeze
+
+      module_function
+
+      # Returns the row cap as an Integer, or nil for "no cap".
+      def max_rows
+        options = TalkToYourApp.configuration.enabled_plugins[:db] || {}
+        return DEFAULT_MAX_ROWS unless options.key?(:max_rows)
+
+        value = options[:max_rows]
+        return nil if UNLIMITED.include?(value)
+
+        Integer(value)
+      end
+
+      # The DB plugin: read-only SQL plus schema introspection, all against a
+      # separately-configured read-only connection. Requires the operator to
+      # declare a :replica_readonly connection; boot fails otherwise.
+      class Plugin < TalkToYourApp::Plugin
+        requires_connection :replica_readonly
+        tools Tools::Query, Tools::Tables, Tools::Schema
+
+        # The read-only guarantee rests on the connection being declared with
+        # role: :reading (which enables Rails' write prevention). Enforce it at
+        # boot so a misconfigured :writing role can't silently expose a writable
+        # "read-only" SQL tool. (A missing connection is caught by the
+        # ConnectionRegistry validation that runs alongside this.)
+        def self.validate_enablement!(_options)
+          return unless TalkToYourApp::ConnectionRegistry.registered?(:replica_readonly)
+
+          spec = TalkToYourApp::ConnectionRegistry.fetch(:replica_readonly)
+          return if spec.reading?
+
+          raise TalkToYourApp::ConfigurationError,
+            "talk_to_your_app: the DB plugin's :replica_readonly connection must be declared with " \
+            "role: :reading (got role: #{spec.role.inspect}). A read-only tool must not run on a writable connection."
+        end
+      end
+    end
+  end
+end
+
+TalkToYourApp.register_plugin(:db, TalkToYourApp::Plugins::Db::Plugin)

data/lib/talk_to_your_app/plugins/db/tools/query.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require_relative "../../../tool"
+require_relative "../../../connection_registry"
+require_relative "../../../renderers/html_table"
+
+module TalkToYourApp
+  module Plugins
+    module Db
+      module Tools
+        # Runs a read-only SQL query on the declared :replica_readonly connection
+        # and renders the rows as JSON, plain text, or an HTML table. The query
+        # runs inside a transaction with a per-query statement timeout, so a slow
+        # query cannot poison the connection pool. Writes are rejected by the
+        # underlying read-only database role — the gem does not parse SQL.
+        class Query < TalkToYourApp::Tool
+          DEFAULT_TIMEOUT_MS = 30_000
+          CONNECTION = :replica_readonly
+
+          name        "db.query"
+          description "Run a read-only SQL query and return the rows."
+          connection  CONNECTION
+          argument    :sql, :string, required: true, description: "A read-only SQL statement."
+          argument    :format, :string, enum: %w[json text html], default: "json",
+            description: "Output format for the result rows."
+
+          def call(args, ctx)
+            format = args[:format] || "json"
+            result = ctx.connection do |conn|
+              conn.transaction do
+                apply_statement_timeout(conn, timeout_ms)
+                begin
+                  conn.exec_query(args[:sql])
+                ensure
+                  clear_statement_timeout(conn)
+                end
+              end
+            end
+            render(result, format)
+          rescue ActiveRecord::QueryCanceled, ActiveRecord::StatementTimeout => e
+            error("Query exceeded the #{timeout_ms}ms statement timeout: #{e.message}")
+          rescue ActiveRecord::ReadOnlyError => e
+            # Rails' connected_to(role: :reading) blocks writes before they reach
+            # the database; the read-only DB role is the backstop behind it.
+            error("Write rejected: this connection is read-only. #{e.message}")
+          rescue ActiveRecord::StatementInvalid => e
+            error("Query failed: #{e.message}")
+          end
+
+          private
+
+          def timeout_ms
+            spec = TalkToYourApp::ConnectionRegistry.fetch(CONNECTION)
+            spec.statement_timeout || DEFAULT_TIMEOUT_MS
+          end
+
+          # The SQL that arms a per-query timeout for an adapter, or nil when the
+          # adapter has no per-statement timeout. Pure (no connection) so it is
+          # unit-testable without each database installed.
+          #   Postgres -> transaction-local `statement_timeout` (unwound with the txn).
+          #   MySQL    -> session `max_execution_time` (ms), bounding read-only SELECTs.
+          #   SQLite / MariaDB / others -> none (documented in the README).
+          def self.timeout_statement(adapter_name, ms)
+            case adapter_name
+            when /postgres/i      then "SET LOCAL statement_timeout = #{ms.to_i}"
+            when /mysql|trilogy/i then "SET SESSION max_execution_time = #{ms.to_i}"
+            end
+          end
+
+          def apply_statement_timeout(conn, ms)
+            sql = self.class.timeout_statement(conn.adapter_name, ms)
+            return unless sql
+
+            conn.execute(sql)
+          rescue ActiveRecord::StatementInvalid
+            # The server does not support this timeout mechanism (e.g. MariaDB has
+            # no `max_execution_time`). Run without a per-statement timeout rather
+            # than failing every query; the read-only role still applies.
+            nil
+          end
+
+          # Postgres' SET LOCAL unwinds with the transaction, but MySQL's session
+          # variable persists on the pooled connection — clear it so a later
+          # borrower of the reader connection is not capped by a stale value.
+          def clear_statement_timeout(conn)
+            return unless conn.adapter_name.match?(/mysql|trilogy/i)
+
+            conn.execute("SET SESSION max_execution_time = 0")
+          rescue ActiveRecord::StatementInvalid
+            nil
+          end
+
+          def render(result, format)
+            columns = result.columns
+            max = TalkToYourApp::Plugins::Db.max_rows # nil means no cap
+            truncated = max && result.rows.length > max
+            rows = truncated ? result.rows.first(max) : result.rows
+
+            case format
+            when "html"
+              html = Renderers::HtmlTable.render(columns, rows)
+              text(truncated ? "#{html}<p>truncated to #{max} rows</p>" : html)
+            when "text"
+              body = render_text(columns, rows)
+              text(truncated ? "#{body}\n(truncated to #{max} rows)" : body)
+            else
+              payload = { columns: columns, rows: rows }
+              payload.merge!(truncated: true, max_rows: max) if truncated
+              text(JSON.generate(payload))
+            end
+          end
+
+          def render_text(columns, rows)
+            display = rows.map { |row| row.map { |cell| cell.nil? ? "NULL" : cell.to_s } }
+            widths = columns.each_index.map do |i|
+              ([columns[i].to_s] + display.map { |r| r[i].to_s }).map(&:length).max
+            end
+            header = columns.each_with_index.map { |c, i| c.to_s.ljust(widths[i]) }.join("  ")
+            body = display.map { |r| r.each_with_index.map { |c, i| c.ljust(widths[i]) }.join("  ") }
+            ([header] + body).join("\n")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/talk_to_your_app/plugins/db/tools/schema.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative "../../../tool"
+
+module TalkToYourApp
+  module Plugins
+    module Db
+      module Tools
+        # Describes a single table from the live read-only database: its columns,
+        # primary key, indexes, and foreign keys. Lets a client learn a table's
+        # shape without a schema dump.
+        class Schema < TalkToYourApp::Tool
+          CONNECTION = :replica_readonly
+
+          name        "db.schema"
+          description "Describe a table: columns, primary key, indexes, and foreign keys."
+          connection  CONNECTION
+          argument    :table, :string, required: true, description: "Table name (see db.tables)."
+
+          def call(args, ctx)
+            table = args[:table].to_s
+            ctx.connection do |conn|
+              unless conn.tables.include?(table)
+                next error("Unknown table #{table.inspect}. Use db.tables to list available tables.")
+              end
+
+              json(describe(conn, table))
+            end
+          rescue ActiveRecord::ActiveRecordError => e
+            error("Could not describe #{args[:table].inspect}: #{e.message}")
+          end
+
+          private
+
+          def describe(conn, table)
+            {
+              table: table,
+              primary_key: conn.primary_key(table),
+              columns: conn.columns(table).map do |col|
+                { name: col.name, type: col.sql_type, null: col.null, default: col.default }
+              end,
+              indexes: conn.indexes(table).map do |idx|
+                { name: idx.name, columns: idx.columns, unique: idx.unique }
+              end,
+              foreign_keys: foreign_keys(conn, table),
+            }
+          end
+
+          def foreign_keys(conn, table)
+            return [] unless conn.supports_foreign_keys?
+
+            conn.foreign_keys(table).map do |fk|
+              { column: fk.column, references_table: fk.to_table, references_column: fk.primary_key }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/talk_to_your_app/plugins/db/tools/tables.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "../../../tool"
+
+module TalkToYourApp
+  module Plugins
+    module Db
+      module Tools
+        # Lists the table names in the read-only database, so a client can
+        # discover the schema before querying.
+        class Tables < TalkToYourApp::Tool
+          CONNECTION = :replica_readonly
+
+          name        "db.tables"
+          description "List the table names in the read-only database."
+          connection  CONNECTION
+
+          def call(_args, ctx)
+            tables = ctx.connection { |conn| conn.tables.sort }
+            json(tables: tables)
+          rescue ActiveRecord::ActiveRecordError => e
+            error("Could not list tables: #{e.message}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/talk_to_your_app/plugins/flipper/plugin.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require_relative "../../plugin"
+require_relative "tools/list_flags"
+require_relative "tools/read_flag"
+require_relative "tools/enable_flag"
+require_relative "tools/disable_flag"
+require_relative "tools/enabled_flags"
+
+module TalkToYourApp
+  module Plugins
+    # The Flipper plugin: list flags, read a flag's state (globally or for an
+    # actor), and enable/disable flags globally or per actor. All operations run
+    # through the writer-capable :flipper_writer connection — deliberately
+    # separate from the DB plugin's read-only one.
+    module Flipper
+      # A minimal actor: Flipper only needs an object responding to #flipper_id.
+      # We reconstitute one from a class name + id rather than loading the host's
+      # real record, which avoids coupling to the host's user model and any
+      # privilege leak from instantiating it.
+      Actor = Struct.new(:flipper_id)
+
+      module_function
+
+      # Builds an actor from a class name + id, or nil when none was supplied.
+      def actor_for(actor_class, actor_id)
+        return nil if actor_class.nil? || actor_id.nil?
+
+        Actor.new("#{actor_class};#{actor_id}")
+      end
+
+      # True when a call names more than one gate dimension (actor, group,
+      # percentage). gate_from would silently pick one by precedence and drop the
+      # rest, so the tools reject the call instead.
+      def gate_conflict?(args)
+        selectors = []
+        selectors << :actor if args[:actor_class] && args[:actor_id]
+        selectors << :group if args[:group]
+        selectors << :percentage unless args[:percentage].nil?
+        selectors.size > 1
+      end
+
+      # Resolves which Flipper gate a tool call targets from its arguments. In
+      # precedence order: a specific actor, a named group, a percentage, else the
+      # global boolean gate.
+      def gate_from(args)
+        if (actor = actor_for(args[:actor_class], args[:actor_id]))
+          { type: :actor, actor: actor }
+        elsif args[:group]
+          { type: :group, group: args[:group].to_sym }
+        elsif !args[:percentage].nil?
+          type = args[:percentage_type] == "time" ? :percentage_of_time : :percentage_of_actors
+          { type: type, percentage: args[:percentage].to_i }
+        else
+          { type: :boolean }
+        end
+      end
+
+      # Applies :enable or :disable across the resolved gate. Every branch is an
+      # explicit named call so the dispatch is statically obvious and an unknown
+      # gate type fails fast rather than silently toggling the boolean gate.
+      def apply(operation, name, gate)
+        enabling = operation == :enable
+        case gate[:type]
+        when :boolean
+          enabling ? ::Flipper.enable(name) : ::Flipper.disable(name)
+        when :actor
+          enabling ? ::Flipper.enable(name, gate[:actor]) : ::Flipper.disable(name, gate[:actor])
+        when :group
+          enabling ? ::Flipper.enable_group(name, gate[:group]) : ::Flipper.disable_group(name, gate[:group])
+        when :percentage_of_actors
+          enabling ? ::Flipper.enable_percentage_of_actors(name, gate[:percentage]) : ::Flipper.disable_percentage_of_actors(name)
+        when :percentage_of_time
+          enabling ? ::Flipper.enable_percentage_of_time(name, gate[:percentage]) : ::Flipper.disable_percentage_of_time(name)
+        else
+          raise ArgumentError, "unknown Flipper gate type: #{gate[:type].inspect}"
+        end
+      end
+
+      # Reads a flag's effective state, globally or for an actor. Unknown flags
+      # read false.
+      def state(name, actor)
+        actor ? ::Flipper.enabled?(name, actor) : ::Flipper.enabled?(name)
+      end
+
+      # The full per-gate configuration of a flag, for read_flag.
+      def gate_values(name)
+        values = ::Flipper[name].gate_values
+        {
+          boolean: values.boolean,
+          actors: values.actors.to_a,
+          groups: values.groups.to_a,
+          percentage_of_actors: values.percentage_of_actors,
+          percentage_of_time: values.percentage_of_time,
+        }
+      end
+
+      # A flag is "enabled" if any gate is active.
+      def active?(gates)
+        gates[:boolean] ||
+          gates[:actors].any? ||
+          gates[:groups].any? ||
+          gates[:percentage_of_actors].to_i.positive? ||
+          gates[:percentage_of_time].to_i.positive?
+      end
+
+      # Last-change timestamps for many flags in a single query, keyed by flag
+      # name, read from the flipper_features table when the ActiveRecord adapter
+      # is in use. Flipper records no enable/disable history, so updated_at is
+      # the last time the feature row changed. Returns an empty hash (callers
+      # fall back to nil timestamps) for non-ActiveRecord adapters. Batched to
+      # avoid an N+1 across all flags.
+      def preload_timestamps(names)
+        return {} unless defined?(::Flipper::Adapters::ActiveRecord::Feature)
+
+        ::Flipper::Adapters::ActiveRecord::Feature.where(key: names.map(&:to_s)).each_with_object({}) do |row, acc|
+          acc[row.key] = { created_at: row.created_at&.utc&.iso8601, updated_at: row.updated_at&.utc&.iso8601 }
+        end
+      rescue StandardError
+        {}
+      end
+
+      class Plugin < TalkToYourApp::Plugin
+        requires_connection :flipper_writer
+        requires_gem "Flipper", gem_name: "flipper"
+        tools Tools::ListFlags, Tools::ReadFlag, Tools::EnableFlag, Tools::DisableFlag, Tools::EnabledFlags
+      end
+    end
+  end
+end
+
+TalkToYourApp.register_plugin(:flipper, TalkToYourApp::Plugins::Flipper::Plugin)

data/lib/talk_to_your_app/plugins/flipper/tools/disable_flag.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "../../../tool"
+
+module TalkToYourApp
+  module Plugins
+    module Flipper
+      module Tools
+        # Disables a flag. With no gate arguments it disables globally; supply
+        # actor_class+actor_id, group, or percentage (+ optional percentage_type)
+        # to clear that specific gate.
+        class DisableFlag < TalkToYourApp::Tool
+          name        "flipper.disable_flag"
+          description "Disable a feature flag globally, for an actor, a group, or a percentage."
+          connection  :flipper_writer
+          argument    :name, :string, required: true, description: "Flag name."
+          argument    :actor_class, :string, description: "Actor class name, e.g. \"User\"."
+          argument    :actor_id, :string, description: "Actor id, e.g. \"42\"."
+          argument    :group, :string, description: "A registered Flipper group name."
+          argument    :percentage, :integer, minimum: 0, maximum: 100,
+            description: "Percentage gate to clear (0-100); the value is ignored on disable."
+          argument    :percentage_type, :string, enum: %w[actors time], default: "actors",
+            description: "Whether percentage applies to actors or time."
+
+          def call(args, ctx)
+            return error("Specify exactly one gate: an actor, a group, or a percentage.") if Flipper.gate_conflict?(args)
+
+            gate = Flipper.gate_from(args)
+            result = ctx.connection do
+              Flipper.apply(:disable, args[:name], gate)
+              Flipper.gate_values(args[:name])
+            end
+            json(name: args[:name], enabled: Flipper.active?(result), gate_type: gate[:type], gates: result)
+          rescue StandardError => e
+            error("Flipper storage unavailable: #{e.class}: #{e.message}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/talk_to_your_app/plugins/flipper/tools/enable_flag.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "../../../tool"
+
+module TalkToYourApp
+  module Plugins
+    module Flipper
+      module Tools
+        # Enables a flag. With no gate arguments it enables globally (boolean
+        # gate); supply actor_class+actor_id for a single actor, group for a
+        # registered group, or percentage (+ optional percentage_type) for a
+        # percentage rollout.
+        class EnableFlag < TalkToYourApp::Tool
+          name        "flipper.enable_flag"
+          description "Enable a feature flag globally, for an actor, a group, or a percentage."
+          connection  :flipper_writer
+          argument    :name, :string, required: true, description: "Flag name."
+          argument    :actor_class, :string, description: "Actor class name, e.g. \"User\"."
+          argument    :actor_id, :string, description: "Actor id, e.g. \"42\"."
+          argument    :group, :string, description: "A registered Flipper group name."
+          argument    :percentage, :integer, minimum: 0, maximum: 100,
+            description: "Percentage rollout (0-100)."
+          argument    :percentage_type, :string, enum: %w[actors time], default: "actors",
+            description: "Whether percentage applies to actors or time."
+
+          def call(args, ctx)
+            return error("Specify exactly one gate: an actor, a group, or a percentage.") if Flipper.gate_conflict?(args)
+
+            gate = Flipper.gate_from(args)
+            result = ctx.connection do
+              Flipper.apply(:enable, args[:name], gate)
+              Flipper.gate_values(args[:name])
+            end
+            json(name: args[:name], enabled: Flipper.active?(result), gate_type: gate[:type], gates: result)
+          rescue StandardError => e
+            error("Flipper storage unavailable: #{e.class}: #{e.message}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/talk_to_your_app/plugins/flipper/tools/enabled_flags.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "../../../tool"
+
+module TalkToYourApp
+  module Plugins
+    module Flipper
+      module Tools
+        # Lists the currently-enabled feature flags (any active gate) with their
+        # per-gate configuration and last-change timestamps, for inspection.
+        # Flipper does not record full enable/disable history; `updated_at` is
+        # the last time the feature changed (ActiveRecord adapter only).
+        class EnabledFlags < TalkToYourApp::Tool
+          name        "flipper.enabled_flags"
+          description "List currently-enabled feature flags with their gates and last-change timestamps."
+          connection  :flipper_writer
+
+          def call(_args, ctx)
+            flags = ctx.connection do
+              features = ::Flipper.features.to_a
+              timestamps = Flipper.preload_timestamps(features.map(&:key))
+              no_timestamps = { created_at: nil, updated_at: nil }
+              features.filter_map do |feature|
+                gates = Flipper.gate_values(feature.key)
+                next unless Flipper.active?(gates)
+
+                { name: feature.key, enabled: true, gates: gates }.merge(timestamps.fetch(feature.key, no_timestamps))
+              end
+            end
+            json(
+              enabled_flags: flags.sort_by { |f| f[:name] },
+              note: "Flipper does not store enable/disable history; updated_at is the last feature change (ActiveRecord adapter only).",
+            )
+          rescue StandardError => e
+            error("Flipper storage unavailable: #{e.class}: #{e.message}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/talk_to_your_app/plugins/flipper/tools/list_flags.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "../../../tool"
+
+module TalkToYourApp
+  module Plugins
+    module Flipper
+      module Tools
+        # Lists the keys of all configured feature flags.
+        class ListFlags < TalkToYourApp::Tool
+          name        "flipper.list_flags"
+          description "List all configured feature flag names."
+          connection  :flipper_writer
+
+          def call(_args, ctx)
+            names = ctx.connection { ::Flipper.features.map(&:key) }
+            json(flags: names.sort)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/talk_to_your_app/plugins/flipper/tools/read_flag.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "../../../tool"
+
+module TalkToYourApp
+  module Plugins
+    module Flipper
+      module Tools
+        # Reads a flag's effective state plus its full per-gate configuration.
+        # With an actor, `enabled` reflects that actor; otherwise it reflects the
+        # global state. Unknown flags read as disabled.
+        class ReadFlag < TalkToYourApp::Tool
+          name        "flipper.read_flag"
+          description "Read a feature flag's state and per-gate configuration."
+          connection  :flipper_writer
+          argument    :name, :string, required: true, description: "Flag name."
+          argument    :actor_class, :string, description: "Actor class name, e.g. \"User\"."
+          argument    :actor_id, :string, description: "Actor id, e.g. \"42\"."
+
+          def call(args, ctx)
+            actor = Flipper.actor_for(args[:actor_class], args[:actor_id])
+            enabled, gates = ctx.connection do
+              [Flipper.state(args[:name], actor), Flipper.gate_values(args[:name])]
+            end
+            json(name: args[:name], enabled: enabled, actor: actor&.flipper_id, gates: gates)
+          rescue StandardError => e
+            error("Flipper storage unavailable: #{e.class}: #{e.message}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/talk_to_your_app/plugins/health/plugin.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "../../plugin"
+require_relative "registry"
+require_relative "tools/list_checks"
+require_relative "tools/run_check"
+
+module TalkToYourApp
+  module Plugins
+    module Health
+      # The Health plugin exposes the operator-registered checks via two tools:
+      # list and run. No connection or soft-dependency gem is required — checks
+      # own whatever resources they touch.
+      class Plugin < TalkToYourApp::Plugin
+        tools Tools::ListChecks, Tools::RunCheck
+
+        # Load app/talk_to_your_app/health/ (one Health.register per file) when
+        # the tool list is read — once, at rack-app build / boot, mirroring the
+        # custom_tools plugin. This surfaces a broken health file at deploy
+        # rather than on the first health.run, and avoids re-globbing the
+        # directory (and re-logging a failed load) on every tool call.
+        def self.tools(*classes)
+          TalkToYourApp.require_app_dir("health") if classes.empty?
+          super
+        end
+      end
+    end
+  end
+end
+
+TalkToYourApp.register_plugin(:health, TalkToYourApp::Plugins::Health::Plugin)