mcptask-rails-runner 0.3.0-aarch64-linux

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 03223dd8a23acf3c545df7ab4cf4b83ef43882ea8a91a91236d206fd4563a457
+  data.tar.gz: 31c7064d6f89e918936152b815cea1fd79151921140691bfd43b6373eea6aa5c
+SHA512:
+  metadata.gz: 9942953edb8f0874ba056310ed56ef8b1fe58fa8ba3861b62a0d54225773495dc512b5798105a7f22f060489c1ae184a044ad8248caebeb53b3898e0c4b55bf1
+  data.tar.gz: 555ac773cc0e86295d7c2b9d463f80b86c3da786f62aae217291e1fee0f3fc0bc2aa6d9955898e870b45cc11479d31ed1d0e7be4e7863e08c30ab0b21b2cd211

data/CHANGELOG.md

@@ -0,0 +1,33 @@
+# Changelog
+
+The version number tracks the `mcptask_runner` binary the gem ships, so the
+entries below describe wrapper changes only. Binary changes are listed in the
+[mcptask-releases](https://github.com/jchsoft/mcptask-releases/releases)
+release notes for the same tag.
+
+## 0.3.0
+
+- The Go runner is the runner: this gem is the Rails distribution, and the
+  legacy `mcptask_runner` gem is retired to critical fixes and its role as the
+  conformance suite's reference implementation.
+
+- The ARM Linux platform gem is named `aarch64-linux`, which is the platform
+  such hosts actually resolve. 0.2.4 published it as `arm64-linux`, which
+  matches nothing: every Graviton server, ARM CI runner and Docker container on
+  Apple Silicon fell back to the binary-less `ruby` gem and failed at run time.
+  That gem stays published and unreachable.
+- `mcptask_runner:install` and `:update` copy the binary out of the gem to
+  `~/.mcptask/bin/mcptask_runner` and run it from there, so the scheduled job
+  they generate survives the next `bundle update` — which deletes the gem
+  directory the job used to point into. They print which version they wrote and
+  never replace a newer installed binary with an older one. Migrating hosts
+  should re-run install once, with `FORCE=1`, to regenerate the job.
+
+## 0.2.4
+
+- First release. Thin Rails wrapper around the `mcptask_runner` Go binary,
+  with the rake surface of the legacy `mcptask_runner` gem kept unchanged so
+  migrating is a one-line Gemfile edit.
+- Platform gems for `arm64-darwin`, `x86_64-darwin`, `arm64-linux`,
+  `x86_64-linux` and `x64-mingw-ucrt`; the `ruby` fallback gem explains how to
+  supply a binary through `MCPTASK_RUNNER_BIN`.

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 JchSoft s.r.o.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,143 @@
+# mcptask-rails-runner
+
+Rails distribution of the [mcptask.online](https://mcptask.online) autonomous
+runner, and the way a Rails app installs it. A thin Ruby wrapper around the
+`mcptask_runner` Go binary: the gem ships the platform-specific binary inside
+itself (`libexec/`) and exposes the same rake tasks as the legacy
+`mcptask_runner` gem, delegating 1:1 to the CLI.
+
+The legacy gem is retired. It gets critical fixes only, and it stays in
+existence as the reference implementation the Go runner's conformance suite
+measures against; everything new is written in Go. What you gain by moving:
+Linux and Windows hosts, a scheduled job with no bundler in its path, and a
+handful of places where the old implementation was simply wrong (its token
+resolution read a different half of `.mcp.json` in each of three places, and
+its stream reader died mid-run on an API error envelope).
+
+One gem version carries exactly one binary version — `mcptask-rails-runner
+X.Y.Z` contains the binary from the `vX.Y.Z` release of
+[jchsoft/mcptask-releases](https://github.com/jchsoft/mcptask-releases).
+
+`mcptask_runner:install` and `:update` copy that binary out of the gem to
+`~/.mcptask/bin/mcptask_runner` and run it from there. The scheduled job runs
+that copy, because a job pointing inside a gem directory dies at the next
+`bundle update` — at 08:00, in a log nobody reads. So the pin is per project:
+the Gemfile decides what a foreground `rake mcptask_runner:*` runs, while the
+machine has one installed binary however many projects it carries, and the
+newest version any of them offers is the one that stays. Install and update
+print which version they wrote, and never replace a newer installed binary
+with an older one.
+
+## Requirements
+
+- Ruby >= 3.0, Rails >= 6.0
+- [Claude Code](https://claude.com/claude-code) CLI
+- An mcptask.online account
+
+## Installation
+
+```ruby
+# Gemfile
+gem "mcptask-rails-runner"
+```
+
+```bash
+bundle install
+bundle exec rake mcptask_runner:install
+```
+
+## Migrating from the legacy mcptask_runner gem
+
+The rake surface is identical — the migration is one Gemfile line:
+
+```diff
+- gem "mcptask_runner", git: "git@github.com:jchsoft/mcptask_runner.git"
++ gem "mcptask-rails-runner"
+```
+
+Then:
+
+```bash
+bundle install
+FORCE=1 bundle exec rake mcptask_runner:install
+```
+
+Re-running install is what regenerates the scheduled job. The legacy launcher
+runs `bundle exec rake` and logs the active version by grepping `Gemfile.lock`
+for the old gem name — neither survives the rename, so a job left as it is
+keeps working but stops recording what it ran. The regenerated one execs
+`~/.mcptask/bin/mcptask_runner` directly, with no bundler in the 08:00 path.
+
+Every `rake mcptask_runner:*` invocation and shell alias keeps working
+unchanged. Your existing
+`config/mcptask_runner.yml`, `.mcp.json` and `.claude/` setup are read by the
+Go binary as-is. The only legacy task without a counterpart is
+`mcptask_runner:prepare:permissions` — permission sync is part of
+`mcptask_runner:install` now.
+
+## Tasks
+
+| Task | Delegates to |
+|---|---|
+| `mcptask_runner:install` | `mcptask_runner init` (from `~/.mcptask/bin`) |
+| `mcptask_runner:update` | `mcptask_runner update` (from `~/.mcptask/bin`) |
+| `mcptask_runner:bug_report` | `mcptask_runner bug-report` |
+| `mcptask_runner:version` | `mcptask_runner version` |
+| `mcptask_runner:manual:once` (`once_dry`, `today`, `daily`, `review`, `reviews`, `workflow`, `queue`) | `mcptask_runner run <mode>` |
+| `mcptask_runner:manual:story[123]` / `manual:task[123]` | `run story_manual --story-id 123` / `run task_manual --task-id 123` |
+| `mcptask_runner:auto:once` | `run once_auto_squash` |
+| `mcptask_runner:auto:squash:today` (`queue`, `story[123]`, `task[123]`) | `run <mode>_auto_squash` |
+
+`verbose=true` and `ignore_quota=true` environment variables are honored by
+the binary itself, exactly as before.
+
+## Supported platforms
+
+Platform gems exist for `arm64-darwin`, `x86_64-darwin`, `aarch64-linux`,
+`x86_64-linux` and `x64-mingw-ucrt`. On anything else bundler falls back to
+the binary-less `ruby` platform gem, which fails at run time with
+instructions: install the binary from
+[mcptask-releases](https://github.com/jchsoft/mcptask-releases) (or via
+`install.sh` / npm `@mcptask/cli`) and point `MCPTASK_RUNNER_BIN` at it. The
+same variable also serves offline or air-gapped installs.
+
+The wrapper always executes the binary through an absolute path — inside the
+gem for the run tasks, `~/.mcptask/bin` for install and update — and never
+through PATH: the binary shares its name with the legacy tooling, and a PATH
+lookup could pick up the wrong install. `MCPTASK_RUNNER_BIN` overrides both,
+and install leaves `~/.mcptask/bin` untouched while it is set.
+
+## Development
+
+```bash
+bundle install
+bundle exec rake test          # unit tests (binary resolution + task mapping)
+bin/fetch-binaries             # stage release binaries into tmp/binaries/
+bundle exec rake package:all   # build all platform gems into pkg/
+```
+
+## Releasing
+
+Releases are cut by tagging: bump `lib/mcptask_rails_runner/version.rb` to
+match an existing `mcptask-releases` tag, push a matching `vX.Y.Z` tag, and
+the Release workflow downloads the binaries (sha256-verified), builds the
+platform gems and publishes them to rubygems.org through OIDC trusted
+publishing. See `.github/workflows/release.yml`.
+
+One-time setup on rubygems.org, before the first tag can publish anything —
+the gem name has to exist as a trusted-publisher entry:
+
+1. Sign in on rubygems.org, open **Profile → Trusted publishers → Create**.
+2. For a gem that has never been pushed, use **Create a pending trusted
+   publisher** with gem name `mcptask-rails-runner`; for an existing gem, add
+   the publisher on the gem's own page.
+3. Repository owner `jchsoft`, repository name `mcptask-rails-runner`,
+   workflow filename `release.yml`, environment empty.
+
+No API key is stored anywhere: `rubygems/configure-rubygems-credentials`
+exchanges the workflow's OIDC token for a short-lived credential at push time.
+The same model as the npm publish in the Go repository.
+
+## License
+
+MIT

data/lib/mcptask/rails/runner.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+# Bundler's default require for a gem named mcptask-rails-runner.
+require "mcptask_rails_runner"

data/lib/mcptask_rails_runner/binary.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module McptaskRailsRunner
+  # Locates, installs and executes the bundled Go binary.
+  module Binary
+    GEM_ROOT = File.expand_path("../..", __dir__)
+
+    SUPPORTED_PLATFORMS = %w[
+      arm64-darwin
+      x86_64-darwin
+      aarch64-linux
+      x86_64-linux
+      x64-mingw-ucrt
+    ].freeze
+
+    # Where the binary is installed to live, outside every gem directory.
+    #
+    # The scheduled job runs this path, and it has to be one that survives a
+    # `bundle update`: a job pointing into
+    # gems/mcptask-rails-runner-<version>-<platform>/libexec dies the moment the
+    # gem is bumped, at 08:00, in a log nobody reads. Under the runner's own
+    # ~/.mcptask rather than /usr/local/bin, because `bundle install` has no
+    # sudo and a gem cannot write there. The Go side knows the same path — see
+    # InstalledBinary in internal/install/schedule.go.
+    INSTALL_DIR = File.join(Dir.home, ".mcptask", "bin")
+
+    # The line `mcptask_runner version` prints the version on.
+    VERSION_LINE = /Version:\s*(\S+)/
+
+    module_function
+
+    def executable_name
+      Gem.win_platform? ? "mcptask_runner.exe" : "mcptask_runner"
+    end
+
+    # Absolute path to the binary this gem runs. Never resolved through PATH:
+    # the binary shares the mcptask_runner name with the legacy gem's rake
+    # namespace, and a PATH lookup could pick up a stale or wrong install.
+    def path(gem_root: GEM_ROOT)
+      override = ENV["MCPTASK_RUNNER_BIN"]
+      return override unless override.nil? || override.empty?
+
+      bundled_path(gem_root: gem_root)
+    end
+
+    # The copy that ships inside this gem, which is the one the Gemfile pins.
+    def bundled_path(gem_root: GEM_ROOT)
+      exe = File.join(gem_root, "libexec", executable_name)
+      return exe if File.file?(exe)
+
+      raise Error, <<~MSG
+        mcptask_runner binary not found at #{exe}.
+
+        The platform gem for #{Gem::Platform.local} was probably not installed.
+        Supported platforms: #{SUPPORTED_PLATFORMS.join(', ')}.
+
+        On a supported platform, re-run `bundle install` (and make sure the
+        platform is in Gemfile.lock: `bundle lock --add-platform #{Gem::Platform.local}`).
+        On an unsupported platform, install the binary from
+        https://github.com/jchsoft/mcptask-releases and point the
+        MCPTASK_RUNNER_BIN environment variable at it.
+      MSG
+    end
+
+    # The version-free path the installed copy lives at.
+    def installed_path(install_dir: INSTALL_DIR)
+      File.join(install_dir, executable_name)
+    end
+
+    # Copies the bundled binary out of the gem, and returns what to run.
+    #
+    # The gem bootstraps the binary; it does not host it. Everything the
+    # scheduled job touches has to outlive `bundle update`, and a gem directory
+    # does not — so install and update put a copy where nothing but they will
+    # ever move it. A copy rather than a symlink: a link into the gem's libexec
+    # dangles on the same bundle update, which is the identical 08:00 failure
+    # moved one step along, and Windows wants a privilege for symlinks besides.
+    #
+    # Teaching the launcher to run `bundle exec rake` instead would fix the path
+    # and put bundler and Gemfile.lock back into the 08:00 path — the layer the
+    # Go port set out to remove.
+    #
+    # Newest wins, and says so. A host with several projects has several gem
+    # versions and one installed binary, so a project pinning an older gem must
+    # not quietly drag the machine's runner backwards.
+    def install!(install_dir: INSTALL_DIR, gem_root: GEM_ROOT, out: $stdout)
+      override = ENV["MCPTASK_RUNNER_BIN"]
+      unless override.nil? || override.empty?
+        out.puts "[mcptask_runner] MCPTASK_RUNNER_BIN is set — running #{override} " \
+                 "and leaving #{installed_path(install_dir: install_dir)} alone."
+        return override
+      end
+
+      source = bundled_path(gem_root: gem_root)
+      target = installed_path(install_dir: install_dir)
+
+      existing = installed_version(target)
+      if existing && existing > Gem::Version.new(VERSION)
+        out.puts "[mcptask_runner] #{target} already holds #{existing}, which is newer than this " \
+                 "gem's #{VERSION} — keeping it. Delete that file to install this gem's binary instead."
+        return target
+      end
+
+      copy(source, target)
+      out.puts "[mcptask_runner] installed mcptask_runner #{VERSION} into #{target}" \
+               "#{existing ? " (replacing #{existing})" : ''}."
+      target
+    end
+
+    # Replaces the current process, so the binary's exit code and signal
+    # handling reach the caller (rake) unchanged.
+    def exec!(*args)
+      Kernel.exec(path, *args)
+    end
+
+    # Installs the binary outside the gem first, then runs that copy.
+    #
+    # Used by install and update, the two tasks that generate the scheduled job:
+    # the job runs whichever binary is executing them, so it has to be the copy
+    # at the version-free path rather than the one inside this gem.
+    def exec_installed!(*args)
+      Kernel.exec(install!, *args)
+    end
+
+    # What the installed copy reports about itself, or nil when there is none —
+    # or when it cannot be asked, which a stray file at that path cannot be.
+    #
+    # Asked of the binary rather than recorded in a marker file beside it: the
+    # binary is what actually runs at 08:00, and a marker can only be right
+    # about installs that went through here.
+    def installed_version(target)
+      return nil unless File.file?(target)
+
+      banner = IO.popen([target, "version"], err: File::NULL, &:read)
+      raw = banner.to_s[VERSION_LINE, 1]
+      raw && Gem::Version.new(raw)
+    rescue StandardError
+      nil
+    end
+
+    # Written beside the target and renamed into place: a half-copied binary
+    # over a working one is a scheduled job that fails on a corrupt file, and
+    # the rename also sidesteps the ETXTBSY a running copy would give.
+    def copy(source, target)
+      FileUtils.mkdir_p(File.dirname(target))
+      staged = "#{target}.new"
+      FileUtils.cp(source, staged)
+      FileUtils.chmod(0o755, staged)
+      File.rename(staged, target)
+    end
+  end
+end

data/lib/mcptask_rails_runner/railtie.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "rails/railtie"
+
+module McptaskRailsRunner
+  class Railtie < ::Rails::Railtie
+    rake_tasks do
+      load File.expand_path("../tasks/mcptask_runner.rake", __dir__)
+    end
+  end
+end

data/lib/mcptask_rails_runner/version.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module McptaskRailsRunner
+  # The gem version names the mcptask_runner binary release it carries (tag
+  # v#{VERSION} in jchsoft/mcptask-releases). Bump both together.
+  #
+  # What it does not name is the binary the host runs at 08:00. That one is
+  # installed outside every gem directory, by install and update, and a machine
+  # has one of it however many projects and gem versions it carries — see
+  # Binary::INSTALL_DIR. So the pin is per project and per foreground rake
+  # invocation; the installed copy is per machine, and the newest binary any of
+  # those projects offers is the one that stays.
+  VERSION = "0.3.0"
+end

data/lib/mcptask_rails_runner.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "mcptask_rails_runner/version"
+
+module McptaskRailsRunner
+  class Error < StandardError; end
+
+  # Validates a rake bracket argument such as manual:story[123].
+  def self.piece_id!(value, name, example)
+    id = Integer(value, exception: false)
+    raise ArgumentError, "#{name} is required and must be a positive integer (usage: rake '#{example}')" if id.nil? || id < 1
+
+    id.to_s
+  end
+end
+
+require_relative "mcptask_rails_runner/binary"
+
+# Only inside a booted Rails app — rails/railtie needs active_support loaded,
+# and outside Rails there is nothing to hook the rake tasks into.
+require_relative "mcptask_rails_runner/railtie" if defined?(::Rails::Railtie)

data/lib/tasks/mcptask_runner.rake

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+# Rake surface kept identical to the legacy mcptask_runner gem, so migrating
+# a customer is only a Gemfile line swap. Every task delegates 1:1 to the
+# bundled Go CLI via Kernel#exec — the binary's exit code and signal handling
+# reach the caller unchanged, and nothing runs after the delegation line.
+#
+# Two of them delegate to the installed copy instead of the bundled one. install
+# and update are the tasks that generate the scheduled job, and the job runs
+# whichever binary generated it: pointing it inside this gem would have it die
+# at the next `bundle update`, which deletes that directory. Everything else
+# runs the binary the Gemfile pins, which is what a foreground rake invocation
+# should do.
+
+require "mcptask_rails_runner"
+
+namespace :mcptask_runner do
+  desc "Install skills, permissions, token and scheduled job into this project"
+  task :install do
+    McptaskRailsRunner::Binary.exec_installed!("init")
+  end
+
+  desc "Refresh bundled skills and helpers"
+  task :update do
+    McptaskRailsRunner::Binary.exec_installed!("update")
+  end
+
+  desc "File a bug against the project with the last run log attached"
+  task :bug_report do
+    McptaskRailsRunner::Binary.exec!("bug-report")
+  end
+
+  desc "Print runner version and resolved configuration"
+  task :version do
+    McptaskRailsRunner::Binary.exec!("version")
+  end
+
+  namespace :manual do
+    {
+      once: "once",
+      once_dry: "once_dry",
+      today: "today",
+      daily: "daily",
+      review: "review",
+      reviews: "reviews",
+      workflow: "workflow",
+      queue: "queue_manual"
+    }.each do |task_name, mode|
+      desc "Run the work loop in #{mode} mode"
+      task task_name do
+        McptaskRailsRunner::Binary.exec!("run", mode)
+      end
+    end
+
+    desc "Work a single story in manual mode"
+    task :story, [:story_id] do |_t, args|
+      id = McptaskRailsRunner.piece_id!(args[:story_id], "story_id", "mcptask_runner:manual:story[123]")
+      McptaskRailsRunner::Binary.exec!("run", "story_manual", "--story-id", id)
+    end
+
+    desc "Work a single task in manual mode"
+    task :task, [:task_id] do |_t, args|
+      id = McptaskRailsRunner.piece_id!(args[:task_id], "task_id", "mcptask_runner:manual:task[123]")
+      McptaskRailsRunner::Binary.exec!("run", "task_manual", "--task-id", id)
+    end
+  end
+
+  namespace :auto do
+    desc "Run the work loop in once_auto_squash mode"
+    task :once do
+      McptaskRailsRunner::Binary.exec!("run", "once_auto_squash")
+    end
+
+    namespace :squash do
+      desc "Run the work loop in today_auto_squash mode"
+      task :today do
+        McptaskRailsRunner::Binary.exec!("run", "today_auto_squash")
+      end
+
+      desc "Run the work loop in queue_auto_squash mode"
+      task :queue do
+        McptaskRailsRunner::Binary.exec!("run", "queue_auto_squash")
+      end
+
+      desc "Work a single story in auto-squash mode"
+      task :story, [:story_id] do |_t, args|
+        id = McptaskRailsRunner.piece_id!(args[:story_id], "story_id", "mcptask_runner:auto:squash:story[123]")
+        McptaskRailsRunner::Binary.exec!("run", "story_auto_squash", "--story-id", id)
+      end
+
+      desc "Work a single task in auto-squash mode"
+      task :task, [:task_id] do |_t, args|
+        id = McptaskRailsRunner.piece_id!(args[:task_id], "task_id", "mcptask_runner:auto:squash:task[123]")
+        McptaskRailsRunner::Binary.exec!("run", "task_auto_squash", "--task-id", id)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: mcptask-rails-runner
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: aarch64-linux
+authors:
+- Josef Chmel
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+description: Thin Rails wrapper around the mcptask_runner Go binary. Ships the platform-specific
+  binary inside the gem and exposes the same rake tasks as the legacy mcptask_runner
+  gem, delegating 1:1 to the CLI.
+email:
+- info@jchsoft.cz
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/mcptask/rails/runner.rb
+- lib/mcptask_rails_runner.rb
+- lib/mcptask_rails_runner/binary.rb
+- lib/mcptask_rails_runner/railtie.rb
+- lib/mcptask_rails_runner/version.rb
+- lib/tasks/mcptask_runner.rake
+- libexec/mcptask_runner
+homepage: https://github.com/jchsoft/mcptask-rails-runner
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/jchsoft/mcptask-rails-runner
+  bug_tracker_uri: https://github.com/jchsoft/mcptask-rails-runner/issues
+  changelog_uri: https://github.com/jchsoft/mcptask-rails-runner/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: mcptask.online autonomous runner for Rails apps
+test_files: []