vanken 0.1.0

data/lib/vanken/gateway/file_reader.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require "redhound"
+require "stringio"
+require "io/wait"
+
+module Vanken
+  module Gateway
+    class FileReader
+      include Enumerable #[Core::Frame]
+      QUEUED_BYTE_LIMIT = 64 << 20 #: Integer
+      class BufferedInput
+        # @rbs (IO input) -> void
+        def initialize(input)
+          @input, @buffer, @stopped = input, StringIO.new("".b), false
+          @input.binmode
+        end
+
+        # @rbs (Integer length) -> String?
+        def read(length)
+          return "".b if length.zero?
+          until @stopped
+            part = @buffer.read(length)
+            return part if part && !part.empty?
+
+            part = @input.read_nonblock(65_536, exception: false)
+            case part
+            when String then @buffer.string = part
+            when :wait_readable then @input.wait_readable(0.05)
+            else return nil
+            end
+          end
+          nil
+        end
+
+        # @rbs () -> void
+        def stop = (@stopped = true)
+      end
+      private_constant :BufferedInput, :QUEUED_BYTE_LIMIT
+
+      # @rbs (String | IO | StringIO input) -> void
+      def initialize(input)
+        io = input == "-" ? $stdin : input
+        @buffered_input = nil #: BufferedInput?
+        @packets = nil #: Thread::SizedQueue[Redhound::Packet | StandardError]?
+        @pump = nil #: Thread?
+        @budget_mutex, @budget_available, @queued_bytes = Mutex.new, ConditionVariable.new, 0
+        @stopped = false
+        @buffered_input = BufferedInput.new(io) if io.is_a?(IO) && !io.stat.file?
+        @reader = Redhound.open(@buffered_input || input)
+        @number = 0
+        if @buffered_input
+          # One parsed packet waiting for the byte budget can retain at most another 16 MiB.
+          @packets = SizedQueue.new(256)
+          @pump = Thread.new { pump_packets }
+        end
+      rescue Redhound::Error, IOError, SystemCallError => error
+        raise Vanken::FileError, error.message
+      end
+      # @rbs (?timeout: Numeric?) -> Core::Frame?
+      def next_frame(timeout: nil)
+        return nil if @stopped
+        raise ArgumentError, "timeout must be nonnegative" if timeout && timeout.negative?
+
+        packet = @packets ? @packets.pop(timeout: timeout && Float(timeout)) : @reader.next_packet(timeout: timeout)
+        raise packet if packet.is_a?(StandardError)
+        return nil unless packet
+        if @packets
+          @budget_mutex.synchronize do
+            @queued_bytes -= packet.data.bytesize
+            @budget_available.signal
+          end
+        end
+        @number += 1
+        interface = packet.interface && %i[name index linktype snaplen flags mtu mac description filter].to_h { |key| [key.to_s, packet.interface.public_send(key)] }
+        # Omit absent optional values; keep the declared interface metadata for saving.
+        interface&.compact!
+        Core::Frame.new(bytes: packet.data, timestamp_ns: packet.timestamp_ns, original_length: packet.original_length,
+          linktype: packet.linktype, interface: interface, direction: packet.direction, number: @number)
+      rescue Redhound::Error, IOError, SystemCallError => error
+        raise Vanken::FileError, error.message
+      end
+      # @rbs () { (Core::Frame) -> void } -> void
+      # @rbs () -> Enumerator[Core::Frame, void]
+      def each
+        return enum_for(:each) unless block_given?
+        loop do
+          packet = next_frame(timeout: 0.1)
+          yield packet if packet
+          break if eof?
+        end
+      end
+      # @rbs () -> bool
+      def eof? = @stopped || (@packets ? @packets.closed? && @packets.empty? : @reader.stopped?)
+      # @rbs () -> void
+      def stop
+        @budget_mutex.synchronize do
+          @stopped = true
+          @budget_available.broadcast
+        end
+        @buffered_input&.stop
+        @packets&.close
+        @reader.stop
+        @pump&.join
+      end
+      # @rbs () -> void
+      def close
+        stop
+        @reader.close
+      end
+      # @rbs () -> Redhound::Capture::Stats
+      def stats = @reader.stats
+
+      private
+
+      # @rbs () -> void
+      def pump_packets
+        queue = @packets
+        return unless queue
+        until @stopped
+          packet = @reader.next_packet
+          break unless packet
+          break unless reserve_bytes(packet)
+
+          queue << packet
+        end
+      rescue ClosedQueueError
+        nil
+      rescue StandardError => error
+        begin
+          queue << error unless @stopped
+        rescue ClosedQueueError
+          nil
+        end
+      ensure
+        queue&.close
+      end
+
+      # @rbs (Redhound::Packet packet) -> bool
+      def reserve_bytes(packet)
+        size = packet.data.bytesize
+        @budget_mutex.synchronize do
+          @budget_available.wait(@budget_mutex) until @stopped || @queued_bytes + size <= QUEUED_BYTE_LIMIT
+          return false if @stopped
+
+          @queued_bytes += size
+        end
+        true
+      end
+    end
+  end
+end

data/lib/vanken/gateway/file_writer.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require "redhound"
+require_relative "../errors"
+
+module Vanken
+  module Gateway
+    class FileWriter
+      # @rbs (String | IO output, **untyped options) -> FileWriter
+      # @rbs [T] (String | IO output, **untyped options) { (FileWriter) -> T } -> T
+      def self.open(output, **options)
+        writer = new(output, **options)
+        return writer unless block_given?
+        begin
+          yield writer
+        ensure
+          writer.close
+        end
+      end
+      # @rbs (String | IO output, ?format: Symbol | String, **untyped options) -> void
+      def initialize(output, format: :pcapng, **options)
+        @format = format.to_sym
+        @interfaces = {} #: Hash[Hash[String, untyped], Redhound::Capture::Interface]
+        if output.is_a?(String)
+          @owned = File.open(output, "wb", 0o600)
+          @owned.chmod(0o600)
+        end
+        @writer = Redhound::Writer.open(@owned || output, format: @format, **options)
+      rescue Redhound::Error, IOError, SystemCallError => error
+        @owned&.close
+        raise Vanken::FileError, error.message
+      end
+      # @rbs (Core::Frame | Redhound::Packet frame) -> self
+      def <<(frame)
+        packet = defined?(Core::Frame) && frame.is_a?(Core::Frame) ? Dissector.packet(frame, interfaces: @interfaces) : frame
+        if @format == :pcap
+          @linktype ||= packet.linktype
+          raise Vanken::FileError, "pcap requires one link type; save as pcapng" unless packet.linktype == @linktype
+        end
+        @writer << packet
+        self
+      rescue Redhound::Error, ArgumentError, IOError, SystemCallError => error
+        raise Vanken::FileError, error.message
+      end
+      # @rbs () -> void
+      def flush = @writer.flush
+      # @rbs (Redhound::Capture::Stats | Hash[Symbol | String, Integer] stats, ?interface: Redhound::Capture::Interface?) -> void
+      def write_stats(stats, interface: nil)
+        if stats.is_a?(Hash)
+          values = stats.transform_keys(&:to_sym)
+          stats = Redhound::Capture::Stats.new(received: values.fetch(:received, 0), dropped: values.fetch(:dropped, 0), if_dropped: values.fetch(:if_dropped, 0))
+        end
+        @writer.write_stats(stats, interface: interface)
+      end
+      # @rbs () -> void
+      def close
+        @writer&.close
+      ensure
+        @owned&.close unless @owned&.closed?
+      end
+    end
+  end
+end

data/lib/vanken/gateway/interfaces.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "redhound"
+
+module Vanken
+  module Gateway
+    module Interfaces
+      class NotFound < StandardError; end
+
+      # @rbs () -> Array[Hash[Symbol, untyped]]
+      def self.list
+        result = Redhound::Capture.interfaces.map do |interface|
+          {name: interface.name, index: interface.index, linktype: interface.linktype,
+           snaplen: interface.snaplen, description: interface.description, mac: interface.mac,
+           mtu: interface.mtu, up: interface.up?, running: interface.running?, loopback: interface.loopback?}
+        end #: Array[Hash[Symbol, untyped]]
+        if RUBY_PLATFORM.include?("linux")
+          result << {name: "any", index: 0, linktype: 276, snaplen: 262_144,
+                     description: "All interfaces", mac: nil, mtu: nil, up: true, running: true, loopback: false}
+        end
+        result
+      end
+
+      # @rbs (String name) -> Hash[Symbol, untyped]
+      def self.find(name)
+        list.find { |interface| interface[:name] == name } || raise(NotFound, "interface #{name.inspect} not found")
+      end
+    end
+  end
+end

data/lib/vanken/gateway/live_capture.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "redhound"
+require_relative "interfaces"
+require_relative "capture_filter"
+
+module Vanken
+  module Gateway
+    class LiveCapture
+      class Error < StandardError
+        attr_reader :code #: String
+        attr_reader :exit_code #: Integer
+
+        # @rbs (String message, code: String, ?exit_code: Integer) -> void
+        def initialize(message, code:, exit_code: 1)
+          @code, @exit_code = code, exit_code
+          super(message)
+        end
+      end
+
+      attr_reader :backend #: Symbol
+
+      # @rbs (interface: String, ?backend: Symbol | String, ?snaplen: Integer, ?promiscuous: bool, ?buffer_size: Integer?, ?direction: Symbol, ?filter: String?) -> LiveCapture
+      def self.open(interface:, backend: :auto, snaplen: 262_144, promiscuous: true, buffer_size: nil, direction: :inout, filter: nil)
+        metadata = Interfaces.find(interface)
+        if filter && !filter.empty?
+          CaptureFilter.compile(filter, linktype: metadata[:linktype], snaplen: snaplen, live: RUBY_PLATFORM.include?("linux"))
+        end
+        new(Redhound::Capture.open(interface: interface, backend: backend, snaplen: snaplen, promiscuous: promiscuous,
+          buffer_size: buffer_size, direction: direction, filter: filter))
+      rescue Interfaces::NotFound, Redhound::InterfaceNotFound => e
+        raise Error.new(e.message, code: "interface_not_found")
+      rescue CaptureFilter::Error, Redhound::FilterError => e
+        raise Error.new(e.message, code: "invalid_filter", exit_code: 2)
+      rescue Redhound::PermissionDenied, Errno::EACCES, Errno::EPERM => e
+        raise Error.new(e.message, code: "permission_denied", exit_code: 3)
+      rescue Redhound::UnsupportedPlatform => e
+        raise Error.new(e.message, code: "unsupported_platform")
+      rescue Redhound::CaptureError, NotImplementedError, ArgumentError => e
+        raise Error.new(e.message, code: "backend_unavailable")
+      end
+
+      # @rbs (Redhound::Capture::Source source) -> void
+      def initialize(source)
+        @source = source
+        @backend = case source
+                   when Redhound::Capture::Linux::TPacketV3 then :ring
+                   when Redhound::Capture::Linux::PacketSocket then :socket
+                   when Redhound::Capture::Bsd::BpfDevice then :bpf
+                   else :unknown
+                   end
+      end
+
+      # @rbs (?timeout: Numeric?) -> Redhound::Packet?
+      def next_packet(timeout: 0.05) = @source.next_packet(timeout: timeout)
+      # @rbs () -> bool
+      def stopped? = @source.stopped?
+      # @rbs () -> Hash[Symbol, Integer]
+      def stats = @source.stats.to_h
+      # @rbs () -> Integer
+      def linktype = @source.linktype
+      # @rbs () -> Array[Hash[Symbol, untyped]]
+      def interfaces
+        @source.interfaces.map do |interface|
+          {name: interface.name, linktype: interface.linktype, snaplen: interface.snaplen,
+           description: interface.description, mac: interface.mac, mtu: interface.mtu}
+        end
+      end
+
+      # @rbs () -> void
+      def stop = @source.stop
+      # @rbs () -> void
+      def close = @source.close
+
+      # @rbs () -> String
+      def self.version = Redhound::VERSION
+    end
+  end
+end

data/lib/vanken/gateway/packet_snapshot.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Vanken
+  module Gateway
+    module FieldValues
+      ALIASES = {"ip.addr" => %w[ip.src ip.dst], "ipv6.addr" => %w[ipv6.src ipv6.dst],
+                 "eth.addr" => %w[eth.src eth.dst], "tcp.port" => %w[tcp.srcport tcp.dstport],
+                 "udp.port" => %w[udp.srcport udp.dstport]}.freeze
+      TCP_FLAGS = {"fin" => 1, "syn" => 2, "rst" => 4, "psh" => 8, "ack" => 16, "urg" => 32}.freeze
+
+      # @rbs (String name) { (String) -> Array[untyped] } -> Array[untyped]
+      def self.read(name)
+        if name.start_with?("tcp.flags.") && (bit = TCP_FLAGS[name.delete_prefix("tcp.flags.")])
+          return yield("tcp.flags").map { |flags| flags & bit != 0 }
+        end
+        ALIASES.fetch(name, [name]).flat_map { |field| yield field }.compact
+      end
+    end
+
+    # A field-only copy of stateful dissection, with an explicit binary JSON representation.
+    class PacketSnapshot
+      attr_reader :columns #: Core::column_values
+      attr_reader :annotations #: Core::annotation_values
+
+      # @rbs (fields: Hash[String, Array[untyped]], types: Hash[String, Symbol], layers: Array[String], columns: Core::column_values, annotations: Core::annotation_values) -> void
+      def initialize(fields:, types:, layers:, columns:, annotations:)
+        @fields, @types, @layers = fields, types, layers
+        @columns, @annotations = columns, annotations
+      end
+
+      # @rbs (PacketView packet) -> PacketSnapshot
+      def self.from_packet(packet)
+        groups = packet.fields.group_by(&:name)
+        new(fields: groups.transform_values { |fields| fields.map(&:value) },
+          types: groups.transform_values { |fields| fields.first.type }, layers: packet.columns[:layers],
+          columns: packet.columns, annotations: packet.annotations)
+      end
+
+      # @rbs (Hash[String, untyped] value) -> PacketSnapshot
+      def self.from_h(value)
+        new(fields: decode(value.fetch("fields")), types: value.fetch("types").transform_values(&:to_sym),
+          layers: value.fetch("layers"), columns: decode(value.fetch("columns")), annotations: decode(value.fetch("annotations")))
+      end
+
+      # @rbs () -> Hash[String, untyped]
+      def to_h
+        {"fields" => self.class.encode(@fields), "types" => @types.transform_values(&:to_s),
+         "layers" => @layers, "columns" => self.class.encode(@columns), "annotations" => self.class.encode(@annotations)}
+      end
+
+      # @rbs (String name) -> Array[untyped]
+      def values(name) = FieldValues.read(name) { |field| Array(@fields[field]) }
+      # @rbs (String name) -> Symbol?
+      def field_type(name) = @types[name]
+      # @rbs (String name) -> bool
+      def layer?(name) = @layers.include?(name)
+
+      # @rbs (untyped value) -> untyped
+      def self.encode(value)
+        case value
+        when String
+          value.encoding == Encoding::UTF_8 && value.valid_encoding? ? value :
+            {"$bytes" => value.unpack1("H*"), "$encoding" => value.encoding.name}
+        when Symbol then {"$symbol" => value.to_s}
+        when Array then value.map { |item| encode(item) }
+        when Hash then {"$hash" => value.map { |key, item| [encode(key), encode(item)] }}
+        when Integer, Float, TrueClass, FalseClass, NilClass then value
+        else raise TypeError, "unsupported snapshot value: #{value.class}"
+        end
+      end
+
+      # @rbs (untyped value) -> untyped
+      def self.decode(value)
+        case value
+        when Array then value.map { |item| decode(item) }
+        when Hash
+          if value.key?("$bytes")
+            [value.fetch("$bytes")].pack("H*").force_encoding(value.fetch("$encoding"))
+          elsif value.key?("$symbol")
+            value.fetch("$symbol").to_sym
+          else
+            value.fetch("$hash").to_h { |key, item| [decode(key), decode(item)] }
+          end
+        else value
+        end
+      end
+    end
+  end
+end

data/lib/vanken/ui/actions.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Vanken
+  module UI
+    module Actions
+      def self.install(ui)
+        commands = {
+          open: ["開く", "cmd-o", -> { ui.open_dialog }], save: ["名前を付けて保存", "cmd-shift-s", -> { ui.save_dialog }],
+          close_file: ["ファイルを閉じる", "cmd-w", -> { ui.close_document }], reload: ["再読み込み", "cmd-r", -> { ui.reload_file }],
+          quit: ["終了", "cmd-q", -> { ui.quit }], preferences: ["設定", "cmd-,", -> { ui.preferences_dialog }],
+          capture: ["キャプチャ開始／停止", "cmd-e", -> { ui.capture_toggle }], restart: ["キャプチャ再開", nil, -> { ui.restart_capture }],
+          apply_filter: ["フィルタを適用", "enter", -> { ui.apply_filter }], clear_filter: ["フィルタをクリア", nil, -> { ui.clear_filter }],
+          filter_history: ["フィルタ履歴", nil, -> { ui.filter_history }], bookmark: ["フィルタを保存", nil, -> { ui.bookmark_filter }],
+          filter_selected: ["選択した項目でフィルタ", nil, -> { ui.filter_from_selection }],
+          prepare_selected: ["選択した項目のフィルタを準備", nil, -> { ui.filter_from_selection(prepare: true) }],
+          columns: ["表示する列", nil, -> { ui.columns_dialog }], autoscroll: ["末尾追従", nil, -> { ui.toggle_autoscroll }],
+          zoom_in: ["拡大", "cmd-+", -> { ui.zoom(1) }], zoom_out: ["縮小", "cmd--", -> { ui.zoom(-1) }], zoom_reset: ["標準サイズ", "cmd-0", -> { ui.zoom }],
+          previous_packet: ["前のパケット", "alt-up", -> { ui.navigate(-1) }], next_packet: ["次のパケット", "alt-down", -> { ui.navigate(1) }],
+          first_packet: ["最初のパケット", nil, -> { ui.first_packet }], last_packet: ["最後のパケット", nil, -> { ui.last_packet }],
+          go_to_packet: ["パケットへ移動", "cmd-g", -> { ui.go_to_packet }], copy_filter: ["項目をフィルタとしてコピー", nil, -> { ui.copy_text(ui.selected_node.filter) if ui.selected_node&.filter }]
+        }
+        %i[selected not and and_not or or_not].zip(["選択項目", "選択項目を除外", "AND", "AND NOT", "OR", "OR NOT"]).each do |mode, label|
+          commands[:"filter_#{mode}"] = ["適用: #{label}", nil, -> { ui.filter_from_selection(mode) }]
+          commands[:"prepare_#{mode}"] = ["準備: #{label}", nil, -> { ui.filter_from_selection(mode, prepare: true) }]
+        end
+        {hex: "16 進数", text: "テキスト", dump: "ダンプ", escaped: "エスケープした文字列"}.each do |format, label|
+          commands[:"copy_#{format}"] = ["バイトをコピー: #{label}", nil, -> { ui.copy_bytes(format) }]
+        end
+        commands.each do |name, (title, keys, operation)|
+          ui.app.actions.register(name, title: title) { |_| operation.call }
+          next unless keys
+          key = RUBY_PLATFORM.include?("darwin") ? keys : keys.sub("cmd", "ctrl")
+          ui.window.dispatcher.keymap.bind(key, name, context: name == :apply_filter ? "in_display_filter && !in_completion" : "")
+        end
+        ui.app.menu_bar = Zaniah::Menu.build do
+          submenu("ファイル") { %i[open save close_file reload quit].each { |action| item(action) } }
+          submenu("編集") { %i[copy_filter copy_hex copy_text copy_dump copy_escaped preferences].each { |action| item(action) } }
+          submenu("表示") { %i[columns autoscroll zoom_in zoom_out zoom_reset].each { |action| item(action) } }
+          submenu("移動") { %i[previous_packet next_packet first_packet last_packet go_to_packet].each { |action| item(action) } }
+          submenu("キャプチャ") { %i[capture restart].each { |action| item(action) } }
+          submenu("フィルタ") do
+            %i[apply_filter clear_filter filter_history bookmark].each { |action| item(action) }
+            submenu("選択項目を適用") { %i[selected not and and_not or or_not].each { |mode| item(:"filter_#{mode}") } }
+            submenu("選択項目から準備") { %i[selected not and and_not or or_not].each { |mode| item(:"prepare_#{mode}") } }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vanken/ui/application.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+require "vanken"
+require "zaniah/ui"
+require "zaniah/process_pool"
+require "uri"
+require_relative "main_view"
+require_relative "file_operations"
+require_relative "filter_operations"
+require_relative "selection"
+require_relative "dialogs"
+require_relative "actions"
+require_relative "packet_source"
+require_relative "../gateway/interfaces"
+require_relative "../gateway/capture_filter"
+require_relative "../app/capture_controller"
+require_relative "../config/log"
+
+module Vanken
+  module UI
+    class Application
+      include FileOperations, FilterOperations, Selection, Dialogs
+      attr_reader :app, :window, :preferences, :table, :tree, :hex, :filter_field, :capture,
+                  :dialog_kind, :packet_source, :interface_infos
+
+      def initialize(backend: nil, preferences: Config::Preferences.new, debug: false)
+        @preferences = preferences
+        @log = Config::Log.open(debug: debug, directory: File.join(preferences.directory, "logs"))
+        @app = Zaniah::App.new
+        @entity = @app.new_entity { {document: nil, number: nil, node: nil, details: [], bytes: "".b, error: nil} }
+        @selection_generation, @file_generation, @filter_generation = 0, 0, 0
+        @pool_mutex = Mutex.new
+        @autoscroll = false
+        @backend = backend || (RUBY_PLATFORM.match?(/darwin/) ? :mac : RUBY_PLATFORM.match?(/mingw|mswin/) ? :windows : :linux)
+        @filter_field = Zaniah::UI::TextField.new("", placeholder: "表示フィルタ", clearable: false).test_id("vk.filter.input")
+        @filter_field.completion(CompletionProvider.new(self)).on_change { |text, _| validate_filter(text) }
+        @packet_source = PacketSource.new(self)
+        @capture = App::CaptureController.new(preferences: preferences,
+          on_document: ->(document) { @app.executor.post { attach_document(document) unless @closing } },
+          on_update: ->(*) { @app.executor.post { changed unless @closing } })
+        @window = @app.open_window(backend: @backend, width: preferences.get("layout.width"), height: preferences.get("layout.height"), title: "Vanken")
+        unless @backend == :tui
+          @window.text_system = Zaniah::TextSystem::Renderer.new
+          @window.text_system.scale_factor = @window.scale_factor
+        end
+        @window.on_close do
+          if !@closing && (@capture.running? || document&.dirty?)
+            request_destructive { @closing = true; @window.close }
+            false
+          else
+            true
+          end
+        end
+        @window.on_state_change do |state|
+          @preferences.set("layout.width", state.frame.width.to_i.clamp(320, 65_536))
+          @preferences.set("layout.height", state.frame.height.to_i.clamp(240, 65_536))
+        end
+        Actions.install(self)
+        change_theme(preferences.get("appearance.theme"), persist: false)
+        @main_view = MainView.new(self).test_id("vk.main")
+        @window.draw { @main_view }
+        show_error(Vanken::ConfigError.new(preferences.warning)) if preferences.warning
+        @app.executor.background do
+          infos = Gateway::Interfaces.list
+          @app.executor.post do
+            next if @closing
+            @interface_infos = infos
+            changed
+            capture_options if @dialog_kind == :capture_options
+          end
+        rescue StandardError => error
+          @app.executor.post { @interface_error = error.message; changed }
+        end
+      end
+
+      def document = @app.read(@entity)[:document]
+      def selected_number = @app.read(@entity)[:number]
+      def selected_node = @app.read(@entity)[:node]
+      def detail_nodes = @app.read(@entity)[:details]
+      def selected_bytes = @app.read(@entity)[:bytes]
+      def update
+        @app.update(@entity) { |state, cx| yield(state); cx.notify }
+      end
+      def changed
+        return if @closing
+        @packet_source.refresh do
+          next if @closing
+          error = document&.error || @capture.error
+          @app.update(@entity) { |state, cx| state[:error] = error; cx.notify }
+          show_error(error) if error && @last_error != error
+          if document && @pending_filter && document.complete?
+            @pending_filter = false
+            apply_filter
+          end
+        end
+      end
+      def attach_document(value)
+        return if @closing
+        value.scanner = ->(payload) { filter_pool.submit(payload) } if value
+        @selection_generation += 1
+        update { |state| state.merge!(document: value, number: nil, node: nil, details: [], bytes: "".b) }
+        @packet_source.reset
+        @tree&.replace([])
+        @hex.bytes = "".b if @hex
+        @table&.selection&.clear
+        @autoscroll = !!(value && (value.source == :live || value.equal?(@capture.document)) && @preferences.get("packet_list.autoscroll"))
+        @table.follow_tail = @autoscroll if @table
+        @table.scroll_to(0) if @table && value&.displayed_count&.positive? && !@autoscroll
+        @window.title = "Vanken#{value&.path ? " — #{File.basename(value.path)}" : ""}" if @window.respond_to?(:title=)
+      end
+      def run = @app.run
+      def native? = !%i[headless tui].include?(@backend)
+      def monospace_font = @window.text_system&.font
+      def install_panes(table, tree, hex) = (@table, @tree, @hex = table, tree, hex)
+      def filter_pool
+        @pool_mutex.synchronize do
+          @pool ||= Zaniah::ProcessPool.new(workers: @preferences.get("analysis.workers"),
+            handler: "Vanken::Capture::FilterWorker", requires: [File.expand_path("../capture/filter_worker.rb", __dir__)],
+            load_paths: $LOAD_PATH.select { |path| File.directory?(path) })
+        end
+      end
+      def smoke
+        3.times { @app.executor.drain; @window.tick }
+      end
+      def close
+        return if @closed
+        @closing = true
+        @packet_source.reset
+        @selection_generation += 1
+        @filter_generation += 1
+        @file_generation += 1
+        @validation_task&.cancel
+        @capture.close
+        document&.close
+        @pool&.shutdown
+        @app.executor.shutdown
+        @app.executor.drain
+        @window.close
+        @log.close
+        @closed = true
+      end
+      def quit = request_destructive { @closing = true; @window.close }
+
+      def change_theme(name, persist: true)
+        theme = name == "system" ? Zaniah::Theme.for(@window.appearance) : Zaniah::Theme.public_send(name)
+        size = @preferences.get("appearance.font_size")
+        theme = theme.with(typography: theme.typography.with(size_md: size, size_sm: size - 1, size_xs: size - 2))
+        @app.global(:theme, theme)
+        @preferences.set("appearance.theme", name) if persist
+        @window.request_frame
+      end
+      def zoom(delta = nil)
+        size = delta ? (@preferences.get("appearance.font_size") + delta).clamp(8, 32) : 13
+        @preferences.set("appearance.font_size", size)
+        change_theme(@preferences.get("appearance.theme"), persist: false)
+      end
+      def time_format(name)
+        @preferences.set("packet_list.time_format", name.to_s)
+        @packet_source.reset
+        @window.request_frame
+      end
+      def toggle_autoscroll
+        @autoscroll = !@autoscroll
+        @preferences.set("packet_list.autoscroll", @autoscroll)
+        @table.follow_tail = @autoscroll if @table
+        @table.scroll_to(@packet_source.count - 1, align: :end) if @autoscroll && @packet_source.count.positive?
+        @window.request_frame
+      end
+      def autoscroll? = @autoscroll && (!@table || @table.following_tail?)
+      def capture_toggle
+        return @capture.stop if @capture.running?
+        capture_options
+      end
+      def start_capture(options)
+        request_destructive do
+          dismiss_dialog
+          old = document
+          @app.executor.background { old&.close; @capture.start(options) unless @closing }
+        end
+      end
+      def restart_capture
+        request_destructive do
+          old = document
+          @capture.stop
+          @app.executor.background { @capture.wait; old&.close; @capture.start(@capture.options) unless @closing }
+        end
+      end
+      def status_text
+        doc = document
+        return "キャプチャファイルを開くか、インタフェースを選んで開始してください" unless doc
+        dropped = @capture.stats.fetch("dropped", @capture.stats.fetch(:dropped, 0))
+        total = doc.store.durable_count
+        "#{doc.loading? ? '読み込み中' : 'パケット'} #{@packet_source.packet_count} / #{total}   表示 #{@packet_source.count}   ドロップ #{dropped}#{doc.progress ? "   #{(doc.progress * 100).round}%" : ''}"
+      end
+      def copy_text(text) = @window.write_clipboard([Zaniah::Clipboard::Item.new({"text/plain" => text})])
+      def show_error(error)
+        @log.error("#{error.class}: #{error.message}")
+        @last_error = error
+        @dialog_kind = :error
+        @dialog = Zaniah::UI::Dialog.new(Zaniah::UI::Label.new(error.message, wrap: :word), title: "操作を完了できません").test_id("vk.error")
+        @window.request_frame
+      end
+    end
+  end
+end