vanken 0.1.0 → 0.2.0

data/lib/vanken/gateway/resolver.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require "ipaddr"
+require "resolv"
+require "timeout"
+
+module Vanken
+  module Gateway
+    # Reverse DNS never runs on the requesting thread. Callbacks run on the
+    # worker; UI callers must post their publication to the UI executor.
+    class Resolver
+      NEGATIVE_TTL = 30.0
+
+      # @rbs @timeout: Float
+      # @rbs @limit: Integer
+      # @rbs @resolver: untyped
+      # @rbs @queue: SizedQueue[String?]
+      # @rbs @cache: Hash[String, [String?, Float?]]
+      # @rbs @pending: Hash[String, Array[^(String) -> void]]
+      # @rbs @mutex: Mutex
+      # @rbs @closed: bool
+      # @rbs @worker: Thread
+
+      # @rbs (?timeout: Integer | Float, ?limit: Integer, ?resolver: untyped) -> void
+      def initialize(timeout: 1.0, limit: 256, resolver: nil)
+        unless timeout.is_a?(Numeric) && timeout.to_f.finite? && timeout.positive?
+          raise ArgumentError, "timeout must be finite and positive"
+        end
+        raise ArgumentError, "limit must be a positive integer" unless limit.is_a?(Integer) && limit.positive?
+        @timeout, @limit = timeout.to_f, limit
+        @resolver = resolver || Resolv::DNS.new
+        @resolver.timeouts = [@timeout] if @resolver.respond_to?(:timeouts=)
+        @queue = SizedQueue.new(@limit) #: SizedQueue[String?]
+        @cache = {} #: Hash[String, [String?, Float?]]
+        @pending = {} #: Hash[String, Array[^(String) -> void]]
+        @mutex = Mutex.new
+        @closed = false
+        @worker = Thread.new { work }
+        @worker.report_on_exception = false
+      end
+
+      # @rbs (String address) ?{ (String) -> void } -> String
+      def request(address, &callback)
+        key = numeric_address(address)
+        return address unless key
+        @mutex.synchronize do
+          return address if @closed
+          entry = @cache.delete(key)
+          if entry && (!entry[1] || entry[1] > now)
+            @cache[key] = entry
+            return entry[0] || address
+          end
+          if (waiting = @pending[key])
+            waiting << callback if callback
+          else
+            begin
+              @queue.push(key, true)
+              @pending[key] = callback ? [callback] : []
+            rescue ThreadError
+              # A future viewport request may retry after capacity is available.
+            end
+          end
+          address
+        end
+      end
+
+      # @rbs () -> void
+      def close
+        @mutex.synchronize do
+          return if @closed
+          @closed = true
+          @pending.clear
+          @queue.clear
+          @queue << nil
+        end
+        @worker.join(@timeout + 0.1) unless Thread.current == @worker
+        nil
+      end
+
+      private
+
+      # @rbs (String address) -> String?
+      def numeric_address(address)
+        return nil if address.include?("/")
+        IPAddr.new(address).to_s
+      rescue IPAddr::Error
+        nil
+      end
+
+      # @rbs () -> Float
+      def now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+      # @rbs (String address) -> String?
+      def lookup(address)
+        name = Timeout.timeout(@timeout) { @resolver.getname(address) }
+        name.to_s.dup.freeze unless name.nil? || name.to_s.empty?
+      rescue StandardError
+        nil
+      end
+
+      # @rbs () -> void
+      def work
+        while (address = @queue.pop)
+          name = lookup(address)
+          callbacks = @mutex.synchronize do
+            return if @closed
+            @cache[address] = [name, name ? nil : now + NEGATIVE_TTL]
+            @cache.shift while @cache.size > @limit
+            @pending.delete(address) || []
+          end
+          next unless name
+          callbacks.each do |callback|
+            break if @mutex.synchronize { @closed }
+            begin
+              callback.call(name)
+            rescue StandardError
+              # One consumer must not prevent other consumers or DNS requests.
+            end
+          end
+        end
+      ensure
+        begin
+          @resolver.close if @resolver.respond_to?(:close)
+        rescue StandardError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/vanken/gateway/statistics.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require_relative "dissector"
+
+module Vanken
+  module Gateway
+    HierarchyRow = Data.define(
+      :path, #: Array[Symbol]
+      :packets, #: Integer
+      :bytes #: Integer
+    )
+    ConversationRow = Data.define(
+      :addr_a, #: String
+      :port_a, #: Integer
+      :addr_b, #: String
+      :port_b, #: Integer
+      :packets_ab, #: Integer
+      :packets_ba, #: Integer
+      :bytes_ab, #: Integer
+      :bytes_ba, #: Integer
+      :start_ns, #: Integer
+      :end_ns, #: Integer
+      :duration_ns #: Integer
+    )
+    EndpointRow = Data.define(
+      :address, #: String
+      :port, #: Integer
+      :packets_tx, #: Integer
+      :packets_rx, #: Integer
+      :bytes_tx, #: Integer
+      :bytes_rx #: Integer
+    )
+    StatisticsTable = Data.define(
+      :kind, #: Symbol
+      :type, #: Symbol?
+      :rows, #: Array[HierarchyRow | ConversationRow | EndpointRow]
+      :evicted #: Integer
+    )
+
+    # The upstream session and its private table schema stay inside the Gateway.
+    class Statistics
+      # @rbs (?specs: Array[String], ?registry: Redhound::Registry, **untyped options) -> void
+      def initialize(specs: ["phs"], registry: Redhound::Registry.default, **options)
+        @session = Redhound::Analysis::Session.new(stats: specs, registry: registry, **options)
+      end
+
+      # @rbs (PacketView packet) -> void
+      def update(packet) = @session.update(packet.raw_packet)
+
+      # @rbs () -> Array[StatisticsTable]
+      def tables
+        @session.statistics.map do |table|
+          value = table.to_h
+          rows = value[:rows].map do |row|
+            fields = row.dup #: Hash[Symbol, untyped]
+            fields[:path] = fields[:path].dup.freeze if fields[:path]
+            fields.each_value { |item| item.freeze if item.is_a?(String) }
+            case value[:kind]
+            when :phs
+              HierarchyRow.new(path: fields.fetch(:path), packets: fields.fetch(:packets), bytes: fields.fetch(:bytes))
+            when :conv
+              ConversationRow.new(addr_a: fields.fetch(:addr_a), port_a: fields.fetch(:port_a),
+                addr_b: fields.fetch(:addr_b), port_b: fields.fetch(:port_b),
+                packets_ab: fields.fetch(:packets_ab), packets_ba: fields.fetch(:packets_ba),
+                bytes_ab: fields.fetch(:bytes_ab), bytes_ba: fields.fetch(:bytes_ba),
+                start_ns: fields.fetch(:start_ns), end_ns: fields.fetch(:end_ns), duration_ns: fields.fetch(:duration_ns))
+            when :endpoints
+              EndpointRow.new(address: fields.fetch(:address), port: fields.fetch(:port),
+                packets_tx: fields.fetch(:packets_tx), packets_rx: fields.fetch(:packets_rx),
+                bytes_tx: fields.fetch(:bytes_tx), bytes_rx: fields.fetch(:bytes_rx))
+            else raise Vanken::Error, "invalid upstream statistics table"
+            end
+          end
+          StatisticsTable.new(kind: value[:kind], type: value[:type], rows: rows.freeze, evicted: table.evicted)
+        end.freeze
+      end
+
+      # @rbs () -> void
+      def close = @session.finish(StringIO.new, StringIO.new)
+    end
+  end
+end

data/lib/vanken/gateway/stream.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require "tempfile"
+require_relative "dissector"
+
+module Vanken
+  module Gateway
+    StreamChunk = Data.define(
+      :direction, #: Integer
+      :bytes, #: String
+      :missing, #: Integer
+      :number, #: Integer
+      :sequence #: Integer
+    )
+    StreamText = Data.define(
+      :direction, #: Integer
+      :text #: String
+    )
+
+    class Stream
+      DISPLAY_LIMIT = 16 << 20 #: Integer
+      SEQUENCE_MOD = 1 << 32 #: Integer
+      attr_reader :nodes #: Array[String]
+      attr_reader :chunks #: Array[StreamChunk]
+      attr_reader :stream_id #: Integer
+
+      # @rbs (untyped document, Integer stream_id, ?cancelled: (^() -> bool)?) -> void
+      def initialize(document, stream_id, cancelled: nil)
+        raise ArgumentError, "invalid stream number" unless stream_id.is_a?(Integer) && stream_id >= 0
+        @stream_id, @nodes, @chunks = stream_id, [], []
+        pieces = [[], []] #: Array[Array[StreamChunk]]
+        starts = [nil, nil] #: Array[Integer?]
+        frontiers = [0, 0]
+        frames = document.stream_frames(stream_id)
+        frames.each do |number|
+          raise Vanken::Error, "operation cancelled" if cancelled&.call || document.closing?
+          packet = document.packet(number)
+          tcp = packet.layers.find { |layer| layer.protocol == :tcp && !layer.embedded }
+          next unless tcp
+          columns = packet.columns
+          endpoints = [endpoint(columns[:source], columns[:src_port]), endpoint(columns[:destination], columns[:dst_port])]
+          @nodes = tcp[:flags] & 0x12 == 0x12 ? endpoints.reverse : endpoints if @nodes.empty?
+          direction = endpoints == @nodes ? 0 : 1
+          sequence = document.annotations[number][:seq_rel]
+          difference = (sequence - frontiers[direction]) % SEQUENCE_MOD
+          difference -= SEQUENCE_MOD if difference >= SEQUENCE_MOD / 2
+          sequence = frontiers[direction] + difference
+          sequence += 1 if tcp[:flags] & 2 != 0
+          starts[direction] ||= sequence if tcp[:flags] & 2 != 0
+          data = packet.bytes.byteslice(tcp.payload_offset, tcp.payload_end - tcp.payload_offset)
+          frontiers[direction] = [frontiers[direction], sequence + data.bytesize].max
+          next if data.empty?
+          insert(pieces[direction], StreamChunk.new(direction: direction, bytes: data, missing: 0, number: number, sequence: sequence))
+        end
+        directions = pieces.each_with_index.map do |segments, direction|
+          cursor = starts[direction]
+          segments.flat_map do |segment|
+            missing = cursor && segment.sequence > cursor ? segment.sequence - cursor : 0
+            cursor = segment.sequence + segment.bytes.bytesize
+            gap = StreamChunk.new(direction: direction, bytes: "".b, missing: missing, number: segment.number, sequence: segment.sequence - missing)
+            missing.positive? ? [gap, segment] : [segment]
+          end
+        end
+        positions = [0, 0]
+        until positions.each_with_index.all? { |index, direction| index == directions[direction].size }
+          direction = [0, 1].reject { |value| positions[value] == directions[value].size }.min_by do |value|
+            directions[value][positions[value]].number
+          end
+          raise Vanken::Error, "invalid stream direction" unless direction
+          @chunks << directions[direction][positions[direction]]
+          positions[direction] += 1
+        end
+        @nodes.freeze
+        @chunks.freeze
+      end
+
+      # @rbs (?direction: Integer?) -> Integer
+      def byte_size(direction: nil) = selected(direction).sum { |chunk| chunk.bytes.bytesize }
+
+      # @rbs (?format: Symbol, ?direction: Integer?, ?limit: Integer) -> Array[StreamText]
+      def preview(format: :ascii, direction: nil, limit: DISPLAY_LIMIT)
+        validate(format, direction)
+        raise ArgumentError, "invalid display limit" unless limit.is_a?(Integer) && limit >= 0
+        remaining = limit
+        result = [] #: Array[StreamText]
+        selected(direction).each do |chunk|
+          break if remaining.zero?
+          bytes = chunk.bytes.byteslice(0, remaining) || "".b
+          remaining -= bytes.bytesize
+          result << StreamText.new(direction: chunk.direction, text: render(chunk, bytes, format))
+        end
+        result
+      end
+
+      # @rbs (String path, ?format: Symbol, ?direction: Integer?, ?cancelled: (^() -> bool)?) -> String
+      def save(path, format: :raw, direction: nil, cancelled: nil)
+        validate(format, direction)
+        file = Tempfile.create([".vanken-stream-", ".tmp"], File.dirname(File.expand_path(path)))
+        begin
+          file.binmode
+          selected(direction).each do |chunk|
+            raise Vanken::Error, "operation cancelled" if cancelled&.call
+            file.write(render(chunk, chunk.bytes, format))
+          end
+          file.flush
+          file.fsync
+          file.close
+          File.rename(file.path, File.expand_path(path))
+        ensure
+          file.close unless file.closed?
+          FileUtils.rm_f(file.path)
+        end
+        path
+      end
+
+      private
+
+      # @rbs (Integer? direction) -> Array[StreamChunk]
+      def selected(direction) = @chunks.select { |chunk| direction.nil? || chunk.direction == direction }
+      def endpoint(address, port) = address.include?(":") ? "[#{address}]:#{port}" : "#{address}:#{port}"
+      def validate(format, direction)
+        raise ArgumentError, "invalid stream format" unless %i[ascii hex raw].include?(format)
+        raise ArgumentError, "invalid stream direction" unless [nil, 0, 1].include?(direction)
+      end
+
+      def render(chunk, bytes, format)
+        return "".b if format == :raw && chunk.missing.positive?
+        return "[#{chunk.missing} bytes missing]" if chunk.missing.positive?
+        return bytes if format == :raw
+        return bytes.gsub(/[^\x20-\x7e\r\n\t]/n) { |byte| Kernel.format("\\x%02x", byte.getbyte(0)) } if format == :ascii
+        bytes.bytes.each_slice(16).with_index.map do |row, index|
+          Kernel.format("%08x  %s\n", chunk.sequence + (index * 16), row.map { |byte| Kernel.format("%02x", byte) }.join(" "))
+        end.join
+      end
+
+      # Keep capture arrival precedence while inserting only previously unseen ranges.
+      def insert(segments, chunk)
+        first, last = chunk.sequence, chunk.sequence + chunk.bytes.bytesize
+        index = segments.bsearch_index { |segment| segment.sequence + segment.bytes.bytesize > first } || segments.size
+        uncovered = [] #: Array[[Integer, Integer]]
+        cursor = first
+        while index < segments.size && segments[index].sequence < last
+          previous = segments[index]
+          uncovered << [cursor, [previous.sequence, last].min] if previous.sequence > cursor
+          cursor = [cursor, previous.sequence + previous.bytes.bytesize].max
+          index += 1
+        end
+        uncovered << [cursor, last] if cursor < last
+        uncovered.each do |start, finish|
+          segment = chunk.with(sequence: start, bytes: chunk.bytes.byteslice(start - first, finish - start))
+          position = segments.bsearch_index { |previous| previous.sequence > start } || segments.size
+          # ponytail: array insertion is O(n) for heavily reordered streams; use an interval tree if measured.
+          segments.insert(position, segment)
+        end
+      end
+    end
+  end
+end

data/lib/vanken/ui/actions.rb

@@ -5,44 +5,70 @@ module Vanken
     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 }]
+          open: [ui.t("開く"), "cmd-o", -> { ui.open_dialog }], save: [ui.t("名前を付けて保存"), "cmd-shift-s", -> { ui.save_dialog }],
+          close_file: [ui.t("ファイルを閉じる"), "cmd-w", -> { ui.close_document }], reload: [ui.t("再読み込み"), "cmd-r", -> { ui.reload_file }],
+          quit: [ui.t("終了"), "cmd-q", -> { ui.quit }], preferences: [ui.t("設定"), "cmd-,", -> { ui.preferences_dialog }],
+          capture: [ui.t("キャプチャ開始／停止"), "cmd-e", -> { ui.capture_toggle }], restart: [ui.t("キャプチャ再開"), nil, -> { ui.restart_capture }],
+          apply_filter: [ui.t("フィルタを適用"), "enter", -> { ui.apply_filter }], clear_filter: [ui.t("フィルタをクリア"), nil, -> { ui.clear_filter }],
+          filter_history: [ui.t("フィルタ履歴"), nil, -> { ui.filter_history }], bookmark: [ui.t("フィルタを保存"), nil, -> { ui.bookmark_filter }],
+          filter_selected: [ui.t("選択した項目でフィルタ"), nil, -> { ui.filter_from_selection }],
+          prepare_selected: [ui.t("選択した項目のフィルタを準備"), nil, -> { ui.filter_from_selection(prepare: true) }],
+          columns: [ui.t("表示する列"), nil, -> { ui.columns_dialog }], autoscroll: [ui.t("末尾追従"), nil, -> { ui.toggle_autoscroll }],
+          zoom_in: [ui.t("拡大"), "cmd-+", -> { ui.zoom(1) }], zoom_out: [ui.t("縮小"), "cmd--", -> { ui.zoom(-1) }], zoom_reset: [ui.t("標準サイズ"), "cmd-0", -> { ui.zoom }],
+          previous_packet: [ui.t("前のパケット"), "alt-up", -> { ui.navigate(-1) }], next_packet: [ui.t("次のパケット"), "alt-down", -> { ui.navigate(1) }],
+          first_packet: [ui.t("最初のパケット"), nil, -> { ui.first_packet }], last_packet: [ui.t("最後のパケット"), nil, -> { ui.last_packet }],
+          go_to_packet: [ui.t("パケットへ移動"), "cmd-g", -> { ui.go_to_packet }], copy_filter: [ui.t("項目をフィルタとしてコピー"), 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) }]
+        commands.merge!(
+          find_packet: [ui.t("パケット検索"), "cmd-f", -> { ui.find_packet }], find_next: [ui.t("次を検索"), "cmd-n", -> { ui.find_next }], find_prev: [ui.t("前を検索"), "cmd-b", -> { ui.find_prev }],
+          mark_packet: [ui.t("マーク／解除"), "cmd-m", -> { ui.mark_packet }], mark_all_displayed: [ui.t("表示中をすべてマーク"), "cmd-shift-m", -> { ui.mark_all_displayed }], unmark_all: [ui.t("すべてのマークを解除"), "cmd-alt-m", -> { ui.unmark_all }],
+          ignore_packet: [ui.t("無視／解除"), "cmd-d", -> { ui.ignore_packet }], time_reference: [ui.t("時刻基準／解除"), "cmd-t", -> { ui.time_reference }],
+          prev_in_conversation: [ui.t("同一会話の前"), "cmd-,", -> { ui.prev_in_conversation }], next_in_conversation: [ui.t("同一会話の次"), "cmd-.", -> { ui.next_in_conversation }],
+          coloring_rules: [ui.t("色付けルール"), nil, -> { ui.coloring_dialog }], toggle_coloring: [ui.t("色付け"), nil, -> { ui.toggle_coloring }],
+          follow_tcp_stream: [ui.t("TCP ストリームを追跡"), "cmd-alt-shift-t", -> { ui.follow_tcp_stream }], decode_as: [ui.t("別プロトコルとして解析"), "cmd-shift-u", -> { ui.decode_as }],
+          expert_info: [ui.t("エキスパート情報"), nil, -> { ui.expert_info }], reload_plugins: [ui.t("プラグイン再読み込み"), "cmd-shift-l", -> { ui.reload_plugins }], plugins: [ui.t("ディセクタプラグイン"), nil, -> { ui.plugins_dialog }],
+          file_properties: [ui.t("キャプチャファイルのプロパティ"), "cmd-alt-shift-c", -> { ui.file_properties }], protocol_hierarchy: [ui.t("プロトコル階層"), nil, -> { ui.protocol_hierarchy }],
+          conversations: [ui.t("会話"), nil, -> { ui.conversations }], endpoints: [ui.t("端点"), nil, -> { ui.endpoints }], io_graph: [ui.t("I/O グラフ"), nil, -> { ui.io_graph }],
+          export_packets: [ui.t("指定パケットのエクスポート"), nil, -> { ui.export_packets }], export_dissections: [ui.t("解析結果のエクスポート"), nil, -> { ui.export_dissections }],
+          command_palette: [ui.t("コマンドパレット"), "cmd-shift-k", -> { ui.command_palette }], profiles: [ui.t("プロファイル"), nil, -> { ui.profiles_dialog }])
+        commands[:preferences][1] = "cmd-shift-p"
+        commands[:restart][1] = "cmd-shift-r"
+        {"relative" => "相対時刻", "absolute" => "絶対時刻", "delta" => "前パケットとの差", "delta_displayed" => "前表示パケットとの差", "epoch" => "エポック時刻"}.each { |name, label| commands[:"time_format_#{name}"] = [ui.t("時刻: %{name}", name: ui.t(label)), nil, -> { ui.time_format(name) }] }
+        {"system" => "システム設定", "dark" => "ダーク", "light" => "ライト", "high_contrast" => "ハイコントラスト"}.each { |name, label| commands[:"theme_#{name}"] = [ui.t("テーマ: %{name}", name: ui.t(label)), nil, -> { ui.change_theme(name) }] }
+        %i[selected not and and_not or or_not].zip([ui.t("選択項目"), ui.t("選択項目を除外"), "AND", "AND NOT", "OR", "OR NOT"]).each do |mode, label|
+          commands[:"filter_#{mode}"] = [ui.t("適用: %{label}", label: label), nil, -> { ui.filter_from_selection(mode) }]
+          commands[:"prepare_#{mode}"] = [ui.t("準備: %{label}", label: 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) }]
+        {hex: ui.t("16 進数"), text: ui.t("テキスト"), dump: ui.t("ダンプ"), escaped: ui.t("エスケープした文字列")}.each do |format, label|
+          commands[:"copy_#{format}"] = [ui.t("バイトをコピー: %{label}", label: label), nil, -> { ui.copy_bytes(format) }]
         end
         commands.each do |name, (title, keys, operation)|
-          ui.app.actions.register(name, title: title) { |_| operation.call }
+          needs_document = %i[find_packet find_next find_prev mark_packet mark_all_displayed unmark_all ignore_packet time_reference prev_in_conversation next_in_conversation follow_tcp_stream expert_info file_properties protocol_hierarchy conversations endpoints io_graph export_packets export_dissections]
+          enabled = ->(*) { !needs_document.include?(name) || !!ui.document }
+          checked = name == :autoscroll ? ->(*) { ui.autoscroll? } : name == :toggle_coloring ? ->(*) { ui.coloring_enabled? } : nil
+          ui.app.actions.register(name, title: title, enabled: enabled, checked: checked) { |_| operation.call }
           next unless keys
-          key = RUBY_PLATFORM.include?("darwin") ? keys : keys.sub("cmd", "ctrl")
+          key = ui.native? && 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
+          submenu(ui.t("ファイル")) { %i[open save close_file reload export_packets export_dissections quit].each { |action| item(action) } }
+          submenu(ui.t("編集")) { %i[find_packet find_next find_prev mark_packet mark_all_displayed unmark_all ignore_packet time_reference copy_filter copy_hex copy_text copy_dump copy_escaped preferences profiles].each { |action| item(action) } }
+          submenu(ui.t("表示")) do
+            %i[columns autoscroll coloring_rules toggle_coloring zoom_in zoom_out zoom_reset].each { |action| item(action) }
+            submenu(ui.t("時刻形式")) { %w[relative absolute delta delta_displayed epoch].each { |name| item(:"time_format_#{name}") } }
+            submenu(ui.t("テーマ")) { %w[system dark light high_contrast].each { |name| item(:"theme_#{name}") } }
+          end
+          submenu(ui.t("移動")) { %i[previous_packet next_packet first_packet last_packet go_to_packet prev_in_conversation next_in_conversation].each { |action| item(action) } }
+          submenu(ui.t("キャプチャ")) { %i[capture restart].each { |action| item(action) } }
+          submenu(ui.t("フィルタ")) 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}") } }
+            submenu(ui.t("選択項目を適用")) { %i[selected not and and_not or or_not].each { |mode| item(:"filter_#{mode}") } }
+            submenu(ui.t("選択項目から準備")) { %i[selected not and and_not or or_not].each { |mode| item(:"prepare_#{mode}") } }
           end
+          submenu(ui.t("分析")) { %i[follow_tcp_stream decode_as expert_info plugins reload_plugins].each { |action| item(action) } }
+          submenu(ui.t("統計")) { %i[file_properties protocol_hierarchy conversations endpoints io_graph].each { |action| item(action) } }
+          submenu(ui.t("ヘルプ")) { item(:command_palette) }
         end
       end
     end