keenetic 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 150b29909b27e3c0c7704dead364af88b95152e02c48ad237dd2bbdaf5d6471e
-  data.tar.gz: dde2d8a08098c812502fb07cb3cad0262d004ff6c431be3b8d11b21f2216491a
+  metadata.gz: 3fa7552177bec3d537db352ed748bcd24e07bee6156272569a121b7cb18c6a2f
+  data.tar.gz: e48b1c10d4cc62466ebd5e34b200f399e28e8261e0e1a83a1a4b1ee86efc4ee3
 SHA512:
-  metadata.gz: 12e93dc8b6b71b665fd88994236ef984c042dc2cbf16b3108456f9615e55c5751a76b657adaf7ff970c4a83ffd3d4aa49ade8800b772666abc27c23e082bc630
-  data.tar.gz: 7921327abfc55e5f1d2c4846602ecad522fe69478b8d78ddf2a3519ebe9b15aff87950618eeef2a8fe4a6e889c08e8b350931bfe2bc430549bb12a36668e8d95
+  metadata.gz: f801f8df36437d0f2ea76f6765beaeee3a68750b2974b8b3fc4eed9145be5a5c123940245b56566c690ef906d791eaf8223ae3f016b4bb0472c1a2a3476f77df
+  data.tar.gz: 984b84f49fb83117ab0c9c89b60a0b88718ccbbd92258c69987be8103bec4d2fd66554c4413c001e45167396735c634a578e839c35cce74b0124d2d3c829f930

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Anton
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -48,6 +48,34 @@ client.internet.speed
 
 # Ports
 client.ports.all
+
+# Static Routes
+client.routes.all
+client.routes.add(host: '1.2.3.4', interface: 'Wireguard0', comment: 'VPN host')
+client.routes.add(network: '10.0.0.0/24', interface: 'Wireguard0', comment: 'VPN network')
+client.routes.add_batch([
+  { host: '1.2.3.4', interface: 'Wireguard0', comment: 'Host 1' },
+  { network: '10.0.0.0/24', interface: 'Wireguard0', comment: 'Network 1' }
+])
+client.routes.delete(host: '1.2.3.4')
+client.routes.delete(network: '10.0.0.0/24')
+
+# Hotspot / Policies
+client.hotspot.policies                                         # all IP policies
+client.hotspot.hosts                                            # all registered hosts
+client.hotspot.set_host_policy(mac: 'AA:BB:CC:DD:EE:FF', policy: 'Policy0')
+client.hotspot.set_host_policy(mac: 'AA:BB:CC:DD:EE:FF', policy: nil)  # remove policy
+
+# Configuration
+client.system_config.save       # save to flash
+client.system_config.download   # download startup-config.txt
+
+# Raw RCI Access (for custom commands)
+client.rci({ 'show' => { 'system' => {} } })
+client.rci([
+  { 'show' => { 'system' => {} } },
+  { 'show' => { 'version' => {} } }
+])
 ```
 
 ## Error Handling

data/lib/keenetic/client.rb

@@ -102,6 +102,55 @@ module Keenetic
       @logs ||= Resources::Logs.new(self)
     end
 
+    # @return [Resources::Routes] Static routes resource
+    def routes
+      @routes ||= Resources::Routes.new(self)
+    end
+
+    # @return [Resources::Hotspot] Hotspot hosts and policies resource
+    def hotspot
+      @hotspot ||= Resources::Hotspot.new(self)
+    end
+
+    # @return [Resources::Config] Configuration management resource
+    def system_config
+      @system_config ||= Resources::Config.new(self)
+    end
+
+    # Execute arbitrary RCI command(s).
+    #
+    # Provides raw access to the Keenetic RCI (Remote Command Interface).
+    # Use this for custom commands not covered by the gem's resources.
+    #
+    # == Keenetic API
+    #   POST http://<host>/rci/
+    #   Content-Type: application/json
+    #   Body: Array or Hash of RCI commands
+    #
+    # @param body [Hash, Array<Hash>] RCI command(s) to execute
+    # @return [Hash, Array, nil] Parsed JSON response
+    #
+    # @example Execute single command
+    #   client.rci({ 'show' => { 'system' => {} } })
+    #   # => { "show" => { "system" => { ... } } }
+    #
+    # @example Execute batch commands
+    #   client.rci([
+    #     { 'show' => { 'system' => {} } },
+    #     { 'show' => { 'version' => {} } }
+    #   ])
+    #   # => [{ "show" => { "system" => { ... } } }, { "show" => { "version" => { ... } } }]
+    #
+    # @example Execute write command
+    #   client.rci([
+    #     { 'ip' => { 'hotspot' => { 'host' => { 'mac' => 'aa:bb:cc:dd:ee:ff', 'permit' => true } } } }
+    #   ])
+    #
+    def rci(body)
+      commands = body.is_a?(Array) ? body : [body]
+      batch(commands)
+    end
+
     # Make a GET request to the router API.
     #
     # == Keenetic API

data/lib/keenetic/resources/config.rb

@@ -0,0 +1,53 @@
+module Keenetic
+  module Resources
+    # Manages router configuration operations.
+    #
+    # == API Endpoints Used
+    #
+    # === Save Configuration
+    #   POST /rci/ (batch format)
+    #   Body: [{"system": {"configuration": {"save": {}}}}]
+    #   Saves current configuration to persistent storage
+    #
+    # === Download Configuration
+    #   GET /ci/startup-config.txt
+    #   Returns: Plain text configuration file
+    #
+    class Config < Base
+      # Save current configuration to persistent storage.
+      #
+      # == Keenetic API Request
+      #   POST /rci/ (batch format)
+      #   Body: [{"system": {"configuration": {"save": {}}}}]
+      #
+      # Configuration changes are typically auto-saved, but this method
+      # forces an immediate save to flash storage.
+      #
+      # @return [Array<Hash>] API response
+      # @example
+      #   client.config.save
+      #   # => [{ "system" => { "configuration" => { "save" => {} } } }]
+      #
+      def save
+        client.batch([{ 'system' => { 'configuration' => { 'save' => {} } } }])
+      end
+
+      # Download the startup configuration file.
+      #
+      # == Keenetic API Request
+      #   GET /ci/startup-config.txt
+      #
+      # Returns the full router configuration as a text file.
+      # This is the same format used for backup/restore operations.
+      #
+      # @return [String] Configuration file content
+      # @example
+      #   config_text = client.config.download
+      #   File.write('router-backup.txt', config_text)
+      #
+      def download
+        get('/ci/startup-config.txt')
+      end
+    end
+  end
+end

data/lib/keenetic/resources/hotspot.rb

@@ -0,0 +1,282 @@
+module Keenetic
+  module Resources
+    # Manages hotspot hosts and IP policies.
+    #
+    # == API Endpoints Used
+    #
+    # === Reading Policies
+    #   POST /rci/ (batch format)
+    #   Body: [{"show": {"sc": {"ip": {"policy": {}}}}}]
+    #   Returns: All IP policies from configuration
+    #
+    # === Reading Hosts
+    #   POST /rci/ (batch format)
+    #   Body: [
+    #     {"show": {"sc": {"ip": {"hotspot": {"host": {}}}}}},
+    #     {"show": {"ip": {"hotspot": {}}}}
+    #   ]
+    #   Returns: Configuration hosts and runtime hosts
+    #
+    # === Setting Host Policy
+    #   POST /rci/ (batch format)
+    #   Body: [
+    #     {"webhelp": {"event": {"push": {"data": "..."}}}},
+    #     {"ip": {"hotspot": {"host": {"mac": "...", "permit": true, "policy": "..."}}}},
+    #     {"system": {"configuration": {"save": {}}}}
+    #   ]
+    #
+    class Hotspot < Base
+      # Get all IP policies.
+      #
+      # == Keenetic API Request
+      #   POST /rci/ (batch format)
+      #   Body: [{"show": {"sc": {"ip": {"policy": {}}}}}]
+      #
+      # == Response Structure from API
+      #   [
+      #     {
+      #       "id": "Policy0",
+      #       "description": "VPN Policy",
+      #       "global": false,
+      #       "interface": [
+      #         { "name": "Wireguard0", "priority": 100 }
+      #       ]
+      #     }
+      #   ]
+      #
+      # @return [Array<Hash>] List of normalized policy hashes
+      # @example
+      #   policies = client.hotspot.policies
+      #   # => [{ id: "Policy0", description: "VPN Policy", global: false, interfaces: [...] }]
+      #
+      def policies
+        response = client.batch([{ 'show' => { 'sc' => { 'ip' => { 'policy' => {} } } } }])
+        policies_data = extract_policies_from_response(response)
+        normalize_policies(policies_data)
+      end
+
+      # Get all registered hosts with their policies.
+      #
+      # == Keenetic API Request
+      #   POST /rci/ (batch format)
+      #   Body: [
+      #     {"show": {"sc": {"ip": {"hotspot": {"host": {}}}}}},
+      #     {"show": {"ip": {"hotspot": {}}}}
+      #   ]
+      #
+      # Returns merged data from configuration (static settings) and runtime (current status).
+      #
+      # @return [Array<Hash>] List of normalized host hashes
+      # @example
+      #   hosts = client.hotspot.hosts
+      #   # => [{ mac: "AA:BB:CC:DD:EE:FF", name: "My Device", policy: "Policy0", permit: true, ... }]
+      #
+      def hosts
+        response = client.batch([
+          { 'show' => { 'sc' => { 'ip' => { 'hotspot' => { 'host' => {} } } } } },
+          { 'show' => { 'ip' => { 'hotspot' => {} } } }
+        ])
+
+        config_hosts = extract_config_hosts(response)
+        runtime_hosts = extract_runtime_hosts(response)
+
+        merge_hosts(config_hosts, runtime_hosts)
+      end
+
+      # Set or remove policy for a host.
+      #
+      # == Keenetic API Request
+      #   POST /rci/ (batch format)
+      #   Body: [
+      #     {"webhelp": {"event": {"push": {"data": "{\"type\":\"configuration_change\",\"value\":{\"url\":\"/policies/policy-consumers\"}}"}}}},
+      #     {"ip": {"hotspot": {"host": {"mac": "...", "permit": true, "policy": "..."}}}},
+      #     {"system": {"configuration": {"save": {}}}}
+      #   ]
+      #
+      # @param mac [String] Client MAC address (required)
+      # @param policy [String, nil] Policy name (e.g., "Policy0"), or nil to remove policy
+      # @param permit [Boolean] Whether to permit the host (default: true)
+      # @return [Array<Hash>] API response
+      #
+      # @example Assign policy to host
+      #   client.hotspot.set_host_policy(mac: "AA:BB:CC:DD:EE:FF", policy: "Policy0")
+      #
+      # @example Remove policy from host
+      #   client.hotspot.set_host_policy(mac: "AA:BB:CC:DD:EE:FF", policy: nil)
+      #
+      # @example Assign policy with deny access
+      #   client.hotspot.set_host_policy(mac: "AA:BB:CC:DD:EE:FF", policy: "Policy0", permit: false)
+      #
+      def set_host_policy(mac:, policy:, permit: true)
+        raise ArgumentError, 'MAC address is required' if mac.nil? || mac.to_s.strip.empty?
+
+        normalized_mac = mac.downcase
+
+        host_params = {
+          'mac' => normalized_mac,
+          'permit' => permit
+        }
+
+        if policy.nil? || policy.to_s.strip.empty?
+          # Remove policy assignment
+          host_params['policy'] = { 'no' => true }
+        else
+          host_params['policy'] = policy
+        end
+
+        commands = [
+          webhelp_event,
+          { 'ip' => { 'hotspot' => { 'host' => host_params } } },
+          save_config_command
+        ]
+
+        client.batch(commands)
+      end
+
+      # Find a specific policy by ID.
+      #
+      # @param id [String] Policy ID (e.g., "Policy0")
+      # @return [Hash, nil] Policy data or nil if not found
+      # @example
+      #   policy = client.hotspot.find_policy(id: "Policy0")
+      #   # => { id: "Policy0", description: "VPN Policy", ... }
+      #
+      def find_policy(id:)
+        policies.find { |p| p[:id] == id }
+      end
+
+      # Find a specific host by MAC address.
+      #
+      # @param mac [String] MAC address (case-insensitive)
+      # @return [Hash, nil] Host data or nil if not found
+      # @example
+      #   host = client.hotspot.find_host(mac: "AA:BB:CC:DD:EE:FF")
+      #   # => { mac: "AA:BB:CC:DD:EE:FF", name: "My Device", policy: "Policy0", ... }
+      #
+      def find_host(mac:)
+        hosts.find { |h| h[:mac]&.downcase == mac.downcase }
+      end
+
+      private
+
+      def extract_policies_from_response(response)
+        return [] unless response.is_a?(Array) && response.first.is_a?(Hash)
+
+        response.dig(0, 'show', 'sc', 'ip', 'policy') || []
+      end
+
+      def extract_config_hosts(response)
+        return [] unless response.is_a?(Array) && response[0].is_a?(Hash)
+
+        hosts = response.dig(0, 'show', 'sc', 'ip', 'hotspot', 'host') || []
+        hosts.is_a?(Array) ? hosts : [hosts]
+      end
+
+      def extract_runtime_hosts(response)
+        return [] unless response.is_a?(Array) && response[1].is_a?(Hash)
+
+        hosts = response.dig(1, 'show', 'ip', 'hotspot', 'host') || []
+        hosts.is_a?(Array) ? hosts : [hosts]
+      end
+
+      def normalize_policies(policies_data)
+        return [] unless policies_data.is_a?(Array)
+
+        policies_data.map { |policy| normalize_policy(policy) }.compact
+      end
+
+      def normalize_policy(data)
+        return nil unless data.is_a?(Hash)
+
+        interfaces = data['interface'] || []
+        interfaces = [interfaces] unless interfaces.is_a?(Array)
+
+        {
+          id: data['id'],
+          description: data['description'],
+          global: normalize_boolean(data['global']),
+          interfaces: interfaces.map { |iface| normalize_policy_interface(iface) }.compact
+        }
+      end
+
+      def normalize_policy_interface(data)
+        return nil unless data.is_a?(Hash)
+
+        {
+          name: data['name'],
+          priority: data['priority']
+        }
+      end
+
+      def merge_hosts(config_hosts, runtime_hosts)
+        # Create lookup from runtime hosts by MAC
+        runtime_by_mac = runtime_hosts.each_with_object({}) do |host, lookup|
+          next unless host.is_a?(Hash) && host['mac']
+
+          lookup[host['mac'].upcase] = host
+        end
+
+        # Process config hosts and merge with runtime data
+        all_hosts = config_hosts.map do |config_host|
+          next unless config_host.is_a?(Hash) && config_host['mac']
+
+          mac = config_host['mac'].upcase
+          runtime_host = runtime_by_mac.delete(mac) || {}
+          normalize_host(config_host, runtime_host)
+        end.compact
+
+        # Add any remaining runtime-only hosts
+        runtime_by_mac.values.each do |runtime_host|
+          all_hosts << normalize_host({}, runtime_host)
+        end
+
+        all_hosts
+      end
+
+      def normalize_host(config_data, runtime_data)
+        config_data ||= {}
+        runtime_data ||= {}
+
+        mac = config_data['mac'] || runtime_data['mac']
+        return nil unless mac
+
+        {
+          mac: mac.upcase,
+          name: config_data['name'] || runtime_data['name'] || runtime_data['hostname'],
+          hostname: runtime_data['hostname'],
+          ip: runtime_data['ip'],
+          interface: runtime_data['interface'],
+          via: runtime_data['via'],
+          policy: config_data['policy'],
+          permit: normalize_boolean(config_data['permit']),
+          deny: normalize_boolean(config_data['deny']),
+          schedule: config_data['schedule'],
+          active: normalize_boolean(runtime_data['active']),
+          registered: normalize_boolean(runtime_data['registered']),
+          access: runtime_data['access'],
+          rxbytes: runtime_data['rxbytes'],
+          txbytes: runtime_data['txbytes'],
+          uptime: runtime_data['uptime'],
+          first_seen: runtime_data['first-seen'],
+          last_seen: runtime_data['last-seen']
+        }
+      end
+
+      def webhelp_event
+        {
+          'webhelp' => {
+            'event' => {
+              'push' => {
+                'data' => '{"type":"configuration_change","value":{"url":"/policies/policy-consumers"}}'
+              }
+            }
+          }
+        }
+      end
+
+      def save_config_command
+        { 'system' => { 'configuration' => { 'save' => {} } } }
+      end
+    end
+  end
+end

data/lib/keenetic/resources/routes.rb

@@ -0,0 +1,432 @@
+module Keenetic
+  module Resources
+    # Manages static routes configuration on the router.
+    #
+    # == API Endpoints Used
+    #
+    # === Reading Static Routes
+    #   POST /rci/ (batch format)
+    #   Body: [{"show": {"sc": {"ip": {"route": {}}}}}]
+    #   Returns: Static routes from router configuration
+    #
+    # === Adding Static Routes
+    #   POST /rci/ (batch format)
+    #   Body: [
+    #     {"webhelp": {"event": {"push": {"data": "..."}}}},
+    #     {"ip": {"route": {...}}},
+    #     {"system": {"configuration": {"save": {}}}}
+    #   ]
+    #
+    # === Deleting Static Routes
+    #   POST /rci/ (batch format)
+    #   Body: [
+    #     {"webhelp": {"event": {"push": {"data": "..."}}}},
+    #     {"ip": {"route": {"no": true, ...}}},
+    #     {"system": {"configuration": {"save": {}}}}
+    #   ]
+    #
+    # == CIDR Support
+    # The gem automatically converts CIDR notation to subnet masks:
+    #   host: "10.0.0.0/24" -> network: "10.0.0.0", mask: "255.255.255.0"
+    #   host: "1.2.3.4/32"  -> host: "1.2.3.4"
+    #
+    class Routes < Base
+      # CIDR prefix to subnet mask mapping
+      CIDR_TO_MASK = {
+        8  => '255.0.0.0',
+        9  => '255.128.0.0',
+        10 => '255.192.0.0',
+        11 => '255.224.0.0',
+        12 => '255.240.0.0',
+        13 => '255.248.0.0',
+        14 => '255.252.0.0',
+        15 => '255.254.0.0',
+        16 => '255.255.0.0',
+        17 => '255.255.128.0',
+        18 => '255.255.192.0',
+        19 => '255.255.224.0',
+        20 => '255.255.240.0',
+        21 => '255.255.248.0',
+        22 => '255.255.252.0',
+        23 => '255.255.254.0',
+        24 => '255.255.255.0',
+        25 => '255.255.255.128',
+        26 => '255.255.255.192',
+        27 => '255.255.255.224',
+        28 => '255.255.255.240',
+        29 => '255.255.255.248',
+        30 => '255.255.255.252',
+        31 => '255.255.255.254',
+        32 => '255.255.255.255'
+      }.freeze
+
+      # Get all static routes from router configuration.
+      #
+      # == Keenetic API Request
+      #   POST /rci/ (batch format)
+      #   Body: [{"show": {"sc": {"ip": {"route": {}}}}}]
+      #
+      # == Response Structure from API
+      #   [
+      #     {
+      #       "network": "10.0.0.0",
+      #       "mask": "255.255.255.0",
+      #       "interface": "Wireguard0",
+      #       "gateway": "",
+      #       "auto": true,
+      #       "reject": false,
+      #       "comment": "VPN route"
+      #     }
+      #   ]
+      #
+      # @return [Array<Hash>] List of normalized static route hashes
+      # @example
+      #   routes = client.routes.all
+      #   # => [{ network: "10.0.0.0", mask: "255.255.255.0", interface: "Wireguard0", ... }]
+      #
+      def all
+        response = client.batch([{ 'show' => { 'sc' => { 'ip' => { 'route' => {} } } } }])
+        routes_data = extract_routes_from_response(response)
+        normalize_routes(routes_data)
+      end
+
+      # Add a single static route.
+      #
+      # == Keenetic API Request
+      #   POST /rci/ (batch format)
+      #   Body: [
+      #     {"webhelp": {"event": {"push": {"data": "{\"type\":\"configuration_change\",\"value\":{\"url\":\"/staticRoutes\"}}"}}}},
+      #     {"ip": {"route": {"host|network": "...", "mask": "...", "interface": "...", ...}}},
+      #     {"system": {"configuration": {"save": {}}}}
+      #   ]
+      #
+      # @param host [String, nil] Single host IP (e.g., "1.2.3.4" or "1.2.3.4/32"), mutually exclusive with network/mask
+      # @param network [String, nil] Network address (e.g., "10.0.0.0" or "10.0.0.0/24")
+      # @param mask [String, nil] Subnet mask (e.g., "255.255.255.0"), required with network unless CIDR notation used
+      # @param interface [String] Interface name (required, e.g., "Wireguard0")
+      # @param comment [String] Route description (required)
+      # @param gateway [String] Gateway address (optional, default "")
+      # @param auto [Boolean] Auto-enable route (optional, default true)
+      # @param reject [Boolean] Reject route (optional, default false)
+      # @return [Array<Hash>] API response
+      # @raise [ArgumentError] if required parameters are missing or invalid
+      #
+      # @example Add host route
+      #   client.routes.add(host: "1.2.3.4", interface: "Wireguard0", comment: "VPN host")
+      #
+      # @example Add network route with CIDR
+      #   client.routes.add(network: "10.0.0.0/24", interface: "Wireguard0", comment: "VPN network")
+      #
+      # @example Add network route with explicit mask
+      #   client.routes.add(network: "10.0.0.0", mask: "255.255.255.0", interface: "Wireguard0", comment: "VPN network")
+      #
+      def add(host: nil, network: nil, mask: nil, interface:, comment:, gateway: '', auto: true, reject: false)
+        route_params = build_route_params(
+          host: host,
+          network: network,
+          mask: mask,
+          interface: interface,
+          comment: comment,
+          gateway: gateway,
+          auto: auto,
+          reject: reject
+        )
+
+        commands = [
+          webhelp_event,
+          { 'ip' => { 'route' => route_params } },
+          save_config_command
+        ]
+
+        response = client.batch(commands)
+        validate_route_response(response)
+        response
+      end
+
+      # Add multiple static routes in a single request.
+      #
+      # == Keenetic API Request
+      #   POST /rci/ (batch format)
+      #   Body: [
+      #     {"webhelp": {"event": {"push": {"data": "..."}}}},
+      #     {"ip": {"route": {...}}},
+      #     {"ip": {"route": {...}}},
+      #     ...
+      #     {"system": {"configuration": {"save": {}}}}
+      #   ]
+      #
+      # @param routes [Array<Hash>] Array of route parameter hashes (same format as #add)
+      # @return [Array<Hash>] API response
+      # @raise [ArgumentError] if routes is empty or any route has invalid parameters
+      #
+      # @example Add multiple routes
+      #   client.routes.add_batch([
+      #     { host: "1.2.3.4", interface: "Wireguard0", comment: "Host 1" },
+      #     { network: "10.0.0.0/24", interface: "Wireguard0", comment: "Network 1" }
+      #   ])
+      #
+      def add_batch(routes)
+        raise ArgumentError, 'Routes array cannot be empty' if routes.nil? || routes.empty?
+
+        commands = [webhelp_event]
+
+        routes.each do |route|
+          route_params = build_route_params(
+            host: route[:host],
+            network: route[:network],
+            mask: route[:mask],
+            interface: route[:interface],
+            comment: route[:comment],
+            gateway: route[:gateway] || '',
+            auto: route.fetch(:auto, true),
+            reject: route.fetch(:reject, false)
+          )
+          commands << { 'ip' => { 'route' => route_params } }
+        end
+
+        commands << save_config_command
+
+        response = client.batch(commands)
+        validate_batch_response(response, routes.size)
+        response
+      end
+
+      # Delete a single static route.
+      #
+      # == Keenetic API Request
+      #   POST /rci/ (batch format)
+      #   Body: [
+      #     {"webhelp": {"event": {"push": {"data": "..."}}}},
+      #     {"ip": {"route": {"no": true, "host|network": "...", "mask": "..."}}},
+      #     {"system": {"configuration": {"save": {}}}}
+      #   ]
+      #
+      # @param host [String, nil] Single host IP (e.g., "1.2.3.4")
+      # @param network [String, nil] Network address (e.g., "10.0.0.0")
+      # @param mask [String, nil] Subnet mask (e.g., "255.255.255.0")
+      # @return [Array<Hash>] API response
+      # @raise [ArgumentError] if neither host nor network is provided
+      #
+      # @example Delete host route
+      #   client.routes.delete(host: "1.2.3.4")
+      #
+      # @example Delete network route with CIDR
+      #   client.routes.delete(network: "10.0.0.0/24")
+      #
+      # @example Delete network route with explicit mask
+      #   client.routes.delete(network: "10.0.0.0", mask: "255.255.255.0")
+      #
+      def delete(host: nil, network: nil, mask: nil)
+        route_params = build_delete_params(host: host, network: network, mask: mask)
+
+        commands = [
+          webhelp_event,
+          { 'ip' => { 'route' => route_params } },
+          save_config_command
+        ]
+
+        client.batch(commands)
+      end
+
+      # Delete multiple static routes in a single request.
+      #
+      # == Keenetic API Request
+      #   POST /rci/ (batch format)
+      #   Body: [
+      #     {"webhelp": {"event": {"push": {"data": "..."}}}},
+      #     {"ip": {"route": {"no": true, ...}}},
+      #     {"ip": {"route": {"no": true, ...}}},
+      #     ...
+      #     {"system": {"configuration": {"save": {}}}}
+      #   ]
+      #
+      # @param routes [Array<Hash>] Array of route identifiers (host or network/mask)
+      # @return [Array<Hash>] API response
+      # @raise [ArgumentError] if routes is empty
+      #
+      # @example Delete multiple routes
+      #   client.routes.delete_batch([
+      #     { host: "1.2.3.4" },
+      #     { network: "10.0.0.0/24" }
+      #   ])
+      #
+      def delete_batch(routes)
+        raise ArgumentError, 'Routes array cannot be empty' if routes.nil? || routes.empty?
+
+        commands = [webhelp_event]
+
+        routes.each do |route|
+          route_params = build_delete_params(
+            host: route[:host],
+            network: route[:network],
+            mask: route[:mask]
+          )
+          commands << { 'ip' => { 'route' => route_params } }
+        end
+
+        commands << save_config_command
+
+        client.batch(commands)
+      end
+
+      # Convert CIDR notation to subnet mask.
+      #
+      # @param cidr [Integer, String] CIDR prefix length (8-32)
+      # @return [String] Subnet mask in dotted notation
+      # @raise [ArgumentError] if CIDR is invalid
+      #
+      # @example
+      #   Keenetic::Resources::Routes.cidr_to_mask(24)
+      #   # => "255.255.255.0"
+      #
+      def self.cidr_to_mask(cidr)
+        prefix = cidr.to_i
+        raise ArgumentError, "Invalid CIDR prefix: #{cidr}" unless CIDR_TO_MASK.key?(prefix)
+
+        CIDR_TO_MASK[prefix]
+      end
+
+      private
+
+      def extract_routes_from_response(response)
+        return [] unless response.is_a?(Array) && response.first.is_a?(Hash)
+
+        response.dig(0, 'show', 'sc', 'ip', 'route') || []
+      end
+
+      def normalize_routes(routes_data)
+        return [] unless routes_data.is_a?(Array)
+
+        routes_data.map { |route| normalize_route(route) }.compact
+      end
+
+      def normalize_route(data)
+        return nil unless data.is_a?(Hash)
+
+        {
+          network: data['network'],
+          mask: data['mask'],
+          host: data['host'],
+          interface: data['interface'],
+          gateway: data['gateway'],
+          comment: data['comment'],
+          auto: normalize_boolean(data['auto']),
+          reject: normalize_boolean(data['reject'])
+        }
+      end
+
+      def build_route_params(host:, network:, mask:, interface:, comment:, gateway:, auto:, reject:)
+        raise ArgumentError, 'Interface is required' if interface.nil? || interface.to_s.strip.empty?
+        raise ArgumentError, 'Comment is required' if comment.nil? || comment.to_s.strip.empty?
+
+        params = {}
+
+        if host && !host.to_s.strip.empty?
+          parsed = parse_cidr(host)
+          if parsed[:cidr] == 32 || parsed[:cidr].nil?
+            params['host'] = parsed[:address]
+          else
+            # If CIDR is not /32, treat as network
+            params['network'] = parsed[:address]
+            params['mask'] = self.class.cidr_to_mask(parsed[:cidr])
+          end
+        elsif network && !network.to_s.strip.empty?
+          parsed = parse_cidr(network)
+          params['network'] = parsed[:address]
+          params['mask'] = parsed[:cidr] ? self.class.cidr_to_mask(parsed[:cidr]) : mask
+          raise ArgumentError, 'Mask is required for network routes without CIDR notation' if params['mask'].nil?
+        else
+          raise ArgumentError, 'Either host or network must be provided'
+        end
+
+        params['interface'] = interface
+        params['comment'] = comment
+        params['gateway'] = gateway.to_s
+        params['auto'] = auto
+        params['reject'] = reject
+
+        params
+      end
+
+      def build_delete_params(host:, network:, mask:)
+        params = { 'no' => true }
+
+        if host && !host.to_s.strip.empty?
+          parsed = parse_cidr(host)
+          if parsed[:cidr] == 32 || parsed[:cidr].nil?
+            params['host'] = parsed[:address]
+          else
+            params['network'] = parsed[:address]
+            params['mask'] = self.class.cidr_to_mask(parsed[:cidr])
+          end
+        elsif network && !network.to_s.strip.empty?
+          parsed = parse_cidr(network)
+          params['network'] = parsed[:address]
+          params['mask'] = parsed[:cidr] ? self.class.cidr_to_mask(parsed[:cidr]) : mask
+          raise ArgumentError, 'Mask is required for network routes without CIDR notation' if params['mask'].nil?
+        else
+          raise ArgumentError, 'Either host or network must be provided'
+        end
+
+        params
+      end
+
+      def parse_cidr(address)
+        return { address: address, cidr: nil } unless address.to_s.include?('/')
+
+        parts = address.to_s.split('/')
+        { address: parts[0], cidr: parts[1].to_i }
+      end
+
+      def webhelp_event
+        {
+          'webhelp' => {
+            'event' => {
+              'push' => {
+                'data' => '{"type":"configuration_change","value":{"url":"/staticRoutes"}}'
+              }
+            }
+          }
+        }
+      end
+
+      def save_config_command
+        { 'system' => { 'configuration' => { 'save' => {} } } }
+      end
+
+      def validate_route_response(response)
+        return unless response.is_a?(Array)
+
+        # Response index 1 is the route command response
+        route_response = response[1]
+        return unless route_response.is_a?(Hash)
+
+        status = route_response.dig('ip', 'route', 'status')
+        return unless status.is_a?(Array) && status.first.is_a?(Hash)
+
+        if status.first['status'] == 'error'
+          error_msg = status.first['message'] || 'Unknown error'
+          raise ApiError.new("Failed to add route: #{error_msg}")
+        end
+      end
+
+      def validate_batch_response(response, routes_count)
+        return unless response.is_a?(Array)
+
+        # Route responses start at index 1 (after webhelp event)
+        (1..routes_count).each do |i|
+          route_response = response[i]
+          next unless route_response.is_a?(Hash)
+
+          status = route_response.dig('ip', 'route', 'status')
+          next unless status.is_a?(Array) && status.first.is_a?(Hash)
+
+          if status.first['status'] == 'error'
+            error_msg = status.first['message'] || 'Unknown error'
+            raise ApiError.new("Failed to add route at index #{i - 1}: #{error_msg}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/keenetic/version.rb

@@ -1,4 +1,3 @@
 module Keenetic
-  VERSION = '0.1.0'.freeze
+  VERSION = '0.2.0'.freeze
 end
-

data/lib/keenetic.rb

@@ -13,6 +13,9 @@ require_relative 'keenetic/resources/policies'
 require_relative 'keenetic/resources/dhcp'
 require_relative 'keenetic/resources/routing'
 require_relative 'keenetic/resources/logs'
+require_relative 'keenetic/resources/routes'
+require_relative 'keenetic/resources/hotspot'
+require_relative 'keenetic/resources/config'
 
 # Keenetic Router API Client
 #
@@ -57,6 +60,23 @@ require_relative 'keenetic/resources/logs'
 #   # Ports
 #   client.ports.all           # Physical port statuses
 #
+#   # Static Routes
+#   client.routes.all          # All static routes
+#   client.routes.add(...)     # Add static route
+#   client.routes.delete(...)  # Delete static route
+#
+#   # Hotspot / Policies
+#   client.hotspot.policies    # All IP policies
+#   client.hotspot.hosts       # All hosts with policies
+#   client.hotspot.set_host_policy(mac: '...', policy: '...')
+#
+#   # Configuration
+#   client.system_config.save         # Save configuration
+#   client.system_config.download     # Download startup config
+#
+#   # Raw RCI Access
+#   client.rci({ ... })        # Execute arbitrary RCI commands
+#
 # == Error Handling
 #
 #   begin

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification
 name: keenetic
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
-- Anton
+- Anton Zaytsev
 autorequire:
 bindir: bin
 cert_chain: []
@@ -45,24 +45,28 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- LICENSE.txt
 - README.md
 - lib/keenetic.rb
 - lib/keenetic/client.rb
 - lib/keenetic/configuration.rb
 - lib/keenetic/errors.rb
 - lib/keenetic/resources/base.rb
+- lib/keenetic/resources/config.rb
 - lib/keenetic/resources/devices.rb
 - lib/keenetic/resources/dhcp.rb
+- lib/keenetic/resources/hotspot.rb
 - lib/keenetic/resources/internet.rb
 - lib/keenetic/resources/logs.rb
 - lib/keenetic/resources/network.rb
 - lib/keenetic/resources/policies.rb
 - lib/keenetic/resources/ports.rb
+- lib/keenetic/resources/routes.rb
 - lib/keenetic/resources/routing.rb
 - lib/keenetic/resources/system.rb
 - lib/keenetic/resources/wifi.rb
 - lib/keenetic/version.rb
-homepage: https://github.com/example/keenetic
+homepage: https://github.com/antonzaytsev/keenetic-ruby
 licenses:
 - MIT
 metadata: