meshtastic 0.0.178 → 0.0.180

data/lib/meshtastic.rb

@@ -12,11 +12,13 @@ module Meshtastic
   require 'meshtastic/clientonly_pb'
   require 'meshtastic/config_pb'
   require 'meshtastic/connection_status_pb'
+  require 'meshtastic/deviceonly_legacy_pb'
   require 'meshtastic/deviceonly_pb'
   require 'meshtastic/device_ui_pb'
   require 'meshtastic/interdevice_pb'
   require 'meshtastic/localonly_pb'
   require 'meshtastic/lorawan_bridge_pb'
+  require 'meshtastic/mesh_beacon_pb'
   require 'meshtastic/mesh_pb'
   require 'meshtastic/module_config_pb'
   require 'meshtastic/mqtt_pb'
@@ -25,6 +27,7 @@ module Meshtastic
   require 'meshtastic/powermon_pb'
   require 'meshtastic/remote_hardware_pb'
   require 'meshtastic/rtttl_pb'
+  require 'meshtastic/serial_hal_pb'
   require 'meshtastic/storeforward_pb'
   require 'meshtastic/telemetry_pb'
   require 'meshtastic/version'
@@ -38,23 +41,20 @@ module Meshtastic
   autoload :ATAK, 'meshtastic/atak'
   autoload :Bluetooth, 'meshtastic/bluetooth'
   autoload :Cannedmessages, 'meshtastic/cannedmessages'
-  autoload :Channel, 'meshtastic/channel'
   autoload :Clientonly, 'meshtastic/clientonly'
-  autoload :Config, 'meshtastic/config'
   autoload :ConnectionStatus, 'meshtastic/connection_status'
   autoload :Deviceonly, 'meshtastic/deviceonly'
   autoload :Localonly, 'meshtastic/localonly'
   autoload :MeshInterface, 'meshtastic/mesh_interface'
-  autoload :ModuleConfig, 'meshtastic/module_config'
   autoload :MQTT, 'meshtastic/mqtt'
-  autoload :Paxcount, 'meshtastic/paxcount'
   autoload :Portnums, 'meshtastic/portnums'
   autoload :RemoteHardware, 'meshtastic/remote_hardware'
   autoload :RTTTL, 'meshtastic/rtttl'
   autoload :Serial, 'meshtastic/serial'
   autoload :Storeforward, 'meshtastic/storeforward'
   autoload :StreamInterface, 'meshtastic/stream_interface'
-  autoload :Telemetry, 'meshtastic/telemetry'
+  autoload :TCP, 'meshtastic/tcp'
+  autoload :Traceroute, 'meshtastic/traceroute'
   autoload :Util, 'meshtastic/util'
   autoload :Xmodem, 'meshtastic/xmodem'
 
@@ -67,7 +67,47 @@ module Meshtastic
 
   # Display a List of Every Meshtastic Module
 
+  public_class_method def self.authors
+    "AUTHOR(S):\n      0day Inc. <support@0dayinc.com>\n    "
+  end
+
   public_class_method def self.help
-    constants.sort
+    puts "        USAGE:
+        # Run the deliver_data class method for this module.
+        #{self}.deliver_data(
+          data: 'optional - value for data passed into deliver_data',
+          serial_obj: 'optional - value for serial_obj passed into deliver_data',
+          bluetooth_obj: 'optional - value for bluetooth_obj passed into deliver_data',
+          tcp_obj: 'optional - value for tcp_obj passed into deliver_data',
+          mqtt_obj: 'optional - value for mqtt_obj passed into deliver_data'
+        )
+
+        # Run the authors class method for this module.
+        #{self}.authors
+
+    "
+  end
+
+  public_class_method def self.deliver_data(opts = {})
+    raise ArgumentError, 'data is required' unless opts[:data].is_a?(Meshtastic::Data)
+
+    if opts[:serial_obj]
+      Serial.send_data(opts)
+    elsif opts[:bluetooth_obj]
+      Bluetooth.send_data(opts)
+    elsif opts[:tcp_obj]
+      TCP.send_data(opts)
+    elsif opts[:mqtt_obj]
+      MQTT.send_data(opts)
+    else
+      raise ArgumentError, 'serial_obj, bluetooth_obj, tcp_obj, or mqtt_obj is required'
+    end
   end
 end
+
+require 'meshtastic/channel'
+require 'meshtastic/config'
+require 'meshtastic/module_config'
+require 'meshtastic/paxcount'
+require 'meshtastic/position'
+require 'meshtastic/telemetry'

data/spec/conventions_spec.rb

@@ -0,0 +1,321 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+# Global source-level conventions for every Ruby module under lib/meshtastic
+# (same rules as /opt/pwn/spec/conventions_spec.rb).
+#
+# RULES
+#   0. Every method on a Meshtastic namespace *module* MUST be referenced via
+#      `self.<method_name>` with public_class_method / private_class_method.
+#      Bare `def foo` at module scope fails. So does `module_function`.
+#      Nested `class` instance methods and class_eval / `class <<` are exempt.
+#   1. Module methods MUST be declared with an explicit visibility decorator
+#      immediately preceding `def self.<name>` on the same line.
+#   2. Methods that accept arguments MUST take exactly `(opts = {})`.
+#   3. Methods declared `(opts = {})` MUST consume opts in the body.
+#   4. Every leaf module file MUST define `def self.help`.
+#   5. Every leaf module file MUST define `def self.authors`.
+#   6. Every public class method except `help` MUST appear in that module's
+#      `help` method — including `authors`. Directly above each method, `help`
+#      MUST print a brief purpose line. Methods that take `(opts = {})` MUST
+#      document each `opts[:key]` they read as `required` or `optional` plus an
+#      operator-usable description — same shape as PWN::WWW::Google.help.
+
+module MeshtasticConventions
+  ROOT = File.expand_path('..', __dir__)
+  LIB  = File.join(ROOT, 'lib', 'meshtastic')
+
+  GLOBAL_ALLOWLIST = [
+    'lib/meshtastic/version.rb' # VERSION constant only
+  ].freeze
+
+  NAMESPACE_INDEX_FILES = [].freeze
+
+  RB_FILES = (
+    Dir[File.join(LIB, '**', '*.rb')] + [File.join(ROOT, 'lib', 'meshtastic.rb')]
+  ).reject do |f|
+    rel = f.sub("#{ROOT}/", '')
+    GLOBAL_ALLOWLIST.include?(rel) || rel.end_with?('_pb.rb')
+  end.sort.freeze
+
+  MODULE_FILES = RB_FILES.select { |f| File.read(f).match?(/^\s*module\s+\w/) }.freeze
+
+  SELF_DEF_RE = /^([ \t]*)((?:public_class_method|private_class_method)\s+)?def self\.([a-z_][\w?!]*)(?:\(([^)]*)\))?/
+
+  BARE_DEF_RE = /^[ \t]*def ([a-z_][\w?!]*)(?:\(([^)]*)\))?/
+
+  MODULE_FUNCTION_RE = /^\s*module_function\b/
+
+  CLASS_LIKE_OPEN_RE = /
+    \Aclass\b
+    | \.class_eval\b
+    | \.module_eval\b
+    | \Aclass_eval\b
+    | \Amodule_eval\b
+    | \Aclass\s*<<
+    | \bClass\.new\b
+    | \bStruct\.new\b
+    | \bModule\.new\b
+    | \bData\.define\b
+  /x
+
+  MODULE_OPEN_RE = /\Amodule\s+[A-Z]/
+
+  module_function
+
+  def line_indent(line)
+    line[/^[ \t]*/].to_s.length
+  end
+
+  def scan_methods(path)
+    src   = File.read(path)
+    lines = src.lines
+    out   = []
+    lines.each_with_index do |line, idx|
+      m = line.match(SELF_DEF_RE)
+      next unless m
+
+      out << {
+        file: path,
+        line: idx + 1,
+        decorator: m[2]&.strip,
+        name: m[3],
+        arglist: m[4],
+        body_excerpt: lines[(idx + 1)..(idx + 60)]&.join.to_s,
+        method_body: method_body_excerpt(lines, idx)
+      }
+    end
+    out
+  end
+
+  def method_body_excerpt(lines, idx)
+    indent = lines[idx][/^[ \t]*/]
+    buf = []
+    ((idx + 1)...lines.length).each do |i|
+      break if lines[i].match?(/^#{Regexp.escape(indent)}end\b/)
+
+      buf << lines[i]
+      break if buf.length >= 120
+    end
+    buf.join
+  end
+
+  def scan_bare_defs(path)
+    stack = []
+    out   = []
+    File.readlines(path).each_with_index do |line, idx|
+      stripped = line.strip
+      next if stripped.empty? || stripped.start_with?('#')
+
+      indent = line_indent(line)
+
+      if stripped == 'end' || stripped.match?(/\Aend\b/)
+        stack.pop while stack.any? && stack.last[:indent] >= indent
+        next
+      end
+
+      if stripped.match?(MODULE_OPEN_RE) && !stripped.match?(/\bend\b/)
+        stack.pop while stack.any? && stack.last[:indent] >= indent
+        stack << { type: :module, indent: indent }
+        next
+      end
+
+      if stripped.match?(CLASS_LIKE_OPEN_RE) && !stripped.match?(/\bend\b/)
+        stack.pop while stack.any? && stack.last[:indent] >= indent
+        stack << { type: :class, indent: indent }
+        next
+      end
+
+      next if line.match?(SELF_DEF_RE)
+
+      m = line.match(BARE_DEF_RE)
+      next unless m
+
+      container = stack.rfind { |frame| frame[:indent] < indent }
+      next if container.nil?
+      next if container[:type] == :class
+
+      out << {
+        file: path,
+        line: idx + 1,
+        name: m[1],
+        arglist: m[2]
+      }
+    end
+    out
+  end
+
+  def scan_module_function(path)
+    out = []
+    File.readlines(path).each_with_index do |line, idx|
+      next if line.match?(/^\s*#/)
+      next unless line.match?(MODULE_FUNCTION_RE)
+
+      out << { file: path, line: idx + 1 }
+    end
+    out
+  end
+
+  ALL_METHODS = MODULE_FILES.flat_map { |f| scan_methods(f) }.freeze
+  ALL_BARE_DEFS = MODULE_FILES.flat_map { |f| scan_bare_defs(f) }.freeze
+  ALL_MODULE_FUNCTIONS = MODULE_FILES.flat_map { |f| scan_module_function(f) }.freeze
+
+  HELP_SKIP = %w[help].freeze
+
+  def help_text(path)
+    lines = File.readlines(path)
+    idx = lines.find_index { |l| l.match?(/def self\.help\b/) }
+    return '' unless idx
+
+    indent = lines[idx][/^[ \t]*/]
+    buf = []
+    ((idx + 1)...lines.length).each do |i|
+      break if lines[i].match?(/^#{Regexp.escape(indent)}end\b/)
+
+      buf << lines[i]
+    end
+    buf.join
+  end
+
+  def opts_keys(body)
+    body.to_s.scan(/opts\[\s*:([A-Za-z_]\w*)\s*\]/).flatten.uniq
+  end
+
+  def thin_option_desc?(key, desc)
+    rest = desc.to_s.strip.sub(/\A(?:required|optional)\s*-\s*/i, '')
+    return true if rest.empty?
+
+    norm = rest.downcase.gsub(/[^a-z0-9]+/, ' ').strip
+    key_norm = key.to_s.downcase.tr('_', ' ')
+    return true if norm == key_norm
+
+    words = rest.split
+    words.length < 2 && rest.length < 18
+  end
+
+  def purpose_above?(help, name)
+    lines = help.to_s.lines
+    idx = lines.find_index { |l| l.match?(/\#\{self\}(?:::[A-Z]\w*)*\.#{Regexp.escape(name)}(?!\w)/) }
+    return false unless idx
+
+    prev = nil
+    (idx - 1).downto(0) do |i|
+      next if lines[i].strip.empty?
+
+      prev = lines[i]
+      break
+    end
+    return false unless prev
+
+    text = prev.strip.sub(/\A#\s*/, '')
+    return false if text.match?(/\AUSAGE:/i)
+    return false if text.match?(/\.\w+\s*\(/) || text.match?(/\#\{self\}/)
+    return false if text.match?(/\A\w+\s*=\s*(?:PWN|Meshtastic)::/)
+    return false if text.downcase.gsub(/[^a-z0-9]+/, ' ').strip == name.downcase.tr('_', ' ')
+
+    words = text.split
+    words.length >= 3 || text.length >= 20
+  end
+
+  def rel(path)
+    path.sub("#{ROOT}/", '')
+  end
+end
+
+describe 'Meshtastic module conventions' do
+  c = MeshtasticConventions
+
+  it '0) every Meshtastic module method is referenced via `self.<method_name>` (no bare module-level `def`, no module_function)' do
+    bare = c::ALL_BARE_DEFS
+    mfun = c::ALL_MODULE_FUNCTIONS
+    parts = []
+    unless bare.empty?
+      parts << 'bare module-level `def <name>` (use `public_class_method def self.<name>` / `private_class_method def self.<name>`):'
+      parts.concat(bare.map { |m| "  #{c.rel(m[:file])}:#{m[:line]}  def #{m[:name]}" })
+    end
+    unless mfun.empty?
+      parts << '`module_function` is forbidden (declare each method with def self.<name>):'
+      parts.concat(mfun.map { |m| "  #{c.rel(m[:file])}:#{m[:line]}  module_function" })
+    end
+    msg = parts.join("\n")
+    expect(bare + mfun).to be_empty, msg
+  end
+
+  it '1) every `def self.<name>` is decorated with public_class_method or private_class_method' do
+    bare = c::ALL_METHODS.select { |m| m[:decorator].nil? }
+    msg  = bare.map { |m| "  #{c.rel(m[:file])}:#{m[:line]}  def self.#{m[:name]}" }.join("\n")
+    expect(bare).to be_empty, "bare `def self.*` (add public_class_method / private_class_method):\n#{msg}"
+  end
+
+  it '2) every argument-accepting module method takes exactly `(opts = {})`' do
+    bad = c::ALL_METHODS.reject do |m|
+      a = m[:arglist]
+      a.nil? || a.strip.empty? || a.strip == 'opts = {}'
+    end
+    msg = bad.map { |m| "  #{c.rel(m[:file])}:#{m[:line]}  def self.#{m[:name]}(#{m[:arglist]})" }.join("\n")
+    expect(bad).to be_empty, "non-conforming arglists (use `(opts = {})`):\n#{msg}"
+  end
+
+  it '3) methods declared `(opts = {})` actually consume opts in the body' do
+    unused = c::ALL_METHODS.select do |m|
+      m[:arglist]&.strip == 'opts = {}' &&
+        !m[:body_excerpt].match?(/\bopts\s*\[|\bopts\.(?:dig|fetch|key\?|keys|values|merge|each|delete|map|\[)/)
+    end
+    msg = unused.map { |m| "  #{c.rel(m[:file])}:#{m[:line]}  def self.#{m[:name]}(opts = {})  # opts never read" }.join("\n")
+    expect(unused).to be_empty, "declared `(opts = {})` but never read opts (unpack at top of method):\n#{msg}"
+  end
+
+  it '4) every module file defines `def self.help`' do
+    missing = c::MODULE_FILES.reject do |f|
+      c::NAMESPACE_INDEX_FILES.include?(c.rel(f)) || File.read(f).match?(/def self\.help\b/)
+    end
+    msg = missing.map { |f| "  #{c.rel(f)}" }.join("\n")
+    expect(missing).to be_empty, "modules missing `def self.help`:\n#{msg}"
+  end
+
+  it '5) every module file defines `def self.authors`' do
+    missing = c::MODULE_FILES.reject do |f|
+      c::NAMESPACE_INDEX_FILES.include?(c.rel(f)) || File.read(f).match?(/def self\.authors\b/)
+    end
+    msg = missing.map { |f| "  #{c.rel(f)}" }.join("\n")
+    expect(missing).to be_empty, "modules missing `def self.authors`:\n#{msg}"
+  end
+
+  it '6) every public class method is documented in help with required/optional options (Google.help shape)' do
+    misses = []
+    c::MODULE_FILES.each do |path|
+      next if c::NAMESPACE_INDEX_FILES.include?(c.rel(path))
+
+      help = c.help_text(path)
+      misses << "#{c.rel(path)}  missing method authors in help" unless help.match?(/\.authors(?!\w)/)
+      pubs = c::ALL_METHODS.select do |m|
+        m[:file] == path &&
+          m[:decorator] == 'public_class_method' &&
+          !c::HELP_SKIP.include?(m[:name])
+      end
+      pubs.each do |meth|
+        name = meth[:name]
+        unless help.match?(/\.#{Regexp.escape(name)}(?!\w)/)
+          misses << "#{c.rel(path)}  missing method #{name} in help"
+          next
+        end
+        misses << "#{c.rel(path)}  #{name}: missing purpose line above the method in help" unless c.purpose_above?(help, name)
+        next unless meth[:arglist]&.strip == 'opts = {}'
+
+        c.opts_keys(meth[:method_body]).each do |key|
+          descs = help.scan(/#{Regexp.escape(key)}:\s*['"]((?:required|optional)\s*-\s*[^'"]+)/i).flatten
+          if descs.empty?
+            misses << "#{c.rel(path)}  #{name} option #{key}: missing required/optional description"
+            next
+          end
+          next unless descs.any? { |d| c.thin_option_desc?(key, d) }
+
+          misses << "#{c.rel(path)}  #{name} option #{key}: description too thin (say what to pass, not just the key name)"
+        end
+      end
+    end
+    extra = misses.length > 80 ? "\n... #{misses.length} total" : ''
+    expect(misses).to be_empty, "#{misses.first(80).join("\n")}#{extra}"
+  end
+end

data/spec/lib/meshtastic/admin/channel_spec.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Meshtastic::Admin::Channel do
+  def fake_serial_obj
+    written = +''.b
+    serial_conn = Object.new
+    serial_conn.define_singleton_method(:write) do |b|
+      written << b
+      b.bytesize
+    end
+    serial_conn.define_singleton_method(:flush) { true }
+    serial_conn.define_singleton_method(:closed?) { false }
+    serial_conn.define_singleton_method(:close) { true }
+    { serial_conn: serial_conn, written: written, my_node_num: 0xb0b }
+  end
+
+  def decode_admin(serial_obj)
+    frame = serial_obj[:written]
+    body = frame.byteslice(4, (frame.getbyte(2) << 8) + frame.getbyte(3))
+    Meshtastic::AdminMessage.decode(Meshtastic::ToRadio.decode(body).packet.decoded.payload)
+  end
+
+  it 'requests a channel by index via Admin' do
+    serial_obj = fake_serial_obj
+    described_class.get(serial_obj: serial_obj, index: 1)
+    expect(decode_admin(serial_obj).get_channel_request).to eq(1)
+  end
+
+  it 'sets a Channel protobuf including settings and role' do
+    serial_obj = fake_serial_obj
+    settings = described_class.build_settings(name: 'LongFast', uplink_enabled: true)
+    described_class.set(serial_obj: serial_obj, index: 0, role: :PRIMARY, settings: settings)
+    channel = decode_admin(serial_obj).set_channel
+    expect(channel.index).to eq(0)
+    expect(channel.role).to eq(:PRIMARY)
+    expect(channel.settings.name).to eq('LongFast')
+    expect(channel.settings.uplink_enabled).to be true
+  end
+
+  it 'prints usage without raising' do
+    expect { described_class.help }.to output(/USAGE/).to_stdout
+  end
+end

data/spec/lib/meshtastic/admin/config_spec.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Meshtastic::Admin::Config do
+  def fake_serial_obj
+    written = +''.b
+    serial_conn = Object.new
+    serial_conn.define_singleton_method(:write) do |b|
+      written << b
+      b.bytesize
+    end
+    serial_conn.define_singleton_method(:flush) { true }
+    serial_conn.define_singleton_method(:closed?) { false }
+    serial_conn.define_singleton_method(:close) { true }
+    { serial_conn: serial_conn, written: written, my_node_num: 0xb0b }
+  end
+
+  def decode_admin(serial_obj)
+    frame = serial_obj[:written]
+    body = frame.byteslice(4, (frame.getbyte(2) << 8) + frame.getbyte(3))
+    Meshtastic::AdminMessage.decode(Meshtastic::ToRadio.decode(body).packet.decoded.payload)
+  end
+
+  it 'requests LoRa config via Admin' do
+    serial_obj = fake_serial_obj
+    described_class.get(serial_obj: serial_obj, config_type: :LORA_CONFIG)
+    expect(decode_admin(serial_obj).get_config_request).to eq(:LORA_CONFIG)
+  end
+
+  it 'sets a Config protobuf' do
+    serial_obj = fake_serial_obj
+    config = Meshtastic::Config.new
+    config.device = Meshtastic::Config::DeviceConfig.new(role: :CLIENT)
+    described_class.set(serial_obj: serial_obj, config: config)
+    expect(decode_admin(serial_obj).set_config.device.role).to eq(:CLIENT)
+  end
+
+  it 'requests each ConfigType via named getters' do
+    serial_obj = fake_serial_obj
+    described_class.get_lora(serial_obj: serial_obj)
+    expect(decode_admin(serial_obj).get_config_request).to eq(:LORA_CONFIG)
+  end
+
+  it 'prints usage without raising' do
+    expect { described_class.help }.to output(/USAGE/).to_stdout
+  end
+end

data/spec/lib/meshtastic/admin/firmware_spec.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'tempfile'
+require 'digest'
+
+describe Meshtastic::Admin::Firmware do
+  def fake_serial_obj
+    written = +''.b
+    serial_conn = Object.new
+    serial_conn.define_singleton_method(:write) do |b|
+      written << b
+      b.bytesize
+    end
+    serial_conn.define_singleton_method(:flush) { true }
+    serial_conn.define_singleton_method(:closed?) { false }
+    serial_conn.define_singleton_method(:close) { true }
+    { serial_conn: serial_conn, written: written, my_node_num: 0xb0b }
+  end
+
+  def decode_frames(serial_obj)
+    buf = serial_obj[:written].dup
+    frames = []
+    until buf.bytesize < 4
+      break unless buf.getbyte(0) == Meshtastic::START1 && buf.getbyte(1) == Meshtastic::START2
+
+      len = (buf.getbyte(2) << 8) + buf.getbyte(3)
+      break if buf.bytesize < 4 + len
+
+      frames << Meshtastic::ToRadio.decode(buf.byteslice(4, len))
+      buf = buf.byteslice((4 + len)..)
+    end
+    frames
+  end
+
+  def firmware_file(bytes = "hello firmware\n")
+    file = Tempfile.new(['fw', '.bin'])
+    file.binmode
+    file.write(bytes)
+    file.flush
+    file
+  end
+
+  it 'sends ota_request with SHA-256 and BLE mode' do
+    serial_obj = fake_serial_obj
+    file = firmware_file('abc')
+    described_class.request_ota(serial_obj: serial_obj, firmware: file.path, mode: :OTA_BLE)
+    packet = decode_frames(serial_obj).last.packet
+    admin = Meshtastic::AdminMessage.decode(packet.decoded.payload)
+    expect(packet.decoded.portnum).to eq(:ADMIN_APP)
+    expect(admin.ota_request.reboot_ota_mode).to eq(:OTA_BLE)
+    expect(admin.ota_request.ota_hash.bytesize).to eq(32)
+    expect(admin.ota_request.ota_hash).to eq(Digest::SHA256.digest('abc'))
+  ensure
+    file.close!
+  end
+
+  it 'sends enter_dfu_mode_request' do
+    serial_obj = fake_serial_obj
+    described_class.enter_dfu(serial_obj: serial_obj)
+    admin = Meshtastic::AdminMessage.decode(decode_frames(serial_obj).last.packet.decoded.payload)
+    expect(admin.enter_dfu_mode_request).to be true
+  end
+
+  it 'builds XModem SOH blocks with CRC16 and an EOT' do
+    blocks = described_class.xmodem_blocks(bytes: 'A' * 130)
+    expect(blocks.first.control).to eq(:SOH)
+    expect(blocks.first.seq).to eq(1)
+    expect(blocks.first.buffer.bytesize).to eq(128)
+    expect(blocks[1].seq).to eq(2)
+    expect(blocks.last.control).to eq(:EOT)
+  end
+
+  it 'streams XModem ToRadio frames after ota_request on serial' do
+    serial_obj = fake_serial_obj
+    file = firmware_file('A' * 10)
+    described_class.install(serial_obj: serial_obj, firmware: file.path, mode: :OTA_BLE)
+    frames = decode_frames(serial_obj)
+    admin = Meshtastic::AdminMessage.decode(frames.first.packet.decoded.payload)
+    expect(admin.ota_request.ota_hash.bytesize).to eq(32)
+    xmodem = frames[1..]
+    expect(xmodem.first.xmodemPacket.control).to eq(:SOH)
+    expect(xmodem.last.xmodemPacket.control).to eq(:EOT)
+  ensure
+    file.close!
+  end
+
+  it 'publishes ota_request over MQTT without XModem PhoneAPI frames' do
+    published = []
+    mqtt_obj = Object.new
+    mqtt_obj.define_singleton_method(:client_id) { '00000b0b' }
+    mqtt_obj.define_singleton_method(:publish) do |topic, payload|
+      published << { topic: topic, payload: payload }
+      payload.bytesize
+    end
+    file = firmware_file('xyz')
+    described_class.install(mqtt_obj: mqtt_obj, firmware: file.path, mode: :OTA_WIFI, to: '!aabbccdd')
+    expect(published.size).to eq(1)
+    envelope = Meshtastic::ServiceEnvelope.decode(published.first[:payload])
+    packet = envelope.packet
+    nonce = [packet.id].pack('V').ljust(8, "\x00") + [packet.from].pack('V').ljust(8, "\x00")
+    psk = Base64.strict_decode64('1PG7OiApB1nwvP+rz05pAQ==')
+    cipher = OpenSSL::Cipher.new('AES-128-CTR')
+    cipher.decrypt
+    cipher.key = psk
+    cipher.iv = nonce
+    data = Meshtastic::Data.decode(cipher.update(packet.encrypted) + cipher.final)
+    expect(data.portnum).to eq(:ADMIN_APP)
+    admin = Meshtastic::AdminMessage.decode(data.payload)
+    expect(admin.ota_request.reboot_ota_mode).to eq(:OTA_WIFI)
+  ensure
+    file.close!
+  end
+
+  it 'prints usage without raising' do
+    expect { described_class.help }.to output(/firmware/).to_stdout
+  end
+end

data/spec/lib/meshtastic/admin_pb_spec.rb

@@ -2,5 +2,5 @@
 
 require 'spec_helper'
 
-describe Meshtastic::AdminPB do
+describe Meshtastic::AdminMessage do
 end