rshelly 0.1.0

data/lib/rshelly/client.rb

@@ -0,0 +1,400 @@
+# frozen_string_literal: true
+
+require "json"
+require "ipaddr"
+require "net/http"
+require "openssl"
+require "uri"
+
+module Shelly
+  class Client
+    GEN1_MODELS = {
+      "SHPLG-S" => "PlugS",
+      "SHHT-1" => "H&T",
+      "SHSW-1" => "Shelly1",
+      "SHRGBW2" => "RGBW2"
+    }.freeze
+
+    attr_reader :host, :port, :timeout, :scheme
+
+    def initialize(host, port: nil, timeout: 5, scheme: "http", generation: nil)
+      uri = normalize_uri(host, port, scheme)
+      @scheme = uri.scheme
+      @host = uri.host
+      @port = uri.port
+      @timeout = timeout
+      @generation = normalize_generation(generation)
+      @shelly_info = nil
+    end
+
+    def base_url
+      default_port = scheme == "https" ? 443 : 80
+      port_part = port == default_port ? "" : ":#{port}"
+      "#{scheme}://#{host}#{port_part}"
+    end
+
+    def gen
+      @generation ||= (shelly_info["gen"] || 1).to_i
+    end
+
+    def gen1?
+      gen == 1
+    end
+
+    def gen2?
+      gen >= 2
+    end
+
+    def shelly_info
+      @shelly_info ||= get_json("/shelly")
+    end
+
+    def status
+      gen1? ? get_json("/status") : rpc("Shelly.GetStatus")
+    end
+
+    def config
+      gen1? ? get_json("/settings") : rpc("Shelly.GetConfig")
+    end
+
+    def settings
+      get_json("/settings")
+    end
+
+    def get(path, params = {})
+      request(:get, path, params: params)
+    end
+
+    def post(path, body = nil, params: {}, headers: {})
+      request(:post, path, params: params, body: body, headers: headers)
+    end
+
+    def get_json(path, params = {})
+      parse_json(get(path, params))
+    end
+
+    def rpc(method, params = nil, **keyword_params)
+      params = keyword_params unless keyword_params.empty?
+      payload = { id: 1, method: method }
+      payload[:params] = params unless params.nil?
+
+      response = parse_json(post("/rpc", JSON.generate(payload), headers: { "Content-Type" => "application/json" }))
+      raise RpcError, response["error"]["message"] if response.is_a?(Hash) && response["error"]
+
+      result = response.fetch("result", response)
+      result.nil? ? {} : result
+    end
+
+    def switch_status(id = 0)
+      gen1? ? get_json("/relay/#{id}") : rpc("Switch.GetStatus", { id: id })
+    end
+
+    def switch_set(id: 0, on:)
+      if gen1?
+        get_json("/relay/#{id}", turn: on ? "on" : "off")
+      else
+        rpc("Switch.Set", { id: id, on: !!on })
+      end
+    end
+
+    def switch_toggle(id = 0)
+      if gen1?
+        get_json("/relay/#{id}", turn: "toggle")
+      else
+        rpc("Switch.Toggle", { id: id })
+      end
+    end
+
+    def meter_status(id = 0)
+      if gen1?
+        get_json("/meter/#{id}")
+      else
+        rpc("Switch.GetStatus", { id: id })
+      end
+    end
+
+    def temperature_status(id: 100)
+      if gen1?
+        status.fetch("ext_temperature", {})
+      else
+        rpc("Temperature.GetStatus", { id: id })
+      end
+    end
+
+    def rgbw_status(id = 0)
+      ensure_gen2!("RGBW")
+      rpc("RGBW.GetStatus", { id: id })
+    end
+
+    def light_status(id = 0)
+      ensure_gen2!("Light")
+      rpc("Light.GetStatus", { id: id })
+    end
+
+    def light_set(id: 0, on: nil, brightness: nil, transition_duration: nil)
+      ensure_gen2!("Light")
+      params = compact_hash(
+        id: id,
+        on: on.nil? ? nil : !!on,
+        brightness: brightness,
+        transition_duration: transition_duration
+      )
+      rpc("Light.Set", params)
+    end
+
+    def rgbw_set(id: 0, on: nil, brightness: nil, white: nil, red: nil, green: nil, blue: nil, transition_duration: nil)
+      ensure_gen2!("RGBW")
+      params = compact_hash(
+        id: id,
+        on: on.nil? ? nil : !!on,
+        brightness: brightness,
+        white: white,
+        red: red,
+        green: green,
+        blue: blue,
+        transition_duration: transition_duration
+      )
+      rpc("RGBW.Set", params)
+    end
+
+    def input_set_config(id:, type:, name: nil, enable: nil)
+      ensure_gen2!("input configuration")
+      config = compact_hash(type: type, name: name, enable: enable)
+      rpc("Input.SetConfig", { id: id, config: config })
+    end
+
+    def webhook_delete_all
+      ensure_gen2!("webhooks")
+      rpc("Webhook.DeleteAll")
+    end
+
+    def webhook_create(cid:, event:, urls:, name: event, enable: true)
+      ensure_gen2!("webhooks")
+      rpc("Webhook.Create", {
+        cid: cid,
+        enable: enable,
+        name: name,
+        event: event,
+        urls: Array(urls)
+      })
+    end
+
+    def set_device_name(name)
+      if gen1?
+        get_json("/settings", name: name)
+      else
+        rpc("Sys.SetConfig", { config: { device: { name: name } } })
+      end
+    end
+
+    def enable_mqtt(server:, enable: true)
+      if gen1?
+        get_json("/settings", mqtt_enable: enable, mqtt_server: server)
+      else
+        rpc("MQTT.SetConfig", { config: { enable: enable, server: server } })
+      end
+    end
+
+    def set_wifi(slot:, ssid:, password:, ip: nil, netmask: nil, gw: nil, dns: nil, enable: true)
+      slot = normalize_wifi_slot(slot)
+      ip_config = build_wifi_ip_config(ip: ip, netmask: netmask, gw: gw, dns: dns)
+
+      if gen1?
+        params = {
+          enabled: enable ? 1 : 0,
+          ssid: ssid,
+          key: password,
+          ipv4_method: ip ? "static" : "dhcp"
+        }.merge(ip_config[:gen1])
+        get_json(slot == :primary ? "/settings/sta" : "/settings/sta1", params)
+      else
+        sta_key = slot == :primary ? :sta : :sta1
+        sta_config = {
+          ssid: ssid,
+          pass: password,
+          enable: enable,
+          ipv4mode: ip ? "static" : "dhcp"
+        }.merge(ip_config[:gen2])
+        rpc("WiFi.SetConfig", { config: { sta_key => sta_config } })
+      end
+    end
+
+    def update_info
+      if gen1?
+        ota = get_json("/ota")
+        current = shelly_info["fw"] || shelly_info.dig("build_info", "build_id")
+        new_version = ota["new_version"]
+        new_version = nil if new_version == current
+        {
+          "current_version" => current,
+          "has_update" => !!ota["has_update"],
+          "new_version" => new_version
+        }
+      else
+        st = status
+        stable = st.dig("sys", "available_updates", "stable")
+        {
+          "current_version" => shelly_info["fw_id"] || shelly_info["ver"],
+          "has_update" => !stable.nil?,
+          "new_version" => stable && stable["version"]
+        }
+      end
+    end
+
+    def update_start(stage: "stable")
+      if gen1?
+        get_json("/ota", update: true)
+      else
+        rpc("Shelly.Update", { stage: stage })
+      end
+    end
+
+    def reboot
+      if gen1?
+        response = get("/reboot").to_s.strip
+        response = JSON.parse(response) if response.start_with?('"')
+        response.empty? ? { "reboot" => true } : { "reboot" => true, "response" => response }
+      else
+        rpc("Shelly.Reboot")
+        { "reboot" => true }
+      end
+    rescue JSON::ParserError
+      { "reboot" => true, "response" => response }
+    end
+
+    def normalized_info
+      info = shelly_info
+      cfg = config rescue {}
+      st = status rescue {}
+      update = update_info rescue {}
+      merged = deep_merge(info, cfg, st)
+      device = merged["device"] || merged.dig("sys", "device") || {}
+
+      {
+        "ip" => host,
+        "gen" => gen,
+        "model_id" => info["type"] || info["model"] || merged["model"],
+        "model" => merged["app"] || GEN1_MODELS[info["type"]],
+        "mac" => device["mac"] || merged["mac"],
+        "name" => merged["name"] || device["name"] || device["hostname"],
+        "hostname" => device["hostname"] || merged["hostname"],
+        "firmware" => info["fw"] || info["fw_id"] || info["ver"] || device["fw_id"] || merged.dig("build_info", "build_id"),
+        "update" => update,
+        "raw" => merged
+      }
+    end
+
+    private
+
+    def normalize_uri(host, port, scheme)
+      raw = host.to_s
+      raw = "#{scheme}://#{raw}" unless raw.match?(%r{\Ahttps?://})
+      uri = URI(raw)
+      uri.port = port if port
+      uri
+    end
+
+    def request(method, path, params: {}, body: nil, headers: {})
+      uri = URI.join(base_url, path)
+      unless params.empty?
+        existing = URI.decode_www_form(uri.query.to_s)
+        uri.query = URI.encode_www_form(existing + params.map { |key, value| [key.to_s, value.to_s] })
+      end
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+      http.open_timeout = timeout
+      http.read_timeout = timeout
+      http.write_timeout = timeout
+
+      klass = method == :post ? Net::HTTP::Post : Net::HTTP::Get
+      req = klass.new(uri)
+      headers.each { |key, value| req[key] = value }
+      req.body = body if body
+
+      response = http.request(req)
+      return response.body if response.is_a?(Net::HTTPSuccess)
+
+      raise HttpError, "#{method.to_s.upcase} #{uri} failed with #{response.code}: #{response.body}"
+    rescue Timeout::Error, SystemCallError, SocketError, EOFError, IOError, Net::HTTPError, OpenSSL::SSL::SSLError => e
+      raise HttpError, "#{method.to_s.upcase} #{uri} failed: #{e.class}: #{e.message}"
+    end
+
+    def parse_json(body)
+      stripped = body.to_s.strip
+      return {} if stripped.empty? || stripped == "null"
+
+      JSON.parse(stripped)
+    rescue JSON::ParserError => e
+      raise HttpError, "invalid JSON response: #{e.message}: #{stripped.inspect}"
+    end
+
+    def normalize_generation(generation)
+      return nil if generation.nil?
+
+      value = Integer(generation)
+      raise ArgumentError unless value.positive?
+
+      value
+    rescue ArgumentError, TypeError
+      raise ArgumentError, "generation must be a positive integer"
+    end
+
+    def ensure_gen2!(feature)
+      raise UnsupportedDeviceError, "#{feature} requires a Gen2+ device" unless gen2?
+    end
+
+    def normalize_wifi_slot(slot)
+      case slot.to_s.downcase
+      when "primary", "wifi1", "sta", "0", "1" then :primary
+      when "secondary", "wifi2", "sta1", "2" then :secondary
+      else
+        raise ArgumentError, "wifi slot must be primary or secondary"
+      end
+    end
+
+    def build_wifi_ip_config(ip:, netmask:, gw:, dns:)
+      return { gen1: {}, gen2: {} } unless ip
+
+      ipaddr = IPAddr.new(ip)
+      raise ArgumentError, "static IP must be an IPv4 address" unless ipaddr.ipv4?
+
+      netmask ||= "255.255.255.0"
+      gw ||= derived_gateway(ipaddr)
+      dns ||= gw
+
+      {
+        gen1: { ip: ip, netmask: netmask, gateway: gw, dns: dns },
+        gen2: { ip: ip, netmask: netmask, gw: gw, nameserver: dns }
+      }
+    rescue ArgumentError => e
+      raise ArgumentError, "invalid wifi static IP configuration: #{e.message}"
+    end
+
+    def derived_gateway(ipaddr)
+      octets = ipaddr.to_s.split(".")
+      octets[-1] = "1"
+      octets.join(".")
+    end
+
+    def compact_hash(hash)
+      hash.reject { |_, value| value.nil? }
+    end
+
+    def deep_merge(*hashes)
+      hashes.reduce({}) do |memo, hash|
+        deep_merge_pair(memo, hash || {})
+      end
+    end
+
+    def deep_merge_pair(left, right)
+      left.merge(right) do |_, old_value, new_value|
+        if old_value.is_a?(Hash) && new_value.is_a?(Hash)
+          deep_merge_pair(old_value, new_value)
+        else
+          new_value
+        end
+      end
+    end
+  end
+end