harnex 0.2.0

data/lib/harnex/commands/status.rb

@@ -0,0 +1,171 @@
+require "json"
+require "net/http"
+require "optparse"
+require "time"
+require "uri"
+
+module Harnex
+  class Status
+    DESCRIPTION_WIDTH = 30
+    REPO_WIDTH = 20
+
+    def self.usage(program_name = "harnex status")
+      <<~TEXT
+        Usage: #{program_name} [options]
+
+        Options:
+          --id ID      Show a specific session
+          --repo PATH  Filter to PATH's repo root (default: current repo)
+          --all        List sessions across all repos
+          --json       Output JSON instead of a table
+          -h, --help   Show this help
+      TEXT
+    end
+
+    def initialize(argv)
+      @argv = argv.dup
+      @options = {
+        id: nil,
+        repo_path: Dir.pwd,
+        all: false,
+        json: false,
+        help: false
+      }
+    end
+
+    def run
+      parser.parse!(@argv)
+      if @options[:help]
+        puts self.class.usage
+        return 0
+      end
+
+      sessions = load_sessions
+      if @options[:json]
+        puts JSON.generate(sessions)
+        return 0
+      end
+
+      if sessions.empty?
+        if @options[:all]
+          puts "No active harnex sessions."
+        else
+          puts "No active harnex sessions for #{Harnex.resolve_repo_root(@options[:repo_path])}."
+        end
+        return 0
+      end
+
+      puts render_table(sessions)
+      0
+    end
+
+    private
+
+    def parser
+      @parser ||= OptionParser.new do |opts|
+        opts.banner = "Usage: harnex status [options]"
+        opts.on("--id ID", "Show a specific session") { |value| @options[:id] = Harnex.normalize_id(value) }
+        opts.on("--repo PATH", "Filter to PATH's repo root") { |value| @options[:repo_path] = value }
+        opts.on("--all", "List sessions across all repos") { @options[:all] = true }
+        opts.on("--json", "Output JSON instead of a table") { @options[:json] = true }
+        opts.on("-h", "--help", "Show help") { @options[:help] = true }
+      end
+    end
+
+    def load_sessions
+      repo_root = @options[:all] ? nil : Harnex.resolve_repo_root(@options[:repo_path])
+      sessions = Harnex.active_sessions(repo_root, id: @options[:id])
+
+      sessions.map { |session| load_live_status(session) }
+        .sort_by { |session| [session["repo_root"].to_s, session["started_at"].to_s, session["id"].to_s] }
+        .reverse
+    end
+
+    def load_live_status(session)
+      uri = URI("http://#{session.fetch('host')}:#{session.fetch('port')}/status")
+      request = Net::HTTP::Get.new(uri)
+      request["Authorization"] = "Bearer #{session['token']}" if session["token"]
+
+      response = Net::HTTP.start(uri.host, uri.port, open_timeout: 0.25, read_timeout: 0.25) do |http|
+        http.request(request)
+      end
+
+      return session unless response.is_a?(Net::HTTPSuccess)
+
+      session.merge(JSON.parse(response.body))
+    rescue StandardError
+      session
+    end
+
+    def render_table(sessions)
+      columns = ["ID", "CLI", "PID", "PORT", "AGE", "STATE", "REPO", "DESC"]
+
+      rows = sessions.map { |session| table_row(session, columns) }
+      widths = columns.to_h { |column| [column, ([column.length] + rows.map { |row| row.fetch(column).length }).max] }
+
+      lines = []
+      lines << format_row(columns.to_h { |column| [column, column] }, columns, widths)
+      lines << format_row(columns.to_h { |column| [column, "-" * widths.fetch(column)] }, columns, widths)
+      lines.concat(rows.map { |row| format_row(row, columns, widths) })
+      lines.join("\n")
+    end
+
+    def table_row(session, columns)
+      row = {
+        "ID" => session["id"].to_s,
+        "CLI" => Harnex.session_cli(session).empty? ? "-" : Harnex.session_cli(session),
+        "PID" => session["pid"].to_s,
+        "PORT" => session["port"].to_s,
+        "AGE" => timeago(session["started_at"]),
+        "STATE" => session.dig("input_state", "state").to_s.empty? ? "-" : session.dig("input_state", "state").to_s,
+        "DESC" => truncate(session["description"])
+      }
+      row["REPO"] = truncate_repo(session["repo_root"])
+      row
+    end
+
+    def format_row(row, columns, widths)
+      columns.map { |column| row.fetch(column).ljust(widths.fetch(column)) }.join("  ")
+    end
+
+    def timeago(timestamp)
+      return "-" if timestamp.to_s.empty?
+
+      seconds = (Time.now - Time.parse(timestamp.to_s)).to_i
+      seconds = 0 if seconds.negative?
+
+      case seconds
+      when 0...60
+        "#{seconds}s"
+      when 60...3600
+        "#{seconds / 60}m"
+      when 3600...86_400
+        "#{seconds / 3600}h"
+      else
+        "#{seconds / 86_400}d"
+      end
+    rescue StandardError
+      timestamp.to_s
+    end
+
+    def truncate(value)
+      text = value.to_s
+      return "-" if text.empty?
+      return text if text.length <= DESCRIPTION_WIDTH
+
+      "#{text[0, DESCRIPTION_WIDTH - 3]}..."
+    end
+
+    def truncate_repo(path)
+      text = display_path(path)
+      return "-" if text.empty?
+      return text if text.length <= REPO_WIDTH
+
+      "..#{text[-(REPO_WIDTH - 2)..]}"
+    end
+
+    def display_path(path)
+      path.to_s.sub(/\A#{Regexp.escape(Dir.home)}/, "~")
+    end
+  end
+end

data/lib/harnex/commands/stop.rb

@@ -0,0 +1,127 @@
+require "json"
+require "net/http"
+require "optparse"
+require "uri"
+
+module Harnex
+  class Stopper
+    DEFAULT_TIMEOUT = 5.0
+    MIN_HTTP_TIMEOUT = 0.1
+
+    class TimeoutError < RuntimeError; end
+
+    def self.usage(program_name = "harnex stop")
+      <<~TEXT
+        Usage: #{program_name} [options]
+
+        Options:
+          --id ID      Session ID to stop (required)
+          --repo PATH  Resolve the session using PATH's repo root (default: current repo)
+          --cli CLI    Filter by CLI type
+          --timeout S  How long to retry transient API failures (default: #{DEFAULT_TIMEOUT})
+          -h, --help   Show this help
+
+        Sends the adapter stop sequence to the session.
+        Use `harnex wait --id ID` afterward to block until the session finishes.
+      TEXT
+    end
+
+    def initialize(argv)
+      @argv = argv.dup
+      @options = {
+        id: nil,
+        repo_path: Dir.pwd,
+        cli: nil,
+        timeout: DEFAULT_TIMEOUT,
+        help: false
+      }
+    end
+
+    def run
+      parser.parse!(@argv)
+      if @options[:help]
+        puts self.class.usage
+        return 0
+      end
+
+      raise "--id is required for harnex stop" unless @options[:id]
+
+      repo_root = Harnex.resolve_repo_root(@options[:repo_path])
+      registry = Harnex.read_registry(repo_root, @options[:id], cli: @options[:cli])
+      unless registry
+        warn("harnex stop: no session found with id #{@options[:id].inspect}")
+        return 1
+      end
+
+      uri = URI("http://#{registry.fetch('host')}:#{registry.fetch('port')}/stop")
+      request = Net::HTTP::Post.new(uri)
+      request["Authorization"] = "Bearer #{registry['token']}" if registry["token"]
+
+      deadline = monotonic_now + @options[:timeout]
+      response = with_http_retry(deadline: deadline) do
+        Net::HTTP.start(
+          uri.host,
+          uri.port,
+          open_timeout: http_timeout(deadline, cap: 1.0),
+          read_timeout: http_timeout(deadline, cap: 2.0)
+        ) { |http| http.request(request) }
+      end
+
+      parsed = parse_json_body(response.body)
+      puts JSON.generate(parsed)
+      response.is_a?(Net::HTTPSuccess) && parsed["error"].nil? ? 0 : 1
+    rescue TimeoutError => e
+      puts JSON.generate(ok: false, id: @options[:id], status: "timeout", error: e.message)
+      124
+    end
+
+    private
+
+    def with_http_retry(deadline:)
+      loop do
+        raise TimeoutError, timeout_message if deadline_reached?(deadline)
+
+        return yield
+      rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH, EOFError, Net::ReadTimeout, Net::OpenTimeout
+        raise TimeoutError, timeout_message if deadline_reached?(deadline)
+
+        sleep 0.1
+      end
+    end
+
+    def monotonic_now
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
+    def deadline_reached?(deadline)
+      monotonic_now >= deadline
+    end
+
+    def http_timeout(deadline, cap: nil)
+      remaining = deadline - monotonic_now
+      remaining = [remaining, MIN_HTTP_TIMEOUT].max
+      cap ? [remaining, cap].min : remaining
+    end
+
+    def timeout_message
+      "request timed out after #{@options[:timeout]}s"
+    end
+
+    def parse_json_body(body)
+      JSON.parse(body.to_s.empty? ? "{}" : body.to_s)
+    rescue JSON::ParserError
+      { "ok" => false, "error" => "invalid json response", "raw_body" => body.to_s }
+    end
+
+    def parser
+      @parser ||= OptionParser.new do |opts|
+        opts.banner = "Usage: harnex stop [options]"
+        opts.on("--id ID", "Session ID to stop") { |value| @options[:id] = Harnex.normalize_id(value) }
+        opts.on("--repo PATH", "Resolve the session using PATH's repo root") { |value| @options[:repo_path] = value }
+        opts.on("--cli CLI", "Filter by CLI type") { |value| @options[:cli] = value }
+        opts.on("--timeout SECS", Float, "How long to retry transient API failures") { |value| @options[:timeout] = value }
+        opts.on("-h", "--help", "Show help") { @options[:help] = true }
+      end
+    end
+  end
+end

data/lib/harnex/commands/wait.rb

@@ -0,0 +1,165 @@
+require "json"
+require "net/http"
+require "optparse"
+require "uri"
+
+module Harnex
+  class Waiter
+    POLL_INTERVAL = 0.5
+
+    def self.usage(program_name = "harnex wait")
+      <<~TEXT
+        Usage: #{program_name} [options]
+
+        Options:
+          --id ID         Session ID to wait for (required)
+          --until STATE   Wait until session reaches STATE (e.g. "prompt")
+                          Without --until, waits for session exit (default)
+          --repo PATH     Resolve session using PATH's repo root (default: current repo)
+          --timeout SECS  Maximum time to wait in seconds (default: unlimited)
+          -h, --help      Show this help
+      TEXT
+    end
+
+    def initialize(argv)
+      @argv = argv.dup
+      @options = {
+        id: nil,
+        until_state: nil,
+        repo_path: Dir.pwd,
+        timeout: nil,
+        help: false
+      }
+    end
+
+    def run
+      parser.parse!(@argv)
+      if @options[:help]
+        puts self.class.usage
+        return 0
+      end
+
+      raise "--id is required for harnex wait" unless @options[:id]
+
+      if @options[:until_state]
+        wait_until_state
+      else
+        wait_until_exit
+      end
+    end
+
+    private
+
+    def wait_until_state
+      repo_root = Harnex.resolve_repo_root(@options[:repo_path])
+      target_state = @options[:until_state]
+      start_time = Time.now
+      deadline = @options[:timeout] ? start_time + @options[:timeout] : nil
+
+      registry = Harnex.read_registry(repo_root, @options[:id])
+      unless registry
+        warn("harnex wait: no session found with id #{@options[:id].inspect}")
+        return 1
+      end
+
+      target_pid = registry["pid"]
+      host = registry["host"]
+      port = registry["port"]
+      token = registry["token"]
+
+      warn("harnex wait: waiting for #{@options[:id]} to reach #{target_state}")
+
+      loop do
+        unless Harnex.alive_pid?(target_pid)
+          waited = (Time.now - start_time).round(1)
+          puts JSON.generate(ok: false, id: @options[:id], state: "exited", waited_seconds: waited)
+          return 1
+        end
+
+        state = fetch_agent_state(host, port, token)
+        if state == target_state
+          waited = (Time.now - start_time).round(1)
+          puts JSON.generate(ok: true, id: @options[:id], state: state, waited_seconds: waited)
+          return 0
+        end
+
+        if deadline && Time.now >= deadline
+          waited = (Time.now - start_time).round(1)
+          puts JSON.generate(ok: false, id: @options[:id], state: state || "unknown", waited_seconds: waited, status: "timeout")
+          return 124
+        end
+
+        sleep POLL_INTERVAL
+      end
+    end
+
+    def wait_until_exit
+      repo_root = Harnex.resolve_repo_root(@options[:repo_path])
+      deadline = @options[:timeout] ? Time.now + @options[:timeout] : nil
+      exit_path = Harnex.exit_status_path(repo_root, @options[:id])
+
+      registry = Harnex.read_registry(repo_root, @options[:id])
+      unless registry
+        return read_exit_status(exit_path, @options[:id]) if File.exist?(exit_path)
+
+        warn("harnex wait: no session found with id #{@options[:id].inspect}")
+        return 1
+      end
+
+      target_pid = registry["pid"]
+      warn("harnex wait: watching session #{@options[:id]} (pid #{target_pid})")
+
+      loop do
+        unless Harnex.alive_pid?(target_pid)
+          return read_exit_status(exit_path, @options[:id])
+        end
+
+        if deadline && Time.now >= deadline
+          puts JSON.generate(ok: false, id: @options[:id], status: "timeout", pid: target_pid)
+          return 124
+        end
+
+        sleep POLL_INTERVAL
+      end
+    end
+
+    def fetch_agent_state(host, port, token)
+      uri = URI("http://#{host}:#{port}/status")
+      request = Net::HTTP::Get.new(uri)
+      request["Authorization"] = "Bearer #{token}" if token
+
+      response = Net::HTTP.start(uri.host, uri.port, open_timeout: 1, read_timeout: 1) do |http|
+        http.request(request)
+      end
+
+      return nil unless response.is_a?(Net::HTTPSuccess)
+
+      data = JSON.parse(response.body)
+      data["agent_state"]
+    rescue StandardError
+      nil
+    end
+
+    def read_exit_status(exit_path, id)
+      if File.exist?(exit_path)
+        data = JSON.parse(File.read(exit_path))
+        puts JSON.generate(data)
+        data["exit_code"] || 0
+      else
+        puts JSON.generate(ok: true, id: id, status: "exited")
+        0
+      end
+    end
+
+    def parser
+      @parser ||= OptionParser.new do |opts|
+        opts.banner = "Usage: harnex wait [options]"
+        opts.on("--id ID", "Session ID to wait for") { |value| @options[:id] = Harnex.normalize_id(value) }
+        opts.on("--until STATE", "Wait until session reaches STATE") { |value| @options[:until_state] = value }
+        opts.on("--repo PATH", "Resolve session using PATH's repo root") { |value| @options[:repo_path] = value }
+        opts.on("--timeout SECONDS", Float, "Maximum time to wait") { |value| @options[:timeout] = value }
+        opts.on("-h", "--help", "Show help") { @options[:help] = true }
+      end
+    end
+  end
+end