vanken 0.1.0 → 0.3.0

data/sig/generated/vanken/capture/permission_setup.rbs

@@ -0,0 +1,43 @@
+# Generated from lib/vanken/capture/permission_setup.rb with RBS::Inline
+
+module Vanken
+  module Capture
+    class PermissionSetup
+      PREFIX: ::String
+
+      SOURCE: untyped
+
+      def self.run: (untyped argv, ?stdout: untyped, ?stderr: untyped) -> untyped
+
+      attr_reader platform: untyped
+
+      def initialize: (?platform: untyped, ?ruby: untyped, ?gem_home: untyped, ?policy: untyped, ?group: untyped, ?root: untyped) -> untyped
+
+      def staged?: () -> untyped
+
+      def plan: () -> untyped
+
+      def install: () -> untyped
+
+      def validate_runtime!: () -> untyped
+
+      def validate_group!: () -> untyped
+
+      def next_steps: () -> untyped
+
+      private
+
+      def asset: (untyped relative, ?mode: untyped) -> untyped
+
+      def trusted_tree!: (untyped path, ?untyped visited) -> untyped
+
+      def trusted_path!: (untyped path) -> untyped
+
+      def safe_entry!: (untyped path) -> untyped
+
+      def secure_directory!: (untyped path) -> untyped
+
+      def validate_sudoers!: (untyped path) -> untyped
+    end
+  end
+end

data/sig/generated/vanken/config/analysis_settings.rbs

@@ -0,0 +1,31 @@
+# Generated from lib/vanken/config/analysis_settings.rb with RBS::Inline
+
+module Vanken
+  module Config
+    class AnalysisSettings
+      def initialize: (?directory: untyped) -> untyped
+
+      def decode_as: () -> untyped
+
+      def decode_as=: (untyped rules) -> untyped
+
+      def plugin_entries: () -> untyped
+
+      def plugins: () -> untyped
+
+      def untrusted_plugins: () -> untyped
+
+      def register_plugin: (untyped path) -> untyped
+
+      def remove_plugin: (untyped path) -> untyped
+
+      def trust_plugins: (untyped paths) -> untyped
+
+      private
+
+      def save_plugins: (untyped entries) -> untyped
+
+      def validate_rules: (untyped rules) -> untyped
+    end
+  end
+end

data/sig/generated/vanken/config/columns.rbs

@@ -0,0 +1,37 @@
+# Generated from lib/vanken/config/columns.rb with RBS::Inline
+
+module Vanken
+  module Config
+    class Columns
+      BUILTINS: untyped
+
+      def self.load: (directory: untyped, ?legacy: untyped) -> untyped
+
+      def initialize: (?untyped payload) -> untyped
+
+      def replace: (untyped payload) -> untyped
+
+      def self.valid_field?: (untyped field) -> untyped
+
+      def to_h: () -> untyped
+
+      def custom: () -> untyped
+
+      def table_columns: () -> untyped
+
+      def add: (untyped field, ?label: untyped, ?width: untyped) -> untyped
+
+      def remove: (untyped key) -> untyped
+
+      def move: (untyped key, untyped index) -> untyped
+
+      def update_layout: (untyped items) -> untyped
+
+      def save: (untyped directory) -> untyped
+
+      def self.display: (untyped values, ?type: untyped) -> untyped
+
+      def self.sort_value: (untyped value, ?type: untyped) -> untyped
+    end
+  end
+end

data/sig/generated/vanken/config/messages.rbs

@@ -0,0 +1,14 @@
+# Generated from lib/vanken/config/messages.rb with RBS::Inline
+
+module Vanken
+  module Config
+    module Messages
+      EN: Hash[String, String]
+
+      JA: Hash[String, String]
+
+      # @rbs (String text, ?language: String, **untyped values) -> String
+      def self.translate: (String text, ?language: String, **untyped values) -> String
+    end
+  end
+end

data/sig/generated/vanken/config/preferences.rbs

@@ -15,7 +15,7 @@ module Vanken
 
       attr_reader directory: untyped
 
-      def initialize: (?directory: untyped) -> untyped
+      def initialize: (?directory: untyped, ?state_directory: untyped) -> untyped
 
       def get: (untyped path) -> untyped
 

data/sig/generated/vanken/config/profiles.rbs

@@ -0,0 +1,29 @@
+# Generated from lib/vanken/config/profiles.rb with RBS::Inline
+
+module Vanken
+  module Config
+    class Profiles
+      FILES: untyped
+
+      attr_reader directory: untyped
+
+      attr_reader active: untyped
+
+      def initialize: (?directory: untyped) -> untyped
+
+      def names: () -> untyped
+
+      def preferences: () -> untyped
+
+      def create: (untyped name, ?copy_from: untyped) -> untyped
+
+      def switch: (untyped name) -> untyped
+
+      def delete: (untyped name) -> untyped
+
+      private
+
+      def profile_directory: (untyped name) -> untyped
+    end
+  end
+end

data/sig/generated/vanken/config/sessions.rbs

@@ -0,0 +1,17 @@
+# Generated from lib/vanken/config/sessions.rb with RBS::Inline
+
+module Vanken
+  module Config
+    module Sessions
+      def self.candidates: (?parent: untyped) -> untyped
+
+      def self.recover: (untyped directory, ?parent: untyped, **untyped options) -> untyped
+
+      def self.discard: (untyped directory, ?parent: untyped) -> untyped
+
+      def self.orphan?: (untyped directory) -> untyped
+
+      def self.with_session: (untyped directory, parent: untyped) -> untyped
+    end
+  end
+end

data/sig/generated/vanken/config/yaml_file.rbs

@@ -0,0 +1,11 @@
+# Generated from lib/vanken/config/yaml_file.rb with RBS::Inline
+
+module Vanken
+  module Config
+    module YamlFile
+      def self.read: (untyped path, ?default: untyped) -> untyped
+
+      def self.write: (untyped path, untyped value) -> untyped
+    end
+  end
+end

data/sig/generated/vanken/core/coloring.rbs

@@ -0,0 +1,52 @@
+# Generated from lib/vanken/core/coloring.rb with RBS::Inline
+
+module Vanken
+  module Core
+    module Coloring
+      class Rule < Data
+        attr_reader name(): String
+
+        attr_reader filter(): String
+
+        attr_reader light(): Hash[String, String]
+
+        attr_reader dark(): Hash[String, String]
+
+        attr_reader enabled(): bool
+
+        attr_reader program(): DisplayFilter::Program
+
+        def self.new: (String name, String filter, Hash[String, String] light, Hash[String, String] dark, bool enabled, DisplayFilter::Program program) -> instance
+                    | (name: String, filter: String, light: Hash[String, String], dark: Hash[String, String], enabled: bool, program: DisplayFilter::Program) -> instance
+
+        def self.members: () -> [ :name, :filter, :light, :dark, :enabled, :program ]
+
+        def members: () -> [ :name, :filter, :light, :dark, :enabled, :program ]
+      end
+
+      class RuleSet
+        DEFAULT_PATH: untyped
+
+        attr_reader rules: Array[Rule]
+
+        # @rbs (Hash[String, untyped] payload, ?catalog: untyped) -> void
+        def initialize: (Hash[String, untyped] payload, ?catalog: untyped) -> void
+
+        # @rbs (_FilterView view, ?theme: Symbol) -> Hash[Symbol, String]?
+        def match: (_FilterView view, ?theme: Symbol) -> Hash[Symbol, String]?
+
+        # @rbs () -> Hash[String, untyped]
+        def to_h: () -> Hash[String, untyped]
+
+        # @rbs (String path) -> void
+        def save: (String path) -> void
+
+        # @rbs (String path, ?catalog: untyped) -> RuleSet
+        def self.load: (String path, ?catalog: untyped) -> RuleSet
+
+        # @rbs (?catalog: untyped) -> RuleSet
+        def self.defaults: (?catalog: untyped) -> RuleSet
+      end
+    end
+  end
+end

data/sig/generated/vanken/core/stores.rbs

@@ -68,6 +68,10 @@ module Vanken
 
       attr_reader experts: Hash[Integer, Array[Hash[Symbol, untyped]]]
 
+      attr_reader expert_count: Integer
+
+      attr_reader expert_max: Integer
+
       # @rbs! @extra: Hash[Integer, Hash[String, untyped]]
       # @rbs! @io: File?
       # @rbs (String directory, ?persist: bool) -> void

data/sig/generated/vanken/gateway/display_capture_filter.rbs

@@ -0,0 +1,37 @@
+# Generated from lib/vanken/gateway/display_capture_filter.rb with RBS::Inline
+
+module Vanken
+  module Gateway
+    class DisplayCaptureFilter
+      class Packet < Struct[untyped]
+        attr_accessor data(): untyped
+
+        attr_accessor original_length(): untyped
+
+        attr_accessor linktype(): untyped
+
+        attr_accessor meta(): untyped
+
+        def self.new: (?untyped data, ?untyped original_length, ?untyped linktype, ?untyped meta) -> instance
+                    | (?data: untyped, ?original_length: untyped, ?linktype: untyped, ?meta: untyped) -> instance
+      end
+
+      TUNNEL_PORTS: untyped
+
+      attr_reader expression: untyped
+
+      def initialize: (untyped expression) -> untyped
+
+      # nil requests the ordinary VDF evaluator; false is a definite non-match.
+      def match: (untyped frame) -> untyped
+
+      private
+
+      def convert: (untyped node) -> untyped
+
+      def term: (untyped field, untyped member) -> untyped
+
+      def eligible?: (untyped frame) -> untyped
+    end
+  end
+end

data/sig/generated/vanken/gateway/dissector.rbs

@@ -12,6 +12,17 @@ module Vanken
       def self.rank: (Symbol? value) -> Integer
     end
 
+    # The public plugin DSL registers through Registry.default; keep that lookup local.
+    module RegistryScope
+      module Default
+        # @rbs () -> Redhound::Registry
+        def default: () -> Redhound::Registry
+      end
+
+      # @rbs [T] (Redhound::Registry registry) { () -> T } -> T
+      def self.with: [T] (Redhound::Registry registry) { () -> T } -> T
+    end
+
     class Dissector
       attr_reader registry: Redhound::Registry
 
@@ -28,6 +39,8 @@ module Vanken
     class PacketView
       attr_reader raw_packet: Redhound::Packet
 
+      attr_reader registry: Redhound::Registry
+
       # @rbs (Redhound::Packet packet, Redhound::Registry registry) -> void
       def initialize: (Redhound::Packet packet, Redhound::Registry registry) -> void
 
@@ -91,8 +104,8 @@ module Vanken
     end
 
     class FieldCatalog
-      # @rbs () -> void
-      def initialize: () -> void
+      # @rbs (?registry: Redhound::Registry) -> void
+      def initialize: (?registry: Redhound::Registry) -> void
 
       # @rbs () -> Array[String]
       def names: () -> Array[String]

data/sig/generated/vanken/gateway/exporter.rbs

@@ -0,0 +1,27 @@
+# Generated from lib/vanken/gateway/exporter.rb with RBS::Inline
+
+module Vanken
+  module Gateway
+    class Exporter
+      DEFAULT_COLUMNS: untyped
+
+      def initialize: (untyped document) -> untyped
+
+      def numbers: (?scope: untyped, ?range: untyped, ?selected: untyped, ?exclude_ignored: untyped) -> untyped
+
+      def write: (untyped path, format: untyped, ?numbers: untyped, ?columns: untyped, ?cancelled: untyped) -> untyped
+
+      private
+
+      def ranges: (untyped value, untyped limit) -> untyped
+
+      def check_cancelled: (untyped cancelled) -> untyped
+
+      def json: (untyped file, untyped numbers, untyped format, untyped cancelled) -> untyped
+
+      def text_node: (untyped file, untyped node, untyped depth) -> untyped
+
+      def csv_value: (untyped number, untyped column) -> untyped
+    end
+  end
+end

data/sig/generated/vanken/gateway/file_writer.rbs

@@ -17,6 +17,9 @@ module Vanken
       # @rbs () -> void
       def flush: () -> void
 
+      # @rbs () -> Integer
+      def bytes_written: () -> Integer
+
       # @rbs (Redhound::Capture::Stats | Hash[Symbol | String, Integer] stats, ?interface: Redhound::Capture::Interface?) -> void
       def write_stats: (Redhound::Capture::Stats | Hash[Symbol | String, Integer] stats, ?interface: Redhound::Capture::Interface?) -> void
 

data/sig/generated/vanken/gateway/interfaces.rbs

@@ -11,6 +11,18 @@ module Vanken
 
       # @rbs (String name) -> Hash[Symbol, untyped]
       def self.find: (String name) -> Hash[Symbol, untyped]
+
+      # @rbs () -> Hash[String, Integer]
+      def self.traffic_counters: () -> Hash[String, Integer]
+
+      # @rbs (String text) -> Hash[String, Integer]
+      def self.parse_linux_counters: (String text) -> Hash[String, Integer]
+
+      # @rbs (String text) -> Hash[String, Integer]
+      def self.parse_darwin_counters: (String text) -> Hash[String, Integer]
+
+      # @rbs (?previous: Hash[Symbol, untyped]?, ?history: Hash[String, Array[Integer]], ?now: Integer | Float) -> Hash[Symbol, untyped]
+      def self.sample_traffic: (?previous: Hash[Symbol, untyped]?, ?history: Hash[String, Array[Integer]], ?now: Integer | Float) -> Hash[Symbol, untyped]
     end
   end
 end

data/sig/generated/vanken/gateway/resolver.rbs

@@ -0,0 +1,52 @@
+# Generated from lib/vanken/gateway/resolver.rb with RBS::Inline
+
+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: ::Float
+
+      @worker: Thread
+
+      @closed: bool
+
+      @mutex: Mutex
+
+      @pending: Hash[String, Array[^(String) -> void]]
+
+      @cache: Hash[String, [ String?, Float? ]]
+
+      @queue: SizedQueue[String?]
+
+      @resolver: untyped
+
+      @limit: Integer
+
+      @timeout: Float
+
+      # @rbs (?timeout: Integer | Float, ?limit: Integer, ?resolver: untyped) -> void
+      def initialize: (?timeout: Integer | Float, ?limit: Integer, ?resolver: untyped) -> void
+
+      # @rbs (String address) ?{ (String) -> void } -> String
+      def request: (String address) ?{ (String) -> void } -> String
+
+      # @rbs () -> void
+      def close: () -> void
+
+      private
+
+      # @rbs (String address) -> String?
+      def numeric_address: (String address) -> String?
+
+      # @rbs () -> Float
+      def now: () -> Float
+
+      # @rbs (String address) -> String?
+      def lookup: (String address) -> String?
+
+      # @rbs () -> void
+      def work: () -> void
+    end
+  end
+end

data/sig/generated/vanken/gateway/statistics.rbs

@@ -0,0 +1,104 @@
+# Generated from lib/vanken/gateway/statistics.rb with RBS::Inline
+
+module Vanken
+  module Gateway
+    class HierarchyRow < Data
+      attr_reader path(): Array[Symbol]
+
+      attr_reader packets(): Integer
+
+      attr_reader bytes(): Integer
+
+      def self.new: (Array[Symbol] path, Integer packets, Integer bytes) -> instance
+                  | (path: Array[Symbol], packets: Integer, bytes: Integer) -> instance
+
+      def self.members: () -> [ :path, :packets, :bytes ]
+
+      def members: () -> [ :path, :packets, :bytes ]
+    end
+
+    class ConversationRow < Data
+      attr_reader addr_a(): String
+
+      attr_reader port_a(): Integer
+
+      attr_reader addr_b(): String
+
+      attr_reader port_b(): Integer
+
+      attr_reader packets_ab(): Integer
+
+      attr_reader packets_ba(): Integer
+
+      attr_reader bytes_ab(): Integer
+
+      attr_reader bytes_ba(): Integer
+
+      attr_reader start_ns(): Integer
+
+      attr_reader end_ns(): Integer
+
+      attr_reader duration_ns(): Integer
+
+      def self.new: (String addr_a, Integer port_a, String addr_b, Integer port_b, Integer packets_ab, Integer packets_ba, Integer bytes_ab, Integer bytes_ba, Integer start_ns, Integer end_ns, Integer duration_ns) -> instance
+                  | (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) -> instance
+
+      def self.members: () -> [ :addr_a, :port_a, :addr_b, :port_b, :packets_ab, :packets_ba, :bytes_ab, :bytes_ba, :start_ns, :end_ns, :duration_ns ]
+
+      def members: () -> [ :addr_a, :port_a, :addr_b, :port_b, :packets_ab, :packets_ba, :bytes_ab, :bytes_ba, :start_ns, :end_ns, :duration_ns ]
+    end
+
+    class EndpointRow < Data
+      attr_reader address(): String
+
+      attr_reader port(): Integer
+
+      attr_reader packets_tx(): Integer
+
+      attr_reader packets_rx(): Integer
+
+      attr_reader bytes_tx(): Integer
+
+      attr_reader bytes_rx(): Integer
+
+      def self.new: (String address, Integer port, Integer packets_tx, Integer packets_rx, Integer bytes_tx, Integer bytes_rx) -> instance
+                  | (address: String, port: Integer, packets_tx: Integer, packets_rx: Integer, bytes_tx: Integer, bytes_rx: Integer) -> instance
+
+      def self.members: () -> [ :address, :port, :packets_tx, :packets_rx, :bytes_tx, :bytes_rx ]
+
+      def members: () -> [ :address, :port, :packets_tx, :packets_rx, :bytes_tx, :bytes_rx ]
+    end
+
+    class StatisticsTable < Data
+      attr_reader kind(): Symbol
+
+      attr_reader type(): Symbol?
+
+      attr_reader rows(): Array[HierarchyRow | ConversationRow | EndpointRow]
+
+      attr_reader evicted(): Integer
+
+      def self.new: (Symbol kind, Symbol? type, Array[HierarchyRow | ConversationRow | EndpointRow] rows, Integer evicted) -> instance
+                  | (kind: Symbol, type: Symbol?, rows: Array[HierarchyRow | ConversationRow | EndpointRow], evicted: Integer) -> instance
+
+      def self.members: () -> [ :kind, :type, :rows, :evicted ]
+
+      def members: () -> [ :kind, :type, :rows, :evicted ]
+    end
+
+    # 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: Array[String], ?registry: Redhound::Registry, **untyped options) -> void
+
+      # @rbs (PacketView packet) -> void
+      def update: (PacketView packet) -> void
+
+      # @rbs () -> Array[StatisticsTable]
+      def tables: () -> Array[StatisticsTable]
+
+      # @rbs () -> void
+      def close: () -> void
+    end
+  end
+end

data/sig/generated/vanken/gateway/stream.rbs

@@ -0,0 +1,75 @@
+# Generated from lib/vanken/gateway/stream.rb with RBS::Inline
+
+module Vanken
+  module Gateway
+    class StreamChunk < Data
+      attr_reader direction(): Integer
+
+      attr_reader bytes(): String
+
+      attr_reader missing(): Integer
+
+      attr_reader number(): Integer
+
+      attr_reader sequence(): Integer
+
+      def self.new: (Integer direction, String bytes, Integer missing, Integer number, Integer sequence) -> instance
+                  | (direction: Integer, bytes: String, missing: Integer, number: Integer, sequence: Integer) -> instance
+
+      def self.members: () -> [ :direction, :bytes, :missing, :number, :sequence ]
+
+      def members: () -> [ :direction, :bytes, :missing, :number, :sequence ]
+    end
+
+    class StreamText < Data
+      attr_reader direction(): Integer
+
+      attr_reader text(): String
+
+      def self.new: (Integer direction, String text) -> instance
+                  | (direction: Integer, text: String) -> instance
+
+      def self.members: () -> [ :direction, :text ]
+
+      def members: () -> [ :direction, :text ]
+    end
+
+    class Stream
+      DISPLAY_LIMIT: Integer
+
+      SEQUENCE_MOD: 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: (untyped document, Integer stream_id, ?cancelled: (^() -> bool)?) -> void
+
+      # @rbs (?direction: Integer?) -> Integer
+      def byte_size: (?direction: Integer?) -> Integer
+
+      # @rbs (?format: Symbol, ?direction: Integer?, ?limit: Integer) -> Array[StreamText]
+      def preview: (?format: Symbol, ?direction: Integer?, ?limit: Integer) -> Array[StreamText]
+
+      # @rbs (String path, ?format: Symbol, ?direction: Integer?, ?cancelled: (^() -> bool)?) -> String
+      def save: (String path, ?format: Symbol, ?direction: Integer?, ?cancelled: (^() -> bool)?) -> String
+
+      private
+
+      # @rbs (Integer? direction) -> Array[StreamChunk]
+      def selected: (Integer? direction) -> Array[StreamChunk]
+
+      def endpoint: (untyped address, untyped port) -> untyped
+
+      def validate: (untyped format, untyped direction) -> untyped
+
+      def render: (untyped chunk, untyped bytes, untyped format) -> untyped
+
+      # Keep capture arrival precedence while inserting only previously unseen ranges.
+      def insert: (untyped segments, untyped chunk) -> untyped
+    end
+  end
+end