feat(ota): manual update check + robust release parse, friendlier status (1.0.7)

Config-page "Check for updates now" button posts /api/ota/check, which sets
ota_check_now; otaAutoService() on Core 0 honors it immediately, bypassing the
6-hour timer (consumed only once the device is idle so it never interrupts a
pass/stream/upload).

Buffer the GitHub release JSON with getString() before parsing instead of
deserializing straight off the TLS stream. A mid-transfer stall -- seen on the
check that runs right after an STM flash -- was surfacing as a bare
"bad API response"; the body is now read whole within the timeout, and any real
parse failure reports the ArduinoJson error detail (and is logged with the body
length) so it can't be mistaken for "up to date".

Reword the result: both MCUs current -> "Up to date (ESP x, STM y)"; something
newer -> "Update available: ESP ... | STM ...".

Bump FW_VERSION 1.0.6 -> 1.0.7. Verified on hardware: repeated manual checks
report "Up to date (ESP 1.0.7, STM 1.0.6)" with no bad-response flicker.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: daniel-frenkel

version/r1.1/firmware/platformio/esp32_firmware_platformio/platformio.ini

@@ -63,7 +63,7 @@ build_flags =
     -DARDUINO_USB_CDC_ON_BOOT=1
     ; ESP32 firmware version: reported in the heartbeat and used by the OTA
     ; flow to decide whether this board needs updating. Bump on every release.
-    '-DFW_VERSION="1.0.6"'
+    '-DFW_VERSION="1.0.7"'
     ; Bootstrap token for register_device/capture transport auth. Sourced from
     ; the environment so the secret is never committed: set MSC_BOOTSTRAP_TOKEN
     ; before building (PowerShell: $env:MSC_BOOTSTRAP_TOKEN="..."; bash:

version/r1.1/firmware/platformio/esp32_firmware_platformio/src/config_portal.h

@@ -129,6 +129,7 @@ button.warn{background:#3a2326;color:#f87171;border:1px solid #5b2a2e}
 <div class=row><span class=k>Boot count</span><span class=v id=bootCount>&mdash;</span></div>
 <div class=row><span class=k>Firmware</span><span class=v id=fwVersion>&mdash;</span></div>
 <div class=row><span class=k>Update status</span><span class=v id=otaStatus>&mdash;</span></div>
+<button onclick=checkUpdate()>Check for updates now</button>
 </div>
 
 <div class=toast id=toast></div>
@@ -186,6 +187,10 @@ async function clearWifi(){
   await post('/api/clear',{});
   document.body.innerHTML='<h1>Cleared. Rebooting&hellip;</h1><p class=sub>Join the MiniSpeedCam WiFi to reconfigure.</p>';
 }
+async function checkUpdate(){
+  await post('/api/ota/check',{});
+  toast('Checking GitHub for updates...');
+}
 function syncStream(on){
   if(on===streamShown)return;
   const img=$('streamImg');
@@ -401,6 +406,16 @@ static esp_err_t portalStreamPost(httpd_req_t* req) {
   return httpd_resp_sendstr(req, "{\"ok\":true}");
 }
 
+// POST /api/ota/check -> request an immediate GitHub update check. Only sets the
+// flag; taskCore0's otaAutoService() runs the check (and applies any newer image)
+// the next time it's idle, bypassing the periodic timer. The result appears in
+// the "Update status" line the page already polls.
+static esp_err_t portalOtaCheckPost(httpd_req_t* req) {
+  ota_check_now = true;
+  httpd_resp_set_type(req, "application/json");
+  return httpd_resp_sendstr(req, "{\"ok\":true}");
+}
+
 static httpd_handle_t config_httpd = NULL;
 
 /**
@@ -417,7 +432,7 @@ void load_config_portal(void) {
   // /api/state polls; the old separate :81 stream server is gone (its sockets
   // freed), so this single server can afford more open sockets.
   config.max_open_sockets = 7;
-  config.max_uri_handlers = 8;
+  config.max_uri_handlers = 10;
   config.lru_purge_enable = true;
   config.stack_size       = 8192;   // headroom for ArduinoJson + String building
 
@@ -432,12 +447,14 @@ void load_config_portal(void) {
   httpd_uri_t u_wifi   = { .uri = "/api/wifi",     .method = HTTP_POST, .handler = portalWifiPost,     .user_ctx = NULL };
   httpd_uri_t u_clear  = { .uri = "/api/clear",    .method = HTTP_POST, .handler = portalClearPost,    .user_ctx = NULL };
   httpd_uri_t u_stream = { .uri = "/api/stream",   .method = HTTP_POST, .handler = portalStreamPost,   .user_ctx = NULL };
+  httpd_uri_t u_otachk = { .uri = "/api/ota/check",.method = HTTP_POST, .handler = portalOtaCheckPost, .user_ctx = NULL };
   httpd_register_uri_handler(config_httpd, &u_root);
   httpd_register_uri_handler(config_httpd, &u_state);
   httpd_register_uri_handler(config_httpd, &u_set);
   httpd_register_uri_handler(config_httpd, &u_wifi);
   httpd_register_uri_handler(config_httpd, &u_clear);
   httpd_register_uri_handler(config_httpd, &u_stream);
+  httpd_register_uri_handler(config_httpd, &u_otachk);
 
   // The aiming MJPEG stream shares this same server (GET /stream), shown inline
   // in a small window on the config page. See camera_stream.cpp.

version/r1.1/firmware/platformio/esp32_firmware_platformio/src/ota.h

@@ -122,10 +122,21 @@ bool otaCheckGithub() {
     filter["tag_name"] = true;
     filter["assets"][0]["name"] = true;
     filter["assets"][0]["browser_download_url"] = true;
-    JsonDocument doc;
-    DeserializationError err = deserializeJson(doc, https.getStream(), DeserializationOption::Filter(filter));
+    // Buffer the body before parsing. Reading the (large) release JSON straight
+    // off the TLS stream is fragile -- a mid-transfer stall (seen on the check
+    // that runs right after an STM flash) surfaces as "bad API response"
+    // (IncompleteInput). getString() reads the whole body within the timeout so
+    // the parser sees it intact; the error detail makes any recurrence concrete
+    // (and is NOT an "up to date" signal).
+    String body = https.getString();
     https.end();
-    if (err) { otaSetStatus("check: bad API response"); return false; }
+    JsonDocument doc;
+    DeserializationError err = deserializeJson(doc, body, DeserializationOption::Filter(filter));
+    if (err) {
+      Serial.printf("[OTA] api parse failed: %s (body=%u B)\n", err.c_str(), (unsigned)body.length());
+      otaSetStatus("check: bad API response (%s)", err.c_str());
+      return false;
+    }
 
     tag = (const char*)(doc["tag_name"] | "");
     for (JsonObject a : doc["assets"].as<JsonArray>()) {
@@ -171,12 +182,18 @@ bool otaCheckGithub() {
   // a valid health signal for the post-update watchdog (otaHealthService()).
   g_cloud_ok = true;
 
-  char espinfo[44], stminfo[44];
-  if (ota_esp_available) snprintf(espinfo, sizeof espinfo, "%s->%s", FW_VERSION, ota_esp_version.c_str());
-  else                   snprintf(espinfo, sizeof espinfo, "%s ok", FW_VERSION);
-  if (ota_stm_available) snprintf(stminfo, sizeof stminfo, "%s->%s", stm_fw_version.c_str(), ota_stm_version.c_str());
-  else                   snprintf(stminfo, sizeof stminfo, "%s ok", stm_fw_version.c_str());
-  otaSetStatus("ESP %s | STM %s", espinfo, stminfo);
+  if (!ota_esp_available && !ota_stm_available) {
+    // Both current -- the common, friendly "nothing to do" result.
+    otaSetStatus("Up to date (ESP %s, STM %s)", FW_VERSION, stm_fw_version.c_str());
+  } else {
+    // Something newer is available (and about to be applied below) -- show what.
+    char espinfo[44], stminfo[44];
+    if (ota_esp_available) snprintf(espinfo, sizeof espinfo, "%s->%s", FW_VERSION, ota_esp_version.c_str());
+    else                   snprintf(espinfo, sizeof espinfo, "%s ok", FW_VERSION);
+    if (ota_stm_available) snprintf(stminfo, sizeof stminfo, "%s->%s", stm_fw_version.c_str(), ota_stm_version.c_str());
+    else                   snprintf(stminfo, sizeof stminfo, "%s ok", stm_fw_version.c_str());
+    otaSetStatus("Update available: ESP %s | STM %s", espinfo, stminfo);
+  }
   return true;
 }
 
@@ -398,15 +415,21 @@ void otaAutoService() {
 
   if (stm_flash_busy) return;
   if (WiFi.getMode() != WIFI_STA || WiFi.status() != WL_CONNECTED) return;
-  if ((long)(millis() - nextCheck) < 0) return;
 
-  // Only act when idle. Don't advance the timer if busy, so we retry promptly
-  // once the current pass/stream/upload finishes (passes last only seconds).
+  // A manual "check now" (config-page button) bypasses the interval timer; the
+  // periodic check otherwise waits for nextCheck to elapse.
+  bool manual = ota_check_now;
+  if (!manual && (long)(millis() - nextCheck) < 0) return;
+
+  // Only act when idle. Don't advance the timer or consume the manual request if
+  // busy, so it retries promptly once the current pass/stream/upload finishes
+  // (passes last only seconds).
   bool idle = !g_run_active && !stream_active &&
               (uploadQueue == nullptr || uxQueueMessagesWaiting(uploadQueue) == 0);
   if (!idle) return;
 
-  nextCheck = millis() + OTA_CHECK_INTERVAL_MS;  // schedule the next check regardless of outcome
+  ota_check_now = false;                          // consume the manual request (if any)
+  nextCheck = millis() + OTA_CHECK_INTERVAL_MS;   // schedule the next periodic check regardless of outcome
 
   if (!otaCheckGithub()) return;
 

version/r1.1/firmware/platformio/esp32_firmware_platformio/src/variables.h

@@ -189,6 +189,10 @@ const char* server_github_latest = "https://api.github.com/repos/" GITHUB_OWNER
 // URLs/MD5s and the *_available flags are touched only on Core 0, so they need
 // no guarding.
 char ota_status[96] = "idle";
+// Manual "check for updates now" request from the config-page button. Set by the
+// POST /api/ota/check handler (httpd task) and consumed by otaAutoService() on
+// Core 0, which then runs a check immediately instead of waiting for the timer.
+volatile bool ota_check_now = false;
 String ota_esp_version, ota_esp_url, ota_esp_md5;
 String ota_stm_version, ota_stm_url, ota_stm_md5;
 bool ota_esp_available = false;