harnex 0.2.0

data/lib/harnex/commands/send.rb

@@ -0,0 +1,415 @@
+require "json"
+require "net/http"
+require "optparse"
+require "uri"
+
+module Harnex
+  class Sender
+    DEFAULT_TIMEOUT = 120.0
+    MIN_HTTP_TIMEOUT = 0.1
+    POLL_INTERVAL = 0.5
+    IDLE_FENCE_TIMEOUT = 30.0
+    class TimeoutError < RuntimeError; end
+
+    def self.build_parser(options, program_name = "harnex send")
+      OptionParser.new do |opts|
+        opts.banner = "Usage: #{program_name} --id ID [options] [text...]"
+        opts.on("--id ID", "Target session ID") { |value| options[:id] = Harnex.normalize_id(value) }
+        opts.on("--repo PATH", "Resolve the target using PATH's repo root") { |value| options[:repo_path] = value }
+        opts.on("--cli CLI", "Filter by CLI type") { |value| options[:cli] = value }
+        opts.on("--message TEXT", "Message text to inject instead of positional args") { |value| options[:message] = value }
+        opts.on("--no-submit", "Inject text without pressing Enter") { options[:submit] = false }
+        opts.on("--submit-only", "Press Enter without injecting text") do
+          options[:submit_only] = true
+          options[:submit] = true
+        end
+        opts.on("--force", "Send even if the agent is not at a prompt") { options[:force] = true }
+        opts.on("--no-wait", "Return immediately after queueing (HTTP 202). Use for fire-and-forget or when polling delivery separately.") { options[:wait] = false }
+        opts.on("--wait-for-idle", "After a successful send, wait for the agent to return to prompt") { options[:wait_for_idle] = true }
+        opts.on("--relay", "Force relay header formatting") { options[:relay] = true }
+        opts.on("--no-relay", "Disable automatic relay headers") { options[:relay] = false }
+        opts.on("--port PORT", Integer, "Send directly to a specific port") { |value| options[:port] = value }
+        opts.on("--token TOKEN", "Auth token for --port mode") { |value| options[:token] = value }
+        opts.on("--host HOST", "Override the host when --port is used") { |value| options[:host] = value }
+        opts.on("--timeout SECS", Float, "How long to wait for lookup, delivery, or idle wait (default: #{DEFAULT_TIMEOUT.to_i})") { |value| options[:timeout] = value }
+        opts.on("--verbose", "Print lookup and delivery details to stderr") { options[:verbose] = true }
+        opts.on("-h", "--help", "Show help") { options[:help] = true }
+      end
+    end
+
+    def self.usage(program_name = "harnex send")
+      build_parser({}, program_name).to_s
+    end
+
+    def initialize(argv)
+      @options = {
+        repo_path: Dir.pwd,
+        id: nil,
+        cli: nil,
+        message: nil,
+        submit: true,
+        submit_only: false,
+        relay: nil,
+        force: false,
+        wait: true,
+        wait_for_idle: false,
+        port: nil,
+        token: nil,
+        host: DEFAULT_HOST,
+        timeout: DEFAULT_TIMEOUT,
+        verbose: false,
+        help: false
+      }
+      @argv = argv.dup
+    end
+
+    def run
+      parser.parse!(@argv)
+      if @options[:help]
+        puts parser
+        return 0
+      end
+
+      raise "--id is required for harnex send" unless @options[:id]
+      validate_modes!
+
+      repo_root = Harnex.resolve_repo_root(@options[:repo_path])
+      @command_started_at = monotonic_now
+      deadline = @command_started_at + @options[:timeout]
+      verbose("repo_root=#{repo_root}")
+      verbose("id=#{@options[:id]}")
+      verbose("cli=#{@options[:cli] || '(any)'}")
+
+      registry = wait_for_registry(repo_root, deadline: deadline)
+      case registry
+      when :ambiguous
+        raise ambiguous_session_message(repo_root)
+      when :timeout
+        puts JSON.generate(ok: false, id: @options[:id], status: "timeout", error: "lookup timed out after #{@options[:timeout]}s")
+        return 124
+      end
+
+      registry = direct_registry.merge(registry || {})
+      verbose("target=http://#{registry.fetch('host')}:#{registry.fetch('port')}/send")
+
+      text = resolve_text
+      text = relay_text(text, registry)
+      raise "text is required" if text.to_s.empty? && !@options[:submit_only]
+
+      response = with_http_retry(deadline: deadline) do
+        uri = URI("http://#{registry.fetch('host')}:#{registry.fetch('port')}/send")
+        request = Net::HTTP::Post.new(uri)
+        request["Authorization"] = "Bearer #{registry['token']}" if registry["token"]
+        request["Content-Type"] = "application/json"
+        request.body = JSON.generate(
+          text: text,
+          submit: @options[:submit],
+          enter_only: @options[:submit_only],
+          force: @options[:force]
+        )
+
+        Net::HTTP.start(
+          uri.host,
+          uri.port,
+          open_timeout: http_timeout(deadline),
+          read_timeout: http_timeout(deadline)
+        ) { |http| http.request(request) }
+      end
+
+      result = nil
+      exit_code = nil
+
+      if response.code == "202" && @options[:wait]
+        parsed = parse_json_body(response.body)
+        message_id = parsed["message_id"]
+        if message_id
+          verbose("queued message_id=#{message_id}")
+          result = poll_delivery(registry, message_id, deadline: deadline)
+          exit_code =
+            case result["status"]
+            when "timeout" then 124
+            when "delivered" then 0
+            else 1
+            end
+        end
+      end
+
+      unless result
+        result = parse_json_body(response.body)
+        exit_code = response.is_a?(Net::HTTPSuccess) ? 0 : 1
+      end
+
+      if exit_code == 0 && @options[:wait_for_idle]
+        result = wait_for_idle_state(registry, deadline)
+        exit_code = result["ok"] ? 0 : (result["state"] == "exited" ? 1 : 124)
+      end
+
+      puts JSON.generate(result)
+      exit_code
+    rescue TimeoutError => e
+      puts JSON.generate(ok: false, id: @options[:id], status: "timeout", error: e.message)
+      124
+    end
+
+    private
+
+    def resolve_text
+      return "" if @options[:submit_only]
+      return @options[:message] if @options[:message]
+      return @argv.join(" ") unless @argv.empty?
+      return STDIN.read unless STDIN.tty?
+
+      raise "harnex send: no message provided (use --message, positional args, or pipe)"
+    end
+
+    def poll_delivery(registry, message_id, deadline:)
+      base = "http://#{registry.fetch('host')}:#{registry.fetch('port')}"
+      uri = URI("#{base}/messages/#{message_id}")
+
+      loop do
+        return({ "ok" => false, "status" => "timeout", "error" => timeout_message("delivery") }) if deadline_reached?(deadline)
+
+        request = Net::HTTP::Get.new(uri)
+        request["Authorization"] = "Bearer #{registry['token']}" if registry["token"]
+        response = 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) }
+        parsed = parse_json_body(response.body)
+        status = parsed["status"]
+
+        return parsed if %w[delivered failed].include?(status)
+        return parsed.merge("status" => "timeout", "error" => timeout_message("delivery")) if deadline_reached?(deadline)
+
+        verbose("delivery status=#{status || 'unknown'}")
+        sleep 0.25
+      rescue StandardError => e
+        return({ "ok" => false, "status" => "timeout", "error" => timeout_message("delivery") }) if deadline_reached?(deadline)
+
+        sleep 0.25
+      end
+    end
+
+    def wait_for_idle_state(registry, deadline)
+      host = registry.fetch("host")
+      port = registry.fetch("port")
+      token = registry["token"]
+      last_state = "prompt"
+      fence_deadline = [monotonic_now + IDLE_FENCE_TIMEOUT, deadline].min
+
+      loop do
+        return wait_for_idle_timeout(last_state) if deadline_reached?(deadline)
+
+        state = fetch_agent_state(host, port, token)
+        return wait_for_idle_exited if state.nil?
+
+        last_state = state
+        break if state != "prompt"
+        return wait_for_idle_success("prompt") if monotonic_now >= fence_deadline
+
+        sleep POLL_INTERVAL
+      end
+
+      loop do
+        return wait_for_idle_timeout(last_state) if deadline_reached?(deadline)
+
+        state = fetch_agent_state(host, port, token)
+        return wait_for_idle_exited if state.nil?
+
+        last_state = state
+        return wait_for_idle_success(state) if state == "prompt"
+
+        sleep POLL_INTERVAL
+      end
+    end
+
+    def relay_text(text, registry)
+      return text if text.to_s.empty?
+      return text unless relay_enabled_for?(registry)
+      return text if text.lstrip.start_with?("[harnex relay ")
+
+      context = Harnex.current_session_context
+      Harnex.format_relay_message(
+        text,
+        from: context.fetch(:cli),
+        id: context.fetch(:id)
+      )
+    end
+
+    def relay_enabled_for?(registry)
+      return false if @options[:submit_only]
+      return false if @options[:relay] == false
+
+      context = Harnex.current_session_context
+      return false unless context
+      return true if @options[:relay] == true
+
+      target_session_id = registry["session_id"].to_s
+      return false if target_session_id.empty?
+
+      target_session_id != context.fetch(:session_id)
+    end
+
+    def verbose(message)
+      return unless @options[:verbose]
+
+      warn("[harnex send] #{message}")
+    end
+
+    def wait_for_registry(repo_root, deadline:)
+      return nil if @options[:port]
+
+      loop do
+        registry = resolve_registry(repo_root)
+        return registry unless registry == :retry
+        return :timeout if deadline_reached?(deadline)
+
+        sleep 0.1
+      end
+    end
+
+    def resolve_registry(repo_root)
+      sessions = Harnex.active_sessions(repo_root, id: @options[:id], cli: @options[:cli])
+      return :retry if sessions.empty?
+      return sessions.first if sessions.length == 1
+
+      :ambiguous
+    end
+
+    def direct_registry
+      return {} unless @options[:port]
+
+      registry = {
+        "host" => @options[:host],
+        "port" => @options[:port]
+      }
+      registry["token"] = @options[:token] if @options[:token]
+      registry
+    end
+
+    def missing_session_message(repo_root)
+      base = "no active harnex session found for #{repo_root}"
+      filters = []
+      filters << "id: #{@options[:id]}" if @options[:id]
+      filters << "cli: #{@options[:cli]}" if @options[:cli]
+      return "#{base} (#{filters.join(', ')})" unless filters.empty?
+
+      available = Harnex.active_sessions(repo_root).map { |session| "#{session['id']}(#{Harnex.session_cli(session)})" }.uniq.sort
+      suffix = available.empty? ? "" : " | active: #{available.join(', ')}"
+      "#{base}#{suffix}"
+    end
+
+    def ambiguous_session_message(repo_root)
+      available = Harnex.active_sessions(repo_root, id: @options[:id], cli: @options[:cli])
+      detail = available.map { |session| "#{session['id']}(#{Harnex.session_cli(session)})" }.join(", ")
+      filters = []
+      filters << "id #{@options[:id].inspect}" if @options[:id]
+      filters << "cli #{@options[:cli].inspect}" if @options[:cli]
+      scope = filters.empty? ? repo_root : "#{repo_root} with #{filters.join(' and ')}"
+      "multiple active harnex sessions found for #{scope}; use --id, --cli, or `harnex status` | active: #{detail}"
+    end
+
+    def with_http_retry(deadline:)
+      loop do
+        raise TimeoutError, timeout_message("request") if deadline_reached?(deadline)
+
+        return yield
+      rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH, EOFError, Net::ReadTimeout, Net::OpenTimeout => e
+        raise TimeoutError, timeout_message("request") if deadline_reached?(deadline)
+
+        verbose("retrying after #{e.class}")
+        sleep 0.1
+      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 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(phase)
+      "#{phase} timed out after #{@options[:timeout]}s"
+    end
+
+    def waited_seconds
+      return 0.0 unless @command_started_at
+
+      (monotonic_now - @command_started_at).round(1)
+    end
+
+    def wait_for_idle_success(state)
+      {
+        "ok" => true,
+        "id" => @options[:id],
+        "state" => state,
+        "waited_seconds" => waited_seconds
+      }
+    end
+
+    def wait_for_idle_timeout(state)
+      {
+        "ok" => false,
+        "id" => @options[:id],
+        "state" => state || "unknown",
+        "error" => "timeout",
+        "waited_seconds" => waited_seconds
+      }
+    end
+
+    def wait_for_idle_exited
+      {
+        "ok" => false,
+        "id" => @options[:id],
+        "state" => "exited",
+        "waited_seconds" => waited_seconds
+      }
+    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 validate_modes!
+      raise "--submit-only cannot be combined with --no-submit" if @options[:submit_only] && !@options[:submit]
+
+      return unless @options[:submit_only]
+      return if @options[:message].nil? && @argv.empty?
+
+      raise "--submit-only does not accept message text"
+    end
+
+    def parser
+      @parser ||= self.class.build_parser(@options)
+    end
+  end
+end

data/lib/harnex/commands/skills.rb

@@ -0,0 +1,163 @@
+require "fileutils"
+
+module Harnex
+  class Skills
+    SKILLS_ROOT = File.expand_path("../../../../skills", __FILE__)
+    DEFAULT_SKILL = "harnex"
+
+    def self.usage
+      <<~TEXT
+        Usage: harnex skills install [SKILL...] [--global]
+
+        Subcommands:
+          install     Install bundled skills into the current repo
+
+        Options:
+          --global    Install to ~/.claude/skills and ~/.codex/skills
+                      instead of the current repo
+
+        Available skills: #{bundled_skill_names.join(', ')}
+
+        With no SKILL argument, installs #{DEFAULT_SKILL.inspect}.
+        Pass one or more skill names to install specific skills.
+
+        Without --global, copies the skill to .claude/skills/<skill>/
+        in the current repo and symlinks .codex/skills/<skill> to it.
+
+        With --global, symlinks both ~/.claude/skills/<skill> and
+        ~/.codex/skills/<skill> to the bundled source.
+      TEXT
+    end
+
+    def self.bundled_skill_names
+      Dir.children(SKILLS_ROOT).select { |name| File.directory?(File.join(SKILLS_ROOT, name)) }.sort
+    end
+
+    def initialize(argv)
+      @argv = argv.dup
+    end
+
+    def run
+      subcommand = @argv.shift
+      case subcommand
+      when "install"
+        skill_names, global, help = parse_install_args(@argv)
+        if help
+          puts self.class.usage
+          return 0
+        end
+
+        skill_names.each do |skill_name|
+          skill_source = resolve_skill_source(skill_name)
+          unless skill_source
+            return missing_skill(skill_name)
+          end
+
+          result = global ? install_global(skill_name, skill_source) : install_local(skill_name, skill_source)
+          return result unless result == 0
+        end
+        0
+      when "-h", "--help", nil
+        puts self.class.usage
+        0
+      else
+        warn("harnex skills: unknown subcommand #{subcommand.inspect}")
+        puts self.class.usage
+        1
+      end
+    end
+
+    private
+
+    def parse_install_args(args)
+      skill_names = []
+      global = false
+      help = false
+
+      args.each do |arg|
+        case arg
+        when "--global"
+          global = true
+        when "-h", "--help"
+          help = true
+        when /\A-/
+          raise "harnex skills: unknown option #{arg.inspect}"
+        else
+          skill_names << arg
+        end
+      end
+
+      skill_names = [DEFAULT_SKILL] if skill_names.empty?
+
+      [skill_names, global, help]
+    end
+
+    def resolve_skill_source(skill_name)
+      return nil unless self.class.bundled_skill_names.include?(skill_name)
+
+      File.join(SKILLS_ROOT, skill_name)
+    end
+
+    def missing_skill(skill_name)
+      warn("harnex skills: unknown skill #{skill_name.inspect}")
+      available = self.class.bundled_skill_names
+      warn("available skills: #{available.join(', ')}") unless available.empty?
+      1
+    end
+
+    def install_local(skill_name, skill_source)
+      repo_root = Harnex.resolve_repo_root(Dir.pwd)
+      claude_dir = File.join(repo_root, ".claude", "skills", skill_name)
+      codex_dir = File.join(repo_root, ".codex", "skills", skill_name)
+
+      # Copy skill to .claude/skills/<skill>/
+      if Dir.exist?(claude_dir)
+        warn("harnex skills: #{claude_dir} already exists, overwriting")
+        FileUtils.rm_rf(claude_dir)
+      end
+      FileUtils.mkdir_p(File.dirname(claude_dir))
+      FileUtils.cp_r(skill_source, claude_dir)
+      puts "installed #{claude_dir}"
+
+      # Symlink .codex/skills/<skill> -> .claude/skills/<skill>
+      codex_parent = File.dirname(codex_dir)
+      FileUtils.mkdir_p(codex_parent)
+      FileUtils.rm_rf(codex_dir) if File.exist?(codex_dir) || File.symlink?(codex_dir)
+
+      # Relative symlink so it works if the repo moves
+      relative = relative_path(from: codex_parent, to: claude_dir)
+      File.symlink(relative, codex_dir)
+      puts "symlinked #{codex_dir} -> #{relative}"
+
+      0
+    end
+
+    def install_global(skill_name, skill_source)
+      claude_dir = File.expand_path("~/.claude/skills/#{skill_name}")
+      codex_dir = File.expand_path("~/.codex/skills/#{skill_name}")
+
+      [claude_dir, codex_dir].each do |dir|
+        parent = File.dirname(dir)
+        FileUtils.mkdir_p(parent)
+        FileUtils.rm_rf(dir) if File.exist?(dir) || File.symlink?(dir)
+        File.symlink(skill_source, dir)
+        puts "symlinked #{dir} -> #{skill_source}"
+      end
+
+      0
+    end
+
+    def relative_path(from:, to:)
+      from_parts = File.expand_path(from).split("/")
+      to_parts = File.expand_path(to).split("/")
+
+      # Drop common prefix
+      while from_parts.first == to_parts.first && !from_parts.empty?
+        from_parts.shift
+        to_parts.shift
+      end
+
+      ([".."] * from_parts.length + to_parts).join("/")
+    end
+  end
+end