Merge pull request #3298 from meshcore-dev/companion-cli

Companion CLI

src/helpers/AdvertDataHelpers.cpp

@@ -28,6 +28,14 @@
     return i;
   }
 
+bool AdvertDataParser::isValidName(const char *n) {
+  while (*n) {
+    if (*n == '[' || *n == ']' || *n == '\\' || *n == ':' || *n == ',' || *n == '?' || *n == '*') return false;
+    n++;
+  }
+  return true;
+}
+
   AdvertDataParser::AdvertDataParser(const uint8_t app_data[], uint8_t app_data_len) {
     _name[0] = 0;
     _lat = _lon = 0;

src/helpers/AdvertDataHelpers.h

@@ -50,6 +50,8 @@ class AdvertDataParser {
 public:
   AdvertDataParser(const uint8_t app_data[], uint8_t app_data_len);
 
+  static bool isValidName(const char* name);
+
   bool isValid() const { return _valid; }
   uint8_t getType() const { return _flags & 0x0F; }
   uint16_t getFeat1() const { return _extra1; }

src/helpers/BaseChatMesh.cpp

@@ -9,6 +9,8 @@
   #define TXT_ACK_DELAY     200
 #endif
 
+#define CLI_REPLY_DELAY_MILLIS      600
+
 void BaseChatMesh::sendFloodScoped(const ContactInfo& recipient, mesh::Packet* pkt, uint32_t delay_millis) {
   sendFlood(pkt, delay_millis);
 }
@@ -227,8 +229,8 @@ void BaseChatMesh::onPeerDataRecv(mesh::Packet* packet, uint8_t type, int sender
   ContactInfo& from = contacts[i];
 
   if (type == PAYLOAD_TYPE_TXT_MSG && len > 5) {
-    uint32_t timestamp;
-    memcpy(&timestamp, data, 4);  // timestamp (by sender's RTC clock - which could be wrong)
+    uint32_t sender_timestamp;
+    memcpy(&sender_timestamp, data, 4);  // timestamp (by sender's RTC clock - which could be wrong)
     uint8_t flags = data[4] >> 2;   // message attempt number, and other flags
 
     // len can be > original length, but 'text' will be padded with zeroes
@@ -236,7 +238,7 @@ void BaseChatMesh::onPeerDataRecv(mesh::Packet* packet, uint8_t type, int sender
 
     if (flags == TXT_TYPE_PLAIN) {
       from.lastmod = getRTCClock()->getCurrentTime(); // update last heard time
-      onMessageRecv(from, packet, timestamp, (const char *) &data[5]);  // let UI know
+      onMessageRecv(from, packet, sender_timestamp, (const char *) &data[5]);  // let UI know
 
       int text_len = strlen((char *)&data[5]);
       uint8_t ack_hash[6];    // calc truncated hash of the message timestamp + text + sender pub_key, to prove to sender that we got it
@@ -254,20 +256,43 @@ void BaseChatMesh::onPeerDataRecv(mesh::Packet* packet, uint8_t type, int sender
         sendAckTo(from, ack_hash, 6);
       }
     } else if (flags == TXT_TYPE_CLI_DATA) {
-      onCommandDataRecv(from, packet, timestamp, (const char *) &data[5]);  // let UI know
+      char *text = (char *)&data[5];
+      onCommandDataRecv(from, packet, sender_timestamp, text);  // let UI know
       // NOTE: no ack expected for CLI_DATA replies
+    } else if (flags == TXT_TYPE_CLI_COMMAND) {
+      uint8_t temp[166];
+      char *command = (char *)&data[5];
+      char *reply = (char *)&temp[5];
+      *reply = 0;
 
-      if (packet->isRouteFlood()) {
-        // let this sender know path TO here, so they can use sendDirect() (NOTE: no ACK as extra)
-        mesh::Packet* path = createPathReturn(from.id, secret, packet->path, packet->path_len, 0, NULL, 0);
-        if (path) sendFloodScoped(from, path);
+      onCLICommandRecv(from, packet, sender_timestamp, command, reply);  // let UI know
+      // NOTE: no ack expected for CLI_COMMAND replies
+
+      int text_len = strlen(reply);
+      if (text_len > 0) {
+        uint32_t timestamp = getRTCClock()->getCurrentTimeUnique();
+        if (timestamp == sender_timestamp) {
+          // WORKAROUND: the two timestamps need to be different, in the CLI view
+          timestamp++;
+        }
+        memcpy(temp, &timestamp, 4);
+        temp[4] = (TXT_TYPE_CLI_DATA << 2);
+
+        auto reply_pkt = createDatagram(PAYLOAD_TYPE_TXT_MSG, from.id, secret, temp, 5 + text_len);
+        if (reply_pkt) {
+          if (from.out_path_len == OUT_PATH_UNKNOWN) {
+            sendFloodScoped(from, reply_pkt, CLI_REPLY_DELAY_MILLIS);
+          } else {
+            sendDirect(reply_pkt, from.out_path, from.out_path_len, CLI_REPLY_DELAY_MILLIS);
+          }
+        }
       }
     } else if (flags == TXT_TYPE_SIGNED_PLAIN) {
-      if (timestamp > from.sync_since) {  // make sure 'sync_since' is up-to-date
-        from.sync_since = timestamp;
+      if (sender_timestamp > from.sync_since) {  // make sure 'sync_since' is up-to-date
+        from.sync_since = sender_timestamp;
       }
       from.lastmod = getRTCClock()->getCurrentTime(); // update last heard time
-      onSignedMessageRecv(from, packet, timestamp, &data[5], (const char *) &data[9]);  // let UI know
+      onSignedMessageRecv(from, packet, sender_timestamp, &data[5], (const char *) &data[9]);  // let UI know
 
       uint32_t ack_hash;    // calc truncated hash of the message timestamp + text + OUR pub_key, to prove to sender that we got it
       mesh::Utils::sha256((uint8_t *) &ack_hash, 4, data, 9 + strlen((char *)&data[9]), self_id.pub_key, PUB_KEY_SIZE);
@@ -464,13 +489,13 @@ int  BaseChatMesh::sendMessage(const ContactInfo& recipient, uint32_t timestamp,
   return rc;
 }
 
-int  BaseChatMesh::sendCommandData(const ContactInfo& recipient, uint32_t timestamp, uint8_t attempt, const char* text, uint32_t& est_timeout) {
+int  BaseChatMesh::sendCommandData(const ContactInfo& recipient, uint32_t timestamp, uint8_t attempt, uint8_t txt_type, const char* text, uint32_t& est_timeout) {
   int text_len = strlen(text);
   if (text_len > MAX_TEXT_LEN) return MSG_SEND_FAILED;
 
   uint8_t temp[5+MAX_TEXT_LEN+1];
   memcpy(temp, &timestamp, 4);   // mostly an extra blob to help make packet_hash unique
-  temp[4] = (attempt & 3) | (TXT_TYPE_CLI_DATA << 2);
+  temp[4] = (attempt & 3) | (txt_type << 2);
   memcpy(&temp[5], text, text_len + 1);
 
   auto pkt = createDatagram(PAYLOAD_TYPE_TXT_MSG, recipient.id, recipient.getSharedSecret(self_id), temp, 5 + text_len);

src/helpers/BaseChatMesh.h

@@ -114,6 +114,7 @@ protected:
   virtual bool onContactPathRecv(ContactInfo& from, uint8_t* in_path, uint8_t in_path_len, uint8_t* out_path, uint8_t out_path_len, uint8_t extra_type, uint8_t* extra, uint8_t extra_len);
   virtual void onMessageRecv(const ContactInfo& contact, mesh::Packet* pkt, uint32_t sender_timestamp, const char *text) = 0;
   virtual void onCommandDataRecv(const ContactInfo& contact, mesh::Packet* pkt, uint32_t sender_timestamp, const char *text) = 0;
+  virtual void onCLICommandRecv(const ContactInfo& contact, mesh::Packet* pkt, uint32_t sender_timestamp, const char *text, char* reply) = 0;
   virtual void onSignedMessageRecv(const ContactInfo& contact, mesh::Packet* pkt, uint32_t sender_timestamp, const uint8_t *sender_prefix, const char *text) = 0;
   virtual uint32_t calcFloodTimeoutMillisFor(uint32_t pkt_airtime_millis) const = 0;
   virtual uint32_t calcDirectTimeoutMillisFor(uint32_t pkt_airtime_millis, uint8_t path_len) const = 0;
@@ -156,7 +157,7 @@ public:
   mesh::Packet* createSelfAdvert(const char* name);
   mesh::Packet* createSelfAdvert(const char* name, double lat, double lon);
   int  sendMessage(const ContactInfo& recipient, uint32_t timestamp, uint8_t attempt, const char* text, uint32_t& expected_ack, uint32_t& est_timeout);
-  int  sendCommandData(const ContactInfo& recipient, uint32_t timestamp, uint8_t attempt, const char* text, uint32_t& est_timeout);
+  int  sendCommandData(const ContactInfo& recipient, uint32_t timestamp, uint8_t attempt, uint8_t txt_type, const char* text, uint32_t& est_timeout);
   bool sendGroupMessage(uint32_t timestamp, mesh::GroupChannel& channel, const char* sender_name, const char* text, int text_len);
   bool sendGroupData(mesh::GroupChannel& channel, uint8_t* path, uint8_t path_len, uint16_t data_type, const uint8_t* data, int data_len);
   int  sendLogin(const ContactInfo& recipient, const char* password, uint32_t& est_timeout);

src/helpers/CommonCLI.cpp

@@ -164,6 +164,7 @@ void CommonCLI::savePrefs() {
     _prefs->advert_interval = 0;  // turn it off, now that device has been manually configured
   }
   _callbacks->savePrefs();
+  _prefs->clearDirty();
 }
 
 uint8_t CommonCLI::buildAdvertData(uint8_t node_type, uint8_t* app_data) {
@@ -180,6 +181,16 @@ uint8_t CommonCLI::buildAdvertData(uint8_t node_type, uint8_t* app_data) {
 }
 
 void CommonCLI::handleCommand(uint32_t sender_timestamp, char* command, char* reply) {
+    if (_prefs->getRadioPrefs()->handleCommand(command, sender_timestamp, reply)) {   // is a radio CLI command?
+      if (_prefs->getRadioPrefs()->isDirty()) { savePrefs(); }
+      return;
+    }
+    // hook for variant-specific CLI processing
+    if (_board->handleCommand(command, sender_timestamp, reply)) {
+      if (_prefs->isDirty()) { savePrefs(); }
+      return;
+    }
+
     if (memcmp(command, "poweroff", 8) == 0 || memcmp(command, "shutdown", 8) == 0) {
       _board->powerOff();  // doesn't return
     } else if (memcmp(command, "reboot", 6) == 0) {
@@ -447,39 +458,8 @@ void CommonCLI::handleCommand(uint32_t sender_timestamp, char* command, char* re
 
 void CommonCLI::handleSetCmd(uint32_t sender_timestamp, char* command, char* reply) {
   const char* config = &command[4];
-  if (memcmp(config, "dutycycle ", 10) == 0) {
-    float dc = atof(&config[10]);
-    if (dc < 1 || dc > 100) {
-      strcpy(reply, "ERROR: dutycycle must be 1-100");
-    } else {
-      _prefs->airtime_factor = (100.0f / dc) - 1.0f;
-      savePrefs();
-      float actual = 100.0f / (_prefs->airtime_factor + 1.0f);
-      int a_int = (int)actual;
-      int a_frac = (int)((actual - a_int) * 10.0f + 0.5f);
-      sprintf(reply, "OK - %d.%d%%", a_int, a_frac);
-    }
-  } else if (memcmp(config, "af ", 3) == 0) {
-    _prefs->airtime_factor = atof(&config[3]);
-    savePrefs();
-    strcpy(reply, "OK");
-  } else if (memcmp(config, "int.thresh ", 11) == 0) {
-    _prefs->interference_threshold = atoi(&config[11]);
-    savePrefs();
-    strcpy(reply, "OK");
-  } else if (memcmp(config, "cad ", 4) == 0) {
-    _prefs->cad_enabled = memcmp(&config[4], "on", 2) == 0;
-    savePrefs();
-    strcpy(reply, "OK");
-  } else if (memcmp(config, "agc.reset.interval ", 19) == 0) {
-    _prefs->agc_reset_interval = atoi(&config[19]) / 4;
-    savePrefs();
-    sprintf(reply, "OK - interval rounded to %d", ((uint32_t) _prefs->agc_reset_interval) * 4);
-  } else if (memcmp(config, "multi.acks ", 11) == 0) {
-    _prefs->multi_acks = atoi(&config[11]);
-    savePrefs();
-    strcpy(reply, "OK");
-  } else if (memcmp(config, "allow.read.only ", 16) == 0) {
+
+  if (memcmp(config, "allow.read.only ", 16) == 0) {
     _prefs->allow_read_only = memcmp(&config[16], "on", 2) == 0;
     savePrefs();
     strcpy(reply, "OK");
@@ -532,77 +512,6 @@ void CommonCLI::handleSetCmd(uint32_t sender_timestamp, char* command, char* rep
     _prefs->disable_fwd = memcmp(&config[7], "off", 3) == 0;
     savePrefs();
     strcpy(reply, _prefs->disable_fwd ? "OK - repeat is now OFF" : "OK - repeat is now ON");
-  } else if (memcmp(config, "radio.rxgain ", 13) == 0) {
-    bool enabled = memcmp(&config[13], "on", 2) == 0;
-    _prefs->rx_boosted_gain = enabled;
-    savePrefs();
-    if (_callbacks->setRxBoostedGain(enabled)) {
-      strcpy(reply, "OK");
-    } else {
-      strcpy(reply, "Error: unsupported");
-    }
-  } else if (memcmp(config, "radio.fem.rxgain ", 17) == 0) {
-    if (!_board->canControlLoRaFemLna()) {
-      strcpy(reply, "Error: unsupported");
-    } else if (memcmp(&config[17], "on", 2) == 0) {
-      if (_board->setLoRaFemLnaEnabled(true)) {
-        _prefs->radio_fem_rxgain = 1;
-        savePrefs();
-        strcpy(reply, "OK - LoRa FEM RX gain on");
-      } else {
-        strcpy(reply, "Error: failed to apply LoRa FEM RX gain");
-      }
-    } else if (memcmp(&config[17], "off", 3) == 0) {
-      if (_board->setLoRaFemLnaEnabled(false)) {
-        _prefs->radio_fem_rxgain = 0;
-        savePrefs();
-        strcpy(reply, "OK - LoRa FEM RX gain off");
-      } else {
-        strcpy(reply, "Error: failed to apply LoRa FEM RX gain");
-      }
-    } else {
-      strcpy(reply, "Error: state must be on or off");
-    }
-  } else if (memcmp(config, "radio.fem.txgain ", 17) == 0) {
-    if (!_board->canControlLoRaFemPaGain()) {
-      strcpy(reply, "Error: unsupported");
-    } else if (memcmp(&config[17], "on", 2) == 0) {
-      if (_board->setLoRaFemPaGainEnabled(true)) {
-        _prefs->radio_fem_txgain = 1;
-        savePrefs();
-        strcpy(reply, "OK - LoRa FEM TX gain on");
-      } else {
-        strcpy(reply, "Error: failed to apply LoRa FEM TX gain");
-      }
-    } else if (memcmp(&config[17], "off", 3) == 0) {
-      if (_board->setLoRaFemPaGainEnabled(false)) {
-        _prefs->radio_fem_txgain = 0;
-        savePrefs();
-        strcpy(reply, "OK - LoRa FEM TX gain off");
-      } else {
-        strcpy(reply, "Error: failed to apply LoRa FEM TX gain");
-      }
-    } else {
-      strcpy(reply, "Error: state must be on or off");
-    }
-  } else if (memcmp(config, "radio ", 6) == 0) {
-    strcpy(tmp, &config[6]);
-    const char *parts[4];
-    int num = mesh::Utils::parseTextParts(tmp, parts, 4);
-    float freq  = num > 0 ? strtof(parts[0], nullptr) : 0.0f;
-    float bw    = num > 1 ? strtof(parts[1], nullptr) : 0.0f;
-    uint8_t sf  = num > 2 ? atoi(parts[2]) : 0;
-    uint8_t cr  = num > 3 ? atoi(parts[3]) : 0;
-    if (freq >= 150.0f && freq <= 2500.0f && sf >= 5 && sf <= 12 && cr >= 5 && cr <= 8 && bw >= 7.0f && bw <= 500.0f) {
-      _prefs->sf = sf;
-      _prefs->cr = cr;
-      _prefs->freq = freq;
-      _prefs->bw = bw;
-      _callbacks->savePrefs();
-      strcpy(reply, "OK - reboot to apply");
-    } else {
-      strcpy(reply, "Error, invalid radio params");
-    }
   } else if (memcmp(config, "lat ", 4) == 0) {
     _prefs->node_lat = atof(&config[4]);
     savePrefs();
@@ -611,24 +520,6 @@ void CommonCLI::handleSetCmd(uint32_t sender_timestamp, char* command, char* rep
     _prefs->node_lon = atof(&config[4]);
     savePrefs();
     strcpy(reply, "OK");
-  } else if (memcmp(config, "rxdelay ", 8) == 0) {
-    float db = atof(&config[8]);
-    if (db >= 0 && db <= 20.0f) {
-      _prefs->rx_delay_base = db;
-      savePrefs();
-      strcpy(reply, "OK");
-    } else {
-      strcpy(reply, "Error, must be 0-20");
-    }
-  } else if (memcmp(config, "txdelay ", 8) == 0) {
-    float f = atof(&config[8]);
-    if (f >= 0 && f <= 2.0f) {
-      _prefs->tx_delay_factor = f;
-      savePrefs();
-      strcpy(reply, "OK");
-    } else {
-      strcpy(reply, "Error, must be 0-2");
-    }
   } else if (memcmp(config, "flood.max.unscoped ", 19) == 0) {
     uint8_t m = atoi(&config[19]);
     if (m <= 64) {
@@ -656,15 +547,6 @@ void CommonCLI::handleSetCmd(uint32_t sender_timestamp, char* command, char* rep
     } else {
       strcpy(reply, "Error, max 64");
     }
-  } else if (memcmp(config, "direct.txdelay ", 15) == 0) {
-    float f = atof(&config[15]);
-    if (f >= 0 && f <= 2.0f) {
-      _prefs->direct_tx_delay_factor = f;
-      savePrefs();
-      strcpy(reply, "OK");
-    } else {
-      strcpy(reply, "Error, must be 0-2");
-    }
   } else if (memcmp(config, "owner.info ", 11) == 0) {
     config += 11;
     char *dp = _prefs->owner_info;
@@ -675,16 +557,6 @@ void CommonCLI::handleSetCmd(uint32_t sender_timestamp, char* command, char* rep
     *dp = 0;
     savePrefs();
     strcpy(reply, "OK");
-  } else if (memcmp(config, "path.hash.mode ", 15) == 0) {
-    config += 15;
-    uint8_t mode = atoi(config);
-    if (mode < 3) {
-      _prefs->path_hash_mode = mode;
-      savePrefs();
-      strcpy(reply, "OK");
-    } else {
-      strcpy(reply, "Error, must be 0,1, or 2");
-    }
   } else if (memcmp(config, "loop.detect ", 12) == 0) {
     config += 12;
     uint8_t mode;
@@ -705,11 +577,6 @@ void CommonCLI::handleSetCmd(uint32_t sender_timestamp, char* command, char* rep
       savePrefs();
       strcpy(reply, "OK");
     }
-  } else if (memcmp(config, "tx ", 3) == 0) {
-    _prefs->tx_power_dbm = atoi(&config[3]);
-    savePrefs();
-    _callbacks->setTxPower(_prefs->tx_power_dbm);
-    strcpy(reply, "OK");
   } else if (sender_timestamp == 0 && memcmp(config, "freq ", 5) == 0) {
     _prefs->freq = atof(&config[5]);
     savePrefs();
@@ -806,22 +673,7 @@ void CommonCLI::handleSetCmd(uint32_t sender_timestamp, char* command, char* rep
 
 void CommonCLI::handleGetCmd(uint32_t sender_timestamp, char* command, char* reply) {
   const char* config = &command[4];
-  if (memcmp(config, "dutycycle", 9) == 0) {
-    float dc = 100.0f / (_prefs->airtime_factor + 1.0f);
-    int dc_int = (int)dc;
-    int dc_frac = (int)((dc - dc_int) * 10.0f + 0.5f);
-    sprintf(reply, "> %d.%d%%", dc_int, dc_frac);
-  } else if (memcmp(config, "af", 2) == 0) {
-    sprintf(reply, "> %s", StrHelper::ftoa(_prefs->airtime_factor));
-  } else if (memcmp(config, "int.thresh", 10) == 0) {
-    sprintf(reply, "> %d", (uint32_t) _prefs->interference_threshold);
-  } else if (memcmp(config, "cad", 3) == 0) {
-    sprintf(reply, "> %s", _prefs->cad_enabled ? "on" : "off");
-  } else if (memcmp(config, "agc.reset.interval", 18) == 0) {
-    sprintf(reply, "> %d", ((uint32_t) _prefs->agc_reset_interval) * 4);
-  } else if (memcmp(config, "multi.acks", 10) == 0) {
-    sprintf(reply, "> %d", (uint32_t) _prefs->multi_acks);
-  } else if (memcmp(config, "allow.read.only", 15) == 0) {
+  if (memcmp(config, "allow.read.only", 15) == 0) {
     sprintf(reply, "> %s", _prefs->allow_read_only ? "on" : "off");
   } else if (memcmp(config, "flood.advert.interval", 21) == 0) {
     sprintf(reply, "> %d", ((uint32_t) _prefs->flood_advert_interval));
@@ -842,37 +694,12 @@ void CommonCLI::handleGetCmd(uint32_t sender_timestamp, char* command, char* rep
     sprintf(reply, "> %s", StrHelper::ftoa(_prefs->node_lat));
   } else if (memcmp(config, "lon", 3) == 0) {
     sprintf(reply, "> %s", StrHelper::ftoa(_prefs->node_lon));
-  } else if (memcmp(config, "radio.rxgain", 12) == 0) {
-    sprintf(reply, "> %s", _prefs->rx_boosted_gain ? "on" : "off");
-  } else if (memcmp(config, "radio.fem.rxgain", 16) == 0) {
-    if (!_board->canControlLoRaFemLna()) {
-      strcpy(reply, "Error: unsupported");
-    } else {
-      sprintf(reply, "> %s", _board->isLoRaFemLnaEnabled() ? "on" : "off");
-    }
-  } else if (memcmp(config, "radio.fem.txgain", 16) == 0) {
-    if (!_board->canControlLoRaFemPaGain()) {
-      strcpy(reply, "Error: unsupported");
-    } else {
-      sprintf(reply, "> %s", _board->isLoRaFemPaGainEnabled() ? "on" : "off");
-    }
-  } else if (memcmp(config, "radio", 5) == 0) {
-    char freq[16], bw[16];
-    strcpy(freq, StrHelper::ftoa(_prefs->freq));
-    strcpy(bw, StrHelper::ftoa3(_prefs->bw));
-    sprintf(reply, "> %s,%s,%d,%d", freq, bw, (uint32_t)_prefs->sf, (uint32_t)_prefs->cr);
-  } else if (memcmp(config, "rxdelay", 7) == 0) {
-    sprintf(reply, "> %s", StrHelper::ftoa(_prefs->rx_delay_base));
-  } else if (memcmp(config, "txdelay", 7) == 0) {
-    sprintf(reply, "> %s", StrHelper::ftoa(_prefs->tx_delay_factor));
   } else if (memcmp(config, "flood.max.advert", 16) == 0) {
     sprintf(reply, "> %d", (uint32_t)_prefs->flood_max_advert);
   } else if (memcmp(config, "flood.max.unscoped", 18) == 0) {
     sprintf(reply, "> %d", (uint32_t)_prefs->flood_max_unscoped);
   } else if (memcmp(config, "flood.max", 9) == 0) {
     sprintf(reply, "> %d", (uint32_t)_prefs->flood_max);
-  } else if (memcmp(config, "direct.txdelay", 14) == 0) {
-    sprintf(reply, "> %s", StrHelper::ftoa(_prefs->direct_tx_delay_factor));
   } else if (memcmp(config, "owner.info", 10) == 0) {
     auto start = reply;
     *reply++ = '>';
@@ -883,8 +710,6 @@ void CommonCLI::handleGetCmd(uint32_t sender_timestamp, char* command, char* rep
       sp++;
     }
     *reply = 0;  // set null terminator
-  } else if (memcmp(config, "path.hash.mode", 14) == 0) {
-    sprintf(reply, "> %d", (uint32_t)_prefs->path_hash_mode);
   } else if (memcmp(config, "loop.detect", 11) == 0) {
     if (_prefs->loop_detect == LOOP_DETECT_OFF) {
       strcpy(reply, "> off");
@@ -895,10 +720,6 @@ void CommonCLI::handleGetCmd(uint32_t sender_timestamp, char* command, char* rep
     } else {
       strcpy(reply, "> strict");
     }
-  } else if (memcmp(config, "tx", 2) == 0 && (config[2] == 0 || config[2] == ' ')) {
-    sprintf(reply, "> %d", (int32_t) _prefs->tx_power_dbm);
-  } else if (memcmp(config, "freq", 4) == 0) {
-    sprintf(reply, "> %s", StrHelper::ftoa(_prefs->freq));
   } else if (memcmp(config, "public.key", 10) == 0) {
     strcpy(reply, "> ");
     mesh::Utils::toHex(&reply[2], _callbacks->getSelfId().pub_key, PUB_KEY_SIZE);

src/helpers/CommonCLI.h

@@ -6,6 +6,8 @@
 #include <helpers/ClientACL.h>
 #include <helpers/RegionMap.h>
 #include <helpers/ConfigSerializer.h>
+#include <helpers/CommonRadioPrefs.h>
+#include <helpers/DynamicConfigSerializer.h>
 
 #if defined(WITH_RS232_BRIDGE) || defined(WITH_ESPNOW_BRIDGE)
 #define WITH_BRIDGE
@@ -72,7 +74,7 @@ public:
   uint8_t extra_sf[4];
 
 private:
-  class RadioPrefs : public ConfigSerializer {
+  class RadioPrefs : public CommonRadioPrefs {
     NodePrefs* _parent;
   protected:
     void structure() override {
@@ -96,6 +98,41 @@ private:
     }
   public:
     RadioPrefs(NodePrefs* parent) : _parent(parent) { }
+    // CommonRadioPrefs interface
+    float getFreq() const override { return _parent->freq; }
+    void setFreq(float f) override { _parent->freq = f; markDirty(); }
+    float getBandwidth() const override { return _parent->bw; }
+    void setBandwidth(float bw) override { _parent->bw = bw; markDirty(); }
+    uint8_t getSpreadFactor() const override { return _parent->sf; }
+    void setSpreadFactor(uint8_t sf) override { _parent->sf = sf; markDirty(); }
+    uint8_t getCodingRate() const override { return _parent->cr; }
+    void setCodingRate(uint8_t cr) override { _parent->cr = cr; markDirty(); }
+    float getAirtimeFactor() const override { return _parent->airtime_factor; }
+    void setAirtimeFactor(float af) override { _parent->airtime_factor = af; markDirty(); }
+    bool isCadEnabled() const override { return _parent->cad_enabled; }
+    void setCadEnabled(bool en) override { _parent->cad_enabled = en; markDirty(); }
+    uint8_t getIntThresh() const override { return _parent->interference_threshold; }
+    void setIntThresh(uint8_t t) override { _parent->interference_threshold = t; markDirty(); }
+    uint8_t getRxGain() const override { return _parent->rx_boosted_gain; }
+    void setRxGain(uint8_t g) override { _parent->rx_boosted_gain = g; markDirty(); }
+    uint8_t getTxPower() const override { return _parent->tx_power_dbm; }
+    void setTxPower(uint8_t dbm) override { _parent->tx_power_dbm = dbm; markDirty(); }
+    float getRxDelay() const override { return _parent->rx_delay_base; }
+    void setRxDelay(float d) override { _parent->rx_delay_base = d; markDirty(); }
+    uint8_t getAgcResetInt() const override { return _parent->agc_reset_interval * 4; }
+    void setAgcResetInt(uint8_t secs) override { _parent->agc_reset_interval = secs / 4; markDirty(); }
+    uint8_t getHashMode() const override { return _parent->path_hash_mode; }
+    void setHashMode(uint8_t m) override { _parent->path_hash_mode = m; markDirty(); }
+    uint8_t getMultiAcks() const override { return _parent->multi_acks; }
+    void setMultiAcks(uint8_t m) override { _parent->multi_acks = m; markDirty(); }
+    float getFloodTxDelay() const override { return _parent->tx_delay_factor; }
+    void setFloodTxDelay(float d) override { _parent->tx_delay_factor = d; markDirty(); }
+    float getDirectTxDelay() const override { return _parent->direct_tx_delay_factor; }
+    void setDirectTxDelay(float d) override { _parent->direct_tx_delay_factor = d; markDirty(); }
+    uint8_t getFEMRxGain() const override { return _parent->radio_fem_rxgain; }
+    void setFEMRxGain(uint8_t g) override { _parent->radio_fem_rxgain = g; markDirty(); }
+    uint8_t getFEMTxGain() const override { return _parent->radio_fem_txgain; }
+    void setFEMTxGain(uint8_t g) override { _parent->radio_fem_txgain = g; markDirty(); }
   };
   RadioPrefs radio;
 
@@ -166,6 +203,8 @@ private:
   };
   RoomPrefs room;
 
+  DynamicConfigSerializer custom;
+
 protected:
   void structure() override {
     def("name", node_name, sizeof(node_name));
@@ -182,16 +221,23 @@ protected:
     def("repeat", repeat);
     def("room", room);
     def("power", power);
+    def("custom", custom);
   }
 
 public:
-  NodePrefs() : ConfigSerializer(), bridge(this), gps(this), radio(this), power(this), repeat(this), room(this) {
+  NodePrefs() : ConfigSerializer(), bridge(this), gps(this), radio(this), power(this), repeat(this), room(this), custom(&radio) {
     node_name[0] = 0;
     password[0] = 0;
     guest_password[0] = 0;
     bridge_secret[0] = 0;
     owner_info[0] = 0;
   }
+
+  CommonRadioPrefs* getRadioPrefs() { return &radio; }
+  KeyValueStore* getCustom() { return &custom; }
+
+  bool isDirty() const override { return ConfigSerializer::isDirty() || radio.isDirty() || custom.isDirty(); }
+  void clearDirty() override { ConfigSerializer::clearDirty(); radio.clearDirty(); custom.clearDirty(); }
 };
 
 class CommonCLICallbacks {

src/helpers/CommonRadioPrefs.cpp

@@ -0,0 +1,224 @@
+#include "CommonRadioPrefs.h"
+#include "TxtDataHelpers.h"
+#include "Utils.h"
+#include "target.h"
+
+bool CommonRadioPrefs::getByKey(const char* key, char* value, size_t max_len) {
+  if (strcmp(key, "fem_rxgain") == 0) {
+    snprintf(value, max_len, "%d", (uint32_t)getFEMRxGain());
+    return true;
+  }
+  if (strcmp(key, "fem_txgain") == 0) {
+    snprintf(value, max_len, "%d", (uint32_t)getFEMTxGain());
+    return true;
+  }
+  return false;
+}
+bool CommonRadioPrefs::setByKey(const char* key, const char* value) {
+  if (strcmp(key, "fem_rxgain") == 0) {
+    setFEMRxGain(atoi(value));
+    markDirty();
+    return true;
+  }
+  if (strcmp(key, "fem_txgain") == 0) {
+    setFEMTxGain(atoi(value));
+    markDirty();
+    return true;
+  }
+  return false;
+}
+
+bool CommonRadioPrefs::handleCommand(const char* command, uint32_t sender_timestamp, char* reply) {
+  if (strcmp(command, "get radio") == 0) {
+    char freq[16], bw[16];
+    strcpy(freq, StrHelper::ftoa(getFreq()));
+    strcpy(bw, StrHelper::ftoa3(getBandwidth()));
+    sprintf(reply, "> %s,%s,%d,%d", freq, bw, (uint32_t)getSpreadFactor(), (uint32_t)getCodingRate());
+    return true;
+  }
+  if (memcmp(command, "set radio ", 10) == 0) {
+    char tmp[132];
+    strcpy(tmp, &command[10]);
+    const char *parts[4];
+    int num = mesh::Utils::parseTextParts(tmp, parts, 4);
+    float freq  = num > 0 ? strtof(parts[0], nullptr) : 0.0f;
+    float bw    = num > 1 ? strtof(parts[1], nullptr) : 0.0f;
+    uint8_t sf  = num > 2 ? atoi(parts[2]) : 0;
+    uint8_t cr  = num > 3 ? atoi(parts[3]) : 0;
+    if (freq >= 150.0f && freq <= 2500.0f && sf >= 5 && sf <= 12 && cr >= 5 && cr <= 8 && bw >= 7.0f && bw <= 500.0f) {
+      setSpreadFactor(sf);
+      setCodingRate(cr);
+      setFreq(freq);
+      setBandwidth(bw);
+      strcpy(reply, "OK - reboot to apply");
+    } else {
+      strcpy(reply, "Error, invalid radio params");
+    }
+    return true;
+  }
+
+  if (strcmp(command, "get freq") == 0) {
+    sprintf(reply, "> %s", StrHelper::ftoa(getFreq()));
+    return true;
+  }
+
+  if (strcmp(command, "get af") == 0) {
+    sprintf(reply, "> %s", StrHelper::ftoa(getAirtimeFactor()));
+    return true;
+  }
+  if (memcmp(command, "set af ", 7) == 0) {
+    setAirtimeFactor(atof(&command[7]));
+    strcpy(reply, "OK");
+    return true;
+  }
+
+  if (strcmp(command, "get dutycycle") == 0) {
+    float dc = 100.0f / (getAirtimeFactor() + 1.0f);
+    int dc_int = (int)dc;
+    int dc_frac = (int)((dc - dc_int) * 10.0f + 0.5f);
+    sprintf(reply, "> %d.%d%%", dc_int, dc_frac);
+    return true;
+  }
+  if (memcmp(command, "set dutycycle ", 14) == 0) {
+    float dc = atof(&command[14]);
+    if (dc < 1 || dc > 100) {
+      strcpy(reply, "ERROR: dutycycle must be 1-100");
+    } else {
+      setAirtimeFactor((100.0f / dc) - 1.0f);
+      float actual = 100.0f / (getAirtimeFactor() + 1.0f);
+      int a_int = (int)actual;
+      int a_frac = (int)((actual - a_int) * 10.0f + 0.5f);
+      sprintf(reply, "OK - %d.%d%%", a_int, a_frac);
+    }
+    return true;
+  }
+
+  if (strcmp(command, "get int.thresh") == 0) {
+    sprintf(reply, "> %d", (uint32_t) getIntThresh());
+    return true;
+  }
+  if (memcmp(command, "set int.thresh ", 15) == 0) {
+    setIntThresh(atoi(&command[15]));
+    strcpy(reply, "OK");
+    return true;
+  }
+
+  if (strcmp(command, "get cad") == 0) {
+    sprintf(reply, "> %s", isCadEnabled() ? "on" : "off");
+    return true;
+  }
+  if (memcmp(command, "set cad ", 8) == 0) {
+    setCadEnabled(memcmp(&command[8], "on", 2) == 0);
+    strcpy(reply, "OK");
+    return true;
+  }
+
+  if (strcmp(command, "get radio.rxgain") == 0) {
+    sprintf(reply, "> %s", getRxGain() != 0 ? "on" : "off");
+    return true;
+  }
+  if (memcmp(command, "set radio.rxgain ", 17) == 0) {
+    bool enabled = memcmp(&command[17], "on", 2) == 0;
+    setRxGain(enabled);
+    if (radio_driver.setRxBoostedGainMode(enabled)) {
+      strcpy(reply, "OK");
+    } else {
+      strcpy(reply, "Error: unsupported");
+    }
+    return true;
+  }
+
+  if (memcmp(command, "get tx", 6) == 0 && (command[6] == 0 || command[6] == ' ')) {
+    sprintf(reply, "> %d", (int32_t) getTxPower());
+    return true;
+  }
+  if (memcmp(command, "set tx ", 7) == 0) {
+    setTxPower(atoi(&command[7]));
+    radio_driver.setTxPower(getTxPower());
+    strcpy(reply, "OK");
+    return true;
+  }
+
+  if (strcmp(command, "get rxdelay") == 0) {
+    sprintf(reply, "> %s", StrHelper::ftoa(getRxDelay()));
+    return true;
+  }
+  if (memcmp(command, "set rxdelay ", 12) == 0) {
+    float db = atof(&command[12]);
+    if (db >= 0 && db <= 20.0f) {
+      setRxDelay(db);
+      strcpy(reply, "OK");
+    } else {
+      strcpy(reply, "Error, must be 0-20");
+    }
+    return true;
+  }
+
+  if (strcmp(command, "get agc.reset.interval") == 0) {
+    sprintf(reply, "> %d", (uint32_t) getAgcResetInt());
+    return true;
+  }
+  if (memcmp(command, "set agc.reset.interval ", 23) == 0) {
+    setAgcResetInt(atoi(&command[23]));
+    sprintf(reply, "OK - interval rounded to %d", (uint32_t) getAgcResetInt());
+    return true;
+  }
+
+  if (strcmp(command, "get path.hash.mode") == 0) {
+    sprintf(reply, "> %d", (uint32_t)getHashMode());
+    return true;
+  }
+  if (memcmp(command, "set path.hash.mode ", 19) == 0) {
+    const char* config = command + 19;
+    uint8_t mode = atoi(config);
+    if (mode < 3) {
+      setHashMode(mode);
+      strcpy(reply, "OK");
+    } else {
+      strcpy(reply, "Error, must be 0,1, or 2");
+    }
+    return true;
+  }
+
+  if (strcmp(command, "get multi.acks") == 0) {
+    sprintf(reply, "> %d", (uint32_t) getMultiAcks());
+    return true;
+  }
+  if (memcmp(command, "set multi.acks ", 15) == 0) {
+    setMultiAcks(atoi(&command[15]));
+    strcpy(reply, "OK");
+    return true;
+  }
+
+  if (strcmp(command, "get txdelay") == 0) {
+    sprintf(reply, "> %s", StrHelper::ftoa(getFloodTxDelay()));
+    return true;
+  }
+  if (memcmp(command, "set txdelay ", 12) == 0) {
+    float f = atof(&command[12]);
+    if (f >= 0 && f <= 2.0f) {
+      setFloodTxDelay(f);
+      strcpy(reply, "OK");
+    } else {
+      strcpy(reply, "Error, must be 0-2");
+    }
+    return true;
+  }
+
+  if (strcmp(command, "get direct.txdelay") == 0) {
+    sprintf(reply, "> %s", StrHelper::ftoa(getDirectTxDelay()));
+    return true;
+  }
+  if (memcmp(command, "set direct.txdelay ", 19) == 0) {
+    float f = atof(&command[19]);
+    if (f >= 0 && f <= 2.0f) {
+      setDirectTxDelay(f);
+      strcpy(reply, "OK");
+    } else {
+      strcpy(reply, "Error, must be 0-2");
+    }
+    return true;
+  }
+
+  return false; // not handled
+}

src/helpers/CommonRadioPrefs.h

@@ -0,0 +1,69 @@
+#pragma once
+#include "ConfigSerializer.h"
+#include "KeyValueStore.h"
+
+class CommonRadioPrefs : public ConfigSerializer, public KeyValueStore {
+  bool _is_dirty = false;
+protected:
+  CommonRadioPrefs() { }
+public:
+  void markDirty() { _is_dirty = true; }
+  void clearDirty() { _is_dirty = false; }
+  bool isDirty() const { return _is_dirty; }
+
+  virtual float getFreq() const = 0;
+  virtual void setFreq(float f) = 0;
+
+  virtual float getBandwidth() const = 0;
+  virtual void setBandwidth(float bw) = 0;
+
+  virtual uint8_t getSpreadFactor() const = 0;
+  virtual void setSpreadFactor(uint8_t sf) = 0;
+
+  virtual uint8_t getCodingRate() const = 0;
+  virtual void setCodingRate(uint8_t cr) = 0;
+
+  virtual float getAirtimeFactor() const = 0;
+  virtual void setAirtimeFactor(float af) = 0;
+
+  virtual bool isCadEnabled() const = 0;
+  virtual void setCadEnabled(bool en) = 0;
+
+  virtual uint8_t getIntThresh() const = 0;
+  virtual void setIntThresh(uint8_t t) = 0;
+
+  virtual uint8_t getRxGain() const = 0;
+  virtual void setRxGain(uint8_t g) = 0;
+
+  virtual uint8_t getTxPower() const = 0;
+  virtual void setTxPower(uint8_t dbm) = 0;
+
+  virtual float getRxDelay() const = 0;
+  virtual void setRxDelay(float d) = 0;
+
+  virtual uint8_t getAgcResetInt() const = 0;
+  virtual void setAgcResetInt(uint8_t secs) = 0;
+
+  virtual uint8_t getHashMode() const = 0;
+  virtual void setHashMode(uint8_t m) = 0;
+
+  virtual uint8_t getMultiAcks() const = 0;
+  virtual void setMultiAcks(uint8_t m) = 0;
+
+  virtual float getFloodTxDelay() const = 0;
+  virtual void setFloodTxDelay(float d) = 0;
+
+  virtual float getDirectTxDelay() const = 0;
+  virtual void setDirectTxDelay(float d) = 0;
+
+  virtual uint8_t getFEMRxGain() const = 0;
+  virtual void setFEMRxGain(uint8_t g) = 0;
+
+  virtual uint8_t getFEMTxGain() const = 0;
+  virtual void setFEMTxGain(uint8_t g) = 0;
+
+  bool handleCommand(const char* command, uint32_t sender_timestamp, char* reply);
+
+  bool setByKey(const char* key, const char* value) override;   // for dynamic key/value access
+  bool getByKey(const char* key, char* value, size_t max_len) override;
+};

src/helpers/ConfigSerializer.h

@@ -17,7 +17,9 @@
 class ConfigSerializer {
   bool _first;
   int8_t _depth;
+  bool _dirty = false;
 
+protected:
   enum OP { READ, WRITE };
 
   class Context {
@@ -38,13 +40,14 @@ class ConfigSerializer {
     const char* getToken() const { return rd_buf; }
     bool keyMatch(int8_t depth, const char* key) { return strcmp(key, _keys[depth]) == 0; }
     void setKey(uint8_t depth, const char* key) { strcpy(_keys[depth], key);  }
+    const char* getKey(uint8_t depth) { return _keys[depth]; }
   };
 
   Context* _context = NULL;
+  int8_t getDepth() const { return _depth; }
 
   void writeComma();
 
-protected:
   ConfigSerializer() { }
 
   void def(const char* key, char* value, size_t max_len);  // max_len inclusive of null
@@ -62,7 +65,12 @@ protected:
 
   virtual void structure() = 0;
 
+  void markDirty() { _dirty = true; }
+
 public:
   bool loadSerial(Stream& s);
   bool saveSerial(Stream& s);
+
+  virtual bool isDirty() const { return _dirty; }
+  virtual void clearDirty() { _dirty = false; }
 };

src/helpers/ContactInfo.h

@@ -26,6 +26,12 @@ struct ContactInfo {
     return shared_secret;
   }
 
+  bool isFav() const { return flags & 0x01; }
+  bool isTelemBaseAllowed() const { return flags & 0x02; }
+  bool isTelemLocAllowed() const { return flags & 0x04; }
+  bool isTelemEnvAllowed() const { return flags & 0x08; }
+  bool isRemoteCLIAllowed() const { return flags & 0x10; }
+
 private:
   mutable uint8_t shared_secret[PUB_KEY_SIZE];
 };

src/helpers/DynamicConfigSerializer.cpp

@@ -0,0 +1,97 @@
+#include "DynamicConfigSerializer.h"
+#include <Utils.h>
+
+#define PROP_SEP_CHAR   '|'
+#define PROP_SEP_STR    "|"
+#define KEY_SEP_CHAR    ':'
+#define KEY_SEP_STR     ":"
+
+bool DynamicConfigSerializer::setByKeyPrv(const char* key, const char* value) {
+  if (_fallback && _fallback->setByKey(key, value)) return true;
+
+  // TODO: guard for bad chars (':' or '|')
+  char tmp[MAX_DYNAMIC_CONFG];
+  strcpy(tmp, _config);  // make a (modifiable) copy
+
+  const char* parts[8];
+  int n = mesh::Utils::parseTextParts(tmp, parts, 8, PROP_SEP_CHAR);
+
+  // add/replace in _config[]
+  char new_config[MAX_DYNAMIC_CONFG];
+  new_config[0] = 0;
+
+  int keylen = strlen(key);
+  for (int i = 0; i < n; i++) {
+    const char* item = parts[i];
+    if (item[keylen] == KEY_SEP_CHAR && memcmp(item, key, keylen) == 0) {
+      // key exists, so omit old value from this pass (will append new value at end)
+    } else {
+      if (new_config[0]) {
+        strcat(new_config, PROP_SEP_STR);
+      }
+      strcat(new_config, item);
+    }
+  }
+  // now append new key/value (if it fits)
+  if (strlen(new_config) + strlen(key) + strlen(value) + 2 < sizeof(_config)-1) {
+    if (new_config[0]) {
+      strcat(new_config, PROP_SEP_STR);
+    }
+    strcat(new_config, key);
+    strcat(new_config, KEY_SEP_STR);
+    strcat(new_config, value);
+    strcpy(_config, new_config);  // commit new serialized string
+    return true;
+  }
+  return false;   // didn't fit in _config[]
+}
+
+bool DynamicConfigSerializer::setByKey(const char* key, const char* value) {
+  if (setByKeyPrv(key, value)) {
+    markDirty();
+    return true;
+  }
+  return false;
+}
+
+bool DynamicConfigSerializer::getByKey(const char* key, char* value, size_t max_len) {
+  if (_fallback && _fallback->getByKey(key, value, max_len)) return true;
+
+  char tmp[MAX_DYNAMIC_CONFG];
+  strcpy(tmp, _config);  // make a (modifiable) copy
+
+  const char* parts[8];
+  int n = mesh::Utils::parseTextParts(tmp, parts, 8, PROP_SEP_CHAR);
+
+  int keylen = strlen(key);
+  for (int i = 0; i < n; i++) {
+    const char* item = parts[i];
+    if (item[keylen] == KEY_SEP_CHAR && memcmp(item, key, keylen) == 0) {
+      strncpy(value, &item[keylen+1], max_len);
+      value[max_len] = 0;
+      return true;
+    }
+  }
+  return false;
+}
+
+void DynamicConfigSerializer::structure() {
+  if (_context->op() == OP::WRITE) {
+    char tmp[MAX_DYNAMIC_CONFG];
+    strcpy(tmp, _config);  // make a (modifiable) copy
+
+    const char* parts[8];
+    int n = mesh::Utils::parseTextParts(tmp, parts, 8, PROP_SEP_CHAR);
+
+    for (int i = 0; i < n; i++) {
+      char* item = (char *) parts[i];
+      char* eq = strchr(item, KEY_SEP_CHAR);
+      if (eq) {
+        *eq = 0;   // replace separator with null terminator
+        def(item, eq + 1, MAX_DYNAMIC_CONFG/2);
+      }
+    }
+  } else {
+    setByKeyPrv(_context->getKey(getDepth()), _context->getToken());
+  }
+}

src/helpers/DynamicConfigSerializer.h

@@ -0,0 +1,23 @@
+#pragma once
+#include "ConfigSerializer.h"
+#include "KeyValueStore.h"
+
+#ifndef MAX_DYNAMIC_CONFG
+  #define MAX_DYNAMIC_CONFG  128
+#endif
+
+class DynamicConfigSerializer : public ConfigSerializer, public KeyValueStore {
+  char _config[MAX_DYNAMIC_CONFG];
+  KeyValueStore* _fallback;
+
+  bool setByKeyPrv(const char* key, const char* value);
+
+protected:
+  void structure() override;
+
+public:
+  DynamicConfigSerializer(KeyValueStore* fallback = NULL) : _fallback(fallback) { _config[0] = 0; }
+
+  bool setByKey(const char* key, const char* value) override;
+  bool getByKey(const char* key, char* value, size_t max_len) override;
+};

src/helpers/ESP32Board.h

@@ -15,6 +15,7 @@
 #include "soc/rtc.h"
 #include "esp_system.h"
 #include <driver/rtc_io.h>
+#include <helpers/KeyValueStore.h>
 
 class ESP32Board : public mesh::MainBoard {
 protected:
@@ -51,6 +52,8 @@ public:
   #endif    
   }
 
+  void attachDynamicPrefs(KeyValueStore* prefs) { }  // no-op
+
   // Temperature from ESP32 MCU
   float getMCUTemperature() override {
     uint32_t raw = 0;

src/helpers/KeyValueStore.h

@@ -0,0 +1,11 @@
+#pragma once
+#include <stdint.h>
+#include <string.h>
+
+class KeyValueStore {
+protected:
+  KeyValueStore() { }
+public:
+  virtual bool setByKey(const char* key, const char* value) { return false; }
+  virtual bool getByKey(const char* key, char* value, size_t max_len) { return false; }
+};

src/helpers/NRF52Board.h

@@ -2,6 +2,7 @@
 
 #include <Arduino.h>
 #include <MeshCore.h>
+#include <helpers/KeyValueStore.h>
 
 #if defined(NRF52_PLATFORM)
 
@@ -57,6 +58,8 @@ public:
   virtual void sleep(uint32_t secs) override;
   bool isExternalPowered() override;
 
+  void attachDynamicPrefs(KeyValueStore* prefs) { }  // no-op
+
 #ifdef NRF52_POWER_MANAGEMENT
   uint16_t getBootVoltage() override { return boot_voltage_mv; }
   virtual uint32_t getResetReason() const override { return reset_reason; }

src/helpers/TxtDataHelpers.h

@@ -4,8 +4,10 @@
 #include <stdint.h>
 
 #define TXT_TYPE_PLAIN          0      // a plain text message
-#define TXT_TYPE_CLI_DATA       1      // a CLI command
+#define TXT_TYPE_CLI_DATA       1      // a CLI command -or- reply
 #define TXT_TYPE_SIGNED_PLAIN   2      // plain text, signed by sender
+#define TXT_TYPE_CLI_COMMAND    3      // a CLI command (explictly)
+
 #define DATA_TYPE_RESERVED      0x0000 // reserved for future use
 #define DATA_TYPE_DEV           0xFFFF // developer namespace for experimenting with group/channel datagrams and building apps
 

src/helpers/stm32/STM32Board.h

@@ -2,6 +2,7 @@
 
 #include <MeshCore.h>
 #include <Arduino.h>
+#include <helpers/KeyValueStore.h>
 
 class STM32Board : public mesh::MainBoard {
 protected:
@@ -12,6 +13,8 @@ public:
     startup_reason = BD_STARTUP_NORMAL;
   }
 
+  void attachDynamicPrefs(KeyValueStore* prefs) { }  // no-op
+
   uint8_t getStartupReason() const override { return startup_reason; }
 
   uint16_t getBattMilliVolts() override {