harnex 0.6.5 → 0.7.3

data/lib/harnex/adapters/codex_appserver.rb

@@ -1,5 +1,6 @@
 require "json"
 require "open3"
+require_relative "../codex/app_server/client"
 
 module Harnex
   module Adapters
@@ -69,6 +70,10 @@ module Harnex
         :stdio_jsonrpc
       end
 
+      def provider
+        "openai"
+      end
+
       def base_command
         ["codex", "app-server"]
       end
@@ -135,10 +140,10 @@ module Harnex
       # subprocess. In tests, callers may pass pre-built IO objects.
       def start_rpc(env: nil, cwd: nil, read_io: nil, write_io: nil, pid: nil)
         if read_io && write_io
-          @client = JsonRpcClient.new(read_io: read_io, write_io: write_io, pid: pid)
+          @client = Harnex::Codex::AppServer::Client.new(read_io: read_io, write_io: write_io, pid: pid)
         else
           spawn_pid, child_stdin, child_stdout = spawn_subprocess(env, cwd)
-          @client = JsonRpcClient.new(read_io: child_stdout, write_io: child_stdin, pid: spawn_pid)
+          @client = Harnex::Codex::AppServer::Client.new(read_io: child_stdout, write_io: child_stdin, pid: spawn_pid)
         end
 
         @client.on_notification { |msg| handle_notification(msg) }
@@ -189,6 +194,48 @@ module Harnex
         result
       end
 
+      # Plan 30 Phase 2 — subprocess-restart primitive for deployment
+      # fallback. Stops the current JSON-RPC subprocess, spawns a new one
+      # against the supplied deployment_config, and resumes the same
+      # threadId so conversation state carries across. Thin orchestrator:
+      # counter snapshots, the `fallback_triggered` event, and any
+      # Session-level signaling land in plan 30 Phases 3–4 alongside the
+      # per-arm telemetry split. CLI flags land in Phase 5.
+      #
+      # deployment_config: { command: [...argv], env: {...}, cwd: nil }
+      def switch_deployment(deployment_config:,
+                            term_grace_seconds: STOP_TERM_GRACE_SECONDS,
+                            kill_grace_seconds: STOP_KILL_GRACE_SECONDS)
+        raise "codex_appserver: client not started" unless @client
+        raise "codex_appserver: no thread to resume" if @thread_id.nil? || @thread_id.to_s.empty?
+
+        prior_thread_id = @thread_id
+        in_flight =
+          if @current_turn_id
+            { threadId: prior_thread_id, turnId: @current_turn_id }
+          end
+
+        @client.stop_for_fallback(
+          in_flight_turn: in_flight,
+          term_grace_seconds: term_grace_seconds,
+          kill_grace_seconds: kill_grace_seconds
+        )
+
+        @client = Harnex::Codex::AppServer::Client.spawn_with_fallback(
+          prior_thread_id: prior_thread_id,
+          deployment_config: deployment_config,
+          handshake_params: handshake_initialize_params,
+          notification_handler: ->(msg) { handle_notification(msg) },
+          request_handler: ->(method, params) { handle_server_request(method, params) },
+          disconnect_handler: ->(err) { handle_disconnect(err) }
+        )
+
+        @thread_id = prior_thread_id
+        @current_turn_id = nil
+        @state = :prompt
+        self
+      end
+
       def close
         return unless @client
 
@@ -259,7 +306,12 @@ module Harnex
       end
 
       def perform_handshake
-        @client.request("initialize", {
+        @client.request("initialize", handshake_initialize_params)
+        @client.notify("initialized", {})
+      end
+
+      def handshake_initialize_params
+        {
           clientInfo: {
             title: CLIENT_TITLE,
             name: CLIENT_NAME,
@@ -269,8 +321,7 @@ module Harnex
             experimentalApi: false,
             optOutNotificationMethods: OPT_OUT_NOTIFICATIONS
           }
-        })
-        @client.notify("initialized", {})
+        }
       end
 
       def handle_notification(message)
@@ -314,231 +365,6 @@ module Harnex
         "Codex app-server is not at a prompt; wait and retry or use `harnex send --force` (state: #{state[:state]})"
       end
 
-      # Minimal JSON-RPC 2.0 client. One JSON object per line.
-      # Responses keyed by id; everything else is a notification.
-      class JsonRpcClient
-        attr_reader :pid
-
-        def initialize(read_io:, write_io:, pid: nil)
-          @read_io = read_io
-          @write_io = write_io
-          @pid = pid
-          @next_id = 1
-          @pending = {}
-          @id_mutex = Mutex.new
-          @write_mutex = Mutex.new
-          @notification_handler = nil
-          @request_handler = nil
-          @disconnect_handler = nil
-          @disconnect_signaled = false
-          @closed = false
-          @reader_thread = nil
-        end
-
-        def on_notification(&block)
-          @notification_handler = block
-        end
-
-        # Handler for server-initiated requests (id + method). The block
-        # receives (method, params) and returns the response body for the
-        # JSON-RPC `result` field, or nil to reject with -32601.
-        def on_request(&block)
-          @request_handler = block
-        end
-
-        def on_disconnect(&block)
-          @disconnect_handler = block
-        end
-
-        def start
-          @reader_thread = Thread.new { read_loop }
-        end
-
-        def request(method, params = {})
-          raise "codex_appserver client is closed" if @closed
-
-          queue = Queue.new
-          id = @id_mutex.synchronize do
-            assigned = @next_id
-            @next_id += 1
-            @pending[assigned] = queue
-            assigned
-          end
-
-          write_line({ jsonrpc: "2.0", id: id, method: method, params: params })
-          result = queue.pop
-          raise result if result.is_a?(Exception)
-
-          result
-        end
-
-        def notify(method, params = {})
-          return if @closed
-
-          write_line({ jsonrpc: "2.0", method: method, params: params })
-        end
-
-        def close
-          return if @closed
-
-          @closed = true
-
-          @id_mutex.synchronize do
-            @pending.each_value { |q| q.push(StandardError.new("codex_appserver client closed")) }
-            @pending.clear
-          end
-
-          begin
-            @write_io.close unless @write_io.closed?
-          rescue IOError
-            nil
-          end
-
-          if @pid && process_alive?(@pid)
-            sleep 0.05
-            begin
-              Process.kill("TERM", @pid)
-            rescue Errno::ESRCH
-              nil
-            end
-          end
-
-          @reader_thread&.join(2)
-        end
-
-        def terminate_process(term_grace_seconds:, kill_grace_seconds:)
-          return false unless @pid
-
-          begin
-            Process.kill("TERM", @pid)
-          rescue Errno::ESRCH
-            return true
-          end
-
-          return true if wait_for_process_exit(@pid, term_grace_seconds)
-
-          begin
-            Process.kill("KILL", @pid)
-          rescue Errno::ESRCH
-            return true
-          end
-
-          wait_for_process_exit(@pid, kill_grace_seconds)
-        end
-
-        private
-
-        def write_line(message)
-          @write_mutex.synchronize do
-            @write_io.write(JSON.generate(message))
-            @write_io.write("\n")
-            @write_io.flush
-          end
-        rescue Errno::EPIPE, IOError
-          signal_disconnect(nil)
-        end
-
-        def read_loop
-          buffer = +""
-          loop do
-            chunk = @read_io.readpartial(4096)
-            buffer << chunk
-            while (idx = buffer.index("\n"))
-              line = buffer.slice!(0, idx + 1).chomp
-              next if line.strip.empty?
-
-              handle_line(line)
-            end
-          end
-        rescue EOFError, IOError, Errno::EIO
-          nil
-        ensure
-          signal_disconnect(nil)
-        end
-
-        def handle_line(line)
-          message = JSON.parse(line)
-        rescue JSON::ParserError => e
-          signal_disconnect(e)
-          return
-        else
-          dispatch_message(message)
-        end
-
-        def dispatch_message(message)
-          if message["id"] && message["method"]
-            handle_server_request(message)
-            return
-          end
-
-          if message.key?("id")
-            pending = @id_mutex.synchronize { @pending.delete(message["id"]) }
-            return unless pending
-
-            if message["error"]
-              err_msg = message.dig("error", "message") || "RPC error"
-              pending.push(StandardError.new("codex_appserver RPC error: #{err_msg}"))
-              signal_disconnect(message["error"])
-            else
-              pending.push(message["result"] || {})
-            end
-            return
-          end
-
-          @notification_handler&.call(message) if message["method"]
-        end
-
-        def handle_server_request(message)
-          result =
-            begin
-              @request_handler&.call(message["method"], message["params"] || {})
-            rescue StandardError
-              nil
-            end
-
-          if result.nil?
-            write_line({
-              jsonrpc: "2.0",
-              id: message["id"],
-              error: { code: -32601, message: "Unsupported server request: #{message['method']}" }
-            })
-          else
-            write_line({
-              jsonrpc: "2.0",
-              id: message["id"],
-              result: result
-            })
-          end
-        end
-
-        def signal_disconnect(error)
-          return if @disconnect_signaled
-
-          @disconnect_signaled = true
-          @disconnect_handler&.call(error)
-        end
-
-        def process_alive?(pid)
-          Process.kill(0, pid)
-          true
-        rescue Errno::ESRCH, Errno::EPERM
-          false
-        end
-
-        def wait_for_process_exit(pid, timeout_seconds)
-          deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout_seconds.to_f
-          loop do
-            return true unless process_alive?(pid)
-
-            remaining = deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)
-            break if remaining <= 0
-
-            sleep([0.05, remaining].min)
-          end
-
-          !process_alive?(pid)
-        end
-      end
     end
   end
 end

data/lib/harnex/adapters/opencode.rb

@@ -0,0 +1,132 @@
+module Harnex
+  module Adapters
+    class Opencode < Base
+      SUBMIT_DELAY_MS = 75
+      SUBMIT_DELAY_PER_KB_MS = 50
+      EXIT_SIGNAL_DELAY_MS = 100
+
+      def initialize(extra_args = [])
+        super("opencode", extra_args)
+        @screen_seen = false
+      end
+
+      def provider
+        "opencode"
+      end
+
+      def base_command
+        ["opencode"]
+      end
+
+      def infer_repo_path(argv)
+        index = 0
+        while index < argv.length
+          arg = argv[index].to_s
+          case arg
+          when "--dir"
+            next_value = argv[index + 1]
+            return next_value if next_value && !next_value.to_s.strip.empty?
+            break
+          when /\A--dir=(.+)\z/
+            return Regexp.last_match(1)
+          end
+          index += 1
+        end
+
+        positional = argv.find { |value| value && !value.start_with?("-") }
+        return positional if positional
+
+        Dir.pwd
+      end
+
+      def input_state(screen_text)
+        @screen_seen ||= !screen_text.to_s.empty?
+        lines = recent_lines(screen_text, limit: 80)
+        return prompt_state if @screen_seen && lines.empty?
+        return prompt_state if lines.any? { |line| prompt_line?(line) }
+
+        compact = lines.join(" ").gsub(/\s+/, " ")
+
+        # OpenCode's TUI keeps rendering on an alternate screen and does
+        # not expose a stable prompt token in plain text snapshots. Treat
+        # observed screen content as send-ready so inbox messages don't
+        # stall indefinitely in :unknown.
+        return prompt_state if compact.match?(/\bOpenCode\b/i)
+        return prompt_state if compact.match?(/\bSession\b.*\bContinue\b.*\bopencode\s+-s\b/i)
+        return prompt_state if compact.match?(/[■⬝╹]/)
+
+        return prompt_state if @screen_seen
+
+        super
+      end
+
+      def parse_session_summary(transcript_tail)
+        summary = {
+          input_tokens: nil,
+          output_tokens: nil,
+          reasoning_tokens: nil,
+          cached_tokens: nil,
+          total_tokens: nil,
+          agent_session_id: nil
+        }
+
+        text = normalized_screen_text(transcript_tail)
+        if (match = text.match(/\bContinue\s+opencode\s+-s\s+([A-Za-z0-9._:-]+)/))
+          summary[:agent_session_id] = match[1]
+        end
+
+        summary
+      end
+
+      def build_send_payload(text:, submit:, enter_only:, screen_text:, force: false)
+        state = input_state(screen_text)
+        if !force && blocked_state?(state, enter_only: enter_only)
+          raise ArgumentError, blocked_message(state, enter_only: enter_only)
+        end
+
+        steps = []
+        unless enter_only
+          body = text.to_s
+          steps << { text: body, newline: false } unless body.empty?
+        end
+
+        if submit || enter_only
+          step = { text: submit_bytes, newline: false }
+          step[:delay_ms] = submit_delay_ms(text) if steps.any?
+          steps << step
+        end
+
+        {
+          steps: steps,
+          input_state: state,
+          force: force
+        }
+      end
+
+      def inject_exit(writer)
+        # Ctrl+C is OpenCode's native terminal stop path. A second signal
+        # shortly after the first handles "interrupt-first, quit-second"
+        # cases when work is in-flight.
+        writer.write("\u0003")
+        writer.flush
+        sleep(EXIT_SIGNAL_DELAY_MS / 1000.0)
+        writer.write("\u0003")
+        writer.flush
+      end
+
+      private
+
+      def prompt_state
+        {
+          state: "prompt",
+          input_ready: true
+        }
+      end
+
+      def submit_delay_ms(text)
+        extra = (text.to_s.bytesize / 1024.0 * SUBMIT_DELAY_PER_KB_MS).ceil
+        SUBMIT_DELAY_MS + extra
+      end
+    end
+  end
+end

data/lib/harnex/adapters.rb

@@ -3,6 +3,7 @@ require_relative "adapters/generic"
 require_relative "adapters/codex"
 require_relative "adapters/codex_appserver"
 require_relative "adapters/claude"
+require_relative "adapters/opencode"
 
 module Harnex
   module Adapters
@@ -39,7 +40,8 @@ module Harnex
     def registry
       @registry ||= {
         "claude" => Claude,
-        "codex" => Codex
+        "codex" => Codex,
+        "opencode" => Opencode
       }
     end
   end

data/lib/harnex/cli.rb

@@ -23,6 +23,8 @@ module Harnex
         Logs.new(@argv.drop(1)).run
       when "events"
         Events.new(@argv.drop(1)).run
+      when "history"
+        History.new(@argv.drop(1)).run
       when "pane"
         Pane.new(@argv.drop(1)).run
       when "recipes"
@@ -65,6 +67,8 @@ module Harnex
         Logs.usage
       when "events"
         Events.usage
+      when "history"
+        History.usage
       when "pane"
         Pane.usage
       when "recipes"
@@ -90,6 +94,7 @@ module Harnex
           harnex status [options]
           harnex logs --id ID [options]
           harnex events --id ID [options]
+          harnex history [options]
           harnex pane --id ID [options]
           harnex agents-guide [topic]
           harnex doctor
@@ -103,12 +108,13 @@ module Harnex
           status  List live sessions
           logs    Read session output transcripts
           events  Stream per-session JSONL runtime events
+          history List completed dispatches from .harnex/dispatch.jsonl
           pane    Capture the current tmux pane for a live session
           recipes List and read workflow recipes
           guide   Show the getting started guide
           agents-guide
                   Show agent dispatch, chain, buddy, monitoring, and naming guides
-          doctor  Run preflight checks for adapter dependencies
+          doctor  Run preflight checks and optional read-only session sweep
           help    Show command help
 
         New to harnex? Start with: harnex guide
@@ -125,6 +131,7 @@ module Harnex
           harnex status
           harnex logs --id main --follow
           harnex events --id main --snapshot
+          harnex history --limit 20
           harnex pane --id main --lines 40
           harnex agents-guide dispatch
           harnex doctor