harnex 0.2.0

data/lib/harnex/core.rb

@@ -0,0 +1,286 @@
+require "digest"
+require "fileutils"
+require "securerandom"
+require "set"
+require "socket"
+
+module Harnex
+  class BinaryNotFound < RuntimeError; end
+
+  module_function
+
+  def env_value(name, default: nil)
+    ENV.fetch(name, default)
+  end
+
+  DEFAULT_HOST = env_value("HARNEX_HOST", default: "127.0.0.1")
+  DEFAULT_BASE_PORT = Integer(env_value("HARNEX_BASE_PORT", default: "43000"))
+  DEFAULT_PORT_SPAN = Integer(env_value("HARNEX_PORT_SPAN", default: "4000"))
+  DEFAULT_ID = "default"
+  WATCH_DEBOUNCE_SECONDS = 1.0
+  STATE_DIR = File.expand_path(env_value("HARNEX_STATE_DIR", default: "~/.local/state/harnex"))
+  SESSIONS_DIR = File.join(STATE_DIR, "sessions")
+  WatchConfig = Struct.new(:absolute_path, :display_path, :hook_message, :debounce_seconds, keyword_init: true)
+  ID_ADJECTIVES = %w[
+    bold blue calm cool dark dry fast gold gray green
+    keen loud mint pale pink red shy slim soft warm
+  ].freeze
+  ID_NOUNS = %w[
+    ant bat bee cat cod cow cub doe elk fox
+    hen jay kit owl pug ram ray seal wasp yak
+  ].freeze
+
+  def resolve_repo_root(path = Dir.pwd)
+    output, status = Open3.capture2("git", "rev-parse", "--show-toplevel", chdir: path)
+    status.success? ? output.strip : File.expand_path(path)
+  rescue StandardError
+    File.expand_path(path)
+  end
+
+  def repo_key(repo_root)
+    Digest::SHA256.hexdigest(repo_root)[0, 16]
+  end
+
+  def normalize_id(id)
+    value = id.to_s.strip
+    raise "id is required" if value.empty?
+
+    value
+  end
+
+  def id_key(id)
+    normalize_id(id).downcase.gsub(/[^a-z0-9]+/, "-").gsub(/\A-+|-+\z/, "")
+  end
+
+  def cli_key(cli)
+    value = cli.to_s.strip.downcase
+    return nil if value.empty?
+
+    value.gsub(/[^a-z0-9]+/, "-").gsub(/\A-+|-+\z/, "")
+  end
+
+  def current_session_context(env = ENV)
+    session_id = env["HARNEX_SESSION_ID"].to_s.strip
+    cli = env["HARNEX_SESSION_CLI"].to_s.strip
+    id = env["HARNEX_ID"].to_s.strip
+    repo_root = env["HARNEX_SESSION_REPO_ROOT"].to_s.strip
+    return nil if session_id.empty? || cli.empty? || id.empty?
+
+    {
+      session_id: session_id,
+      cli: cli,
+      id: id,
+      repo_root: repo_root.empty? ? nil : repo_root
+    }
+  end
+
+  def format_relay_message(text, from:, id:, at: Time.now)
+    header = "[harnex relay from=#{from} id=#{normalize_id(id)} at=#{at.iso8601}]"
+    body = text.to_s
+    return header if body.empty?
+
+    "#{header}\n#{body}"
+  end
+
+  def active_session_ids(repo_root)
+    active_sessions(repo_root).map { |session| session["id"].to_s.downcase }.to_set
+  end
+
+  def generate_id(repo_root)
+    taken = active_session_ids(repo_root)
+    ID_ADJECTIVES.product(ID_NOUNS).shuffle.each do |adj, noun|
+      candidate = "#{adj}-#{noun}"
+      return candidate unless taken.include?(candidate)
+    end
+
+    "session-#{SecureRandom.hex(4)}"
+  end
+
+  def registry_path(repo_root, id = DEFAULT_ID)
+    FileUtils.mkdir_p(SESSIONS_DIR)
+    File.join(SESSIONS_DIR, "#{session_file_slug(repo_root, id)}.json")
+  end
+
+  def exit_status_path(repo_root, id)
+    exit_dir = File.join(STATE_DIR, "exits")
+    FileUtils.mkdir_p(exit_dir)
+    File.join(exit_dir, "#{session_file_slug(repo_root, id)}.json")
+  end
+
+  def output_log_path(repo_root, id)
+    output_dir = File.join(STATE_DIR, "output")
+    FileUtils.mkdir_p(output_dir)
+    File.join(output_dir, "#{session_file_slug(repo_root, id)}.log")
+  end
+
+  def session_file_slug(repo_root, id)
+    slug = id_key(id)
+    slug = "default" if slug.empty?
+    "#{repo_key(repo_root)}--#{slug}"
+  end
+
+  def active_sessions(repo_root = nil, id: nil, cli: nil)
+    FileUtils.mkdir_p(SESSIONS_DIR)
+    pattern =
+      if repo_root
+        File.join(SESSIONS_DIR, "#{repo_key(repo_root)}--*.json")
+      else
+        File.join(SESSIONS_DIR, "*.json")
+      end
+
+    target_id_key = id.nil? ? nil : id_key(id)
+    normalized_cli = cli_key(cli)
+
+    Dir.glob(pattern).sort.filter_map do |path|
+      data = JSON.parse(File.read(path))
+      if data["pid"] && alive_pid?(data["pid"])
+        session = data.merge("registry_path" => path)
+        next if target_id_key && id_key(session["id"].to_s) != target_id_key
+        next if normalized_cli && cli_key(session_cli(session)) != normalized_cli
+
+        session
+      else
+        FileUtils.rm_f(path)
+        nil
+      end
+    rescue JSON::ParserError
+      FileUtils.rm_f(path)
+      nil
+    end
+  end
+
+  def alive_pid?(pid)
+    Process.kill(0, Integer(pid))
+    true
+  rescue Errno::ESRCH
+    false
+  rescue Errno::EPERM
+    true
+  end
+
+  def read_registry(repo_root, id = DEFAULT_ID, cli: nil)
+    sessions = active_sessions(repo_root, id: id, cli: cli)
+    return nil unless sessions.length == 1
+
+    sessions.first
+  end
+
+  def tmux_pane_for_pid(pid)
+    target_pid = Integer(pid)
+    stdout, status = Open3.capture2(
+      "tmux", "list-panes", "-a", "-F",
+      "\#{pane_id}\t\#{pane_pid}\t\#{session_name}\t\#{window_name}"
+    )
+    return nil unless status.success?
+
+    panes = stdout.each_line.filter_map do |line|
+      pane_id, pane_pid, session_name, window_name = line.chomp.split("\t", 4)
+      next if pane_id.to_s.empty?
+
+      {
+        target: pane_id,
+        pane_id: pane_id,
+        pane_pid: pane_pid.to_i,
+        session_name: session_name,
+        window_name: window_name
+      }
+    end
+
+    pane_pids = panes.map { |p| p[:pane_pid] }.to_set
+
+    # Direct match first
+    matches = panes.select { |p| p[:pane_pid] == target_pid }
+
+    # If no direct match, walk up the process tree from target_pid
+    # to find an ancestor that is a tmux pane root process.
+    if matches.empty?
+      ancestor = parent_pid(target_pid)
+      while ancestor && ancestor > 1
+        if pane_pids.include?(ancestor)
+          matches = panes.select { |p| p[:pane_pid] == ancestor }
+          break
+        end
+        ancestor = parent_pid(ancestor)
+      end
+    end
+
+    return nil unless matches.length == 1
+
+    result = matches.first
+    result.delete(:pane_pid)
+    result
+  rescue ArgumentError, Errno::ENOENT
+    nil
+  end
+
+  def parent_pid(pid)
+    stat = File.read("/proc/#{pid}/stat")
+    # Field 4 is ppid (fields are space-separated, field 1 is pid,
+    # field 2 is (comm) which may contain spaces, field 3 is state, field 4 is ppid)
+    parts = stat.match(/\A\d+\s+\(.*?\)\s+\S+\s+(\d+)/)
+    parts ? parts[1].to_i : nil
+  rescue Errno::ENOENT, Errno::EACCES
+    nil
+  end
+
+  def write_registry(path, payload)
+    tmp = "#{path}.tmp.#{Process.pid}"
+    File.write(tmp, JSON.pretty_generate(payload))
+    File.rename(tmp, path)
+  end
+
+  def allocate_port(repo_root, id, requested_port = nil, host: DEFAULT_HOST)
+    if requested_port
+      return requested_port if port_available?(host, requested_port)
+
+      raise "port #{requested_port} is already in use on #{host}"
+    end
+
+    seed = Digest::SHA256.hexdigest("#{repo_root}\0#{normalize_id(id)}").to_i(16)
+    offset = seed % DEFAULT_PORT_SPAN
+
+    DEFAULT_PORT_SPAN.times do |index|
+      port = DEFAULT_BASE_PORT + ((offset + index) % DEFAULT_PORT_SPAN)
+      return port if port_available?(host, port)
+    end
+
+    raise "could not find a free port in #{DEFAULT_BASE_PORT}-#{DEFAULT_BASE_PORT + DEFAULT_PORT_SPAN - 1}"
+  end
+
+  def port_available?(host, port)
+    server = TCPServer.new(host, port)
+    server.close
+    true
+  rescue Errno::EADDRINUSE, Errno::EACCES
+    false
+  end
+
+  def build_adapter(cli, argv)
+    raise ArgumentError, "cli is required" if cli.to_s.strip.empty?
+
+    Adapters.build(cli, argv)
+  end
+
+  def session_cli(session)
+    (session["cli"] || Array(session["command"]).first).to_s
+  end
+
+  def build_watch_config(path, repo_root)
+    return nil if path.nil?
+
+    raise "file watch is unsupported on this system" unless Watcher.available?
+
+    display_path = path.to_s.strip
+    raise ArgumentError, "--watch requires a value" if display_path.empty?
+
+    absolute_path = File.expand_path(display_path, repo_root)
+    FileUtils.mkdir_p(File.dirname(absolute_path))
+
+    WatchConfig.new(
+      absolute_path: absolute_path,
+      display_path: display_path,
+      hook_message: "file-change-hook: read #{display_path}",
+      debounce_seconds: WATCH_DEBOUNCE_SECONDS
+    )
+  end
+end

data/lib/harnex/runtime/api_server.rb

@@ -0,0 +1,187 @@
+require "json"
+require "socket"
+
+module Harnex
+  class ApiServer
+    def initialize(session)
+      @session = session
+      @server = TCPServer.new(session.host, session.port)
+      @server.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true)
+      @thread = nil
+    end
+
+    def start
+      @thread = Thread.new do
+        loop do
+          socket = @server.accept
+          Thread.new(socket) { |client| handle(client) }
+        rescue IOError, Errno::EBADF
+          break
+        end
+      end
+    end
+
+    def stop
+      @server.close
+      @thread&.join(1)
+    rescue IOError, Errno::EBADF
+      nil
+    end
+
+    private
+
+    def handle(client)
+      request_line = client.gets("\r\n")
+      return unless request_line
+
+      method, target, = request_line.split(" ", 3)
+      headers = {}
+      while (line = client.gets("\r\n"))
+        line = line.strip
+        break if line.empty?
+
+        key, value = line.split(":", 2)
+        headers[key.downcase] = value.to_s.strip
+      end
+
+      body = +""
+      length = headers.fetch("content-length", "0").to_i
+      body = client.read(length) if length.positive?
+
+      path = target.to_s.split("?", 2).first
+
+      case [method, path]
+      when ["GET", "/health"], ["GET", "/status"]
+        return unauthorized(client) unless authorized?(headers)
+
+        json(client, 200, @session.status_payload)
+      when ["GET", "/inbox"]
+        return unauthorized(client) unless authorized?(headers)
+
+        json(client, 200, ok: true, messages: @session.inbox.pending_messages)
+      when ["DELETE", "/inbox"]
+        return unauthorized(client) unless authorized?(headers)
+
+        json(client, 200, ok: true, cleared: @session.inbox.clear)
+      when ["POST", "/stop"]
+        return unauthorized(client) unless authorized?(headers)
+
+        json(client, 200, @session.inject_stop)
+      when ["POST", "/send"]
+        return unauthorized(client) unless authorized?(headers)
+
+        payload = parse_send_body(headers, body)
+        if payload[:mode] == :adapter
+          return json(client, 400, ok: false, error: "text is required") if payload[:text].to_s.empty? && !payload[:enter_only]
+
+          result = @session.inbox.enqueue(
+            text: payload[:text],
+            submit: payload[:submit],
+            enter_only: payload[:enter_only],
+            force: payload[:force]
+          )
+          http_code = result.delete(:http_status) || 200
+          json(client, http_code, result)
+        else
+          return json(client, 400, ok: false, error: "text is required") if payload[:text].to_s.empty?
+
+          json(client, 200, @session.inject(payload[:text], newline: payload[:newline]))
+        end
+      else
+        if method == "GET" && path =~ %r{\A/messages/([a-f0-9]+)\z}
+          return unauthorized(client) unless authorized?(headers)
+
+          msg_id = Regexp.last_match(1)
+          msg = @session.inbox.message_status(msg_id)
+          if msg
+            json(client, 200, msg)
+          else
+            json(client, 404, ok: false, error: "message not found")
+          end
+        elsif method == "DELETE" && path =~ %r{\A/inbox/([a-f0-9]+)\z}
+          return unauthorized(client) unless authorized?(headers)
+
+          msg_id = Regexp.last_match(1)
+          msg = @session.inbox.drop(msg_id)
+          if msg
+            json(client, 200, ok: true, message: msg)
+          else
+            json(client, 404, ok: false, error: "message not found")
+          end
+        else
+          json(client, 404, ok: false, error: "not found")
+        end
+      end
+    rescue JSON::ParserError
+      json(client, 400, ok: false, error: "invalid json")
+    rescue ArgumentError => e
+      json(client, 409, ok: false, error: e.message)
+    rescue StandardError => e
+      if e.message.start_with?("inbox full")
+        json(client, 503, ok: false, error: e.message)
+      else
+        json(client, 500, ok: false, error: e.message)
+      end
+    ensure
+      client.close unless client.closed?
+    end
+
+    def parse_send_body(headers, body)
+      if headers["content-type"].to_s.include?("application/json")
+        parsed = JSON.parse(body.empty? ? "{}" : body)
+        if parsed.key?("submit") || parsed.key?("enter_only") || parsed.key?("force")
+          {
+            mode: :adapter,
+            text: parsed["text"].to_s,
+            submit: parsed.fetch("submit", true),
+            enter_only: parsed.fetch("enter_only", false),
+            force: parsed.fetch("force", false)
+          }
+        else
+          {
+            mode: :legacy,
+            text: parsed["text"].to_s,
+            newline: parsed.fetch("newline", true)
+          }
+        end
+      else
+        {
+          mode: :legacy,
+          text: body.to_s,
+          newline: true
+        }
+      end
+    end
+
+    def authorized?(headers)
+      @session.auth_ok?(headers["authorization"].to_s)
+    end
+
+    def unauthorized(client)
+      json(client, 401, ok: false, error: "unauthorized")
+    end
+
+    def json(client, code, payload)
+      body = JSON.generate(payload)
+      client.write("HTTP/1.1 #{code} #{http_reason(code)}\r\n")
+      client.write("Content-Type: application/json\r\n")
+      client.write("Content-Length: #{body.bytesize}\r\n")
+      client.write("Connection: close\r\n")
+      client.write("\r\n")
+      client.write(body)
+    end
+
+    def http_reason(code)
+      {
+        200 => "OK",
+        202 => "Accepted",
+        400 => "Bad Request",
+        401 => "Unauthorized",
+        409 => "Conflict",
+        503 => "Service Unavailable",
+        404 => "Not Found",
+        500 => "Internal Server Error"
+      }.fetch(code, "OK")
+    end
+  end
+end

data/lib/harnex/runtime/file_change_hook.rb

@@ -0,0 +1,111 @@
+module Harnex
+  class FileChangeHook
+    EVENT_HEADER_SIZE = 16
+    WATCH_MASK = Inotify::IN_ATTRIB | Inotify::IN_CLOSE_WRITE | Inotify::IN_CREATE | Inotify::IN_MOVED_TO
+    RETRY_SECONDS = 1.0
+    IDLE_SLEEP_SECONDS = 0.1
+
+    def initialize(session, config)
+      @session = session
+      @config = config
+      @target_dir = File.dirname(config.absolute_path)
+      @target_name = File.basename(config.absolute_path)
+      @buffer = +""
+      @buffer.force_encoding(Encoding::BINARY)
+      @mutex = Mutex.new
+      @change_generation = 0
+      @delivered_generation = 0
+      @last_change_at = nil
+    end
+
+    def start
+      Thread.new { run }
+    end
+
+    private
+
+    def run
+      reader_thread = Thread.new { watch_loop }
+      delivery_loop
+    ensure
+      reader_thread&.kill
+      reader_thread&.join(0.1)
+    end
+
+    def watch_loop
+      io = Watcher.directory_io(@target_dir, WATCH_MASK)
+      loop do
+        chunk = io.readpartial(4096)
+        note_change if relevant_change?(chunk)
+      rescue EOFError, IOError, Errno::EIO
+        break
+      end
+    ensure
+      io&.close unless io&.closed?
+    end
+
+    def delivery_loop
+      loop do
+        generation, delivered_generation, last_change_at = snapshot
+        if generation == delivered_generation || last_change_at.nil?
+          sleep IDLE_SLEEP_SECONDS
+          next
+        end
+
+        remaining = @config.debounce_seconds - (Time.now - last_change_at)
+        if remaining.positive?
+          sleep [remaining, IDLE_SLEEP_SECONDS].max
+          next
+        end
+
+        begin
+          @session.inbox.enqueue(
+            text: @config.hook_message,
+            submit: true,
+            enter_only: false,
+            force: false
+          )
+          mark_delivered
+        rescue StandardError => e
+          break if e.message == "session is not running"
+
+          sleep RETRY_SECONDS
+        end
+      end
+    end
+
+    def relevant_change?(chunk)
+      @buffer << chunk
+      changed = false
+
+      while @buffer.bytesize >= EVENT_HEADER_SIZE
+        _, mask, _, name_length = @buffer.byteslice(0, EVENT_HEADER_SIZE).unpack("iIII")
+        event_size = EVENT_HEADER_SIZE + name_length
+        break if @buffer.bytesize < event_size
+
+        name = @buffer.byteslice(EVENT_HEADER_SIZE, name_length).to_s.delete("\0")
+        changed ||= name == @target_name && (mask & WATCH_MASK).positive?
+        @buffer = @buffer.byteslice(event_size, @buffer.bytesize - event_size).to_s
+      end
+
+      changed
+    end
+
+    def note_change
+      @mutex.synchronize do
+        @change_generation += 1
+        @last_change_at = Time.now
+      end
+    end
+
+    def snapshot
+      @mutex.synchronize { [@change_generation, @delivered_generation, @last_change_at] }
+    end
+
+    def mark_delivered
+      @mutex.synchronize do
+        @delivered_generation = @change_generation
+      end
+    end
+  end
+end