mcptask-rails-runner 0.3.48 → 0.3.50

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ba69c27b9831fcfb8093049ab6684cdb6e494f9c3fef851c5facd47a0dd011e1
-  data.tar.gz: 873ba0f3c9167feb02dac0b443c71e14f5bd9be8e8957fb5d45dbe7531116a5e
+  metadata.gz: a8ed1f78b740e6c06359d6542e3076565af06ab29b8e819af2dc96e4147d2e63
+  data.tar.gz: d516cff029479cd79757e5bb13c104836e7f4f2a03795ff4f6a4baf2450274c7
 SHA512:
-  metadata.gz: dcae134c0fe77e1b12ab0e7c090366306a68cfda319f02853cdba75f53a2d07c3a0fda81b3ee3b9f5e83ca76dbc5369307ebac7c5c8967002f7af9e2aba250f2
-  data.tar.gz: 58e0210a0b512a44bb0a70b3a8672609c661dc60340c8dbba9bbd85e8d196bbcbf2b9a07a0a2d00755530d2bcea4ddb3f0939f24eee87a56d4cb0ea8f9343cf5
+  metadata.gz: 77c3f2e609f5fe842cf432595ec6339fb788a22bc6724a847c6fb7b5532e60ba5730dafb95b16ec8d49fa06265cb6bfd1e1101f52b73659383fc45f344939800
+  data.tar.gz: e6985e3d9a02f888c0e2955ef78d3db100c3fa9f0238796730d78491fcc9f0c5f72f913fb82a6431dce6547fa1d93f090faf813bf9029bdf07a39d1c2267cfd0

data/CHANGELOG.md

@@ -9,6 +9,78 @@ release notes for the same tag.
 
 Nothing yet.
 
+## 0.3.50
+
+Full binary notes in
+[mcptask-releases v0.3.50](https://github.com/jchsoft/mcptask-releases/releases/tag/v0.3.50).
+
+**Upgrading takes two commands.** `mcptask_runner update --self` replaces the binary; then a bare `mcptask_runner update` in every project on the host, because the bundled `.claude/` assets changed (skills/mcptask-read/SKILL.md). Run it while no runner is working that checkout. A runner idling in a wait keeps the old binary until its next task or a restart (`launchctl kill SIGTERM`, wait for the job to stop, then `kickstart` on macOS), so restart it.
+
+**The gem's own line in `rake mcptask_runner:install` / `:update` now takes the shape of init's screen** (Story 14828). It is the first line of that screen, so it speaks the same line kinds, glyphs and codes as the Go binary's output after it:
+
+- `✓ mcptask_runner 0.3.50 installed into ~/.mcptask/bin` (green), with `(was 0.3.49)` when it replaced an older one, or `✓ mcptask_runner 0.3.49 is already current` when the installed copy already held this version. The old `installed ... (replacing 0.3.49)` with the same version on both sides said nothing.
+- `! ...` for a warning the run goes on after (`MCPTASK_RUNNER_BIN` is set, a newer binary is kept): orange `\e[38;5;208m` when `TERM` contains `256color` or `COLORTERM` is set, else yellow. These were yellow with no glyph.
+- `✗ ...` (red) with the step to take when the binary is missing from the gem or the copy fails; the error is still raised after the line.
+- The `[mcptask_runner]` prefix is gone, and the home directory is shown as `~`.
+- Colour only on a terminal, never with `NO_COLOR` non-empty; `MCPTASK_RUNNER_COLOR` keeps its meaning. With colour off the text is plain, glyphs included.
+- Task names and argument forms are unchanged, and so is how the binary is exec'd.
+
+Binary changes carried by this version:
+
+- Re-check now: the card checks a host problem at once
+- Each token variable gets its own export file
+- A runner may now sit retrying instead of ending its day
+- `init` says whose role is missing, and where
+- The `mcptask-read` skill downloads attachments with the signed link only
+- `init` speaks in colour on a terminal
+- `init` runs in four sections, each with one green line
+- `update` speaks the same line kinds as `init`
+- The install has a bad day of its own
+- Every warning and refusal of `init` is a named exception, orange or red, with its step
+- An interrupted `init` continues at its last unanswered question
+- `init` on an installed project sums it up and asks one question
+- A kill never empties a file
+- `init` is tested through a real terminal
+- What `init` says before it has a screen is painted too
+- The scheduled job runs on the days you choose, and `--force` repairs an old one
+- The card carries the scheduled job's plan
+
+## 0.3.49
+
+Full binary notes in
+[mcptask-releases v0.3.49](https://github.com/jchsoft/mcptask-releases/releases/tag/v0.3.49).
+
+**Upgrading takes two commands.** `mcptask_runner update --self` replaces the binary; then a bare `mcptask_runner update` in every project on the host, because the bundled `.claude/` assets changed (helpers/check_test_lock, skills/test-runner/SKILL.md). Run it while no runner is working that checkout. A runner idling in a wait keeps the old binary until its next task or a restart (`launchctl kill SIGTERM`, wait for the job to stop, then `kickstart` on macOS), so restart it.
+
+No wrapper changes.
+
+Binary changes carried by this version:
+
+- `init` asks which project this is
+- `init` switches the job on
+- The install's task logs its progress without a refusal
+- `init` stops asking what it can find out
+- `init` keeps its details in a log
+- A CLI that exits 127 is reported as not found
+- A bug report attaches only the current run's record
+- The story sweep rides out a dropped connection
+- `pr merge` carries a tree-identical head's statuses to the merge commit
+- `init` recognises an Xcode project
+- Two reports stop blaming the child for what happened outside it
+- An mcptask.online outage no longer ends the day
+- A triage that cannot reach its tools is waited out
+- A panic in a background goroutine is reported like a loop panic
+- The daily loop keeps working when a bug report is refused
+- An urgent bug on a dirty branch waits for a person instead of ending the run
+- A usage limit that outlasts the runner's waits no longer ends the day
+- A report no longer lists a settings file the project never had
+- One host refusal is one bug piece a day
+- Git credentials origin refuses are waited out, not filed
+- A refused task waits for a person, and the child no longer looks for a way in
+- A step only a person can take becomes that person's task
+- A Stop from the card during a Story's merge pauses the runner, not ends it
+- The banner says where the runner's own failures go; a refused card is said in the log
+
 ## 0.3.48
 
 Full binary notes in

data/lib/mcptask_rails_runner/binary.rb

@@ -85,38 +85,71 @@ module McptaskRailsRunner
     # 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.
+    #
+    # What it prints is the first line of init's screen, in init's line kinds:
+    # done (green check), a warning the run goes on after (orange bang), or a
+    # refusal with the step to take (red cross), after which the error is still
+    # raised — the line is for the person, the exception is for the report.
     def install!(install_dir: INSTALL_DIR, gem_root: GEM_ROOT, out: $stdout)
       paint = Palette.for(out)
 
       override = ENV["MCPTASK_RUNNER_BIN"]
       unless override.nil? || override.empty?
-        out.puts paint.changed("[mcptask_runner] MCPTASK_RUNNER_BIN is set — running #{override} " \
+        out.puts paint.warning("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)
+      source = bundled_source(gem_root, out, paint)
       target = installed_path(install_dir: install_dir)
 
       existing = installed_version(target)
       if existing && existing > Gem::Version.new(VERSION)
-        out.puts paint.changed("[mcptask_runner] #{target} already holds #{existing}, which is newer than " \
+        out.puts paint.warning("#{display_path(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)
-      # Green when this leaves the machine where it already was — a first
-      # install, or the same version laid down again. Yellow when a binary the
-      # host was running has just been replaced, which is the one line of this
-      # command worth stopping on.
-      line = "[mcptask_runner] installed mcptask_runner #{VERSION} into #{target}" \
-             "#{existing ? " (replacing #{existing})" : ''}."
-      out.puts(existing && existing < Gem::Version.new(VERSION) ? paint.changed(line) : paint.ok(line))
+      copy_or_refuse(source, target, out, paint)
+      out.puts paint.done(installed_line(existing, install_dir))
       target
     end
 
+    # The bundled binary, or the red line that says what to do about its absence
+    # and then the error itself.
+    def bundled_source(gem_root, out, paint)
+      bundled_path(gem_root: gem_root)
+    rescue Error
+      out.puts paint.refusal("mcptask_runner binary missing from this gem — run `bundle install` again, or " \
+                             "set MCPTASK_RUNNER_BIN to a binary from https://github.com/jchsoft/mcptask-releases.")
+      raise
+    end
+
+    def copy_or_refuse(source, target, out, paint)
+      copy(source, target)
+    rescue SystemCallError => e
+      out.puts paint.refusal("could not copy mcptask_runner into #{display_path(File.dirname(target))} " \
+                             "(#{e.message}) — make that directory writable, then run this task again.")
+      raise
+    end
+
+    # "installed" is what happened; "is already current" is what it was worth
+    # saying when the installed copy already held this version, which "replacing
+    # 0.3.49" with 0.3.49 never did.
+    def installed_line(existing, install_dir)
+      return "mcptask_runner #{VERSION} is already current" if existing == Gem::Version.new(VERSION)
+
+      line = "mcptask_runner #{VERSION} installed into #{display_path(install_dir)}"
+      existing ? "#{line} (was #{existing})" : line
+    end
+
+    # The home directory as ~, the way a person types it.
+    def display_path(path)
+      home = Dir.home
+      path == home || path.start_with?("#{home}#{File::SEPARATOR}") ? path.sub(home, "~") : path
+    end
+
     # Replaces the current process, so the binary's exit code and signal
     # handling reach the caller (rake) unchanged.
     def exec!(*args)

data/lib/mcptask_rails_runner/palette.rb

@@ -1,23 +1,33 @@
 # frozen_string_literal: true
 
 module McptaskRailsRunner
-  # Colour for the lines this gem prints before it hands the process over.
+  # Colour and shape for the lines this gem prints before it hands the process
+  # over.
   #
-  # `rake mcptask_runner:update` opens with Binary.install!'s line, and
-  # everything after it comes from the Go binary, which since 0.3.18 colours its
-  # own output by meaning: green when there was nothing to do, yellow when
-  # something moved, red when something is waiting on a decision. A grey first
-  # line in front of that wall reads as the least important thing on the screen,
-  # when it is in fact the only one that replaced a binary.
+  # `rake mcptask_runner:install` opens with Binary.install!'s line, and
+  # everything after it is the Go binary's init screen. That screen has a fixed
+  # set of line kinds (Story 14828): a green check for what is done, an orange
+  # bang for an exception the run goes on after, a red cross plus the step to
+  # take for one that stops it. This gem's own line is the first line of that
+  # screen, so it speaks the same kinds, in the same glyphs and codes.
   #
-  # The rules here are copied from internal/install/color.go in the Go repo
-  # rather than invented — same colours, same two environment levers, same "a
-  # terminal and nowhere else". Two halves of one command that disagreed about
-  # what NO_COLOR means would be a puzzle, not a feature.
+  # The rules here are copied from internal/ansi/ansi.go and
+  # internal/install/color.go in the Go repo rather than invented — same
+  # colours, same levers, same "a terminal and nowhere else". Two halves of one
+  # command that disagreed about what NO_COLOR means would be a puzzle, not a
+  # feature.
   class Palette
     RESET  = "\e[0m"
+    BOLD   = "\e[1m"
+    DIM    = "\e[2m"
+    RED    = "\e[31m"
     GREEN  = "\e[32m"
     YELLOW = "\e[33m"
+    ORANGE = "\e[38;5;208m"
+
+    DONE_GLYPH    = "✓"
+    WARNING_GLYPH = "!"
+    REFUSAL_GLYPH = "✗"
 
     # Values of MCPTASK_RUNNER_COLOR that settle the question, either way.
     FORCE_ON  = %w[1 true always force].freeze
@@ -33,7 +43,14 @@ module McptaskRailsRunner
 
     # for decides how one stream should be written to.
     def self.for(out, env: ENV)
-      new(enabled: enabled?(out, env))
+      new(enabled: enabled?(out, env), orange: orange?(env))
+    end
+
+    # Orange is a 256-colour code. A terminal that does not say it has them gets
+    # the yellow every terminal has, rather than a code it may render as
+    # something else.
+    def self.orange?(env)
+      env["TERM"].to_s.include?("256color") || !env["COLORTERM"].to_s.empty?
     end
 
     # MCPTASK_RUNNER_COLOR is asked first and wins both ways, because it is the
@@ -51,22 +68,36 @@ module McptaskRailsRunner
       Gem.win_platform? ? WINDOWS_ANSI_HINTS.any? { |name| !env[name].to_s.empty? } : true
     end
 
-    def initialize(enabled:)
+    def initialize(enabled:, orange: false)
       @enabled = enabled
+      @orange = orange
     end
 
     def enabled?
       @enabled
     end
 
-    # ok — this is the state you wanted; nothing to read closely.
-    def ok(text)
-      wrap(GREEN, text)
+    # done — this happened, or is already the state you wanted.
+    def done(text)
+      wrap(GREEN, "#{DONE_GLYPH} #{text}")
+    end
+
+    # warning — something is not as expected, and the run goes on.
+    def warning(text)
+      wrap(@orange ? ORANGE : YELLOW, "#{WARNING_GLYPH} #{text}")
+    end
+
+    # refusal — the run has stopped; the text carries the step to take.
+    def refusal(text)
+      wrap(RED, "#{REFUSAL_GLYPH} #{text}")
+    end
+
+    def bold(text)
+      wrap(BOLD, text)
     end
 
-    # changed — something moved, or what you assumed would happen did not.
-    def changed(text)
-      wrap(YELLOW, text)
+    def dim(text)
+      wrap(DIM, text)
     end
 
     private

data/lib/mcptask_rails_runner/version.rb

@@ -10,5 +10,5 @@ module McptaskRailsRunner
   # 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.48"
+  VERSION = "0.3.50"
 end

metadata

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