harnex 0.12.0 → 0.29.0

data/lib/harnex/commands/reply.rb

@@ -0,0 +1,125 @@
+module Harnex
+  # `harnex reply` (#87): send a lane more work. A worker still on its turn
+  # takes the message as a follow-up; a lane that has finished is relaunched
+  # on its own Pi session, so the worker keeps everything it knew.
+  class Reply
+    def self.usage
+      <<~TEXT
+        Usage: harnex reply NAME [options] [--] MESSAGE...
+
+        Send a lane a follow-up and print the result, in the same format as
+        `harnex delegate`. The worker keeps its context: a busy worker gets the
+        message during its turn; a finished lane resumes its Pi session.
+
+        Options:
+          --model NAME    Model for this turn (default: the lane's)
+          --no-wait       Send and return at once; collect with `harnex result NAME`
+          --timeout DUR   Wait at most DUR (default 9m; `none` waits without a cap)
+          --json          Print the lane record and result as JSON
+          -h, --help      Show this help
+
+        Exit codes: 0 done, 1 failed, 2 usage error, 124 still working.
+      TEXT
+    end
+
+    def initialize(argv, out: $stdout, err: $stderr, harnex_command: nil)
+      @argv = argv.dup
+      @out = out
+      @err = err
+      @harnex_command = harnex_command || [Gem.ruby, File.expand_path("../../../bin/harnex", __dir__)]
+      @options = { model: nil, wait: true, timeout: Lanes::DEFAULT_TIMEOUT, json: false, help: false }
+    end
+
+    def run
+      name, message = parse
+      if @options[:help]
+        @out.puts self.class.usage
+        return 0
+      end
+      raise OptionParser::MissingArgument, "NAME" if name.nil?
+      raise OptionParser::MissingArgument, "MESSAGE" if message.strip.empty?
+
+      lane = Lanes.resolve(name)
+      unless Lanes.open?(lane)
+        raise OptionParser::InvalidArgument, "lane #{name} was #{lane['state']}; start a new one with `harnex delegate`"
+      end
+
+      lane["requested_model"] = @options[:model] if @options[:model]
+      turn, exit_code = Lanes.live?(lane) ? follow_up(lane, message) : relaunch(lane, message)
+      return sent(lane) unless @options[:wait]
+
+      lane = Lanes.settle(lane, turn, exit_code)
+      @out.puts(@options[:json] ? JSON.generate(lane: lane, result: turn, exit_code: exit_code) : Lanes.render(lane, turn, exit_code))
+      exit_code
+    rescue Lanes::LaunchError => e
+      @err.puts(e.message)
+      1
+    end
+
+    private
+
+    def follow_up(lane, message)
+      argv = @harnex_command + ["send", "--id", lane["name"], "--repo", lane["run_root"], "--message", message]
+      argv += ["--wait-done"] + (@options[:timeout] ? ["--timeout", @options[:timeout].to_s] : []) if @options[:wait]
+      stdout, stderr, status = Open3.capture3(*argv)
+      result = Lanes.last_json(stdout)
+      raise Lanes::LaunchError, "harnex could not reach lane #{lane['name']}: #{stderr.strip.lines.last}" if result.empty?
+
+      # The lane's turn is out again; `result` waits for the turn this
+      # message started or joined.
+      lane["state"] = "running"
+      lane["after_seq"] = result["after_seq"] if result["after_seq"]
+      Lanes.save(lane)
+      [result, status.exitstatus]
+    end
+
+    def relaunch(lane, message)
+      child_args = []
+      child_args += ["--session", lane["agent_session_id"]] if lane["agent_session_id"]
+      child_args += ["--tools", Ask::READ_ONLY_TOOLS] if lane["read_only"]
+      unless lane["agent_session_id"]
+        @err.puts("harnex reply: no Pi session recorded for #{lane['name']}; the worker starts without its earlier context")
+      end
+      Lanes.launch(lane, @harnex_command, context_args: ["--context", message], child_args: child_args,
+                                          wait: @options[:wait], timeout: @options[:timeout])
+    end
+
+    def sent(lane)
+      @out.puts(@options[:json] ? JSON.generate(lane) : "── #{lane['name']}: message sent; collect: harnex result #{lane['name']}")
+      0
+    end
+
+    def parse
+      words = []
+      index = 0
+      while index < @argv.length
+        arg = @argv[index]
+        case arg
+        when "--"
+          words.concat(@argv[(index + 1)..] || [])
+          break
+        when "-h", "--help" then @options[:help] = true
+        when "--no-wait" then @options[:wait] = false
+        when "--json" then @options[:json] = true
+        when "--model"
+          @options[:model] = @argv[index += 1] || raise(OptionParser::MissingArgument, arg)
+        when "--timeout", "--wait-timeout"
+          @options[:timeout] = Lanes.parse_timeout(@argv[index += 1] || raise(OptionParser::MissingArgument, arg))
+        when "--id"
+          @options[:name] = @argv[index += 1] || raise(OptionParser::MissingArgument, arg)
+        when "--message"
+          @options[:message] = @argv[index += 1] || raise(OptionParser::MissingArgument, arg)
+        when "--wait-done", "--tmux" then nil
+        when /\A--/
+          raise OptionParser::InvalidOption, "harnex reply: unknown flag #{arg}; see harnex reply --help"
+        else
+          words << arg
+        end
+        index += 1
+      end
+      words.unshift(@options[:name]) if @options[:name]
+      words << @options[:message] if @options[:message]
+      [words.first, words.drop(1).join(" ")]
+    end
+  end
+end

data/lib/harnex/commands/result.rb

@@ -0,0 +1,108 @@
+module Harnex
+  # `harnex result` (#87): block until lanes report and print each result as
+  # it lands, in the same format as `delegate`. With no names it waits for
+  # every lane this caller started in this repo that nobody has collected.
+  class LaneResult
+    def self.usage
+      <<~TEXT
+        Usage: harnex result [NAME...] [options]
+
+        Wait for lanes to report and print each result as it lands. With no
+        NAME: every lane you started in this repo whose result you have not
+        collected yet (from `harnex delegate --no-wait`, a timed-out delegate,
+        reply or ask).
+
+        Options:
+          --timeout DUR  Wait at most DUR (default 9m; `none` waits without a cap).
+                         On 124 the workers keep going: run the same command again
+          --json         One JSON line per lane instead of text
+          -h, --help     Show this help
+
+        Exit codes: 0 every lane done, 1 a lane failed, 124 a lane still working.
+      TEXT
+    end
+
+    def initialize(argv, out: $stdout, err: $stderr, harnex_command: nil)
+      @argv = argv.dup
+      @out = out
+      @err = err
+      @harnex_command = harnex_command || [Gem.ruby, File.expand_path("../../../bin/harnex", __dir__)]
+      @options = { timeout: Lanes::DEFAULT_TIMEOUT, json: false, help: false }
+      @print_lock = Mutex.new
+    end
+
+    def run
+      names = parse
+      if @options[:help]
+        @out.puts self.class.usage
+        return 0
+      end
+      Lanes.sweep_merged(Lanes.main_root(Dir.pwd))
+      lanes = names.empty? ? Lanes.pending : names.map { |name| Lanes.resolve(name) }
+      if lanes.empty?
+        @out.puts "no lanes waiting to be collected (see `harnex lanes`)"
+        return 0
+      end
+
+      codes = lanes.map { |lane| Thread.new { collect(lane) } }.map(&:value)
+      return Waiter::DONE_EXIT_TIMEOUT if codes.include?(Waiter::DONE_EXIT_TIMEOUT)
+
+      codes.all?(&:zero?) ? 0 : 1
+    end
+
+    # Exposed for `ask --resume` and the MCP server.
+    def collect(lane)
+      if lane["state"] == "running"
+        turn, exit_code = Lanes.wait(lane, @harnex_command, timeout: @options[:timeout])
+        exit_code ||= 1
+        lane = Lanes.settle(lane, turn, exit_code)
+      else
+        # Already collected: show the last result again.
+        turn = lane["last_turn"] || {}
+        exit_code = lane["state"] == "failed" ? 1 : 0
+      end
+      print_result(lane, turn, exit_code)
+      exit_code
+    end
+
+    private
+
+    def print_result(lane, turn, exit_code)
+      text = if @options[:json]
+               JSON.generate(lane: lane["name"], exit_code: exit_code, state: lane["state"], result: turn)
+             elsif lane["kind"] == "ask" && exit_code.zero?
+               Lanes.final_message(turn)
+             else
+               Lanes.render(lane, turn, exit_code)
+             end
+      @print_lock.synchronize do
+        @out.puts text
+        @out.puts unless @options[:json]
+        @out.flush
+      end
+    end
+
+    def parse
+      names = []
+      index = 0
+      while index < @argv.length
+        arg = @argv[index]
+        case arg
+        when "-h", "--help" then @options[:help] = true
+        when "--json" then @options[:json] = true
+        when "--timeout"
+          value = @argv[index += 1]
+          raise OptionParser::MissingArgument, arg if value.nil?
+
+          @options[:timeout] = Lanes.parse_timeout(value)
+        when /\A--/
+          raise OptionParser::InvalidOption, "harnex result: unknown flag #{arg}; see harnex result --help"
+        else
+          names << arg
+        end
+        index += 1
+      end
+      names
+    end
+  end
+end