omq-cli 0.1.0 → 0.3.0

data/lib/omq/cli.rb

@@ -3,7 +3,13 @@
 require "optparse"
 require_relative "cli/version"
 require_relative "cli/config"
+require_relative "cli/cli_parser"
 require_relative "cli/formatter"
+require_relative "cli/expression_evaluator"
+require_relative "cli/socket_setup"
+require_relative "cli/routing_helper"
+require_relative "cli/transient_monitor"
+require_relative "cli/parallel_recv_runner"
 require_relative "cli/base_runner"
 require_relative "cli/push_pull"
 require_relative "cli/pub_sub"
@@ -12,21 +18,32 @@ require_relative "cli/radio_dish"
 require_relative "cli/req_rep"
 require_relative "cli/pair"
 require_relative "cli/router_dealer"
-require_relative "cli/channel"
 require_relative "cli/client_server"
-require_relative "cli/peer"
 require_relative "cli/pipe"
 
 module OMQ
 
   class << self
-    attr_reader :outgoing_proc, :incoming_proc
+    # @return [Proc, nil] registered outgoing message transform
+    attr_reader :outgoing_proc
+    # @return [Proc, nil] registered incoming message transform
+    attr_reader :incoming_proc
 
+    # Registers an outgoing message transform (used by -r scripts).
+    #
+    # @yield [Array<String>] message parts before sending
+    # @return [Proc]
     def outgoing(&block) = @outgoing_proc = block
+
+    # Registers an incoming message transform (used by -r scripts).
+    #
+    # @yield [Array<String>] message parts after receiving
+    # @return [Proc]
     def incoming(&block) = @incoming_proc = block
   end
 
 
+  # Command-line interface for OMQ socket operations.
   module CLI
     SOCKET_TYPE_NAMES = %w[
       req rep pub sub push pull pair dealer router
@@ -42,206 +59,21 @@ module OMQ
       "sub"     => [SubRunner,     :SUB],
       "req"     => [ReqRunner,     :REQ],
       "rep"     => [RepRunner,     :REP],
-      "dealer"  => [DealerRunner,  :DEALER],
+      "dealer"  => [PairRunner,    :DEALER],
       "router"  => [RouterRunner,  :ROUTER],
       "pair"    => [PairRunner,    :PAIR],
-      "client"  => [ClientRunner,  :CLIENT],
+      "client"  => [ReqRunner,     :CLIENT],
       "server"  => [ServerRunner,  :SERVER],
       "radio"   => [RadioRunner,   :RADIO],
       "dish"    => [DishRunner,    :DISH],
       "scatter" => [ScatterRunner, :SCATTER],
       "gather"  => [GatherRunner,  :GATHER],
-      "channel" => [ChannelRunner, :CHANNEL],
-      "peer"    => [PeerRunner,    :PEER],
+      "channel" => [PairRunner,    :CHANNEL],
+      "peer"    => [ServerRunner,  :PEER],
       "pipe"    => [PipeRunner,    nil],
     }.freeze
 
 
-    EXAMPLES = <<~'TEXT'
-      ── Request / Reply ──────────────────────────────────────────
-
-        ┌─────┐  "hello"    ┌─────┐
-        │ REQ │────────────→│ REP │
-        │     │←────────────│     │
-        └─────┘  "HELLO"    └─────┘
-
-        # terminal 1: echo server
-        omq rep --bind tcp://:5555 --recv-eval '$F.map(&:upcase)'
-
-        # terminal 2: send a request
-        echo "hello" | omq req --connect tcp://localhost:5555
-
-        # or over IPC (unix socket, single machine)
-        omq rep --bind ipc:///tmp/echo.sock --echo &
-        echo "hello" | omq req --connect ipc:///tmp/echo.sock
-
-      ── Publish / Subscribe ──────────────────────────────────────
-
-        ┌─────┐  "weather.nyc 72F"  ┌─────┐
-        │ PUB │────────────────────→│ SUB │ --subscribe "weather."
-        └─────┘                     └─────┘
-
-        # terminal 1: subscriber (all topics by default)
-        omq sub --bind tcp://:5556
-
-        # terminal 2: publisher (needs --delay for subscription to propagate)
-        echo "weather.nyc 72F" | omq pub --connect tcp://localhost:5556 --delay 1
-
-      ── Periodic Publish ───────────────────────────────────────────
-
-        ┌─────┐  "tick 1"    ┌─────┐
-        │ PUB │──(every 1s)─→│ SUB │
-        └─────┘              └─────┘
-
-        # terminal 1: subscriber
-        omq sub --bind tcp://:5556
-
-        # terminal 2: publish a tick every second (wall-clock aligned)
-        omq pub --connect tcp://localhost:5556 --delay 1 \
-          --data "tick" --interval 1
-
-        # 5 ticks, then exit
-        omq pub --connect tcp://localhost:5556 --delay 1 \
-          --data "tick" --interval 1 --count 5
-
-      ── Pipeline ─────────────────────────────────────────────────
-
-        ┌──────┐           ┌──────┐
-        │ PUSH │──────────→│ PULL │
-        └──────┘           └──────┘
-
-        # terminal 1: worker
-        omq pull --bind tcp://:5557
-
-        # terminal 2: send tasks
-        echo "task 1" | omq push --connect tcp://localhost:5557
-
-        # or over IPC (unix socket)
-        omq pull --bind ipc:///tmp/pipeline.sock &
-        echo "task 1" | omq push --connect ipc:///tmp/pipeline.sock
-
-      ── Pipe (PULL → eval → PUSH) ────────────────────────────────
-
-        ┌──────┐         ┌──────┐         ┌──────┐
-        │ PUSH │────────→│ pipe │────────→│ PULL │
-        └──────┘         └──────┘         └──────┘
-
-        # terminal 1: producer
-        echo -e "hello\nworld" | omq push --bind ipc://@work
-
-        # terminal 2: worker — uppercase each message
-        omq pipe -c ipc://@work -c ipc://@sink -e '$F.map(&:upcase)'
-        # terminal 3: collector
-        omq pull --bind ipc://@sink
-
-        # 4 Ractor workers in a single process (-P)
-        omq pipe -c ipc://@work -c ipc://@sink -P4 -r./fib -e 'fib(Integer($_)).to_s'
-
-        # exit when producer disconnects (--transient)
-        omq pipe -c ipc://@work -c ipc://@sink --transient -e '$F.map(&:upcase)'
-
-        # fan-in: multiple sources → one sink
-        omq pipe --in -c ipc://@work1 -c ipc://@work2 \
-          --out -c ipc://@sink -e '$F.map(&:upcase)'
-
-        # fan-out: one source → multiple sinks (round-robin)
-        omq pipe --in -b tcp://:5555 --out -c ipc://@sink1 -c ipc://@sink2 -e '$F'
-
-      ── CLIENT / SERVER (draft) ──────────────────────────────────
-
-        ┌────────┐  "hello"   ┌────────┐
-        │ CLIENT │───────────→│ SERVER │ --recv-eval '$F.map(&:upcase)'
-        │        │←───────────│        │
-        └────────┘  "HELLO"   └────────┘
-
-        # terminal 1: upcasing server
-        omq server --bind tcp://:5555 --recv-eval '$F.map(&:upcase)'
-
-        # terminal 2: client
-        echo "hello" | omq client --connect tcp://localhost:5555
-
-      ── Formats ──────────────────────────────────────────────────
-
-        # ascii (default) — non-printable replaced with dots
-        omq pull --bind tcp://:5557 --ascii
-
-        # quoted — lossless, round-trippable (uses String#dump escaping)
-        omq pull --bind tcp://:5557 --quoted
-
-        # JSON Lines — structured, multipart as arrays
-        echo '["key","value"]' | omq push --connect tcp://localhost:5557 --jsonl
-        omq pull --bind tcp://:5557 --jsonl
-
-        # multipart via tabs
-        printf "routing-key\tpayload" | omq push --connect tcp://localhost:5557
-
-      ── Compression ──────────────────────────────────────────────
-
-        # both sides must use --compress
-        omq pull --bind tcp://:5557 --compress &
-        echo "compressible data" | omq push --connect tcp://localhost:5557 --compress
-
-      ── CURVE Encryption ─────────────────────────────────────────
-
-        # server (prints OMQ_SERVER_KEY=...)
-        omq rep --bind tcp://:5555 --echo --curve-server
-
-        # client (paste the server's key)
-        echo "secret" | omq req --connect tcp://localhost:5555 \
-          --curve-server-key '<key from server>'
-
-      ── ROUTER / DEALER ──────────────────────────────────────────
-
-        ┌────────┐          ┌────────┐
-        │ DEALER │─────────→│ ROUTER │
-        │ id=w1  │          │        │
-        └────────┘          └────────┘
-
-        # terminal 1: router shows identity + message
-        omq router --bind tcp://:5555
-
-        # terminal 2: dealer with identity
-        echo "hello" | omq dealer --connect tcp://localhost:5555 --identity worker-1
-
-      ── Ruby Eval ────────────────────────────────────────────────
-
-        # filter incoming: only pass messages containing "error"
-        omq pull -b tcp://:5557 --recv-eval '$F.first.include?("error") ? $F : nil'
-
-        # transform incoming with gems
-        omq sub -c tcp://localhost:5556 -rjson -e 'JSON.parse($F.first)["temperature"]'
-
-        # require a local file, use its methods
-        omq rep --bind tcp://:5555 --require ./transform.rb -e 'upcase_all($F)'
-
-        # next skips, break stops — regexps match against $_
-        omq pull -b tcp://:5557 -e 'next if /^#/; break if /quit/; $F'
-
-        # BEGIN/END blocks (like awk) — accumulate and summarize
-        omq pull -b tcp://:5557 -e 'BEGIN{@sum = 0} @sum += Integer($_); nil END{puts @sum}'
-
-        # transform outgoing messages
-        echo hello | omq push -c tcp://localhost:5557 --send-eval '$F.map(&:upcase)'
-
-        # REQ: transform request and reply independently
-        echo hello | omq req -c tcp://localhost:5555 -E '$F.map(&:upcase)' -e '$_'
-
-      ── Script Handlers (-r) ────────────────────────────────────
-
-        # handler.rb — register transforms from a file
-        #   db = PG.connect("dbname=app")
-        #   OMQ.incoming { |first_part, _| db.exec(first_part).values.flatten }
-        #   at_exit { db.close }
-        omq pull --bind tcp://:5557 -r./handler.rb
-
-        # combine script handlers with inline eval
-        omq req -c tcp://localhost:5555 -r./handler.rb -E '$F.map(&:upcase)'
-
-        # OMQ.outgoing { |msg| ... }   — registered outgoing transform
-        # OMQ.incoming { |msg| ... }   — registered incoming transform
-        # CLI flags (-e/-E) override registered handlers
-    TEXT
-
     module_function
 
 
@@ -267,27 +99,128 @@ module OMQ
     end
 
 
+    # Main entry point: dispatches to keygen or socket runner.
+    #
+    # @param argv [Array<String>] command-line arguments
+    # @return [void]
+    def run(argv = ARGV)
+      case argv.first
+      when "keygen"
+        argv.shift
+        run_keygen(argv)
+      else
+        run_socket(argv)
+      end
+    end
+
+
+    # Generates a persistent CURVE keypair and prints it as
+    # Z85-encoded env vars.
+    #
+    def run_keygen(argv)
+      crypto_name = nil
+      verbose     = false
+      while (arg = argv.shift)
+        case arg
+        when "--curve-crypto"
+          crypto_name = argv.shift
+        when "-v", "--verbose"
+          verbose = true
+        when "-h", "--help"
+          puts "Usage: omq keygen [--curve-crypto rbnacl|nuckle] [-v]\n\n" \
+               "Generates a CURVE keypair for persistent server identity.\n" \
+               "Output: Z85-encoded env vars for use with --curve-server."
+          exit
+        else
+          abort "omq keygen: unknown option: #{arg}"
+        end
+      end
+      crypto_name ||= ENV["OMQ_CURVE_CRYPTO"]
+
+      crypto = load_curve_crypto(crypto_name, verbose: verbose)
+      require "protocol/zmtp/mechanism/curve"
+      require "protocol/zmtp/z85"
+
+      key = crypto::PrivateKey.generate
+      puts "OMQ_SERVER_PUBLIC='#{Protocol::ZMTP::Z85.encode(key.public_key.to_s)}'"
+      puts "OMQ_SERVER_SECRET='#{Protocol::ZMTP::Z85.encode(key.to_s)}'"
+    end
+
+
+    # Loads the named NaCl-compatible crypto backend.
+    #
+    # @param name [String, nil] "rbnacl", "nuckle", or nil (auto-detect rbnacl)
+    # @param verbose [Boolean] log which backend was loaded to stderr
+    # @return [Module] RbNaCl or Nuckle
+    #
+    def load_curve_crypto(name, verbose: false)
+      crypto = case name&.downcase
+      when "rbnacl"
+        require "rbnacl"
+        RbNaCl
+      when "nuckle"
+        require "nuckle"
+        Nuckle
+      when nil
+        begin
+          require "rbnacl"
+          RbNaCl
+        rescue LoadError
+          abort "CURVE requires a crypto backend. Install rbnacl (recommended):\n" \
+                "  gem install rbnacl    # requires system libsodium\n" \
+                "Or use pure Ruby (not audited):\n" \
+                "  --curve-crypto nuckle\n" \
+                "  # or: OMQ_CURVE_CRYPTO=nuckle"
+        end
+      else
+        abort "Unknown CURVE crypto backend: #{name}. Use 'rbnacl' or 'nuckle'."
+      end
+      $stderr.puts "omq: CURVE crypto backend: #{crypto.name}" if verbose
+      crypto
+    rescue LoadError
+      abort "Could not load #{name} gem: gem install #{name}"
+    end
+
+
     # Parses CLI arguments, validates options, and runs the main
     # event loop inside an Async reactor.
     #
-    def run(argv = ARGV)
+    def run_socket(argv)
       config = build_config(argv)
 
       require "omq"
+      require "omq/rfc/clientserver"
+      require "omq/rfc/radiodish"
+      require "omq/rfc/scattergather"
+      require "omq/rfc/channel"
+      require "omq/rfc/p2p"
       require "async"
       require "json"
       require "console"
 
-      validate_gems!(config)
+      CliParser.validate_gems!(config)
+      require "omq/ractor" if config.parallel
 
       trap("INT")  { Process.exit!(0) }
       trap("TERM") { Process.exit!(0) }
 
       Console.logger = Console::Logger.new(Console::Output::Null.new) unless config.verbose
 
+      if config.type_name.nil?
+        Object.include(OMQ) unless Object.include?(OMQ)
+        Async do
+          config.scripts.each { |s| load_script(s) }
+        rescue => e
+          $stderr.puts "omq: #{e.message}"
+          exit 1
+        end
+        return
+      end
+
       runner_class, socket_sym = RUNNER_MAP.fetch(config.type_name)
 
       Async do |task|
+        config.scripts.each { |s| load_script(s) }
         runner = if socket_sym
                    runner_class.new(config, OMQ.const_get(socket_sym))
                  else
@@ -307,238 +240,37 @@ module OMQ
     end
 
 
-    # Builds a frozen Config from command-line arguments.
-    #
-    def build_config(argv)
-      opts = parse_options(argv)
-      validate!(opts)
-
-      opts[:has_msgpack]  = begin; require "msgpack"; true; rescue LoadError; false; end
-      opts[:has_zstd]     = begin; require "zstd-ruby"; true; rescue LoadError; false; end
-      opts[:stdin_is_tty] = $stdin.tty?
-
-      Ractor.make_shareable(Config.new(**opts))
-    end
-
-
-    # Parses command-line arguments into a mutable options hash.
-    #
-    def parse_options(argv)
-      opts = {
-        endpoints:        [],
-        connects:         [],
-        binds:            [],
-        in_endpoints:     [],
-        out_endpoints:    [],
-        data:             nil,
-        file:             nil,
-        format:           :ascii,
-        subscribes:       [],
-        joins:            [],
-        group:            nil,
-        identity:         nil,
-        target:           nil,
-        interval:         nil,
-        count:            nil,
-        delay:            nil,
-        timeout:          nil,
-        linger:           5,
-        reconnect_ivl:    nil,
-        heartbeat_ivl:    nil,
-        conflate:         false,
-        compress:         false,
-        send_expr:        nil,
-        recv_expr:        nil,
-        parallel:         nil,
-        transient:        false,
-        verbose:          false,
-        quiet:            false,
-        echo:             false,
-        curve_server:     false,
-        curve_server_key: nil,
-        curve_crypto:     nil,
-      }
-
-      pipe_side = nil  # nil = legacy positional mode; :in/:out = modal
-
-      parser = OptionParser.new do |o|
-        o.banner = "Usage: omq TYPE [options]\n\n" \
-                   "Types:    req, rep, pub, sub, push, pull, pair, dealer, router\n" \
-                   "Draft:    client, server, radio, dish, scatter, gather, channel, peer\n" \
-                   "Virtual:  pipe (PULL → eval → PUSH)\n\n"
-
-        o.separator "Connection:"
-        o.on("-c", "--connect URL", "Connect to endpoint (repeatable)") { |v|
-          ep = Endpoint.new(v, false)
-          case pipe_side
-          when :in  then opts[:in_endpoints] << ep
-          when :out then opts[:out_endpoints] << ep
-          else           opts[:endpoints] << ep; opts[:connects] << v
-          end
-        }
-        o.on("-b", "--bind URL", "Bind to endpoint (repeatable)") { |v|
-          ep = Endpoint.new(v, true)
-          case pipe_side
-          when :in  then opts[:in_endpoints] << ep
-          when :out then opts[:out_endpoints] << ep
-          else           opts[:endpoints] << ep; opts[:binds] << v
-          end
-        }
-        o.on("--in",  "Pipe: subsequent -b/-c attach to input (PULL) side")  { pipe_side = :in }
-        o.on("--out", "Pipe: subsequent -b/-c attach to output (PUSH) side") { pipe_side = :out }
-
-        o.separator "\nData source (REP: reply source):"
-        o.on(      "--echo",        "Echo received messages back (REP)")   { opts[:echo] = true }
-        o.on("-D", "--data DATA",   "Message data (literal string)")      { |v| opts[:data] = v }
-        o.on("-F", "--file FILE",   "Read message from file (- = stdin)") { |v| opts[:file] = v }
-
-        o.separator "\nFormat (input + output):"
-        o.on("-A", "--ascii",   "Tab-separated frames, safe ASCII (default)") { opts[:format] = :ascii }
-        o.on("-Q", "--quoted",  "C-style quoted with escapes")                { opts[:format] = :quoted }
-        o.on(      "--raw",     "Raw binary, no framing")                     { opts[:format] = :raw }
-        o.on("-J", "--jsonl",   "JSON Lines (array of strings per line)")     { opts[:format] = :jsonl }
-        o.on(      "--msgpack",  "MessagePack arrays (binary stream)")         { opts[:format] = :msgpack }
-        o.on("-M", "--marshal", "Ruby Marshal stream (binary, Array<String>)") { opts[:format] = :marshal }
-
-        o.separator "\nSubscription/groups:"
-        o.on("-s", "--subscribe PREFIX", "Subscribe prefix (SUB, default all)")       { |v| opts[:subscribes] << v }
-        o.on("-j", "--join GROUP",       "Join group (repeatable, DISH only)")       { |v| opts[:joins] << v }
-        o.on("-g", "--group GROUP",      "Publish group (RADIO only)")              { |v| opts[:group] = v }
-
-        o.separator "\nIdentity/routing:"
-        o.on("--identity ID", "Set socket identity (DEALER/ROUTER)")                      { |v| opts[:identity] = v }
-        o.on("--target ID",   "Target peer (ROUTER/SERVER/PEER, 0x prefix for binary)")   { |v| opts[:target] = v }
-
-        o.separator "\nTiming:"
-        o.on("-i", "--interval SECS", Float, "Repeat interval")          { |v| opts[:interval] = v }
-        o.on("-n", "--count COUNT",   Integer, "Max iterations (0=inf)") { |v| opts[:count] = v }
-        o.on("-d", "--delay SECS",    Float, "Delay before first send")  { |v| opts[:delay] = v }
-        o.on("-t", "--timeout SECS", Float, "Send/receive timeout")       { |v| opts[:timeout] = v }
-        o.on("-l", "--linger SECS",  Float, "Drain time on close (default 5)") { |v| opts[:linger] = v }
-        o.on("--reconnect-ivl IVL", "Reconnect interval: SECS or MIN..MAX (default 0.1)") { |v|
-          opts[:reconnect_ivl] = if v.include?("..")
-                                   lo, hi = v.split("..", 2)
-                                   Float(lo)..Float(hi)
-                                 else
-                                   Float(v)
-                                 end
-        }
-        o.on("--heartbeat-ivl SECS", Float, "ZMTP heartbeat interval (detects dead peers)") { |v| opts[:heartbeat_ivl] = v }
-
-        o.separator "\nDelivery:"
-        o.on("--conflate", "Keep only last message per subscriber (PUB/RADIO)") { opts[:conflate] = true }
-
-        o.separator "\nCompression:"
-        o.on("-z", "--compress", "Zstandard compression per frame") { opts[:compress] = true }
-
-        o.separator "\nProcessing (-e = incoming, -E = outgoing):"
-        o.on("-e", "--recv-eval EXPR", "Eval Ruby for each incoming message ($F = parts)") { |v| opts[:recv_expr] = v }
-        o.on("-E", "--send-eval EXPR", "Eval Ruby for each outgoing message ($F = parts)") { |v| opts[:send_expr] = v }
-        o.on("-r", "--require LIB",  "Require lib/file; scripts can register OMQ.outgoing/incoming") { |v|
-          require "omq" unless defined?(OMQ::VERSION)
-          v.start_with?("./", "../") ? require(File.expand_path(v)) : require(v)
-        }
-        o.on("-P", "--parallel [N]", Integer, "Parallel Ractor workers (pipe only, default: nproc)") { |v|
-          require "etc"
-          opts[:parallel] = v || Etc.nprocessors
-        }
-
-        o.separator "\nCURVE encryption (requires rbnacl or nuckle gem):"
-        o.on("--curve-server",         "Enable CURVE as server (generates keypair)") { opts[:curve_server] = true }
-        o.on("--curve-server-key KEY", "Enable CURVE as client (server's Z85 public key)") { |v| opts[:curve_server_key] = v }
-        o.on("--curve-crypto BACKEND", "Crypto backend: rbnacl (default if installed) or nuckle") { |v| opts[:curve_crypto] = v }
-        o.separator "  Env vars: OMQ_SERVER_KEY (client), OMQ_SERVER_PUBLIC + OMQ_SERVER_SECRET (server)"
-        o.separator "            OMQ_CURVE_CRYPTO (backend: rbnacl or nuckle)"
-
-        o.separator "\nOther:"
-        o.on("-v", "--verbose",     "Print connection events to stderr") { opts[:verbose] = true }
-        o.on("-q", "--quiet",       "Suppress message output")          { opts[:quiet] = true }
-        o.on(      "--transient",   "Exit when all peers disconnect")   { opts[:transient] = true }
-        o.on("-V", "--version")     { require "omq"; puts "omq-cli #{OMQ::CLI::VERSION} (omq #{OMQ::VERSION})"; exit }
-        o.on("-h")                  { puts o; exit }
-        o.on(      "--help")        { page "#{o}\n#{EXAMPLES}"; exit }
-        o.on(      "--examples")    { page EXAMPLES; exit }
-
-        o.separator "\nExit codes: 0 = success, 1 = error, 2 = timeout"
-      end
-
-      begin
-        parser.parse!(argv)
-      rescue OptionParser::ParseError => e
-        abort e.message
-      end
-
-      type_name = argv.shift
-      abort parser.to_s unless type_name
-      unless SOCKET_TYPE_NAMES.include?(type_name.downcase)
-        abort "Unknown socket type: #{type_name}. Known: #{SOCKET_TYPE_NAMES.join(', ')}"
+    def load_script(s)
+      if s == :stdin
+        eval($stdin.read, TOPLEVEL_BINDING, "(stdin)", 1) # rubocop:disable Security/Eval
+      else
+        require s
       end
-
-      opts[:type_name] = type_name.downcase
-
-      normalize    = ->(url) { url.sub(%r{\Atcp://\*:}, "tcp://0.0.0.0:").sub(%r{\Atcp://:}, "tcp://localhost:") }
-      normalize_ep = ->(ep) { Endpoint.new(normalize.call(ep.url), ep.bind?) }
-      opts[:binds].map!(&normalize)
-      opts[:connects].map!(&normalize)
-      opts[:endpoints].map!(&normalize_ep)
-      opts[:in_endpoints].map!(&normalize_ep)
-      opts[:out_endpoints].map!(&normalize_ep)
-
-      opts
     end
+    private_class_method :load_script
 
 
-    # Validates option combinations.
+    # Builds a frozen Config from command-line arguments.
     #
-    def validate!(opts)
-      type_name = opts[:type_name]
-
-      if type_name == "pipe"
-        has_in_out = opts[:in_endpoints].any? || opts[:out_endpoints].any?
-        if has_in_out
-          abort "pipe --in requires at least one endpoint"              if opts[:in_endpoints].empty?
-          abort "pipe --out requires at least one endpoint"             if opts[:out_endpoints].empty?
-          abort "pipe: don't mix --in/--out with bare -b/-c endpoints"  unless opts[:endpoints].empty?
-        else
-          abort "pipe requires exactly 2 endpoints (pull-side and push-side), or use --in/--out" if opts[:endpoints].size != 2
-        end
-      else
-        abort "--in/--out are only valid for pipe" if opts[:in_endpoints].any? || opts[:out_endpoints].any?
-        abort "At least one --connect or --bind is required" if opts[:connects].empty? && opts[:binds].empty?
-      end
-      abort "--data and --file are mutually exclusive"        if opts[:data] && opts[:file]
-      abort "--subscribe is only valid for SUB"               if !opts[:subscribes].empty? && type_name != "sub"
-      abort "--join is only valid for DISH"                   if !opts[:joins].empty? && type_name != "dish"
-      abort "--group is only valid for RADIO"                 if opts[:group] && type_name != "radio"
-      abort "--identity is only valid for DEALER/ROUTER"      if opts[:identity] && !%w[dealer router].include?(type_name)
-      abort "--target is only valid for ROUTER/SERVER/PEER"   if opts[:target] && !%w[router server peer].include?(type_name)
-      abort "--conflate is only valid for PUB/RADIO"          if opts[:conflate] && !%w[pub radio].include?(type_name)
-      abort "--recv-eval is not valid for send-only sockets (use --send-eval / -E)" if opts[:recv_expr] && SEND_ONLY.include?(type_name)
-      abort "--send-eval is not valid for recv-only sockets (use --recv-eval / -e)" if opts[:send_expr] && RECV_ONLY.include?(type_name)
-      abort "--send-eval and --target are mutually exclusive"  if opts[:send_expr] && opts[:target]
-
-      if opts[:parallel]
-        abort "-P/--parallel is only valid for pipe"                                    unless type_name == "pipe"
-        abort "-P/--parallel must be >= 2"                                              if opts[:parallel] < 2
-        all_pipe_eps = opts[:in_endpoints] + opts[:out_endpoints] + opts[:endpoints]
-        abort "-P/--parallel requires all endpoints to use --connect (not --bind)" if all_pipe_eps.any?(&:bind?)
+    def build_config(argv)
+      opts = CliParser.parse(argv)
+      CliParser.validate!(opts)
+
+      opts[:has_msgpack] = begin
+        require "msgpack"
+        true
+      rescue LoadError
+        false
       end
-
-      (opts[:connects] + opts[:binds]).each do |url|
-        abort "inproc not supported, use tcp:// or ipc://" if url.include?("inproc://")
+      opts[:has_zstd] = begin
+        require "zstd-ruby"
+        true
+      rescue LoadError
+        false
       end
-    end
-
-
-    # Validates that required gems are available.
-    #
-    def validate_gems!(config)
-      abort "--msgpack requires the msgpack gem"    if config.format == :msgpack && !config.has_msgpack
-      abort "--compress requires the zstd-ruby gem" if config.compress && !config.has_zstd
+      opts[:stdin_is_tty] = $stdin.tty?
 
-      if config.recv_only? && (config.data || config.file)
-        abort "--data/--file not valid for #{config.type_name} (receive-only)"
-      end
+      Ractor.make_shareable(Config.new(**opts))
     end
   end
 end