tarazed 0.1.0

data/lib/tarazed/pty.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+require "io/console"
+require "shellwords"
+
+module Tarazed
+  class PTY
+    attr_reader :reader, :writer, :pid, :grid, :vt, :status, :initial_cwd, :command_name
+
+    def initialize(command: ENV.fetch("SHELL", "/bin/sh"), cwd: Dir.pwd, columns: 80, rows: 24, env: {},
+      scrollback: 10_000, queue_limit_bytes: 8_388_608)
+      unless queue_limit_bytes.is_a?(Integer) && queue_limit_bytes.positive?
+        raise ArgumentError, "terminal queue limit must be a positive integer"
+      end
+
+      @initial_cwd = File.expand_path(cwd)
+      @command_name = File.basename(Array(command).first.to_s)
+      @grid = Grid.new(columns: columns, rows: rows, scrollback: scrollback)
+      if Gem.win_platform?
+        require_relative "windows/conpty"
+        command = nil if command == "/bin/sh"
+        @native = Windows::ConPTY.new(command: command, cwd: cwd, columns: columns, rows: rows, env: env)
+        @pid = @native.pid
+        @vt = VT.new(grid) { |bytes| write(bytes) }
+        return
+      end
+
+      require "pty"
+      arguments = command.is_a?(Array) ? command : Shellwords.split(command)
+      raise ArgumentError, "terminal command required" if arguments.empty?
+
+      @reader, @writer, @pid = ::PTY.spawn({"TERM" => "xterm-256color", "COLORTERM" => "truecolor"}.merge(env),
+        *arguments, chdir: cwd)
+      @reader.binmode
+      @writer.binmode
+      @writer.sync = true
+      @vt = VT.new(grid) { |bytes| write(bytes) }
+      resize(columns: columns, rows: rows)
+      @queue, @queue_bytes, @queue_limit_bytes = [], 0, queue_limit_bytes
+      @queue_lock, @queue_ready = Mutex.new, ConditionVariable.new
+      start_reader
+    end
+
+    # nil means EOF; an empty String means that no data was ready yet.
+    def read(timeout: 0, max_bytes: 65_536, max_seconds: nil)
+      unless max_bytes.is_a?(Integer) && max_bytes.positive?
+        raise ArgumentError, "terminal read limit must be a positive integer"
+      end
+      raise ArgumentError, "terminal read timeout must be nonnegative" unless timeout.is_a?(Numeric) && timeout >= 0
+      unless max_seconds.nil? || max_seconds.is_a?(Numeric) && max_seconds >= 0
+        raise ArgumentError, "terminal parse budget must be nonnegative"
+      end
+      return nil if @eof
+      if @native
+        data = @native.read_available(limit: max_bytes)
+        data ? vt.feed(data) : @eof = true
+        return data
+      end
+
+      deadline = max_seconds && Process.clock_gettime(Process::CLOCK_MONOTONIC) + max_seconds
+      data = +"".b
+      loop do
+        break if data.bytesize >= max_bytes || deadline && Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+
+        piece = @queue_lock.synchronize do
+          if data.empty? && @queue.empty? && !@reader_eof && timeout.positive?
+            @queue_ready.wait(@queue_lock, timeout)
+          end
+          if @queue.empty?
+            @eof = true if @reader_eof
+            nil
+          else
+            chunk = @queue.shift
+            take = [max_bytes - data.bytesize, chunk.bytesize, 16_384].min
+            result = chunk.byteslice(0, take)
+            @queue.unshift(chunk.byteslice(take..)) if take < chunk.bytesize
+            @queue_bytes -= take
+            @queue_ready.broadcast
+            result
+          end
+        end
+        break unless piece
+
+        vt.feed(piece)
+        data << piece
+      end
+      @eof && data.empty? ? nil : data
+    end
+
+    def pending? = @native ? @native.pending? : @queue_lock.synchronize { !@queue.empty? }
+    def write(bytes) = @native ? @native.write(bytes) : writer.write(bytes)
+    def paste(text) = write(vt.paste(text))
+    def key(name, **modifiers) = write(vt.key(name, **modifiers))
+    def mouse(**event) = write(vt.mouse(**event))
+
+    def resize(columns:, rows:)
+      dimensions = [columns, rows]
+      return self if @pty_size == dimensions
+
+      grid.resize(columns: columns, rows: rows) unless grid.columns == columns && grid.rows == rows
+      @native ? @native.resize(columns, rows) : reader.winsize = [rows, columns]
+      @pty_size = dimensions
+      self
+    end
+
+    def busy?
+      !@native && alive? && reader.tcgetpgrp != pid
+    rescue IOError, SystemCallError, NoMethodError
+      false
+    end
+
+    def foreground_process_name(now: Process.clock_gettime(Process::CLOCK_MONOTONIC))
+      return @foreground_name if @foreground_checked && now - @foreground_checked < 1
+
+      @foreground_checked = now
+      group = reader.tcgetpgrp unless @native
+      value = if group && group != pid && File.file?("/proc/#{group}/comm")
+        File.read("/proc/#{group}/comm")
+      elsif group && group != pid
+        IO.popen(["ps", "-o", "comm=", "-p", group.to_s], &:read)
+      end
+      @foreground_name = value&.strip&.then { |name| File.basename(name) unless name.empty? }
+    rescue IOError, SystemCallError, NoMethodError
+      @foreground_name = nil
+    end
+
+    def signal(name = "INT")
+      return @native.write("\x03") if @native && name == "INT"
+      if @native
+        @native.close
+        return false
+      end
+
+      Process.kill(name, -pid)
+    rescue Errno::ESRCH, Errno::EPERM
+      begin
+        Process.kill(name, pid)
+      rescue Errno::ESRCH, Errno::EPERM
+        false
+      end
+    end
+
+    def alive?
+      return @native.alive? if @native
+      return false if @status
+
+      result = Process.waitpid2(pid, Process::WNOHANG)
+      @status = result.last if result
+      !result
+    rescue Errno::ECHILD
+      false
+    end
+
+    def close
+      if @native
+        @native.close
+        @eof = true
+        return self
+      end
+
+      @closing = true
+      @queue_lock.synchronize { @queue_ready.broadcast }
+      signal("HUP") if alive?
+      reader.close unless reader.closed?
+      writer.close unless writer.closed?
+      deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + 2
+      sleep 0.01 while alive? && Process.clock_gettime(Process::CLOCK_MONOTONIC) < deadline
+      if alive?
+        signal("KILL")
+        _, @status = Process.waitpid2(pid)
+      end
+      @reader_thread&.join(0.2)
+      @eof = true
+      self
+    rescue Errno::ECHILD, IOError
+      self
+    end
+
+    private
+
+    def start_reader
+      @reader_thread = Thread.new do
+        loop do
+          data = reader.readpartial(65_536)
+          @queue_lock.synchronize do
+            @queue_ready.wait(@queue_lock) while !@closing && @queue_bytes >= @queue_limit_bytes
+            break if @closing
+
+            @queue << data
+            @queue_bytes += data.bytesize
+            @queue_ready.broadcast
+          end
+        end
+      rescue Errno::EIO, EOFError, IOError
+        nil
+      ensure
+        @queue_lock.synchronize do
+          @reader_eof = true
+          @queue_ready.broadcast
+        end
+      end
+    end
+  end
+end

data/lib/tarazed/scrollback.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Tarazed
+  class Scrollback
+    include Enumerable
+
+    attr_reader :limit
+
+    def initialize(limit)
+      raise ArgumentError, "scrollback limit must be nonnegative" unless limit.is_a?(Integer) && limit >= 0
+
+      @limit = limit
+      clear
+    end
+
+    def clear = @rows = []
+    def length = @rows.length
+    alias size length
+    def [](index) = @rows[index]
+    def each(&block) = block ? @rows.each(&block) : enum_for(__method__)
+
+    def push(cells)
+      return if limit.zero?
+
+      @rows.shift if @rows.length == limit
+      @rows << cells.map { |cell| cell.dup.tap { |copy| copy.text = copy.text.dup.freeze }.freeze }.freeze
+    end
+  end
+end

data/lib/tarazed/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Tarazed
+  VERSION = "0.1.0"
+end

data/lib/tarazed/vt.rb

@@ -0,0 +1,444 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module Tarazed
+  class VT
+    DEC_GRAPHICS = {"`" => "◆", "a" => "▒", "f" => "°", "g" => "±", "j" => "┘", "k" => "┐",
+      "l" => "┌", "m" => "└", "n" => "┼", "o" => "⎺", "p" => "⎻", "q" => "─", "r" => "⎼", "s" => "⎽",
+      "t" => "├", "u" => "┤", "v" => "┴", "w" => "┬", "x" => "│", "y" => "≤", "z" => "≥", "{" => "π",
+      "|" => "≠", "}" => "£", "~" => "·"}.freeze
+
+    attr_reader :grid, :title, :cwd, :modes, :replies, :bell_count
+
+    def initialize(grid = Grid.new, &reply)
+      @grid = grid
+      @reply = reply
+      @replies = []
+      @input = +"".b
+      @state = :ground
+      @sequence = +"".b
+      @modes = {7 => true, 25 => true}
+      @charsets = [:ascii, :ascii]
+      @charset = 0
+      @bell_count = 0
+    end
+
+    # The parser retains incomplete UTF-8 and control sequences between reads.
+    def feed(bytes)
+      @input << bytes.b
+      if !@input.empty? && @state == :ground && @charsets[@charset] == :ascii && @input.ascii_only? &&
+          !@input.match?(/[\x00-\x1f\x7f]/)
+        grid.put_ascii(@input)
+        @last_printed = @input.getbyte(-1).chr
+        @input.clear
+        return self
+      end
+      index = 0
+      while index < @input.bytesize
+        byte = @input.getbyte(index)
+        if @state == :ground && @charsets[@charset] == :ascii && byte.between?(0x20, 0x7e)
+          finish = index + 1
+          finish += 1 while finish < @input.bytesize && @input.getbyte(finish).between?(0x20, 0x7e)
+          grid.put_ascii(@input.byteslice(index...finish))
+          @last_printed = @input.getbyte(finish - 1).chr
+          index = finish
+          next
+        end
+        if @state == :ground && byte >= 0xa0
+          length = if byte.between?(0xc2, 0xdf)
+            2
+          elsif byte.between?(0xe0, 0xef)
+            3
+          elsif byte.between?(0xf0, 0xf4)
+            4
+          else
+            1
+          end
+          break if index + length > @input.bytesize
+
+          char = @input.byteslice(index, length).force_encoding(Encoding::UTF_8)
+          unless char.valid_encoding?
+            char = "\ufffd"
+            length = 1
+          end
+          print(char)
+          index += length
+          next
+        end
+        consume(byte)
+        index += 1
+      end
+      @input = @input.byteslice(index..) || +"".b
+      self
+    end
+
+    def paste(text)
+      modes[2004] ? "\e[200~#{text.gsub("\e[201~", "")}\e[201~" : text
+    end
+
+    def mouse(button:, column:, row:, action: :press, shift: false, alt: false, control: false)
+      tracking = [1000, 1002, 1003].find { |mode| modes[mode] }
+      return "" unless tracking
+      return "" if action == :move && (tracking == 1000 || (tracking == 1002 && button.nil?))
+
+      code = case button
+      when :left, 0 then 0
+      when :middle, 1 then 1
+      when :right, 2 then 2
+      when :wheel_up then 64
+      when :wheel_down then 65
+      else 3
+      end
+      code |= 32 if action == :move
+      code |= 4 if shift
+      code |= 8 if alt
+      code |= 16 if control
+      column = [column + 1, 1].max
+      row = [row + 1, 1].max
+      if modes[1006]
+        "\e[<#{code};#{column};#{row}#{action == :release ? 'm' : 'M'}"
+      else
+        code = (code & ~3) | 3 if action == :release
+        return "" if column > 223 || row > 223
+
+        "\e[M".b + [code + 32, column + 32, row + 32].pack("C3")
+      end
+    end
+
+    def key(name, shift: false, alt: false, control: false)
+      name = name.to_s
+      modifier = 1 + (shift ? 1 : 0) + (alt ? 2 : 0) + (control ? 4 : 0)
+      arrows = {"up" => "A", "down" => "B", "right" => "C", "left" => "D", "home" => "H", "end" => "F"}
+      if arrows.key?(name)
+        return modifier > 1 ? "\e[1;#{modifier}#{arrows[name]}" : "\e#{modes[1] ? 'O' : '['}#{arrows[name]}"
+      end
+      function = {"insert" => 2, "delete" => 3, "page_up" => 5, "page_down" => 6,
+        "f5" => 15, "f6" => 17, "f7" => 18, "f8" => 19, "f9" => 20, "f10" => 21, "f11" => 23, "f12" => 24}
+      return "\e[#{function[name]}#{modifier > 1 ? ";#{modifier}" : ''}~" if function.key?(name)
+
+      if /\Af[1-4]\z/.match?(name)
+        final = ("P".ord + name[1].to_i - 1).chr
+        return modifier > 1 ? "\e[1;#{modifier}#{final}" : "\eO#{final}"
+      end
+      return "\e[Z" if name == "tab" && shift
+
+      text = {"enter" => "\r", "backspace" => "\x7f", "tab" => "\t", "escape" => "\e"}.fetch(name, name)
+      text = (text.upcase.ord & 0x1f).chr if control && text.length == 1 && ("@".."_").cover?(text.upcase)
+      text = "\0" if control && text == " "
+      alt ? "\e#{text}" : text
+    end
+
+    private
+
+    def consume(byte)
+      return consume_string(byte) if [:osc, :dcs, :string].include?(@state)
+
+      if byte == 0x1b
+        @state = :escape
+        @sequence.clear
+        return
+      elsif [0x18, 0x1a].include?(byte)
+        @state = :ground
+        return
+      elsif byte < 0x20 || byte == 0x7f
+        control(byte)
+        return
+      end
+      case @state
+      when :ground
+        case byte
+        when 0x9b then start_sequence(:csi)
+        when 0x9d then start_sequence(:osc)
+        when 0x90 then start_sequence(:dcs)
+        when 0x84 then grid.linefeed
+        when 0x85 then grid.carriage_return; grid.linefeed
+        when 0x8d then grid.reverse_index
+        else print(byte.chr) if byte < 0x80
+        end
+      when :escape
+        case byte.chr
+        when "[" then start_sequence(:csi)
+        when "]" then start_sequence(:osc)
+        when "P" then start_sequence(:dcs)
+        when "_", "^", "X" then start_sequence(:string)
+        when "(" then @charset_target = 0; @state = :charset
+        when ")" then @charset_target = 1; @state = :charset
+        when "#", "%" then @state = :escape_intermediate; @sequence << byte
+        else
+          escape(byte.chr)
+          @state = :ground
+        end
+      when :escape_intermediate
+        if @sequence == "#" && byte == "8".ord
+          grid.cells.each { |row| row.each { |cell| cell.text = "E"; cell.width = 1 } }
+        end
+        @state = :ground
+      when :charset
+        @charsets[@charset_target] = byte == "0".ord ? :graphics : :ascii
+        @state = :ground
+      when :csi
+        if byte.between?(0x40, 0x7e)
+          csi(byte.chr, @sequence)
+          @state = :ground
+        elsif @sequence.bytesize < 1024 && byte.between?(0x20, 0x3f)
+          @sequence << byte
+        else
+          @state = :csi_ignore
+        end
+      when :csi_ignore
+        @state = :ground if byte.between?(0x40, 0x7e)
+      end
+    end
+
+    def start_sequence(state)
+      @state = state
+      @sequence = +"".b
+      @string_escape = @string_overflow = false
+      @string_utf8_remaining = 0
+    end
+
+    def consume_string(byte)
+      if @string_utf8_remaining.positive? && byte.between?(0x80, 0xbf)
+        @string_utf8_remaining -= 1
+        append_string(byte)
+        return
+      end
+      @string_utf8_remaining = if byte.between?(0xc2, 0xdf)
+        1
+      elsif byte.between?(0xe0, 0xef)
+        2
+      elsif byte.between?(0xf0, 0xf4)
+        3
+      else
+        0
+      end
+      if byte == 0x9c || (@string_escape && byte == 0x5c) || (byte == 7 && @state == :osc)
+        unless @string_overflow
+          osc(@sequence) if @state == :osc
+          dcs(@sequence) if @state == :dcs
+        end
+        @state = :ground
+        @string_escape = false
+      elsif [0x18, 0x1a].include?(byte)
+        @state = :ground
+      elsif byte == 0x1b
+        @string_escape = true
+      else
+        @sequence << 0x1b if @string_escape && !@string_overflow
+        @string_escape = false
+        append_string(byte)
+      end
+    end
+
+    def append_string(byte)
+      @sequence.bytesize < 16_384 ? @sequence << byte : @string_overflow = true
+    end
+
+    def control(byte)
+      case byte
+      when 7 then @bell_count += 1
+      when 8 then grid.backspace
+      when 9 then grid.tab
+      when 10, 11, 12 then grid.linefeed; grid.carriage_return if modes[20]
+      when 13 then grid.carriage_return
+      when 14 then @charset = 1
+      when 15 then @charset = 0
+      end
+    end
+
+    def escape(char)
+      case char
+      when "7" then grid.save_cursor
+      when "8" then grid.restore_cursor
+      when "D" then grid.linefeed
+      when "E" then grid.carriage_return; grid.linefeed
+      when "M" then grid.reverse_index
+      when "H" then grid.tab_set
+      when "=" then @modes[:keypad] = true
+      when ">" then @modes[:keypad] = false
+      when "c"
+        grid.reset
+        @modes = {7 => true, 25 => true}
+        @charsets = [:ascii, :ascii]
+        @charset = 0
+      end
+    end
+
+    def print(char)
+      char = DEC_GRAPHICS.fetch(char, char) if @charsets[@charset] == :graphics
+      grid.put(char)
+      @last_printed = char
+    end
+
+    def csi(final, sequence)
+      prefix = sequence[/\A[?<=>]/]
+      parameters = sequence.sub(/\A[?<=>]/, "").sub(/[\x20-\x2f]+\z/, "")
+      values = parameters.split(";", -1).map { |value| value.empty? ? 0 : value.to_i.clamp(0, 1_000_000) }
+      values = [0] if values.empty?
+      amount = values.first.zero? ? 1 : values.first
+      case final
+      when "A" then grid.move(y: grid.cursor_y - amount)
+      when "B", "e" then grid.move(y: grid.cursor_y + amount)
+      when "C", "a" then grid.move(x: grid.cursor_x + amount)
+      when "D" then grid.move(x: grid.cursor_x - amount)
+      when "E" then grid.move(x: 0, y: grid.cursor_y + amount)
+      when "F" then grid.move(x: 0, y: grid.cursor_y - amount)
+      when "G", "`" then grid.move(x: amount - 1)
+      when "H", "f" then grid.position(amount, values[1].to_i.zero? ? 1 : values[1])
+      when "d" then grid.position(amount, grid.cursor_x + 1)
+      when "I" then grid.tab([amount, grid.columns].min)
+      when "Z" then grid.tab([amount, grid.columns].min, backward: true)
+      when "J" then grid.erase_display(values.first)
+      when "K" then grid.erase_line(values.first)
+      when "L" then grid.insert_lines(amount)
+      when "M" then grid.delete_lines(amount)
+      when "P" then grid.delete_characters(amount)
+      when "@" then grid.insert_characters(amount)
+      when "X" then grid.erase_characters(amount)
+      when "S" then grid.scroll_up(amount)
+      when "T" then grid.scroll_down(amount) unless values.length > 1
+      when "r" then grid.margins(amount, values[1].to_i.zero? ? grid.rows : values[1]) unless prefix
+      when "s" then grid.save_cursor
+      when "u" then grid.restore_cursor
+      when "g" then grid.tab_clear(all: values.first == 3)
+      when "m" then sgr(parameters) unless prefix
+      when "h", "l" then values.each { |mode| set_mode(mode, final == "h", prefix == "?") }
+      when "b"
+        [amount, grid.columns * grid.rows].min.times { grid.put(@last_printed) } if @last_printed
+      when "n"
+        emit("\e[0n") if values.first == 5
+        emit("\e[#{prefix == '?' ? '?' : ''}#{grid.cursor_y + 1};#{grid.cursor_x + 1}R") if values.first == 6
+      when "c"
+        emit(prefix == ">" ? "\e[>0;1;0c" : "\e[?1;2c")
+      when "t"
+        emit("\e[8;#{grid.rows};#{grid.columns}t") if values.first == 18
+        emit("\e]l#{title}\e\\") if values.first == 21
+      when "p"
+        if sequence.end_with?("!")
+          grid.attributes = {}.freeze
+          grid.foreground = grid.background = nil
+          grid.insert_mode = grid.origin_mode = false
+          grid.autowrap = grid.cursor_visible = true
+          grid.margins
+        elsif sequence.end_with?("$")
+          state = modes.key?(values.first) ? modes[values.first] ? 1 : 2 : 0
+          emit("\e[?#{values.first};#{state}$y")
+        end
+      end
+    end
+
+    def set_mode(mode, enabled, private_mode)
+      @modes[mode] = enabled
+      if private_mode
+        case mode
+        when 6 then grid.origin_mode = enabled; grid.position(1, 1)
+        when 7 then grid.autowrap = enabled
+        when 25 then grid.cursor_visible = enabled
+        when 47, 1047 then grid.alternate(enabled, save: false)
+        when 1048 then enabled ? grid.save_cursor : grid.restore_cursor
+        when 1049 then grid.alternate(enabled)
+        when 1000, 1002, 1003
+          [1000, 1002, 1003].each { |other| @modes[other] = false unless other == mode } if enabled
+        end
+      elsif mode == 4
+        grid.insert_mode = enabled
+      end
+    end
+
+    def sgr(parameters)
+      groups = parameters.empty? ? ["0"] : parameters.split(";", -1)
+      attributes = grid.attributes.dup
+      index = 0
+      while index < groups.length
+        parts = groups[index].split(":", -1)
+        value = parts.first.to_i
+        case value
+        when 0 then attributes.clear; grid.foreground = grid.background = nil
+        when 1 then attributes[:bold] = true
+        when 2 then attributes[:dim] = true
+        when 3 then attributes[:italic] = true
+        when 4 then attributes[:underline] = parts[1] ? parts[1].to_i : 1
+        when 5, 6 then attributes[:blink] = true
+        when 7 then attributes[:inverse] = true
+        when 8 then attributes[:hidden] = true
+        when 9 then attributes[:strikethrough] = true
+        when 21 then attributes[:underline] = 2
+        when 22 then attributes.delete(:bold); attributes.delete(:dim)
+        when 23 then attributes.delete(:italic)
+        when 24 then attributes.delete(:underline)
+        when 25 then attributes.delete(:blink)
+        when 27 then attributes.delete(:inverse)
+        when 28 then attributes.delete(:hidden)
+        when 29 then attributes.delete(:strikethrough)
+        when 30..37 then grid.foreground = value - 30
+        when 40..47 then grid.background = value - 40
+        when 90..97 then grid.foreground = value - 90 + 8
+        when 100..107 then grid.background = value - 100 + 8
+        when 39 then grid.foreground = nil
+        when 49 then grid.background = nil
+        when 38, 48, 58
+          color = color_parameter(parts, groups, index)
+          index += color[:consumed]
+          if color[:value]
+            case value
+            when 38 then grid.foreground = color[:value]
+            when 48 then grid.background = color[:value]
+            else attributes[:underline_color] = color[:value]
+            end
+          end
+        when 59 then attributes.delete(:underline_color)
+        end
+        index += 1
+      end
+      grid.attributes = attributes.freeze
+    end
+
+    def color_parameter(parts, groups, index)
+      consumed = 0
+      color = if parts.length > 1
+        kind = parts[1].to_i
+        kind == 5 ? parts[2]&.to_i : kind == 2 && parts.length >= 5 ? parts.last(3).map(&:to_i) : nil
+      else
+        kind = groups[index + 1]&.to_i
+        count = kind == 5 ? 1 : kind == 2 ? 3 : 0
+        if count.positive? && index + 1 + count < groups.length
+          consumed = count + 1
+          count == 1 ? groups[index + 2].to_i : groups[index + 2, count].map(&:to_i)
+        end
+      end
+      color = color.map { |part| part.clamp(0, 255) }.freeze if color.is_a?(Array)
+      color = color.clamp(0, 255) if color.is_a?(Integer)
+      {value: color, consumed: consumed}
+    end
+
+    def osc(sequence)
+      command, payload = sequence.force_encoding(Encoding::UTF_8).scrub.split(";", 2)
+      return unless payload
+
+      case command
+      when "0", "2" then @title = payload
+      when "7"
+        uri = URI.parse(payload)
+        @cwd = URI.decode_uri_component(uri.path) if uri.scheme == "file" && uri.path&.start_with?("/")
+      when "8"
+        _, url = payload.split(";", 2)
+        grid.hyperlink = url.nil? || url.empty? ? nil : url.freeze
+      end
+    rescue URI::InvalidURIError, ArgumentError
+      nil
+    end
+
+    def dcs(sequence)
+      return unless sequence.start_with?("$q")
+
+      request = sequence.delete_prefix("$q")
+      answer = {"m" => "0m", "r" => "#{grid.scroll_top + 1};#{grid.scroll_bottom + 1}r"}[request]
+      emit("\eP#{answer ? 1 : 0}$r#{answer || request}\e\\")
+    end
+
+    def emit(bytes)
+      @reply ? @reply.call(bytes) : @replies << bytes
+    end
+  end
+end