From fa300d4352d22b852f9397a7d621d49b4a679ab0 Mon Sep 17 00:00:00 2001
From: Splatink <splatink@splatink.gr>
Date: Sun, 15 Mar 2026 08:59:23 +0200
Subject: [PATCH] Added experimental 1.9 version

---
 telly-bme-v1.9.ino | 1177 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 1177 insertions(+)
 create mode 100644 telly-bme-v1.9.ino

diff --git a/telly-bme-v1.9.ino b/telly-bme-v1.9.ino
new file mode 100644
index 0000000..f3a53e3
--- /dev/null
+++ b/telly-bme-v1.9.ino
@@ -0,0 +1,1177 @@
+/*
+ * telly-bme v1.9
+ * ESP32-C3 BME280 sensor shell with telnet interface
+ */
+
+#include <BME280I2C.h>
+#include <Wire.h>
+#include <WiFi.h>
+#include <WiFiClient.h>
+#include <NetworkClient.h>
+#include <NetworkServer.h>
+#include <Preferences.h>
+#include <driver/gpio.h>
+#include <ThreeWire.h>
+#include <RtcDS1302.h>
+#include <LittleFS.h>
+#include <HTTPClient.h>
+#include <lwip/sockets.h>
+#include <lwip/netdb.h>
+#include <lwip/icmp.h>
+#include <lwip/ip.h>
+#include <lwip/ip_addr.h>
+#include <math.h>
+
+// ── Pin definitions ───────────────────────────────────────────────────────────
+#define DATA     1
+#define CLOCK    0
+#define WAKE_PIN 2
+#define RUN_PIN  8
+#define BATT_PIN 3
+#define RTC_CLK  6
+#define RTC_DAT  4
+#define RTC_RST  5
+
+// ── Config ────────────────────────────────────────────────────────────────────
+#define VERSION        "1.9"
+#define NAME           "telly-bme"
+#define AP_SSID        "telly-bme-setup"
+#define RESET_HOLD_MS  10000
+#define BLINK_MS       150
+
+#define BATT_MAX_V        4.20f
+#define BATT_MIN_V        3.00f
+#define BATT_CAPACITY     3000.0f
+#define BATT_SLEEP_MA     0.0095f
+#define BATT_AWAKE_MA     50.0f
+#define BATT_WAKE_S       60.0f
+#define BATT_WAKES_PER_HR 1.0f
+#define ADC_SAMPLES       16
+#define ADC_VREF          3.3f
+#define ADC_RESOLUTION    4095.0f
+#define DIVIDER_RATIO     2.0f
+#define ADC_CAL           0.909f
+
+#define HISTORY_SIZE 10
+#define MAX_CMD_LEN  128
+
+#define ED_MAX_LINES    200
+#define ED_MAX_LINE_LEN 256
+#define ED_MAX_FILENAME  64
+
+#define IAC 255
+
+// ── Key codes ────────────────────────────────────────────────────────────────
+#define KEY_NONE      0
+#define KEY_UP        1001
+#define KEY_DOWN      1002
+#define KEY_LEFT      1003
+#define KEY_RIGHT     1004
+#define KEY_HOME      1005
+#define KEY_END       1006
+#define KEY_DEL       1007
+#define KEY_BACKSPACE 1008
+#define KEY_ENTER     1009
+#define KEY_ESC       1010
+
+// ── TelnetStream ─────────────────────────────────────────────────────────────
+struct TelnetStream {
+  NetworkClient *client = nullptr;
+
+  void begin(NetworkClient &c) { client = &c; }
+
+  void flushNegotiation() {
+    unsigned long start = millis();
+    while (millis() - start < 500) {
+      while (client->available()) {
+        uint8_t b = client->read();
+        if (b == IAC) {
+          unsigned long t = millis();
+          while (client->available() < 2 && millis() - t < 100);
+          if (client->available() >= 2) { client->read(); client->read(); }
+        }
+      }
+      delay(10);
+    }
+  }
+
+  int readRaw() {
+    while (client->available()) {
+      uint8_t b = client->read();
+      if (b == IAC) {
+        unsigned long t = millis();
+        while (client->available() < 2 && millis() - t < 50);
+        if (client->available() >= 2) { client->read(); client->read(); }
+        continue;
+      }
+      return b;
+    }
+    return -1;
+  }
+
+  int readRawTimeout(int timeoutMs = 150) {
+    unsigned long start = millis();
+    while (millis() - start < (unsigned long)timeoutMs) {
+      int b = readRaw();
+      if (b >= 0) return b;
+      yield();
+    }
+    return -1;
+  }
+
+  int readKey() {
+    int b = readRaw();
+    if (b < 0) return KEY_NONE;
+    if (b == 0x1B) {
+      int b2 = readRawTimeout(80);
+      if (b2 < 0) return KEY_ESC;
+      if (b2 == '[') {
+        int b3 = readRawTimeout(80);
+        if (b3 < 0) return KEY_ESC;
+        if (b3 >= '0' && b3 <= '9') {
+          int num = b3 - '0';
+          int b4 = readRawTimeout(80);
+          while (b4 >= '0' && b4 <= '9') { num = num*10+(b4-'0'); b4=readRawTimeout(80); }
+          switch (num) {
+            case 1: case 7: return KEY_HOME;
+            case 4: case 8: return KEY_END;
+            case 3: return KEY_DEL;
+            default: return KEY_NONE;
+          }
+        }
+        switch (b3) {
+          case 'A': return KEY_UP;    case 'B': return KEY_DOWN;
+          case 'C': return KEY_RIGHT; case 'D': return KEY_LEFT;
+          case 'H': return KEY_HOME;  case 'F': return KEY_END;
+          default:  return KEY_NONE;
+        }
+      }
+      if (b2 == 'O') {
+        int b3 = readRawTimeout(80);
+        switch (b3) {
+          case 'H': return KEY_HOME; case 'F': return KEY_END;
+          case 'A': return KEY_UP;   case 'B': return KEY_DOWN;
+          case 'C': return KEY_RIGHT;case 'D': return KEY_LEFT;
+          default:  return KEY_NONE;
+        }
+      }
+      return KEY_ESC;
+    }
+    if (b == '\r') { readRawTimeout(20); return KEY_ENTER; }
+    if (b == '\n')           return KEY_ENTER;
+    if (b == 0x7F || b == 0x08) return KEY_BACKSPACE;
+    return b;
+  }
+} ts;
+
+// ── Persistent config ─────────────────────────────────────────────────────────
+Preferences prefs;
+struct NetConfig {
+  char ssid[64], pass[64];
+  bool staticIP, configured;
+  uint32_t ip, gw, sn;
+};
+NetConfig netCfg;
+
+void loadNetConfig() {
+  prefs.begin("net", true);
+  netCfg.configured = prefs.getBool("configured", false);
+  netCfg.staticIP   = prefs.getBool("staticIP",   false);
+  netCfg.ip = prefs.getUInt("ip", 0); netCfg.gw = prefs.getUInt("gw", 0);
+  netCfg.sn = prefs.getUInt("sn", 0);
+  prefs.getString("ssid", netCfg.ssid, sizeof(netCfg.ssid));
+  prefs.getString("pass", netCfg.pass, sizeof(netCfg.pass));
+  prefs.end();
+}
+void saveNetConfig() {
+  prefs.begin("net", false);
+  prefs.putBool("configured", netCfg.configured);
+  prefs.putBool("staticIP",   netCfg.staticIP);
+  prefs.putUInt("ip", netCfg.ip); prefs.putUInt("gw", netCfg.gw);
+  prefs.putUInt("sn", netCfg.sn);
+  prefs.putString("ssid", netCfg.ssid); prefs.putString("pass", netCfg.pass);
+  prefs.end();
+}
+void eraseNetConfig() {
+  prefs.begin("net", false); prefs.clear(); prefs.end();
+  memset(&netCfg, 0, sizeof(netCfg));
+}
+
+// ── RTC DATA ATTR ─────────────────────────────────────────────────────────────
+RTC_DATA_ATTR bool     rtcValid = false;
+RTC_DATA_ATTR uint8_t  rtcBSSID[6];
+RTC_DATA_ATTR int32_t  rtcChannel;
+RTC_DATA_ATTR uint32_t rtcIP, rtcGW, rtcSN, rtcDNS;
+
+// ── Globals ───────────────────────────────────────────────────────────────────
+BME280I2C bme;
+NetworkServer server(23);
+ThreeWire myWire(RTC_DAT, RTC_CLK, RTC_RST);
+RtcDS1302<ThreeWire> rtcModule(myWire);
+
+unsigned long bootTime = 0;
+bool apMode   = false;
+bool btnArmed = false;
+unsigned long btnSince = 0;
+
+// ── LED ───────────────────────────────────────────────────────────────────────
+bool blinkActive=false, blinkState=false;
+unsigned long lastBlink=0;
+void blinkTick() {
+  if (!blinkActive) return;
+  if (millis()-lastBlink >= BLINK_MS) {
+    blinkState=!blinkState;
+    digitalWrite(RUN_PIN, blinkState?0:1);
+    lastBlink=millis();
+  }
+}
+void ledOn()    { blinkActive=false; digitalWrite(RUN_PIN,0); }
+void ledOff()   { blinkActive=false; digitalWrite(RUN_PIN,1); }
+void ledBlink() { blinkActive=true;  lastBlink=millis(); }
+
+// ── Battery ───────────────────────────────────────────────────────────────────
+float readBatteryVoltage() {
+  for (int i=0;i<5;i++) { analogRead(BATT_PIN); delay(10); }
+  long sum=0;
+  for (int i=0;i<ADC_SAMPLES;i++) { sum+=analogRead(BATT_PIN); delay(2); }
+  return (sum/(float)ADC_SAMPLES/ADC_RESOLUTION)*ADC_VREF*DIVIDER_RATIO*ADC_CAL;
+}
+int batteryPercent(float v) {
+  if (v>=BATT_MAX_V) return 100;
+  if (v<=BATT_MIN_V) return 0;
+  struct { float v; int p; } c[] = {
+    {4.20f,100},{4.10f,90},{4.00f,80},{3.90f,70},{3.80f,60},
+    {3.70f,50},{3.60f,40},{3.50f,30},{3.40f,20},{3.20f,10},{3.00f,0}
+  };
+  for (int i=0;i<10;i++)
+    if (v<=c[i].v&&v>=c[i+1].v)
+      return (int)(c[i+1].p+(v-c[i+1].v)/(c[i].v-c[i+1].v)*(c[i].p-c[i+1].p));
+  return 0;
+}
+float estimateRuntime(float v) {
+  float rem=BATT_CAPACITY*(batteryPercent(v)/100.0f);
+  float awake=BATT_WAKES_PER_HR*BATT_WAKE_S;
+  float avg=(BATT_AWAKE_MA*awake+BATT_SLEEP_MA*(3600.0f-awake))/3600.0f;
+  return avg>0?rem/avg:0;
+}
+String batteryInline() {
+  float v=readBatteryVoltage();
+  char buf[24]; snprintf(buf,sizeof(buf),"%.2fV %d%%",v,batteryPercent(v));
+  return String(buf);
+}
+
+// ── RTC ───────────────────────────────────────────────────────────────────────
+bool rtcGetDateTime(RtcDateTime &out) {
+  for (int i=0;i<3;i++) {
+    if (rtcModule.GetIsRunning()&&rtcModule.IsDateTimeValid()) {
+      out=rtcModule.GetDateTime();
+      if (out.Year()>=2020&&out.Year()<=2099) return true;
+    }
+    delay(10);
+  }
+  return false;
+}
+String formatDateTime(const RtcDateTime &dt) {
+  char buf[32];
+  snprintf(buf,sizeof(buf),"%04d-%02d-%02d %02d:%02d:%02d",
+           dt.Year(),dt.Month(),dt.Day(),dt.Hour(),dt.Minute(),dt.Second());
+  return String(buf);
+}
+bool parseDateTime(const String &s, RtcDateTime &out) {
+  if (s.length()<19) return false;
+  int yr=s.substring(0,4).toInt(),mo=s.substring(5,7).toInt(),
+      dy=s.substring(8,10).toInt(),hr=s.substring(11,13).toInt(),
+      mn=s.substring(14,16).toInt(),sc=s.substring(17,19).toInt();
+  if (yr<2020||yr>2099||mo<1||mo>12||dy<1||dy>31||hr>23||mn>59||sc>59) return false;
+  out=RtcDateTime(yr-2000,mo,dy,hr,mn,sc); return true;
+}
+
+// ── Arg parser ────────────────────────────────────────────────────────────────
+int parseArgs(const String &str, String *args, int maxArgs) {
+  int count=0,i=0,len=str.length();
+  while (i<len&&count<maxArgs) {
+    while (i<len&&str[i]==' ') i++;
+    if (i>=len) break;
+    if (str[i]=='"') {
+      i++; String tok="";
+      while (i<len&&str[i]!='"') tok+=str[i++];
+      if (i<len) i++;
+      args[count++]=tok;
+    } else {
+      String tok="";
+      while (i<len&&str[i]!=' ') tok+=str[i++];
+      args[count++]=tok;
+    }
+  }
+  return count;
+}
+
+// ── Line editor ───────────────────────────────────────────────────────────────
+struct History {
+  String entries[HISTORY_SIZE];
+  int count=0, head=0;
+  void push(const String &cmd) {
+    if (!cmd.length()) return;
+    if (count>0&&entries[(head-1+HISTORY_SIZE)%HISTORY_SIZE]==cmd) return;
+    entries[head]=cmd; head=(head+1)%HISTORY_SIZE;
+    if (count<HISTORY_SIZE) count++;
+  }
+  String get(int offset) {
+    if (offset<1||offset>count) return "";
+    return entries[(head-offset+HISTORY_SIZE*10)%HISTORY_SIZE];
+  }
+} cmdHistory;
+
+void printPrompt(NetworkClient &client) {
+  client.print(apMode ? "[setup] ~> " : "~> ");
+}
+
+static void redrawLine(NetworkClient &client, const String &buf, int cursor) {
+  client.print("\r");
+  client.print(apMode ? "[setup] ~> " : "~> ");
+  client.print(buf);
+  client.print("\033[K");
+  int tail=buf.length()-cursor;
+  if (tail>0) client.printf("\033[%dD",tail);
+}
+
+String readCommand(NetworkClient &client) {
+  String buf=""; int cursor=0, histOff=0; String savedBuf="";
+  while (client.connected()) {
+    blinkTick();
+    int k=ts.readKey();
+    if (k==KEY_NONE) { yield(); continue; }
+    switch (k) {
+      case KEY_ENTER: {
+        client.print("\r\n");
+        String cmd=buf; cmd.trim();
+        cmdHistory.push(cmd); return cmd;
+      }
+      case KEY_BACKSPACE:
+        if (cursor>0) { buf.remove(cursor-1,1); cursor--; redrawLine(client,buf,cursor); }
+        break;
+      case KEY_DEL:
+        if (cursor<(int)buf.length()) { buf.remove(cursor,1); redrawLine(client,buf,cursor); }
+        break;
+      case KEY_LEFT:
+        if (cursor>0) { cursor--; client.print("\033[D"); } break;
+      case KEY_RIGHT:
+        if (cursor<(int)buf.length()) { cursor++; client.print("\033[C"); } break;
+      case KEY_HOME:
+        if (cursor>0) { client.printf("\033[%dD",cursor); cursor=0; } break;
+      case KEY_END:
+        if (cursor<(int)buf.length()) {
+          client.printf("\033[%dC",buf.length()-cursor); cursor=buf.length();
+        } break;
+      case KEY_UP:
+        if (histOff==0) savedBuf=buf;
+        if (histOff<cmdHistory.count) {
+          histOff++; buf=cmdHistory.get(histOff); cursor=buf.length();
+          redrawLine(client,buf,cursor);
+        } break;
+      case KEY_DOWN:
+        if (histOff>0) {
+          histOff--;
+          buf=(histOff==0)?savedBuf:cmdHistory.get(histOff);
+          cursor=buf.length(); redrawLine(client,buf,cursor);
+        } break;
+      case KEY_ESC:
+        buf=""; cursor=0; redrawLine(client,buf,cursor); break;
+      default:
+        if (k>=0x20&&k<0x7F&&(int)buf.length()<MAX_CMD_LEN) {
+          buf=buf.substring(0,cursor)+(char)k+buf.substring(cursor);
+          cursor++;
+          if (cursor==(int)buf.length()) client.write((char)k);
+          else redrawLine(client,buf,cursor);
+        }
+        break;
+    }
+  }
+  return "";
+}
+
+// ── Sleep ─────────────────────────────────────────────────────────────────────
+void goToSleep() {
+  ledOff();
+  while (digitalRead(WAKE_PIN)==LOW) delay(10);
+  delay(50);
+  esp_deep_sleep_enable_gpio_wakeup(1ULL<<WAKE_PIN,ESP_GPIO_WAKEUP_GPIO_LOW);
+  esp_deep_sleep_start();
+}
+
+// ── WiFi ──────────────────────────────────────────────────────────────────────
+void startAP() {
+  apMode=true; rtcValid=false;
+  WiFi.mode(WIFI_AP); WiFi.softAP(AP_SSID);
+  server.begin(); ledBlink();
+}
+void connectWiFi() {
+  apMode=false; ledOff();
+  WiFi.mode(WIFI_STA); WiFi.setHostname("esp32-bme");
+  if (netCfg.staticIP&&netCfg.ip)
+    WiFi.config(IPAddress(netCfg.ip),IPAddress(netCfg.gw),IPAddress(netCfg.sn));
+  else if (rtcValid)
+    WiFi.config(IPAddress(rtcIP),IPAddress(rtcGW),IPAddress(rtcSN),IPAddress(rtcDNS));
+  if (rtcValid&&!netCfg.staticIP)
+    WiFi.begin(netCfg.ssid,netCfg.pass,rtcChannel,rtcBSSID,true);
+  else
+    WiFi.begin(netCfg.ssid,netCfg.pass);
+  unsigned long start=millis();
+  while (WiFi.status()!=WL_CONNECTED) {
+    delay(500);
+    if (millis()-start>15000) { rtcValid=false; startAP(); return; }
+  }
+  rtcChannel=WiFi.channel(); memcpy(rtcBSSID,WiFi.BSSID(),6);
+  rtcIP=(uint32_t)WiFi.localIP(); rtcGW=(uint32_t)WiFi.gatewayIP();
+  rtcSN=(uint32_t)WiFi.subnetMask(); rtcDNS=(uint32_t)WiFi.dnsIP();
+  rtcValid=true; server.begin(); ledOn();
+}
+
+// ── ed-style line editor ──────────────────────────────────────────────────────
+
+struct Ed {
+  String lines[ED_MAX_LINES];
+  int    numLines = 0;
+  int    cur      = 0;   // current line (0-indexed)
+  bool   modified = false;
+  char   filename[ED_MAX_FILENAME] = "";
+
+  void init(const char *fname) {
+    numLines=0; cur=0; modified=false;
+    strncpy(filename,fname,ED_MAX_FILENAME-1);
+    File f=LittleFS.open(filename,"r");
+    if (f) {
+      while (f.available()&&numLines<ED_MAX_LINES) {
+        String l=f.readStringUntil('\n'); l.replace("\r","");
+        lines[numLines++]=l;
+      }
+      f.close();
+    }
+    if (numLines==0) { lines[0]=""; numLines=1; }
+    cur=numLines-1;
+  }
+
+  bool save() {
+    File f=LittleFS.open(filename,"w");
+    if (!f) return false;
+    for (int i=0;i<numLines;i++) { f.print(lines[i]); f.print("\n"); }
+    f.close(); modified=false; return true;
+  }
+
+  // ── Address parsing ───────────────────────────────────────────────────────
+  // Resolves a single address token: number, '.', '$', or empty (returns cur)
+  // Returns -1 on error
+  int resolveAddr(const String &s) {
+    if (s==""||s==".") return cur;
+    if (s=="$") return numLines-1;
+    int n=s.toInt();
+    if (n<1||n>numLines) return -1;
+    return n-1;
+  }
+
+  // Parse "addr1,addr2cmd args" or "addrcmd args"
+  // Fills a1,a2 (0-indexed line range) and cmd char and rest of args
+  // Returns false if unparseable
+  bool parseCommand(const String &input, int &a1, int &a2, char &cmd, String &args) {
+    a1=cur; a2=cur; args="";
+    int i=0; int len=input.length();
+    if (len==0) return false;
+
+    // Read first address
+    String addrBuf="";
+    while (i<len&&(isDigit(input[i])||input[i]=='.'||input[i]=='$')) addrBuf+=input[i++];
+
+    bool hasAddr=addrBuf.length()>0;
+    int addr1=resolveAddr(addrBuf);
+    if (hasAddr&&addr1<0) return false;
+    if (hasAddr) { a1=addr1; a2=addr1; }
+
+    // Check for comma (range)
+    if (i<len&&input[i]==',') {
+      i++;
+      String addr2Buf="";
+      while (i<len&&(isDigit(input[i])||input[i]=='.'||input[i]=='$')) addr2Buf+=input[i++];
+      // % is shorthand for 1,$
+      int addr2=resolveAddr(addr2Buf==""?"$":addr2Buf);
+      if (addr2<0) return false;
+      a2=addr2;
+    }
+
+    // % shorthand for whole file
+    if (!hasAddr&&i<len&&input[i]=='%') {
+      a1=0; a2=numLines-1; i++;
+    }
+
+    if (i>=len) { cmd='\0'; return true; }
+    cmd=input[i++];
+    args=input.substring(i); args.trim();
+    return true;
+  }
+
+  // ── Read input lines until lone "." ───────────────────────────────────────
+  void readInputLines(NetworkClient &cl, String *out, int &count, int maxLines) {
+    count=0;
+    cl.print("  (end with a line containing only .)\r\n");
+    while (cl.connected()&&count<maxLines) {
+      cl.print("  ");
+      String line=readCommand(cl);
+      if (line==".") break;
+      out[count++]=line;
+    }
+  }
+
+  // ── Substitute s/from/to/[g] on a single line ─────────────────────────────
+  bool substitute(String &line, const String &from, const String &to, bool global) {
+    if (from.length()==0) return false;
+    bool changed=false;
+    if (global) {
+      int pos=0;
+      String result="";
+      while (pos<=(int)line.length()) {
+        int found=line.indexOf(from,pos);
+        if (found<0) { result+=line.substring(pos); break; }
+        result+=line.substring(pos,found)+to;
+        pos=found+from.length();
+        changed=true;
+        if (from.length()==0) break;
+      }
+      if (changed) line=result;
+    } else {
+      int found=line.indexOf(from);
+      if (found>=0) {
+        line=line.substring(0,found)+to+line.substring(found+from.length());
+        changed=true;
+      }
+    }
+    return changed;
+  }
+
+  // Parse s/from/to/[g]
+  bool parseSubst(const String &args, String &from, String &to, bool &global) {
+    if (args.length()<2||args[0]!='/') return false;
+    char delim=args[0];
+    int p1=args.indexOf(delim,1);
+    if (p1<0) return false;
+    int p2=args.indexOf(delim,p1+1);
+    if (p2<0) return false;
+    from=args.substring(1,p1);
+    to=args.substring(p1+1,p2);
+    global=(args.length()>p2+1&&args[p2+1]=='g');
+    return true;
+  }
+
+  // ── Main run loop ─────────────────────────────────────────────────────────
+  void run(NetworkClient &cl) {
+    cl.printf("  \"%s\" %d lines\r\n", filename, numLines);
+    cl.print("  Commands: p n = i a c d s/// m w q q!  (type 'h' for help)\r\n");
+
+    while (cl.connected()) {
+      cl.print(":");
+      String input=readCommand(cl);
+      if (!cl.connected()) break;
+      input.trim();
+      if (input.length()==0) {
+        // bare Enter — advance one line and print it
+        if (cur<numLines-1) cur++;
+        cl.printf("%s\r\n",lines[cur].c_str());
+        continue;
+      }
+
+      // Special: h for help
+      if (input=="h") {
+        cl.print(
+          "  Addressing\r\n"
+          "    .          current line\r\n"
+          "    $          last line\r\n"
+          "    N          line number\r\n"
+          "    N,M        line range\r\n"
+          "    %          all lines (same as 1,$)\r\n"
+          "  Commands\r\n"
+          "    p          print line(s)\r\n"
+          "    n          print line(s) with line numbers\r\n"
+          "    =          print line count / current line number\r\n"
+          "    i          insert line(s) before current (end with .)\r\n"
+          "    a          append line(s) after current (end with .)\r\n"
+          "    c          change (replace) line(s) with new input\r\n"
+          "    d          delete line(s)\r\n"
+          "    m N        move line(s) after line N\r\n"
+          "    s/x/y/     substitute x with y on current line\r\n"
+          "    s/x/y/g    substitute all occurrences\r\n"
+          "    N,Ms/x/y/g substitute over range\r\n"
+          "    w          save file\r\n"
+          "    q          quit (warns if unsaved)\r\n"
+          "    q!         force quit\r\n"
+          "    wq         save and quit\r\n"
+        );
+        continue;
+      }
+
+      int a1,a2; char cmd; String args;
+      if (!parseCommand(input,a1,a2,cmd,args)) {
+        cl.print("  ?\r\n"); continue;
+      }
+
+      // Validate range
+      if (a1<0||a1>=numLines||a2<a1||a2>=numLines) {
+        cl.print("  ? (address out of range)\r\n"); continue;
+      }
+
+      switch (cmd) {
+        case '\0':
+          // Just an address — print that line and move there
+          cur=a2;
+          cl.printf("%s\r\n",lines[cur].c_str());
+          break;
+
+        case 'p':
+          for (int i=a1;i<=a2;i++) cl.printf("%s\r\n",lines[i].c_str());
+          cur=a2;
+          break;
+
+        case 'n':
+          for (int i=a1;i<=a2;i++) cl.printf("%4d  %s\r\n",i+1,lines[i].c_str());
+          cur=a2;
+          break;
+
+        case '=':
+          if (input=="=")
+            cl.printf("  %d lines total, current line %d\r\n",numLines,cur+1);
+          else
+            cl.printf("  %d\r\n",a2+1);
+          break;
+
+        case 'i': {
+          String newLines[ED_MAX_LINES]; int count=0;
+          readInputLines(cl,newLines,count,ED_MAX_LINES-numLines);
+          if (count>0) {
+            // Shift lines down
+            for (int i=numLines+count-1;i>=a1+count;i--) lines[i]=lines[i-count];
+            for (int i=0;i<count;i++) lines[a1+i]=newLines[i];
+            numLines+=count; cur=a1+count-1; modified=true;
+          }
+          break;
+        }
+
+        case 'a': {
+          String newLines[ED_MAX_LINES]; int count=0;
+          readInputLines(cl,newLines,count,ED_MAX_LINES-numLines);
+          int insertAt=a2+1;
+          if (count>0) {
+            for (int i=numLines+count-1;i>=insertAt+count;i--) lines[i]=lines[i-count];
+            for (int i=0;i<count;i++) lines[insertAt+i]=newLines[i];
+            numLines+=count; cur=insertAt+count-1; modified=true;
+          }
+          break;
+        }
+
+        case 'c': {
+          // Delete range, insert new lines
+          int delCount=a2-a1+1;
+          String newLines[ED_MAX_LINES]; int count=0;
+          readInputLines(cl,newLines,count,ED_MAX_LINES-numLines+delCount);
+          // Delete old lines
+          for (int i=a1;i<numLines-delCount;i++) lines[i]=lines[i+delCount];
+          numLines-=delCount;
+          // Insert new
+          for (int i=numLines+count-1;i>=a1+count;i--) lines[i]=lines[i-count];
+          for (int i=0;i<count;i++) lines[a1+i]=newLines[i];
+          numLines+=count;
+          if (numLines==0) { lines[0]=""; numLines=1; }
+          cur=count>0?a1+count-1:max(0,a1-1);
+          modified=true;
+          break;
+        }
+
+        case 'd': {
+          int delCount=a2-a1+1;
+          for (int i=a1;i<numLines-delCount;i++) lines[i]=lines[i+delCount];
+          numLines-=delCount;
+          if (numLines==0) { lines[0]=""; numLines=1; }
+          cur=min(a1,numLines-1);
+          modified=true;
+          cl.printf("  (%d line%s deleted)\r\n",delCount,delCount==1?"":"s");
+          break;
+        }
+
+        case 'm': {
+          // Move lines a1-a2 after line dest
+          int dest=args.toInt()-1;
+          if (dest<-1||dest>=numLines||(dest>=a1&&dest<=a2)) {
+            cl.print("  ? (invalid destination)\r\n"); break;
+          }
+          int count=a2-a1+1;
+          // Copy lines to temp
+          String tmp[ED_MAX_LINES];
+          for (int i=0;i<count;i++) tmp[i]=lines[a1+i];
+          // Remove from original position
+          for (int i=a1;i<numLines-count;i++) lines[i]=lines[i+count];
+          numLines-=count;
+          // Adjust dest for removal
+          int insertAt=dest>a2?dest-count+1:dest+1;
+          if (insertAt<0) insertAt=0;
+          // Insert
+          for (int i=numLines+count-1;i>=insertAt+count;i--) lines[i]=lines[i-count];
+          for (int i=0;i<count;i++) lines[insertAt+i]=tmp[i];
+          numLines+=count;
+          cur=insertAt+count-1; modified=true;
+          break;
+        }
+
+        case 's': {
+          String from,to; bool global=false;
+          if (!parseSubst(args,from,to,global)) { cl.print("  ? (bad syntax, use s/from/to/ or s/from/to/g)\r\n"); break; }
+          int changed=0;
+          for (int i=a1;i<=a2;i++) if (substitute(lines[i],from,to,global)) changed++;
+          if (changed) { modified=true; cl.printf("  (%d line%s changed)\r\n",changed,changed==1?"":"s"); }
+          else cl.print("  (no match)\r\n");
+          cur=a2;
+          break;
+        }
+
+        case 'w':
+          if (save()) cl.printf("  \"%s\" %d lines written\r\n",filename,numLines);
+          else        cl.print("  ? (write failed)\r\n");
+          break;
+
+        case 'q':
+          if (modified) { cl.print("  ? (unsaved changes — use q! to force quit or w to save)\r\n"); break; }
+          cl.print("\r\n"); return;
+
+        default:
+          cl.print("  ? (unknown command, type h for help)\r\n");
+          break;
+      }
+
+      // Handle wq as a combined command
+      if (input=="wq"||input=="wq!") {
+        if (save()) { cl.printf("  \"%s\" written\r\n",filename); cl.print("\r\n"); return; }
+        else { cl.print("  ? (write failed)\r\n"); }
+      }
+      if (input=="q!") { cl.print("\r\n"); return; }
+    }
+  }
+} ed;
+
+// ── File commands ─────────────────────────────────────────────────────────────
+void cmdLs(NetworkClient &cl) {
+  File root=LittleFS.open("/");
+  if (!root||!root.isDirectory()) { cl.print("Error opening filesystem.\r\n"); return; }
+  cl.print("\r\n  Files on flash:\r\n");
+  int n=0; File f=root.openNextFile();
+  while (f) {
+    cl.printf("    %-36s  %6lu bytes\r\n",f.name(),f.size());
+    n++; f=root.openNextFile();
+  }
+  if (!n) cl.print("    (no files)\r\n");
+  size_t total=LittleFS.totalBytes(),used=LittleFS.usedBytes();
+  cl.printf("\r\n  Used: %u / %u bytes (%.1f%%)\r\n\r\n",used,total,100.0f*used/total);
+}
+void cmdCat(NetworkClient &cl, const String &name) {
+  String path=name.startsWith("/")?name:"/"+name;
+  if (!LittleFS.exists(path)) { cl.printf("Not found: %s\r\n",path.c_str()); return; }
+  File f=LittleFS.open(path,"r");
+  if (!f) { cl.print("Error opening file.\r\n"); return; }
+  while (f.available()) { char c=f.read(); if (c=='\n') cl.print("\r\n"); else cl.write(c); }
+  f.close(); cl.print("\r\n");
+}
+void cmdRm(NetworkClient &cl, const String &name) {
+  String path=name.startsWith("/")?name:"/"+name;
+  if (!LittleFS.exists(path)) { cl.printf("Not found: %s\r\n",path.c_str()); return; }
+  cl.print(LittleFS.remove(path)?"Deleted.\r\n":"Error deleting.\r\n");
+}
+
+// ── ping ──────────────────────────────────────────────────────────────────────
+void cmdPing(NetworkClient &cl, const String &host, int count=4) {
+  // Resolve hostname
+  struct hostent *he = gethostbyname(host.c_str());
+  if (!he) { cl.printf("ping: cannot resolve %s\r\n", host.c_str()); return; }
+  struct in_addr addr; memcpy(&addr, he->h_addr, sizeof(addr));
+  char ipStr[16]; inet_ntoa_r(addr, ipStr, sizeof(ipStr));
+  cl.printf("PING %s (%s)\r\n", host.c_str(), ipStr);
+
+  int sock = socket(AF_INET, SOCK_RAW, IP_PROTO_ICMP);
+  if (sock < 0) { cl.print("ping: failed to create socket (needs root?)\r\n"); return; }
+
+  struct timeval tv; tv.tv_sec=2; tv.tv_usec=0;
+  setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
+
+  struct sockaddr_in dest;
+  memset(&dest,0,sizeof(dest));
+  dest.sin_family=AF_INET;
+  memcpy(&dest.sin_addr, he->h_addr, sizeof(dest.sin_addr));
+
+  int sent=0, received=0;
+  long minMs=99999, maxMs=0, totalMs=0;
+
+  for (int seq=1; seq<=count; seq++) {
+    // Build ICMP echo request
+    uint8_t pkt[64]; memset(pkt,0,sizeof(pkt));
+    struct icmp_echo_hdr *icmp=(struct icmp_echo_hdr*)pkt;
+    ICMPH_TYPE_SET(icmp, ICMP_ECHO);
+    ICMPH_CODE_SET(icmp, 0);
+    icmp->id    = htons(0x1234);
+    icmp->seqno = htons(seq);
+    // Fill payload
+    for (int i=sizeof(struct icmp_echo_hdr);i<64;i++) pkt[i]=(uint8_t)(i&0xFF);
+    // Checksum
+    icmp->chksum=0;
+    uint32_t sum=0;
+    for (int i=0;i<64;i+=2) sum+=((uint16_t)pkt[i]<<8)|pkt[i+1];
+    while (sum>>16) sum=(sum&0xFFFF)+(sum>>16);
+    icmp->chksum=htons(~sum);
+
+    unsigned long t0=millis();
+    int s=sendto(sock,(void*)pkt,sizeof(pkt),0,(struct sockaddr*)&dest,sizeof(dest));
+    sent++;
+
+    if (s<0) { cl.printf("Request %d: send failed\r\n",seq); delay(1000); continue; }
+
+    // Wait for reply
+    uint8_t rbuf[128];
+    struct sockaddr_in from; socklen_t fromLen=sizeof(from);
+    int r=recvfrom(sock,rbuf,sizeof(rbuf),0,(struct sockaddr*)&from,&fromLen);
+    long ms=(long)(millis()-t0);
+
+    if (r>0) {
+      received++;
+      totalMs+=ms;
+      if (ms<minMs) minMs=ms;
+      if (ms>maxMs) maxMs=ms;
+      char fromIp[16]; inet_ntoa_r(from.sin_addr,fromIp,sizeof(fromIp));
+      cl.printf("  %d bytes from %s: seq=%d time=%ldms\r\n",r,fromIp,seq,ms);
+    } else {
+      cl.printf("  Request %d: timeout\r\n",seq);
+    }
+    if (seq<count) delay(1000);
+    blinkTick();
+  }
+  close(sock);
+
+  int loss=sent>0?(int)((sent-received)*100/sent):100;
+  cl.printf("--- %s ping statistics ---\r\n",host.c_str());
+  cl.printf("  %d sent, %d received, %d%% loss\r\n",sent,received,loss);
+  if (received>0)
+    cl.printf("  rtt min/avg/max = %ld/%ld/%ld ms\r\n",minMs,totalMs/received,maxMs);
+  cl.print("\r\n");
+}
+
+// ── curl ──────────────────────────────────────────────────────────────────────
+void cmdCurl(NetworkClient &cl, const String &url) {
+  if (!url.startsWith("http://")&&!url.startsWith("https://")) {
+    cl.print("Usage: curl <url>  (http:// or https://)\r\n"); return;
+  }
+  HTTPClient http;
+  http.begin(url);
+  http.setTimeout(10000);
+  http.addHeader("User-Agent", NAME "/" VERSION);
+
+  cl.printf("GET %s\r\n",url.c_str());
+  int code=http.GET();
+  if (code>0) {
+    cl.printf("HTTP %d\r\n",code);
+    // Print response headers we care about
+    String ct=http.header("Content-Type");
+    if (ct.length()) cl.printf("Content-Type: %s\r\n",ct.c_str());
+    cl.printf("Content-Length: %d\r\n\r\n",http.getSize());
+
+    // Stream response body, converting \n to \r\n
+    WiFiClient *stream=http.getStreamPtr();
+    int remaining=http.getSize();
+    unsigned long t=millis();
+    while ((remaining>0||remaining==-1)&&stream->connected()&&millis()-t<15000) {
+      blinkTick();
+      if (!stream->available()) { delay(10); continue; }
+      char c=stream->read();
+      if (remaining>0) remaining--;
+      if (c=='\n') cl.print("\r\n");
+      else         cl.write(c);
+    }
+    cl.print("\r\n");
+  } else {
+    cl.printf("Error: %s\r\n",http.errorToString(code).c_str());
+  }
+  http.end();
+}
+
+// ── Sensor commands ───────────────────────────────────────────────────────────
+void cmdRead(NetworkClient &cl, const String &sub) {
+  float t=bme.temp(),h=bme.hum(),p=bme.pres(),v=readBatteryVoltage();
+  int bp=batteryPercent(v);
+  if (sub==""||sub=="all")
+    cl.printf("  Temperature: %.1f C\r\n  Humidity:    %.0f %%\r\n"
+              "  Pressure:    %.0f hPa\r\n  Battery:     %.2fV %d%%\r\n",t,h,p,v,bp);
+  else if (sub=="temp")     cl.printf("%.1f C\r\n",t);
+  else if (sub=="hum")      cl.printf("%.0f %%\r\n",h);
+  else if (sub=="pressure") cl.printf("%.0f hPa\r\n",p);
+  else if (sub=="battery")  cl.printf("%.2fV %d%%\r\n",v,bp);
+  else cl.printf("Unknown: '%s'. Try: temp hum pressure battery\r\n",sub.c_str());
+}
+
+void printBattery(NetworkClient &cl) {
+  float v=readBatteryVoltage(); int pct=batteryPercent(v);
+  float rt=estimateRuntime(v); int rd=(int)(rt/24),rh=(int)fmod(rt,24.0f);
+  String bar="["; for(int i=0;i<20;i++) bar+=(i<pct/5?"#":"-"); bar+="]";
+  cl.printf("\r\n  Battery\r\n    Voltage:      %.2f V\r\n    Charge:       %s %d%%\r\n"
+            "    Est. runtime: %dd %dh\r\n"
+            "    (assumes %d wake/hr, %ds awake, %.1fmA awake, %.4fmA sleep)\r\n\r\n",
+            v,bar.c_str(),pct,rd,rh,
+            (int)BATT_WAKES_PER_HR,(int)BATT_WAKE_S,BATT_AWAKE_MA,BATT_SLEEP_MA);
+}
+
+// ── ifconfig ─────────────────────────────────────────────────────────────────
+void cmdIfconfig(NetworkClient &cl, const String &args) {
+  if (!args.length()) {
+    if (apMode) {
+      cl.printf("  Mode:    AP (setup)\r\n  SSID:    %s\r\n  IP:      %s\r\n\r\n",
+                AP_SSID,WiFi.softAPIP().toString().c_str()); return;
+    }
+    uint8_t *b=WiFi.BSSID();
+    cl.printf("\r\n  Network\r\n    Mode:       STA\r\n    IP mode:    %s\r\n"
+              "    Hostname:   %s\r\n    MAC:        %s\r\n    IP:         %s\r\n"
+              "    Subnet:     %s\r\n    Gateway:    %s\r\n    DNS:        %s\r\n"
+              "    SSID:       %s\r\n    BSSID:      %02X:%02X:%02X:%02X:%02X:%02X\r\n"
+              "    Channel:    %d\r\n    RSSI:       %d dBm\r\n    TX power:   %d dBm\r\n"
+              "    WiFi cache: %s\r\n\r\n",
+              netCfg.staticIP?"static":"DHCP",WiFi.getHostname(),
+              WiFi.macAddress().c_str(),WiFi.localIP().toString().c_str(),
+              WiFi.subnetMask().toString().c_str(),WiFi.gatewayIP().toString().c_str(),
+              WiFi.dnsIP().toString().c_str(),WiFi.SSID().c_str(),
+              b[0],b[1],b[2],b[3],b[4],b[5],
+              WiFi.channel(),WiFi.RSSI(),WiFi.getTxPower(),
+              rtcValid?"valid":"cold boot");
+    return;
+  }
+  if (args.startsWith("wifi ")) {
+    String rest=args.substring(5); rest.trim();
+    String t[2];
+    if (parseArgs(rest,t,2)<2) { cl.print("Usage: ifconfig wifi <ssid> <pass>\r\n"); return; }
+    strncpy(netCfg.ssid,t[0].c_str(),sizeof(netCfg.ssid)-1);
+    strncpy(netCfg.pass,t[1]=="open"?"":t[1].c_str(),sizeof(netCfg.pass)-1);
+    netCfg.configured=true; saveNetConfig(); rtcValid=false;
+    cl.printf("WiFi set to '%s'.\r\nGoodbye.\r\n",netCfg.ssid);
+    cl.stop(); delay(300); ESP.restart();
+  } else if (args=="ip dhcp") {
+    netCfg.staticIP=false; netCfg.ip=netCfg.gw=netCfg.sn=0;
+    saveNetConfig(); rtcValid=false;
+    cl.print("Switched to DHCP.\r\n"); cl.stop(); delay(300); ESP.restart();
+  } else if (args.startsWith("ip static ")) {
+    String rest=args.substring(10); rest.trim();
+    int s1=rest.indexOf(' '),s2=rest.indexOf(' ',s1+1);
+    if (s1<0||s2<0) { cl.print("Usage: ifconfig ip static <ip> <gw> <subnet>\r\n"); return; }
+    IPAddress ip,gw,sn;
+    if (!ip.fromString(rest.substring(0,s1))||
+        !gw.fromString(rest.substring(s1+1,s2))||
+        !sn.fromString(rest.substring(s2+1))) { cl.print("Invalid IP.\r\n"); return; }
+    netCfg.staticIP=true; netCfg.ip=(uint32_t)ip; netCfg.gw=(uint32_t)gw; netCfg.sn=(uint32_t)sn;
+    saveNetConfig(); rtcValid=false;
+    cl.printf("Static IP set to %s.\r\n",ip.toString().c_str());
+    cl.stop(); delay(300); ESP.restart();
+  } else cl.print("Unknown ifconfig subcommand.\r\n");
+}
+
+// ── date ──────────────────────────────────────────────────────────────────────
+void cmdDate(NetworkClient &cl, const String &args) {
+  if (!args.length()) {
+    RtcDateTime now;
+    if (!rtcGetDateTime(now)) { cl.print("RTC not set.\r\n"); return; }
+    cl.printf("%s\r\n",formatDateTime(now).c_str());
+  } else if (args.startsWith("set ")) {
+    String v=args.substring(4); v.trim(); RtcDateTime dt;
+    if (!parseDateTime(v,dt)) { cl.print("Format: YYYY-MM-DD HH:MM:SS\r\n"); return; }
+    rtcModule.SetIsWriteProtected(false); rtcModule.SetIsRunning(true);
+    rtcModule.SetDateTime(dt); rtcModule.SetIsWriteProtected(true);
+    RtcDateTime verify;
+    cl.print(rtcGetDateTime(verify)&&verify.Year()==dt.Year()
+             ?"RTC set.\r\n":"Warning: RTC write may have failed.\r\n");
+  } else cl.print("Usage: date  |  date set YYYY-MM-DD HH:MM:SS\r\n");
+}
+
+// ── info ──────────────────────────────────────────────────────────────────────
+void printInfo(NetworkClient &cl) {
+  unsigned long up=(millis()-bootTime)/1000;
+  RtcDateTime now; bool dv=rtcGetDateTime(now); float v=readBatteryVoltage();
+  cl.printf("\r\n  [ %s v%s ]\r\n\r\n  Device\r\n"
+            "    Chip:       ESP32-C3\r\n    Uptime:     %02luh %02lum %02lus\r\n"
+            "    Free heap:  %lu bytes\r\n    Flash:      %lu bytes\r\n"
+            "    CPU freq:   %lu MHz\r\n    WiFi cache: %s\r\n"
+            "    DS1302:     %s\r\n    Date/time:  %s\r\n    Battery:    %.2fV %d%%\r\n\r\n",
+            NAME,VERSION,up/3600,(up%3600)/60,up%60,
+            ESP.getFreeHeap(),ESP.getFlashChipSize(),ESP.getCpuFreqMHz(),
+            rtcValid?"valid":"cold boot",
+            rtcModule.GetIsRunning()?"running":"stopped",
+            dv?formatDateTime(now).c_str():"not set",v,batteryPercent(v));
+}
+
+// ── Banner / help ─────────────────────────────────────────────────────────────
+void printBanner(NetworkClient &cl) {
+  cl.printf("\r\n  +---------------------------------+\r\n"
+            "  |  %s v%s                   |\r\n"
+            "  |  ESP32-C3 BME280 Sensor Shell   |\r\n",NAME,VERSION);
+  if (apMode) cl.print("  |  *** SETUP MODE ***              |\r\n");
+  cl.print("  +---------------------------------+\r\n  Type 'help' for commands.\r\n\r\n");
+}
+
+void printHelp(NetworkClient &cl) {
+  if (apMode) {
+    cl.print("  ifconfig wifi <ssid> <pass>   — configure WiFi\r\n"
+             "  ifconfig wifi <ssid> open     — open WiFi\r\n"
+             "  (quotes for spaces: \"My WiFi\" \"pass\")\r\n"
+             "  help\r\n");
+  } else {
+    cl.print("  Sensor\r\n"
+             "    read                        — all sensors\r\n"
+             "    read temp|hum|pressure|battery\r\n"
+             "    watch                       — live (q+Enter to stop)\r\n"
+             "    battery                     — detail + runtime\r\n"
+             "  Time\r\n"
+             "    date\r\n"
+             "    date set <YYYY-MM-DD HH:MM:SS>\r\n"
+             "  Files\r\n"
+             "    ls\r\n"
+             "    vi <file>                   — line editor (type h inside for help)\r\n"
+             "    cat <file>\r\n"
+             "    rm <file>\r\n"
+             "  Network\r\n"
+             "    ping <host> [count]\r\n"
+             "    curl <url>\r\n"
+             "    ifconfig\r\n"
+             "    ifconfig wifi <ssid> <pass>\r\n"
+             "    ifconfig ip dhcp\r\n"
+             "    ifconfig ip static <ip> <gw> <subnet>\r\n"
+             "  System\r\n"
+             "    info\r\n"
+             "    help  quit  sleep\r\n");
+  }
+}
+
+// ── Button ────────────────────────────────────────────────────────────────────
+void checkButton() {
+  if (digitalRead(WAKE_PIN)==LOW) {
+    if (!btnArmed) { btnArmed=true; btnSince=millis(); }
+    else if (millis()-btnSince>RESET_HOLD_MS) {
+      eraseNetConfig(); rtcValid=false; startAP(); btnArmed=false;
+    }
+  } else {
+    if (btnArmed&&!apMode&&millis()-btnSince>50) goToSleep();
+    btnArmed=false;
+  }
+}
+
+// ── Telnet negotiation ────────────────────────────────────────────────────────
+void negotiateTelnet(NetworkClient &client) {
+  const uint8_t neg[] = {
+    255,251,1,   // IAC WILL ECHO
+    255,251,3,   // IAC WILL SUPPRESS-GO-AHEAD
+    255,253,3,   // IAC DO SUPPRESS-GO-AHEAD
+    255,254,34,  // IAC DONT LINEMODE
+  };
+  client.write(neg,sizeof(neg));
+  delay(100);
+}
+
+// ── Setup ─────────────────────────────────────────────────────────────────────
+void setup() {
+  bootTime=millis();
+  pinMode(WAKE_PIN,INPUT_PULLUP);
+  pinMode(RUN_PIN,OUTPUT);
+  pinMode(BATT_PIN,INPUT);
+  analogReadResolution(12);
+  ledOff();
+  LittleFS.begin(true);
+  rtcModule.Begin();
+  rtcModule.SetIsWriteProtected(false);
+  if (!rtcModule.GetIsRunning()) rtcModule.SetIsRunning(true);
+  rtcModule.SetIsWriteProtected(true);
+  Wire.setPins(DATA,CLOCK); Wire.begin(); bme.begin();
+  loadNetConfig();
+  if (!netCfg.configured) startAP(); else connectWiFi();
+}
+
+// ── Loop ──────────────────────────────────────────────────────────────────────
+void loop() {
+  blinkTick();
+  checkButton();
+
+  NetworkClient client=server.accept();
+  if (!client) return;
+
+  ts.begin(client);
+  negotiateTelnet(client);
+  ts.flushNegotiation();
+  printBanner(client);
+  printPrompt(client);
+
+  while (client.connected()) {
+    blinkTick();
+
+    if (digitalRead(WAKE_PIN)==LOW) {
+      if (!btnArmed) { btnArmed=true; btnSince=millis(); }
+      else if (millis()-btnSince>RESET_HOLD_MS) {
+        client.print("\r\nFactory reset — entering setup mode.\r\n");
+        client.stop(); eraseNetConfig(); rtcValid=false; startAP();
+        btnArmed=false; return;
+      }
+    } else {
+      if (btnArmed&&!apMode&&millis()-btnSince>50) {
+        client.print("\r\nButton pressed — sleeping.\r\n");
+        client.stop(); goToSleep();
+      }
+      btnArmed=false;
+    }
+
+    String cmd=readCommand(client);
+    if (!client.connected()) break;
+
+    if      (cmd=="ifconfig")               cmdIfconfig(client,"");
+    else if (cmd.startsWith("ifconfig "))   cmdIfconfig(client,cmd.substring(9));
+    else if (cmd=="help")                   printHelp(client);
+    else if (!apMode) {
+      if      (cmd=="read")                 cmdRead(client,"");
+      else if (cmd.startsWith("read "))     cmdRead(client,cmd.substring(5));
+      else if (cmd=="watch") {
+        client.print("q + Enter to stop.\r\n");
+        while (client.connected()) {
+          blinkTick();
+          client.printf("\rT: %.1fC  H: %.0f%%  P: %.0fhPa  Batt: %s   ",
+                        bme.temp(),bme.hum(),bme.pres(),batteryInline().c_str());
+          bool quit=false;
+          unsigned long wt=millis(); String wbuf="";
+          while (millis()-wt<1000&&!quit) {
+            blinkTick(); int k=ts.readKey();
+            if (k==KEY_NONE) { yield(); continue; }
+            if (k==KEY_ENTER) { wbuf.trim(); if(wbuf=="q") quit=true; wbuf=""; }
+            else if (k>=' '&&k<0x7F) wbuf+=(char)k;
+          }
+          if (quit) { client.print("\r\n"); break; }
+        }
+      }
+      else if (cmd=="battery")              printBattery(client);
+      else if (cmd=="date")                 cmdDate(client,"");
+      else if (cmd.startsWith("date "))     cmdDate(client,cmd.substring(5));
+      else if (cmd=="info")                 printInfo(client);
+      else if (cmd=="ls")                   cmdLs(client);
+      else if (cmd.startsWith("vi ")) {
+        String fn=cmd.substring(3); fn.trim();
+        if (!fn.startsWith("/")) fn="/"+fn;
+        ed.init(fn.c_str()); ed.run(client);
+      }
+      else if (cmd.startsWith("cat "))      cmdCat(client,cmd.substring(4));
+      else if (cmd.startsWith("rm "))       cmdRm(client,cmd.substring(3));
+      else if (cmd.startsWith("ping ")) {
+        String rest=cmd.substring(5); rest.trim();
+        String parts[2]; int n=parseArgs(rest,parts,2);
+        int count=(n>=2)?parts[1].toInt():4;
+        if (count<1||count>20) count=4;
+        cmdPing(client,parts[0],count);
+      }
+      else if (cmd.startsWith("curl "))     cmdCurl(client,cmd.substring(5));
+      else if (cmd=="quit")  { client.print("Goodbye.\r\n"); client.stop(); return; }
+      else if (cmd=="sleep") { client.print("Sleeping...\r\n"); client.stop(); goToSleep(); }
+      else if (cmd.length()) client.print("Unknown command. Type 'help'.\r\n");
+    } else if (cmd.length()) {
+      client.print("Unknown command. Use 'ifconfig wifi' or 'help'.\r\n");
+    }
+
+    if (client.connected()) printPrompt(client);
+  }
+}