mcptask-rails-runner 0.2.4 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 90fb6326f0a5b5ffde6055867b4709a7574acb7f1e8cc3facc9b00c37d60518e
-  data.tar.gz: 30dd43c20ec169dadcb0729e63e6c074c84180a2649983478bb9c56a57b630fc
+  metadata.gz: '0519b4bebbc7206e258a1c0ca68d4b33a1d4ca65e7b1df96e94bc7fcea9d195a'
+  data.tar.gz: fb10b8db54c85034117828907847bb13c62d80f316591490724c2e8804fcebdd
 SHA512:
-  metadata.gz: f2b2a21772d92034835ba3c75483f51312bda2ea235cc407fca2de43a44f4e5dca62f72f3cb4da04e6d50f0c22fa8bf258b02b3bfd0268378e9b984f8197c51c
-  data.tar.gz: 901f117d861d84118d85e0a1684573858aa826f10a969df45130656b480452022618297f70fd35103e76d88f880525a4a787b0dabde04e7504ee1b0dd3d0fcd6
+  metadata.gz: 5d80a74fce1cb46bcef44e67e6d17c3015a9651a53fc8099b05fd75abb29c9f5b7f37e22d194f1192cfb6e1a7527ae9c5f3ae21b7462ce5bf43d01c64d49722e
+  data.tar.gz: 5fa67df8de13a98d9f42990dacfadea7b56b7cb040bbde6186cb9cb1d764ca46f9a191dbb163c4aade6bb4d036334249820af81e389801c7ba95e3279a2c9773

data/CHANGELOG.md

@@ -5,6 +5,36 @@ 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.1
+
+- `mcptask_runner:install` no longer asks for mcptask.online credentials on a
+  host whose token already resolves — from `.mcp.json` or the environment. It
+  says which one it found and where, and leaves it alone; set `MCPTASK_EMAIL`
+  and `MCPTASK_PASSWORD` to replace it deliberately. Where there really is no
+  token, the step now says whose account it wants, that the password is
+  exchanged once and never stored, which file the token lands in, and that the
+  runner will not start without one.
+- The release workflow waits for the Go binaries instead of failing when the two
+  tags are pushed minutes apart.
+
+## 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,

data/README.md

@@ -1,14 +1,33 @@
 # mcptask-rails-runner
 
 Rails distribution of the [mcptask.online](https://mcptask.online) autonomous
-runner. 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.
+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
@@ -36,8 +55,21 @@ The rake surface is identical — the migration is one Gemfile line:
 + gem "mcptask-rails-runner"
 ```
 
-Then `bundle install` and carry on; every `rake mcptask_runner:*` invocation,
-LaunchAgent and shell alias keeps working. Your existing
+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
@@ -47,8 +79,8 @@ Go binary as-is. The only legacy task without a counterpart is
 
 | Task | Delegates to |
 |---|---|
-| `mcptask_runner:install` | `mcptask_runner init` |
-| `mcptask_runner:update` | `mcptask_runner update` |
+| `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>` |
@@ -61,7 +93,7 @@ the binary itself, exactly as before.
 
 ## Supported platforms
 
-Platform gems exist for `arm64-darwin`, `x86_64-darwin`, `arm64-linux`,
+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
@@ -69,9 +101,11 @@ instructions: install the binary from
 `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, never through PATH — the binary shares its name with the legacy tooling,
-and a PATH lookup could pick up the wrong install.
+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
 
@@ -84,11 +118,23 @@ 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`.
+Releases are cut by tagging, twice — the binaries come from the Go repository
+and the gems from this one:
+
+```bash
+# 1. bump lib/mcptask_rails_runner/version.rb, commit, push
+# 2. in mcptask_go_runner:
+git tag -a v0.3.0 -m v0.3.0 && git push origin v0.3.0
+# 3. here, straight after — no waiting:
+git tag -a v0.3.0 -m v0.3.0 && git push origin v0.3.0
+```
+
+Step 3 needs no waiting because the Release workflow's fetch waits for the
+binaries itself (`MCPTASK_WAIT_FOR_RELEASE`, 15 minutes against a Go release
+that takes about four). It then verifies each archive against the release's
+`checksums.txt`, builds the platform gems and publishes them to rubygems.org
+through OIDC trusted publishing. A tag that disagrees with `version.rb` is
+refused before anything is downloaded. 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:

data/lib/mcptask_rails_runner/binary.rb

@@ -1,31 +1,52 @@
 # frozen_string_literal: true
 
+require "fileutils"
+
 module McptaskRailsRunner
-  # Locates and executes the bundled Go binary.
+  # Locates, installs and executes the bundled Go binary.
   module Binary
     GEM_ROOT = File.expand_path("../..", __dir__)
 
     SUPPORTED_PLATFORMS = %w[
       arm64-darwin
       x86_64-darwin
-      arm64-linux
+      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 bundled binary. Never resolved through PATH: the
-    # binary shares the mcptask_runner name with the legacy gem's rake
+    # 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)
 
@@ -43,10 +64,91 @@ module McptaskRailsRunner
       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/version.rb

@@ -1,7 +1,14 @@
 # frozen_string_literal: true
 
 module McptaskRailsRunner
-  # The gem version is pinned 1:1 to the mcptask_runner binary release it
-  # carries (tag v#{VERSION} in jchsoft/mcptask-releases). Bump both together.
-  VERSION = "0.2.4"
+  # 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.1"
 end

data/lib/tasks/mcptask_runner.rake

@@ -4,18 +4,25 @@
 # 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!("init")
+    McptaskRailsRunner::Binary.exec_installed!("init")
   end
 
   desc "Refresh bundled skills and helpers"
   task :update do
-    McptaskRailsRunner::Binary.exec!("update")
+    McptaskRailsRunner::Binary.exec_installed!("update")
   end
 
   desc "File a bug against the project with the last run log attached"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mcptask-rails-runner
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.3.1
 platform: ruby
 authors:
 - Josef Chmel