rails-hyperdrive 0.9.2 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 57237faa04d72c8dcfd1bc7d2acf3dec207eb641c12c08e8fa63dda0f649bbf7
-  data.tar.gz: 7101691749e528d36d478497874c367472b475c82873f065cbad66439e5d77b3
+  metadata.gz: 5831108b4ac1e545e827ce63f40ce9cb7615f8e51269a2f16914e2ed96f167bb
+  data.tar.gz: cd610fcf5441285f1f8357f4cee2796ad41d89f6d882447f90b6f3a430d7f2d6
 SHA512:
-  metadata.gz: 3ae38d66200e6f17e66b11560cf029afdf9b7bbaf8dbd6477ef92de26cd440c454849900ee83fbe53fce5eae447ba2b6d40461227581cee3fcea5f874eb78f33
-  data.tar.gz: 521d4da069f27f9b91020ac08106db9ea19aed075ce07204924da1839328390c72d85d392b060ac6317bc6fcb930225f78f10055869830abc66808a22d5c4b76
+  metadata.gz: 0d46038fe1baddd36949795d0e13cfa180dda30d77476420866a1efc433089a2c4398ee440e0162ec07fa3bdea9fd07149b239c696a663ef06984027169c3670
+  data.tar.gz: da719e11364876cedddd585b81f812565333d97f4eab1c625d6b60e1a99a0598b695591c3bfac464a0b9b27f4c3f4274d7a14a88f9966d6039fa8a016cf95d81

data/CHANGELOG.md

@@ -7,6 +7,54 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.10.0] - 2026-09-09
+
+### Fixed
+
+- **`bin/rails hyperdrive:init`/`sync`/`discover` run from a subdirectory of the
+  app now write to the app root.** The generators read the lockfile, the config
+  file, and `Gemfile.lock` through `Rails.root` but had no destination root, so
+  Thor defaulted to the current directory and `../bin/rails hyperdrive:init`
+  scattered `.mcp.json`, `.claude/`, and `.hyperdrive/` under wherever it was
+  invoked from. Each generator now starts with the app root as its destination.
+- **A `.hyperdrive/lock.yml` that cannot be read or parsed now stops
+  `hyperdrive:init`/`sync` with an error naming the file.** Previously a syntax
+  error was silently read as an absent lock — the run warned "locally modified"
+  for every installed file and then rewrote the lock with every entry and
+  `claude_md.state` dropped — while an unreadable file, a `!ruby/object` tag, or
+  a YAML alias crashed with a raw backtrace. Unreadable, unparseable, and
+  non-map-root locks all halt before any content write, `--dry-run` included; an
+  empty file still reads as absent. `bundle install` reports the same line and
+  installs nothing. `rake hyperdrive:skills:check`/`render` likewise report
+  unparseable rendered frontmatter as a render error for every YAML failure, not
+  only syntax errors.
+- **The install pipeline no longer reports a disabled artifact left on disk as
+  an orphan**, in any mode — the artifact is still shipped by its gem, so it is
+  not stranded, and its lock entry is carried as before. Additive runs (the
+  `bundle install` hook) now report no disabled artifacts at all.
+- **`hyperdrive:init --mount-at` now accepts only a plain `/segment[/segment]`
+  path** (letters, digits, `_`, `-`) and refuses anything else before writing
+  anything, since the value was interpolated unescaped into `config/routes.rb`
+  as Ruby source. When `config/routes.rb` has no
+  `Rails.application.routes.draw do` block, init warns and tells you the line to
+  add by hand, and the summary no longer claims the mount was written.
+
+### Changed
+
+- **`run_sql` refuses `PRAGMA name = value` assignments.** The paren form
+  (`PRAGMA table_info(users)`) and bare reads stay allowed. The guard remains a
+  guardrail rather than a parser, so a mutation keyword inside a string literal
+  (`SELECT 'update me'`) is still refused.
+- **`McpServer.rack_app` no longer accepts `allowed_hosts:`.** The method
+  memoizes, so the argument was ignored after the first call, and nothing ever
+  passed it; the allowlist is the middleware's own constant.
+- **When one companion ships the same artifact name at two paths** — a skill
+  under both skill roots, or a flat file in both the convention root and its
+  manifest `<kind>_dir:` override — discovery now reports the dropped path as a
+  skip instead of choosing silently. The survivor is unchanged (the
+  lexicographically greatest path), and the gem is not marked as having skipped
+  anything, since the name still installs.
+
 ## [0.9.2] - 2026-09-08
 
 ### Added
@@ -849,7 +897,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `hyperdrive:init` generator that installs architecture skills and auto-discovers
   per-gem skills.
 
-[Unreleased]: https://github.com/rails-hyperdrive/rails-hyperdrive/compare/v0.9.2...HEAD
+[Unreleased]: https://github.com/rails-hyperdrive/rails-hyperdrive/compare/v0.10.0...HEAD
+[0.10.0]: https://github.com/rails-hyperdrive/rails-hyperdrive/releases/tag/v0.10.0
 [0.9.2]: https://github.com/rails-hyperdrive/rails-hyperdrive/releases/tag/v0.9.2
 [0.9.1]: https://github.com/rails-hyperdrive/rails-hyperdrive/releases/tag/v0.9.1
 [0.9.0]: https://github.com/rails-hyperdrive/rails-hyperdrive/releases/tag/v0.9.0

data/README.md

@@ -71,7 +71,7 @@ $ bin/dev
 # → agent has 8 tools, the eager guidelines (via CLAUDE.md), and the lazy skills
 ```
 
-The engine mounts at `/_hyperdrive` by default; `--mount-at /some/path` moves both the route and the URL written to `.mcp.json`. The generated `.mcp.json` points at `http://localhost:3000<mount>/mcp`, so if your dev server runs on another port, edit the URL there.
+The engine mounts at `/_hyperdrive` by default; `--mount-at /some/path` moves both the route and the URL written to `.mcp.json`. That value is interpolated into `config/routes.rb` as Ruby source, so it must be a plain path of one or more `/`-separated segments of letters, digits, `_` and `-`; anything else stops the run before it writes. If `config/routes.rb` has no `Rails.application.routes.draw do` block to anchor to, nothing is mounted and the run warns with the line to add by hand. The generated `.mcp.json` points at `http://localhost:3000<mount>/mcp`, so if your dev server runs on another port, edit the URL there.
 
 ---
 
@@ -82,7 +82,7 @@ The engine mounts at `/_hyperdrive` by default; `--mount-at /some/path` moves bo
 | # | Tool | Purpose |
 |---|------|---------|
 | 1 | `run_ruby` | Eval Ruby in the booted Rails process, with timeout + output capture |
-| 2 | `run_sql` | Read-only SQL via the AR connection (`SELECT`/`WITH`/`EXPLAIN`/`SHOW`/`PRAGMA` only; 100 rows max) |
+| 2 | `run_sql` | Read-only SQL via the AR connection (`SELECT`/`WITH`/`EXPLAIN`/`SHOW`/`PRAGMA` only, and no `PRAGMA` assignments; 100 rows max) |
 | 3 | `tail_logs` | Tail the last N lines of a log under `log/` (defaults to `log/<env>.log`) |
 | 4 | `list_models` | List Active Record model classes with columns/validations/associations |
 | 5 | `locate_source` | Resolve `Const` / `Const#method` / `Const.method` / `dep:<gem>` to a file:line |
@@ -184,7 +184,7 @@ CLAUDE.md                              # user-owned; ONE injected line: @.claude
 .hyperdrive/lock.yml                   # git-tracked manifest (source gem, version, content hash)
 ```
 
-A `git diff` is where you review what a companion gem added. The install summary names each artifact's source gem and version, and every installed file is hashed and attributed to its source in the git-tracked `.hyperdrive/lock.yml`. The files themselves land byte-identical to what the gem ships, with nothing injected. `hyperdrive:init` and `hyperdrive:sync` warn if your app gitignores these paths, since that empties the diff without changing what reaches the agent. The `hyperdrive:discover` cache is the one file rails-hyperdrive adds to `.gitignore`. The lockfile carries a schema version, and a rails-hyperdrive older than the one that wrote it stops with an upgrade message instead of rewriting state it cannot read.
+A `git diff` is where you review what a companion gem added. The install summary names each artifact's source gem and version, and every installed file is hashed and attributed to its source in the git-tracked `.hyperdrive/lock.yml`. The files themselves land byte-identical to what the gem ships, with nothing injected. `hyperdrive:init` and `hyperdrive:sync` warn if your app gitignores these paths, since that empties the diff without changing what reaches the agent. The `hyperdrive:discover` cache is the one file rails-hyperdrive adds to `.gitignore`. The lockfile carries a schema version, and a rails-hyperdrive older than the one that wrote it stops with an upgrade message instead of rewriting state it cannot read. A lockfile that cannot be opened, does not parse, or has something other than a map at its root stops the run the same way, naming the file so you can fix it or restore it from git.
 
 `CLAUDE.md` and `index.md` are the **eager chain**: they exist only because a companion gem ships a guideline, and both go when the last one leaves the bundle (the guideline file itself is left on disk and reported as an orphan). A `CLAUDE.md` you had before `hyperdrive:init` gets the one line appended, and tear-down strips just that line; a `CLAUDE.md` the installer created is deleted only while it is still byte-identical to what was written.
 

data/lib/generators/hyperdrive/install/USAGE

@@ -2,7 +2,11 @@ Description:
     Bootstraps Rails Hyperdrive in this app:
       - adds the rails-hyperdrive server to .mcp.json (Claude Code config),
         merging into any servers already configured there
-      - mounts Rails::Hyperdrive::Engine at /_hyperdrive in config/routes.rb (idempotent)
+      - mounts Rails::Hyperdrive::Engine at /_hyperdrive in config/routes.rb
+        (idempotent; --mount-at takes one or more /segments of letters,
+        digits, _ and -, and is validated before anything is written). With
+        no `Rails.application.routes.draw do` block to anchor to, nothing is
+        mounted and the warning names the line to add by hand
       - registers the bundler-hyperdrive plugin in the Gemfile, so newly
         bundled companion gems install their artifacts on bundle install
       - adds a .gitignore rule for the hyperdrive:discover cache

data/lib/generators/hyperdrive/install/install_generator.rb

@@ -15,7 +15,9 @@ module Rails
         include GitignoreSupport
 
         ENGINE_MOUNT_TOKEN = "Rails::Hyperdrive::Engine"
+        ROUTES_DRAW_ANCHOR = /Rails\.application\.routes\.draw do\s*\n/
         DEFAULT_MOUNT_AT = "/_hyperdrive".freeze
+        MOUNT_PATH_FORMAT = %r{\A/[A-Za-z0-9_-]+(?:/[A-Za-z0-9_-]+)*\z}
 
         MCP_JSON_PATH = ".mcp.json".freeze
         MCP_SERVER_KEY = "rails-hyperdrive".freeze
@@ -65,7 +67,7 @@ module Rails
         # sibling USAGE file for `--help`.
         source_root File.expand_path("templates", __dir__)
 
-        class_option :mount_at,      type: :string,  default: DEFAULT_MOUNT_AT, desc: "Engine mount path."
+        class_option :mount_at,      type: :string,  default: DEFAULT_MOUNT_AT, desc: "Engine mount path: one or more /segments of letters, digits, _ and -. Ignored with --skip-mcp."
         class_option :skip_content,  type: :boolean, default: false, desc: "Skip all .claude content, CLAUDE.md, the config file, and the lockfile; leave the .mcp.json, .gitignore, Gemfile, and mount steps."
         class_option :skip_mcp,      type: :boolean, default: false, desc: "Skip MCP setup entirely; write no .mcp.json entry and no engine mount."
         class_option :dry_run,       type: :boolean, default: false, desc: "Show what would change; write nothing."
@@ -74,6 +76,16 @@ module Rails
           runner.verify_environment!
         end
 
+        # The value is interpolated into config/routes.rb as Ruby source, so it
+        # is validated before anything is written, a dry run included.
+        def verify_options
+          return if options[:skip_mcp]
+          return if mount_path.match?(MOUNT_PATH_FORMAT)
+
+          raise Thor::Error, "hyperdrive: --mount-at must be a plain path of one or more " \
+            "/segments (letters, digits, _ and -), got #{options[:mount_at].to_s.inspect}"
+        end
+
         def discover_artifacts
           runner.discover_artifacts(skip: options[:skip_content])
         end
@@ -132,12 +144,24 @@ module Rails
 
           contents = File.read(::Rails.root.join(routes_file))
           if contents.include?(ENGINE_MOUNT_TOKEN)
+            @mounted = true
             say_status :identical, "#{routes_file} (engine already mounted)", :blue
             return
           end
 
           snippet = "  mount Rails::Hyperdrive::Engine => \"#{mount_path}\" if Rails.env.development?\n"
-          inject_into_file routes_file, snippet, after: /Rails\.application\.routes\.draw do\s*\n/
+          # inject_into_file reports a non-match as an ordinary unchanged line
+          # and returns, so the anchor is checked here or the summary would
+          # claim a mount that never landed.
+          unless contents.match?(ROUTES_DRAW_ANCHOR)
+            say_status :warn, "#{routes_file} has no `Rails.application.routes.draw do` block; add " \
+              "`mount Rails::Hyperdrive::Engine => \"#{mount_path}\" if Rails.env.development?` " \
+              "to your routes by hand", :yellow
+            return
+          end
+
+          inject_into_file routes_file, snippet, after: ROUTES_DRAW_ANCHOR
+          @mounted = true
         end
 
         # The settings are the user's, so an existing file is never rewritten or
@@ -167,7 +191,7 @@ module Rails
           if options[:skip_mcp]
             say "  MCP: skipped (--skip-mcp)"
           else
-            say "  Mount: #{mount_path} (in config/routes.rb)"
+            say "  Mount: #{mount_path} #{@mounted ? "(in config/routes.rb)" : "(not written to config/routes.rb; see warning above)"}"
             say "  Server: #{::Rails::Hyperdrive::McpServer::TOOLS.size} MCP tools at http://localhost:3000#{mount_path}/mcp"
           end
           runner.summary_lines.each { |line| say line } unless options[:skip_content]

data/lib/generators/hyperdrive/sync_runner.rb

@@ -111,9 +111,20 @@ module Rails
         # Raised from install, so it stops the run before any content write —
         # a dry run included.
         def verify_lock_schema!
-          return unless lock.schema_ahead?
+          return unless readable_lock.schema_ahead?
 
-          message = lock.schema_ahead_message(::Rails::Hyperdrive::InstallLayout::LOCK_PATH)
+          halt_lock(lock.schema_ahead_message(::Rails::Hyperdrive::InstallLayout::LOCK_PATH))
+        end
+
+        def readable_lock
+          lock
+        rescue ::Rails::Hyperdrive::LockFile::UnreadableError => e
+          halt_lock(::Rails::Hyperdrive::LockFile.unreadable_message(
+            ::Rails::Hyperdrive::InstallLayout::LOCK_PATH, e.reason
+          ))
+        end
+
+        def halt_lock(message)
           @shell.say_status :error, message, :red
           raise Thor::Error, "hyperdrive: #{message}"
         end

data/lib/rails/commands/hyperdrive/hyperdrive_command.rb

@@ -49,9 +49,13 @@ module Rails
       end
 
       no_commands do
+        # Every generator read goes through ::Rails.root, so the destination
+        # must too — Thor would otherwise default it to the cwd `bin/rails` was
+        # invoked from and split reads and writes across two directories.
         def start_generator(name, generator)
           require_application!
-          ::Rails::Generators::Hyperdrive.const_get(generator).start(@argv)
+          ::Rails::Generators::Hyperdrive.const_get(generator)
+            .start(@argv, destination_root: ::Rails.root.to_s)
         end
       end
     end

data/lib/rails/hyperdrive/auto_install.rb

@@ -55,7 +55,11 @@ module Rails
         return skip(:not_development) unless development?(env)
         return skip(:not_initialized) unless File.exist?(File.join(root, InstallLayout::LOCK_PATH))
 
-        lock = LockFile.load(File.join(root, InstallLayout::LOCK_PATH))
+        begin
+          lock = LockFile.load(File.join(root, InstallLayout::LOCK_PATH))
+        rescue LockFile::UnreadableError => e
+          return halted(LockFile.unreadable_message(InstallLayout::LOCK_PATH, e.reason))
+        end
         return halted(lock.schema_ahead_message(InstallLayout::LOCK_PATH)) if lock.schema_ahead?
 
         config = ConfigFile.load(File.join(root, InstallLayout::CONFIG_PATH))

data/lib/rails/hyperdrive/bundler_artifact_discovery.rb

@@ -101,11 +101,16 @@ module Rails
           warn_unknown_manifest_keys(manifest, spec, seen, report)
         end
 
-        # Collapse same-name variants within one source gem (highest
-        # spec_version, path as tiebreak); never across sources — composite
-        # identity is (name, source_gem).
+        # Collapse same-name candidates within one source gem (the same name
+        # shipped under two roots) to the greatest path; never across sources —
+        # composite identity is (name, source_gem, artifact_type).
         candidates.group_by { |a| [a.name, a.source_gem, a.artifact_type] }.map do |_key, group|
-          group.max_by { |a| [Gem::Version.new(a.spec_version), a.path] }
+          winner = group.max_by(&:path)
+          group.each do |loser|
+            next if loser.equal?(winner)
+            report.skip "skip #{loser.path}: #{winner.path} takes precedence"
+          end
+          winner
         end
       end
 

data/lib/rails/hyperdrive/canonical_skill_render.rb

@@ -124,7 +124,7 @@ module Rails
         meta = YAML.safe_load(frontmatter, permitted_classes: [Symbol]) || {}
         return if meta["name"] && meta["description"]
         raise Error, "#{template}: rendered frontmatter lacks name: or description:"
-      rescue Psych::SyntaxError
+      rescue Psych::Exception
         raise Error, "#{template}: rendered frontmatter is not parseable YAML"
       end
 

data/lib/rails/hyperdrive/install_pipeline.rb

@@ -48,7 +48,11 @@ module Rails
       end
 
       def call
-        return halt_schema_ahead if old_lock.schema_ahead?
+        begin
+          return halt_schema_ahead if old_lock.schema_ahead?
+        rescue LockFile::UnreadableError => e
+          return halt_unreadable_lock(e)
+        end
 
         report_settings_warnings
         @new_lock = LockFile.new(abs(InstallLayout::LOCK_PATH)).carry_document(old_lock)
@@ -89,6 +93,12 @@ module Rails
         @result
       end
 
+      def halt_unreadable_lock(error)
+        @shell.say_status :warn,
+          LockFile.unreadable_message(InstallLayout::LOCK_PATH, error.reason), :yellow
+        @result
+      end
+
       def build_result
         @build_result ||= InstallPlan.build(@artifacts, config: config)
       end
@@ -139,6 +149,8 @@ module Rails
       end
 
       def report_disabled
+        return if additive?
+
         build_result.disabled.each do |entry|
           @shell.say_status :disabled, "#{entry.type} '#{entry.final_name}' (listed in #{InstallLayout::CONFIG_PATH})", :blue
         end
@@ -598,12 +610,25 @@ module Rails
           next if already_removed?(entry.path)
           next unless DriftVerdict.verdict(file: abs(entry.path), lock_entry: entry, gem_sha: nil) == :orphaned
 
+          # A disabled artifact left on disk is still shipped by its gem, so it
+          # is not stranded and draws no orphan report.
+          if disabled_entry?(entry)
+            @new_lock.carry(entry)
+            next
+          end
+
           @result.orphaned << entry.path
           @shell.say_status :orphan, "#{entry.path} (#{orphan_reason(entry)}; left in place)", :yellow
           @new_lock.carry(entry)
         end
       end
 
+      def disabled_entry?(entry)
+        type = InstallLayout::ARTIFACT_TYPES[entry.kind]
+        return false unless type
+        InstallPlan.disabled_dest?(config, type, entry.path, source_gem: entry.source_gem)
+      end
+
       def orphan_reason(entry)
         LockFile.orphan_reason(
           source_label: entry.source_label,

data/lib/rails/hyperdrive/lock_file.rb

@@ -9,6 +9,17 @@ module Rails
       STATE_PRESENT  = "present".freeze
       STATE_REMOVED  = "removed-by-user".freeze
 
+      # A lock that exists but cannot be understood is never treated as absent:
+      # rewriting it would drop every entry and the user's claude_md state.
+      class UnreadableError < StandardError
+        attr_reader :reason
+
+        def initialize(reason)
+          @reason = reason
+          super(reason)
+        end
+      end
+
       # In-memory form of one files: entry. On disk, source_gem and
       # source_version are a single "gem@version" string; the split/join lives
       # in this file only.
@@ -60,8 +71,16 @@ module Rails
       def read
         return self unless File.exist?(@path)
 
-        data = YAML.safe_load(File.read(@path))
-        return self unless data.is_a?(Hash)
+        begin
+          raw = File.read(@path)
+          data = YAML.safe_load(raw)
+        rescue Psych::Exception => e
+          raise UnreadableError, "not valid YAML: #{e.message.to_s.lines.first.to_s.strip}"
+        rescue SystemCallError => e
+          raise UnreadableError, e.message
+        end
+        return self if data.nil?
+        raise UnreadableError, "root is not a map" unless data.is_a?(Hash)
 
         @document = data
         @schema_version = data["version"]
@@ -74,8 +93,10 @@ module Rails
           @files[entry.path] = entry if entry.path
         end
         self
-      rescue Psych::SyntaxError
-        self
+      end
+
+      def self.unreadable_message(display_path, reason)
+        "#{display_path} could not be read (#{reason}); fix it or restore it from git, then re-run"
       end
 
       # A lock written by a newer installer holds state this one cannot read,

data/lib/rails/hyperdrive/mcp_server.rb

@@ -32,15 +32,14 @@ module Rails
         @server ||= build_server
       end
 
-      def rack_app(allowed_hosts: Safety::RackMiddleware::DEFAULT_ALLOWED_HOSTS)
+      def rack_app
         # The transport's own DNS-rebinding check requires same-origin (host:port);
         # it is disabled because Safety::RackMiddleware enforces the localhost
         # Origin allowlist, which accepts any port.
         @rack_app ||= Safety::RackMiddleware.new(
           ::MCP::Server::Transports::StreamableHTTPTransport.new(
             server, stateless: true, enable_json_response: true, dns_rebinding_protection: false
-          ),
-          allowed_hosts: allowed_hosts
+          )
         )
       end
 

data/lib/rails/hyperdrive/sql_safety.rb

@@ -6,6 +6,7 @@ module Rails
     module SqlSafety
       ALLOWED_LEADERS = /\A\s*(WITH\b.*?\bSELECT\b|SELECT\b|EXPLAIN\b|SHOW\b|PRAGMA\b)/im
       FORBIDDEN_TOKEN = /\b(INSERT|UPDATE|DELETE|DROP|ALTER|TRUNCATE|CREATE|GRANT|REVOKE|REPLACE|MERGE|RENAME|VACUUM|ATTACH|DETACH)\b/i
+      PRAGMA_LEADER = /\A\s*PRAGMA\b/i
 
       class Error < StandardError; end
 
@@ -16,6 +17,11 @@ module Rails
         unless sql =~ ALLOWED_LEADERS
           raise Error, "only SELECT / WITH...SELECT / EXPLAIN / SHOW / PRAGMA are allowed"
         end
+        # `PRAGMA x = y` writes; the paren form (`PRAGMA table_info(users)`)
+        # cannot be told apart from a read and stays allowed.
+        if sql =~ PRAGMA_LEADER && sql.include?("=")
+          raise Error, "PRAGMA assignments are not allowed"
+        end
         # Second pass catches a mutation smuggled inside a CTE body
         # (e.g. `WITH x AS (DELETE ...) SELECT ...`).
         if sql =~ FORBIDDEN_TOKEN

data/lib/rails/hyperdrive/tools/run_sql.rb

@@ -6,13 +6,13 @@ module Rails
     module Tools
       class RunSql < Base
         tool_name "run_sql"
-        description "Read-only SQL via ActiveRecord::Base.connection. Rejects INSERT/UPDATE/DELETE/DROP/etc. at the parser level. Caps results at 100 rows."
+        description "Read-only SQL via ActiveRecord::Base.connection. Rejects INSERT/UPDATE/DELETE/DROP/etc. at the parser level, and refuses PRAGMA assignments (`PRAGMA foreign_keys = ON`). Caps results at 100 rows."
 
         ROW_CAP = 100
 
         input_schema(
           properties: {
-            sql: { type: "string", description: "A SELECT / WITH / EXPLAIN / SHOW / PRAGMA statement." }
+            sql: { type: "string", description: "A SELECT / WITH / EXPLAIN / SHOW / PRAGMA statement. PRAGMA reads only: `PRAGMA table_info(users)` is allowed, `PRAGMA name = value` is refused." }
           },
           required: ["sql"]
         )

data/lib/rails/hyperdrive/version.rb

@@ -1,5 +1,5 @@
 module Rails
   module Hyperdrive
-    VERSION = "0.9.2"
+    VERSION = "0.10.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-hyperdrive
 version: !ruby/object:Gem::Version
-  version: 0.9.2
+  version: 0.10.0
 platform: ruby
 authors:
 - Bakaface