esp32.ino

Arduino (C++) · 1357 lines

/*
   KernelESP v1.0.2
   A Linux-like interactive shell for the ESP32
   Tested on ESP32 - Core 2.0.17 (WROOM / S3)
   This version differs from the one uploaded on github
 */

#include <Arduino.h>
#include <WiFi.h>
#include <SPIFFS.h>
#include <WebServer.h>
#include <esp_system.h>
#include <esp_wifi.h>
#include <driver/dac.h>
#include <driver/touch_pad.h>
#include <string.h>
#include <stdlib.h>

// Boards
#ifdef ARDUINO_ESP32S3_DEV
#define KESP_BOARD_SET
#define KESP_GPIO_OPI_MASK ((1ULL<<33)|(1ULL<<34)|(1ULL<<35)|(1ULL<<36)|(1ULL<<37))
#define KESP_GPIO_VALID_GPIO_MASK (SOC_GPIO_VALID_GPIO_MASK & ~(0ULL | (1ULL<<15) | (1ULL<<16) | (1ULL<<19) | (1ULL<<20) | (1ULL<<26) | (1ULL<<27) | (1ULL<<28) | (1ULL<<29) | (1ULL<<30) | (1ULL<<31) | (1ULL<<32) | KESP_GPIO_OPI_MASK | (1ULL<<43) | (1ULL<<44)))
const int boardAdcPins[] = {A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17};
const int boardTouchPins[] = {T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14};
const int boardDiscoPins[] = {2, 4, 5, 12, 13, 14, 17, 18, 21};
const int boardDacPins[] = {};
#endif

// Fallback (original "ESP32 WROOM" values)
#ifndef KESP_BOARD_SET
#define KESP_GPIO_VALID_GPIO_MASK (SOC_GPIO_VALID_GPIO_MASK & ~(0ULL | (1ULL<<0) | (1ULL<<1) | (1ULL<<3) | (1ULL<<6) | (1ULL<<7) | (1ULL<<8) | (1ULL<<9) | (1ULL<<10) | (1ULL<<11) | (1ULL<<20) | (1ULL<<37) | (1ULL<<38)))
const int boardAdcPins[] = {36, 39, 34, 35, 32, 33, 25, 26, 27, 14};
const int boardTouchPins[] = {4, 0, 2, 15, 13, 12, 14, 27, 33, 32};
const int boardDiscoPins[] = {2, 4, 5, 12, 13, 14, 15, 16, 17, 18, 19, 21, 22, 23};
const int boardDacPins[] = {25, 26};
#endif

#define BOARD_ADC_COUNT (sizeof(boardAdcPins)/sizeof(int))
#define BOARD_TOUCH_COUNT (sizeof(boardTouchPins)/sizeof(int))
#define BOARD_DISCO_COUNT (sizeof(boardDiscoPins)/sizeof(int))
#define BOARD_DAC_COUNT (sizeof(boardDacPins)/sizeof(int))

#ifndef KESP_GPIO_VALID_GPIO_MASK
#define KESP_GPIO_VALID_GPIO_MASK SOC_GPIO_VALID_GPIO_MASK
#endif

#define GPIO_AVOID(p) (p >= SOC_GPIO_PIN_COUNT || p < 0 || ((KESP_GPIO_VALID_GPIO_MASK & (1ULL << p)) == 0))

// Limits
#define CMD_LEN       256
#define MAX_ARGS      16
#define ARG_LEN       64
#define PATH_LEN      64
#define DMESG_LINES   12
#define DMESG_LEN     80

// ANSI helpers
#define RESET   "\033[0m"
#define BOLD    "\033[1m"
#define DIM     "\033[2m"
#define RED     "\033[31m"
#define GREEN   "\033[32m"
#define YELLOW  "\033[33m"
#define BLUE    "\033[34m"
#define MAGENTA "\033[35m"
#define CYAN    "\033[36m"
#define WHITE   "\033[37m"
#define GRAY    "\033[90m"
#define BGREEN  "\033[92m"
#define BYELLOW "\033[93m"
#define BCYAN   "\033[96m"

// Pin management
typedef uint8_t pinCap_t;
#define PC_DIN    (1 << 0)
#define PC_DOUT   (1 << 1)
#define PC_LEDPWM (1 << 2)
#define PC_TOUCH  (1 << 3)
#define PC_ANALOG (1 << 4)
#define PC_DAC    (1 << 5)

// Global State
char  inputBuffer[CMD_LEN];
int   inputLen   = 0;
char  currentPath[PATH_LEN] = "/";
unsigned long bootTime;

pinCap_t  pinCapabilities[SOC_GPIO_PIN_COUNT];
pinCap_t  pinAssignment[SOC_GPIO_PIN_COUNT];

// Args storage (avoid heap fragmentation)
char  argStorage[MAX_ARGS][ARG_LEN];
char* args[MAX_ARGS];
uint8_t argCount = 0;

// Kernel log
struct DmesgEntry { unsigned long ts; char msg[DMESG_LEN]; };
DmesgEntry dmesgBuf[DMESG_LINES];
uint8_t dmesgHead = 0;
uint8_t dmesgCount = 0;

// WiFi state
String Hostname       = "kernelesp";
bool   wifiConnected  = false;
bool   apActive       = false;
String staSSID        = "";
String apSSID         = Hostname + "_ap";
String apPASS         = "kernelesp";

// Web server
WebServer* httpServer = nullptr;
bool httpRunning = false;

// Forward Declaration
void executeCommand(char* line);

// Kernel Log
void klog(const char* msg) {
  uint8_t idx = dmesgHead % DMESG_LINES;
  dmesgBuf[idx].ts = (millis() - bootTime) / 1000;
  strncpy(dmesgBuf[idx].msg, msg, DMESG_LEN - 1);
  dmesgBuf[idx].msg[DMESG_LEN - 1] = '\0';
  dmesgHead++;
  if (dmesgCount < DMESG_LINES) dmesgCount++;
}

// Utilities
int safeAtoi(const char* s) {
  if (!s || !*s) return 0;
  return (int)strtol(s, nullptr, 0); 
}

void strlowerBuf(char* s) {
  for (; *s; s++) if (*s >= 'A' && *s <= 'Z') *s += 32;
}

char* ltrim(char* s) {
  while (*s == ' ' || *s == '\t') s++;
  return s;
}

void parseCommand(char* line, char** argv, uint8_t* argc) {
  *argc = 0;
  char* p = line;
  while (*p && *argc < MAX_ARGS) {
    while (*p == ' ') p++;
    if (!*p) break;

    char* dst = argStorage[*argc];
    int di = 0;

    if (*p == '"' || *p == '\'') {
      char q = *p++;
      while (*p && *p != q && di < ARG_LEN - 1) dst[di++] = *p++;
      if (*p == q) p++;
    } else {
      while (*p && *p != ' ' && di < ARG_LEN - 1) dst[di++] = *p++;
    }
    dst[di] = '\0';
    argv[(*argc)++] = dst;
  }
}

// Pin Resolution
void initPins() {
  for (int i = 0; i < SOC_GPIO_PIN_COUNT; i++) {
    pinAssignment[i] = 0;
    pinCapabilities[i] = 0;
    if (GPIO_AVOID(i)) continue;

    pinAssignment[i] = PC_DIN;   
    pinCapabilities[i] = PC_DIN; 
    
    if (GPIO_IS_VALID_OUTPUT_GPIO(i)) {
      pinCapabilities[i] |= PC_DOUT;
      pinCapabilities[i] |= PC_LEDPWM;
    }
  }

  for (int i = 0; i < BOARD_ADC_COUNT; i++) {
    int p = boardAdcPins[i];
    if(p < SOC_GPIO_PIN_COUNT) pinCapabilities[p] |= PC_ANALOG;
  }
  for (int i = 0; i < BOARD_TOUCH_COUNT; i++) {
    int p = boardTouchPins[i];
    if(p < SOC_GPIO_PIN_COUNT) pinCapabilities[p] |= PC_TOUCH;
  }
  for (int i = 0; i < BOARD_DAC_COUNT; i++) {
    int p = boardDacPins[i];
    if(p < SOC_GPIO_PIN_COUNT) pinCapabilities[p] |= PC_DAC;
  }
}

int resolvePin(const char* name, uint32_t capability_mask = 0xFFFFFFFF) {
  if (!name) return -1;
  int ch = -1;
  
  if (name[0] >= '0' && name[0] <= '9') ch = safeAtoi(name);
  else if ((name[0] == 'A' || name[0] == 'a') && name[1]) {
    int idx = safeAtoi(name + 1);
    ch = (idx < BOARD_ADC_COUNT) ? boardAdcPins[idx] : -1;
  }
  else if ((name[0] == 'T' || name[0] == 't') && name[1]) {
    int idx = safeAtoi(name + 1);
    ch = (idx < BOARD_TOUCH_COUNT) ? boardTouchPins[idx] : -1;
  }
  else if ((name[0] == 'D' || name[0] == 'd') && name[1] == 'A' && name[2] == 'C' && name[3]) {
    int idx = safeAtoi(name + 3);
    ch = (idx < BOARD_DAC_COUNT) ? boardDacPins[idx] : -1;
  }
#ifdef LED_BUILTIN
  if (strcasecmp(name, "LED") == 0) ch = LED_BUILTIN; 
#endif

  if (ch >= 0 && ch < SOC_GPIO_PIN_COUNT) {
    if ((pinAssignment[ch] & capability_mask) == 0) return -1;
    return ch;
  }
  return -1;
}

// SPIFFS Filesystem Helpers
String buildPath(const char* name) {
  if (name[0] == '/') return String(name);
  String p = String(currentPath);
  if (!p.endsWith("/")) p += "/";
  p += name;
  return p;
}

void ensureDir(const String& dirPath) {
  String marker = dirPath;
  if (!marker.endsWith("/")) marker += "/";
  marker += ".dir";
  if (!SPIFFS.exists(marker)) {
    File f = SPIFFS.open(marker, FILE_WRITE);
    if (f) f.close();
  }
}

bool isDirectory(const String& path) {
  String marker = path;
  if (!marker.endsWith("/")) marker += "/";
  marker += ".dir";
  return SPIFFS.exists(marker);
}

void initFilesystem() {
  if (!SPIFFS.begin(true)) {
    Serial.println(RED "SPIFFS mount failed — formatting..." RESET);
    SPIFFS.format();
    SPIFFS.begin(true);
  }
  const char* defaults[] = {"/home", "/tmp", "/etc", "/dev"};
  for (auto d : defaults) ensureDir(String(d));
  klog("SPIFFS mounted OK");
}

void showLogo() {
  Serial.print(F("\033[2J\033[H")); 
  Serial.println(F(CYAN
    "  ██╗  ██╗███████╗██████╗ ███╗   ██╗███████╗██╗     ███████╗███████╗██████╗ "  RESET));
  Serial.println(F(CYAN
    "  ██║ ██╔╝██╔════╝██╔══██╗████╗  ██║██╔════╝██║     ██╔════╝██╔════╝██╔══██╗" RESET));
  Serial.println(F(BCYAN
    "  █████╔╝ █████╗  ██████╔╝██╔██╗ ██║█████╗  ██║     █████╗  ███████╗██████╔╝" RESET));
  Serial.println(F(CYAN
    "  ██╔═██╗ ██╔══╝  ██╔══██╗██║╚██╗██║██╔══╝  ██║     ██╔══╝  ╚════██║██╔═══╝ " RESET));
  Serial.println(F(CYAN
    "  ██║  ██╗███████╗██║  ██║██║ ╚████║███████╗███████╗███████╗███████║██║      " RESET));
  Serial.println(F(GRAY
    "  ╚═╝  ╚═╝╚══════╝╚═╝  ╚═╝╚═╝  ╚═══╝╚══════╝╚══════╝╚══════╝╚══════╝╚═╝  v1.1" RESET));
  Serial.println();

  uint32_t heap = ESP.getFreeHeap();
  uint32_t flash = ESP.getFlashChipSize() / 1024;
#ifdef ARDUINO_BOARD
  Serial.printf(GRAY "  Board: " WHITE "%s @ %dMHz  " GRAY
#else
  Serial.printf(GRAY "  CPU: " WHITE "Xtensa @ %dMHz  " GRAY
#endif
                "RAM: " WHITE "%u KB free  " GRAY
                "Flash: " WHITE "%u KB" RESET "\n",
                ESP.getCpuFreqMHz(), heap / 1024, flash);

  if (wifiConnected) {
    Serial.printf(GRAY "  WiFi: " GREEN "Connected  " GRAY "IP: " WHITE "%s" RESET "\n",
                  WiFi.localIP().toString().c_str());
  } else if (apActive) {
    Serial.printf(GRAY "  WiFi: " YELLOW "AP Mode  " GRAY "IP: " WHITE "%s" RESET "\n",
                  WiFi.softAPIP().toString().c_str());
  } else {
    Serial.println(GRAY "  WiFi: " RED "Offline" RESET);
  }
  Serial.println(GRAY "  ─────────────────────────────────────────────────────────────────────────" RESET);
  Serial.println(GRAY "  Type " YELLOW "'help'" GRAY " for commands.  " YELLOW "'wifi help'" GRAY " for network commands." RESET "\n");
}

void printPrompt() {
  const char* wifiTag = wifiConnected ? GREEN " [" BCYAN "net" GREEN "]" : "";
  Serial.printf(BGREEN "root@%s" RESET ":" BLUE "%s" RESET "%s" WHITE "$ " RESET,
                Hostname.c_str(), currentPath, wifiTag);
}

// Hardware Commands
void cmdPinMode(char** argv, uint8_t argc) {
  if (argc < 3) { Serial.println(F("Usage: pinmode <pin> <input|output|pullup|pulldown|analog|touch|ledpwm|dac>")); return; }
  int pin = resolvePin(argv[1]);
  if (pin < 0) { Serial.println(RED "Invalid pin" RESET); return; }
  String m = String(argv[2]); m.toLowerCase();
  
  if (m == "output" || m == "out") {
    if ((pinCapabilities[pin] & PC_DOUT) == 0) { Serial.println(RED "Invalid pin capability" RESET); return; }
    pinAssignment[pin] = PC_DOUT;
    pinMode(pin, OUTPUT);
    Serial.printf("GPIO%d → OUTPUT\n", pin);
  }
  else if (m == "input") {
    if ((pinCapabilities[pin] & PC_DIN) == 0) { Serial.println(RED "Invalid pin capability" RESET); return; }
    pinAssignment[pin] = PC_DIN;
    pinMode(pin, INPUT);
    Serial.printf("GPIO%d → INPUT\n", pin);
  }
  else if (m == "pullup"   || m == "input_pullup") {
    if ((pinCapabilities[pin] & PC_DIN) == 0) { Serial.println(RED "Invalid pin capability" RESET); return; }
    pinAssignment[pin] = PC_DIN;
    pinMode(pin, INPUT_PULLUP);
    Serial.printf("GPIO%d → INPUT_PULLUP\n", pin);
  }
  else if (m == "pulldown" || m == "input_pulldown") {
    if ((pinCapabilities[pin] & PC_DIN) == 0) { Serial.println(RED "Invalid pin capability" RESET); return; }
    pinAssignment[pin] = PC_DIN;
    pinMode(pin, INPUT_PULLDOWN);
    Serial.printf("GPIO%d → INPUT_PULLDOWN\n", pin);
  }
  else if (m == "analog") {
    if ((pinCapabilities[pin] & PC_ANALOG) == 0) { Serial.println(RED "Invalid pin capability" RESET); return; }
    pinAssignment[pin] = PC_ANALOG;
    analogRead(pin);
    Serial.printf("GPIO%d → ANALOG INPUT\n", pin);
  }
  else if (m == "touch") {
    if ((pinCapabilities[pin] & PC_TOUCH) == 0) { Serial.println(RED "Invalid pin capability" RESET); return; }
    pinAssignment[pin] = PC_TOUCH;
    touchRead(pin);
    Serial.printf("GPIO%d → TOUCH INPUT\n", pin);
  }
  else if (m == "ledpwm") {
    if ((pinCapabilities[pin] & PC_LEDPWM) == 0) { Serial.println(RED "Invalid pin capability" RESET); return; }
    pinAssignment[pin] = PC_LEDPWM;
    pinMode(pin, OUTPUT);
    Serial.printf("GPIO%d → LED PWM OUTPUT\n", pin);
  }
  else if (m == "dac") {
    if ((pinCapabilities[pin] & PC_DAC) == 0) { Serial.println(RED "Invalid pin capability" RESET); return; }
    pinAssignment[pin] = PC_DAC;
    pinMode(pin, OUTPUT);
    Serial.printf("GPIO%d → DAC OUTPUT\n", pin);
  }
  else { Serial.println(RED "Unknown mode" RESET); return; }
  
  char buf[48]; snprintf(buf, sizeof(buf), "pinMode GPIO%d %s", pin, argv[2]); klog(buf);
}

void cmdPins(char** argv, uint8_t argc) {
  Serial.println(F("\n  " YELLOW "Pin configuration:\n" RESET));
  Serial.println(F("  Pin    │ Capabilities │ Mode"));
  Serial.println(F("  ───────┼──────────────┼───────────────"));
  for (int i = 0; i < SOC_GPIO_PIN_COUNT; i++) {
    if (pinAssignment[i] == 0) continue;
    const char* mode;
    switch(pinAssignment[i]) {
      case PC_DIN: mode = "Digital input"; break;
      case PC_DOUT: mode = "Digital output"; break;
      case PC_LEDPWM: mode = "LED PWM output"; break;
      case PC_TOUCH: mode = "Touch input"; break;
      case PC_ANALOG: mode = "Analog input"; break;
      case PC_DAC: mode = "DAC output"; break;
      default: mode = RED "ERROR" RESET; break;
    }
    Serial.printf("  GPIO%-2d │ %si%so%sl%st%sa%sd" RESET "        │ %s\n",
      i,
      (pinCapabilities[i] & PC_DIN) ? GREEN : GRAY,
      (pinCapabilities[i] & PC_DOUT) ? GREEN : GRAY,
      (pinCapabilities[i] & PC_LEDPWM) ? GREEN : GRAY,
      (pinCapabilities[i] & PC_TOUCH) ? GREEN : GRAY,
      (pinCapabilities[i] & PC_ANALOG) ? GREEN : GRAY,
      (pinCapabilities[i] & PC_DAC) ? GREEN : GRAY,
      mode);
  }
  Serial.println();
}

void cmdDigitalWrite(char** argv, uint8_t argc) {
  if (argc < 3) { Serial.println(F("Usage: write <pin> <HIGH|LOW|1|0|on|off>")); return; }
  int pin = resolvePin(argv[1], PC_DOUT);
  if (pin < 0) { Serial.println(RED "Invalid pin or capability" RESET); return; }
  String v = String(argv[2]); v.toLowerCase();
  int val = (v == "high" || v == "1" || v == "on") ? HIGH : LOW;
  digitalWrite(pin, val);
  Serial.printf("GPIO%d = %s\n", pin, val ? "HIGH" : "LOW");
}

void cmdDigitalRead(char** argv, uint8_t argc) {
  if (argc < 2) {
    Serial.println(F("\n  " YELLOW "GPIO State:" RESET "\n"));
    Serial.println(F("  Pin  State   │  Pin  State"));
    Serial.println(F("  ─────────────┼─────────────"));
    int printcount = 0;
    for (int i = 0; i < SOC_GPIO_PIN_COUNT; i++) {
      if ((pinAssignment[i] & (PC_DIN | PC_DOUT)) == 0) continue;
      int v = digitalRead(i);
      Serial.printf("  GPIO%-2d  %s%-5s" RESET, i, v ? ((pinAssignment[i] == PC_DIN) ? GREEN : RED) : ((pinAssignment[i] == PC_DIN) ? GRAY : WHITE), v ? "HIGH" : "LOW");
      if (printcount % 2 == 0) Serial.print("  │");
      else Serial.println();
      printcount++;
    }
    Serial.println(F("\n"));
    return;
  }
  int pin = resolvePin(argv[1], PC_DIN | PC_DOUT);
  if (pin < 0) { Serial.println(RED "Invalid pin or capability" RESET); return; }
  int v = digitalRead(pin);
  Serial.printf("GPIO%d = %s%s" RESET "\n", pin, v ? ((pinAssignment[pin] == PC_DIN) ? GREEN : RED) : ((pinAssignment[pin] == PC_DIN) ? GRAY : WHITE), v ? "HIGH" : "LOW");
}

void cmdAnalogRead(char** argv, uint8_t argc) {
  if (argc < 2) {
    Serial.println(F("\n  " YELLOW "ADC Channels:" RESET "\n"));
    for (int i = 0; i < BOARD_ADC_COUNT; i++) {
      if ((pinAssignment[boardAdcPins[i]] & PC_ANALOG) == 0) continue;
      int raw = analogRead(boardAdcPins[i]);
      float v  = raw * 3.3f / 4095.0f;
      int bar  = map(raw, 0, 4095, 0, 30);
      Serial.printf("  A%-2d/GPIO%-2d [", i, boardAdcPins[i]);
      for (int b = 0; b < 30; b++) Serial.print(b < bar ? GREEN "█" RESET : GRAY "░" RESET);
      Serial.printf("] %4d (%.2fV)\n", raw, v);
    }
    Serial.println();
    return;
  }
  int pin = resolvePin(argv[1], PC_ANALOG);
  if (pin < 0) { Serial.println(RED "Invalid pin or capability" RESET); return; }
  int raw = analogRead(pin);
  float v  = raw * 3.3f / 4095.0f;
  Serial.printf("GPIO%d ADC = %d (%.3fV / 3.3V)\n", pin, raw, v);
}

void cmdPWM(char** argv, uint8_t argc) {
  if (argc < 3) { Serial.println(F("Usage: pwm <pin> <duty 0-255> [freq_hz] [channel 0-15]")); return; }
  int pin  = resolvePin(argv[1], PC_LEDPWM);
  if (pin < 0) { Serial.println(RED "Invalid pin or capability" RESET); return; }
  int duty = constrain(safeAtoi(argv[2]), 0, 255);
  int freq = (argc >= 4) ? safeAtoi(argv[3]) : 5000;
  int ch   = (argc >= 5) ? constrain(safeAtoi(argv[4]), 0, 15) : 0;
  
  // 2.0 API calls
  ledcSetup(ch, freq, 8);         
  ledcAttachPin(pin, ch);
  ledcWrite(ch, duty);
  float pct = duty * 100.0f / 255.0f;
  Serial.printf("GPIO%d PWM ch%d: duty=%d (%.0f%%) freq=%dHz\n", pin, ch, duty, pct, freq);
}

void cmdDAC(char** argv, uint8_t argc) {
  if (argc < 3) { Serial.println(F("Usage: dac <pin> <0-255>")); return; }
  int pin = resolvePin(argv[1], PC_DAC);
  if (pin < 0) { Serial.println(RED "Invalid pin or capability" RESET); return; }
  int val = constrain(safeAtoi(argv[2]), 0, 255);
  dacWrite(pin, val);
  float v = val * 3.3f / 255.0f;
  Serial.printf("DAC GPIO%d = %d (%.3fV)\n", pin, val, v);
}

void cmdTouch(char** argv, uint8_t argc) {
  if (argc < 2) {
    Serial.println(F("\n  " YELLOW "Touch Sensor Readings:" RESET "\n"));
    for (int i = 0; i < BOARD_TOUCH_COUNT; i++) {
      if (pinAssignment[boardTouchPins[i]] != PC_TOUCH) continue;
      uint16_t val = touchRead(boardTouchPins[i]);
      int bar = map(constrain(val, 0, 80), 0, 80, 30, 0);
      bool touched = val < 30;
      Serial.printf("  T%-2d/GPIO%-2d [", i, boardTouchPins[i]);
      for (int b = 0; b < 30; b++)
        Serial.print(b < bar ? (touched ? RED "█" RESET : CYAN "█" RESET) : GRAY "░" RESET);
      Serial.printf("] %3d  %s\n", val, touched ? RED "<TOUCH>" RESET : "");
    }
    Serial.println();
    return;
  }
  int pin = resolvePin(argv[1], PC_TOUCH);
  if (pin < 0) { Serial.println(RED "Invalid pin or capability" RESET); return; }
  uint16_t val = touchRead(pin);
  Serial.printf("Touch GPIO%d = %d (%s)\n", pin, val, val < 30 ? RED "TOUCHED" RESET : "not touched");
}

void cmdTone(char** argv, uint8_t argc) {
  if (argc < 3) { Serial.println(F("Usage: tone <pin> <freq_hz> [duration_ms]")); return; }
  int pin  = resolvePin(argv[1], PC_LEDPWM);
  if (pin < 0) { Serial.println(RED "Invalid pin or capability" RESET); return; }
  int freq = safeAtoi(argv[2]);
  if (freq < 1 || freq > 20000) { Serial.println(RED "Frequency: 1-20000 Hz" RESET); return; }
  ledcSetup(14, freq, 8);
  ledcAttachPin(pin, 14);
  ledcWrite(14, 127); 
  if (argc >= 4) {
    int ms = safeAtoi(argv[3]);
    Serial.printf("Tone GPIO%d: %dHz for %dms\n", pin, freq, ms);
    delay(ms);
    ledcWrite(14, 0);
    ledcDetachPin(pin);
  } else {
    Serial.printf("Tone GPIO%d: %dHz continuous. Use 'notone %s' to stop.\n", pin, freq, argv[1]);
  }
}

void cmdNoTone(char** argv, uint8_t argc) {
  int pin = (argc >= 2) ? resolvePin(argv[1], PC_LEDPWM) : -1;
  ledcWrite(14, 0);
  if (pin >= 0) ledcDetachPin(pin);
  Serial.println("Tone stopped");
}

void cmdGPIO(char** argv, uint8_t argc) {
  if (argc < 3) { Serial.println(F("Usage: gpio <pin> <on|off|toggle|read>")); return; }
  int pin = resolvePin(argv[1], PC_DOUT);
  if (pin < 0) { Serial.println(RED "Invalid pin or capability" RESET); return; }
  String act = String(argv[2]); act.toLowerCase();
  if (act == "on"  || act == "1" || act == "high") { digitalWrite(pin, HIGH); Serial.printf("GPIO%d → ON\n", pin); }
  else if (act == "off" || act == "0" || act == "low") { digitalWrite(pin, LOW); Serial.printf("GPIO%d → OFF\n", pin); }
  else if (act == "toggle") {
    int nv = !digitalRead(pin); digitalWrite(pin, nv);
    Serial.printf("GPIO%d toggled → %s\n", pin, nv ? "HIGH" : "LOW");
  }
  else if (act == "read") {
    Serial.printf("GPIO%d = %s\n", pin, digitalRead(pin) ? "HIGH" : "LOW");
  }
  else { Serial.println(RED "Unknown action. Use: on off toggle read" RESET); }
}

void cmdDisco(char** argv, uint8_t argc) {
  int cycles = (argc >= 2) ? constrain(safeAtoi(argv[1]), 1, 30)  : 3;
  int speed  = (argc >= 3) ? constrain(safeAtoi(argv[2]), 5, 500) : 40;
  const int nPins  = BOARD_DISCO_COUNT;
  for (int p : boardDiscoPins) { pinMode(p, OUTPUT); digitalWrite(p, LOW); }
  Serial.printf(MAGENTA "  *** DISCO MODE *** " RESET "cycles=%d speed=%dms\n", cycles, speed);
  for (int c = 0; c < cycles; c++) {
    for (int i = 0; i < nPins; i++) { digitalWrite(boardDiscoPins[i], HIGH); delay(speed); digitalWrite(boardDiscoPins[i], LOW); }
    for (int i = nPins - 2; i > 0; i--) { digitalWrite(boardDiscoPins[i], HIGH); delay(speed); digitalWrite(boardDiscoPins[i], LOW); }
    for (int i = 0; i < nPins; i++) { digitalWrite(boardDiscoPins[i], (c + i) % 2); }
    delay(speed * 4);
    for (int p : boardDiscoPins) digitalWrite(p, LOW);
    Serial.printf("\r  Cycle %d/%d", c + 1, cycles);
  }
  for (int p : boardDiscoPins) pinMode(p, INPUT);
  Serial.println(F("\n  " GREEN "Disco complete!" RESET));
}

void cmdMorse(char** argv, uint8_t argc) {
  if (argc < 3) { Serial.println(F("Usage: morse <pin> <MESSAGE>")); return; }
  int pin = resolvePin(argv[1], PC_DOUT);
  if (pin < 0) { Serial.println(RED "Invalid pin or capability" RESET); return; }
  digitalWrite(pin, LOW);
  const char* mt[] = {".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--.."};
  Serial.printf("Morse GPIO%d: ", pin);
  for (int a = 2; a < argc; a++) {
    for (char* c = argv[a]; *c; c++) {
      char ch = toupper(*c);
      if (ch >= 'A' && ch <= 'Z') {
        Serial.print(ch);
        const char* code = mt[ch - 'A'];
        for (const char* m = code; *m; m++) {
          digitalWrite(pin, HIGH); Serial.print(*m == '.' ? '.' : '-');
          delay(*m == '.' ? 100 : 300);
          digitalWrite(pin, LOW); delay(100);
        }
        delay(300);
      } else if (ch == ' ') { Serial.print(' '); delay(700); }
    }
    Serial.print(' ');
  }
  Serial.println("Done");
}

void cmdSensor(char** argv, uint8_t argc) {
  Serial.println(F("\n  " YELLOW "Sensor Monitor (ADC — 3.3V ref, 12-bit)" RESET "\n"));
  for (int i = 0; i < BOARD_ADC_COUNT; i++) {
    if (pinAssignment[boardAdcPins[i]] != PC_ANALOG) continue;
    long sum = 0;
    for (int j = 0; j < 8; j++) { sum += analogRead(boardAdcPins[i]); delay(1); }
    int avg = sum / 8;
    float v  = avg * 3.3f / 4095.0f;
    int bar  = map(avg, 0, 4095, 0, 32);
    Serial.printf("  A%-2d/GPIO%-2d [", i, boardAdcPins[i]);
    for (int b = 0; b < 32; b++) Serial.print(b < bar ? GREEN "█" RESET : GRAY "░" RESET);
    Serial.printf("] %4d (%.2fV)\n", avg, v);
  }
  Serial.println();
}

void cmdScope(char** argv, uint8_t argc) {
  if (argc < 2) { Serial.println(F("Usage: scope <pin> [samples=80] [delay_ms=5]")); return; }
  int pin     = resolvePin(argv[1], PC_ANALOG);
  if (pin < 0) { Serial.println(RED "Invalid pin or capability" RESET); return; }
  int samples = (argc >= 3) ? constrain(safeAtoi(argv[2]), 10, 200) : 80;
  int dly     = (argc >= 4) ? constrain(safeAtoi(argv[3]), 1, 500)  : 5;

  int* vals = (int*)malloc(samples * sizeof(int));
  if (!vals) { Serial.println(RED "malloc failed" RESET); return; }

  Serial.printf("\n  " CYAN "Scope GPIO%d" RESET " — %d samples @ %dms\n\n", pin, samples, dly);
  for (int i = 0; i < samples; i++) { vals[i] = analogRead(pin); delay(dly); }

  int vmin = 4095, vmax = 0;
  long vsum = 0;
  for (int i = 0; i < samples; i++) {
    if (vals[i] < vmin) vmin = vals[i];
    if (vals[i] > vmax) vmax = vals[i];
    vsum += vals[i];
  }

  int height = 12;
  int range  = vmax - vmin;
  if (range == 0) range = 1;
  for (int row = height - 1; row >= 0; row--) {
    Serial.print("  ");
    for (int i = 0; i < samples && i < 100; i++) {
      int mapped = map(vals[i], vmin, vmax, 0, height - 1);
      if      (mapped == row) Serial.print(CYAN "▪" RESET);
      else if (mapped >  row) Serial.print(GRAY "│" RESET);
      else                    Serial.print(" ");
    }
    Serial.println();
  }
  Serial.printf("  Min:%d  Max:%d  Avg:%ld  (%.2f–%.2fV)\n\n",
                vmin, vmax, vsum / samples,
                vmin * 3.3f / 4095.0f, vmax * 3.3f / 4095.0f);
  free(vals);
}

void cmdMonitor(char** argv, uint8_t argc) {
  if (argc < 3) { Serial.println(F("Usage: monitor <pin> <interval_ms> [duration_s=10]")); return; }
  int pin      = resolvePin(argv[1], PC_ANALOG | PC_DIN);
  if (pin < 0) { Serial.println(RED "Invalid pin or capability" RESET); return; }
  int interval = max(50, safeAtoi(argv[2]));
  int duration = (argc >= 4) ? constrain(safeAtoi(argv[3]), 1, 300) : 10;

  Serial.printf("\n  " YELLOW "Monitor GPIO%d" RESET " every %dms for %ds\n\n", pin, interval, duration);
  unsigned long end = millis() + duration * 1000UL;
  while (millis() < end) {
    unsigned long t = (millis() - bootTime) / 1000;
    if (pinAssignment[pin] == PC_ANALOG) {
      int raw = analogRead(pin);
      float v = raw * 3.3f / 4095.0f;
      Serial.printf("  [t+%lus] %d (%.3fV)\n", t, raw, v);
    } else {
      Serial.printf("  [t+%lus] %s\n", t, digitalRead(pin) ? GREEN "HIGH" RESET : GRAY "LOW" RESET);
    }
    delay(interval);
  }
  Serial.println(GREEN "  Monitor done" RESET "\n");
}

// Filesystem Commands
void cmdLS(char** argv, uint8_t argc) {
  String target = (argc >= 2) ? buildPath(argv[1]) : String(currentPath);
  if (!target.endsWith("/")) target += "/";

  Serial.println(F("\n  " YELLOW "Name                 Size    Modified" RESET));
  Serial.println(F("  " GRAY "───────────────────────────────────────────" RESET));

  int count = 0;
  File root = SPIFFS.open("/");
  File f    = root.openNextFile();
  while (f) {
    String fp = String(f.name()); 
    if (fp.startsWith(target)) {
      String rest = fp.substring(target.length());
      if (rest.length() > 0 && rest.indexOf('/') < 0) {
        bool isDir = rest.endsWith(".dir") || f.isDirectory();
        if (rest == ".dir") { f = root.openNextFile(); continue; } 
        Serial.print("  ");
        if (isDir) {
          Serial.print(BLUE); Serial.printf("%-22s" RESET, (rest + "/").c_str());
          Serial.println(GRAY "  <DIR>" RESET);
        } else {
          Serial.printf(WHITE "%-22s" RESET, rest.c_str());
          Serial.printf("%6d bytes\n", (int)f.size());
        }
        count++;
      }
    }
    f = root.openNextFile();
  }

  if (count == 0) Serial.println(GRAY "  (empty)" RESET);
  size_t total = SPIFFS.totalBytes();
  size_t used  = SPIFFS.usedBytes();
  Serial.printf("\n  " GRAY "%d items  │  SPIFFS: %u / %u KB used" RESET "\n\n",
                count, used / 1024, total / 1024);
}

void cmdCD(char** argv, uint8_t argc) {
  if (argc < 2 || strcmp(argv[1], "/") == 0) {
    strncpy(currentPath, "/", PATH_LEN - 1); return;
  }
  if (strcmp(argv[1], "..") == 0) {
    if (strcmp(currentPath, "/") == 0) return;
    String p = String(currentPath);
    if (p.endsWith("/")) p = p.substring(0, p.length() - 1);
    int last = p.lastIndexOf('/');
    strncpy(currentPath, (last <= 0 ? "/" : p.substring(0, last + 1)).c_str(), PATH_LEN - 1);
    return;
  }
  String target = buildPath(argv[1]);
  if (!target.endsWith("/")) target += "/";
  if (isDirectory(target.substring(0, target.length() - 1)) || target == "/") {
    strncpy(currentPath, target.c_str(), PATH_LEN - 1);
  } else {
    Serial.printf(RED "cd: '%s' not found\n" RESET, argv[1]);
  }
}

void cmdMkdir(char** argv, uint8_t argc) {
  if (argc < 2) { Serial.println(F("Usage: mkdir <name>")); return; }
  String path = buildPath(argv[1]);
  if (isDirectory(path)) { Serial.println(YELLOW "Already exists" RESET); return; }
  ensureDir(path);
  Serial.printf(GREEN "Directory '%s' created\n" RESET, argv[1]);
  klog(("mkdir " + path).c_str());
}

void cmdTouch2(char** argv, uint8_t argc) {
  if (argc < 2) { Serial.println(F("Usage: touch <filename>")); return; }
  String path = buildPath(argv[1]);
  if (!SPIFFS.exists(path)) {
    File f = SPIFFS.open(path, FILE_WRITE);
    if (!f) { Serial.println(RED "Failed to create file" RESET); return; }
    f.close();
  }
  Serial.printf("'%s' OK\n", argv[1]);
}

void cmdCat(char** argv, uint8_t argc) {
  if (argc < 2) { Serial.println(F("Usage: cat <filename>")); return; }
  String path = buildPath(argv[1]);
  File f = SPIFFS.open(path, FILE_READ);
  if (!f) { Serial.printf(RED "File not found: %s\n" RESET, argv[1]); return; }
  if (f.size() == 0) { Serial.println(GRAY "(empty)" RESET); f.close(); return; }
  while (f.available()) {
    char c = f.read();
    Serial.write(c);
  }
  Serial.println();
  f.close();
}

void cmdWrite(char** argv, uint8_t argc) {
  bool appendMode = (argc >= 1 && strcasecmp(argv[0], "append") == 0);
  if (argc < 3) {
    Serial.println(F("Usage: writefile <filename> <content>"));
    Serial.println(F("       append    <filename> <content>"));
    return;
  }
  String path = buildPath(argv[1]);
  File f = SPIFFS.open(path, appendMode ? FILE_APPEND : FILE_WRITE);
  if (!f) { Serial.println(RED "Cannot open file" RESET); return; }
  for (uint8_t i = 2; i < argc; i++) {
    f.print(argv[i]);
    if (i < argc - 1) f.print(' ');
  }
  f.println();
  f.close();
  Serial.printf("Written to '%s'\n", argv[1]);
}

void cmdRM(char** argv, uint8_t argc) {
  if (argc < 2) { Serial.println(F("Usage: rm <name> [-r]")); return; }
  String path = buildPath(argv[1]);
  bool recursive = (argc >= 3 && strcmp(argv[2], "-r") == 0);

  if (isDirectory(path)) {
    if (!recursive) { Serial.println(YELLOW "Use 'rm <dir> -r' to remove directory" RESET); return; }
    String prefix = path; if (!prefix.endsWith("/")) prefix += "/";
    File root = SPIFFS.open("/");
    File fi = root.openNextFile();
    while (fi) {
      if (String(fi.name()).startsWith(prefix)) SPIFFS.remove(fi.name());
      fi = root.openNextFile();
    }
    String marker = path + "/.dir";
    SPIFFS.remove(marker);
    Serial.printf(GREEN "Removed directory '%s'\n" RESET, argv[1]);
  } else if (SPIFFS.exists(path)) {
    SPIFFS.remove(path);
    Serial.printf(GREEN "Removed '%s'\n" RESET, argv[1]);
  } else {
    Serial.printf(RED "Not found: %s\n" RESET, argv[1]);
  }
}

void cmdMv(char** argv, uint8_t argc) {
  if (argc < 3) { Serial.println(F("Usage: mv <src> <dst>")); return; }
  String src = buildPath(argv[1]);
  String dst = buildPath(argv[2]);
  if (!SPIFFS.exists(src)) { Serial.println(RED "Source not found" RESET); return; }
  File fs_ = SPIFFS.open(src, FILE_READ);
  File fd  = SPIFFS.open(dst, FILE_WRITE);
  if (!fs_ || !fd) { Serial.println(RED "Move failed" RESET); return; }
  while (fs_.available()) fd.write(fs_.read());
  fs_.close(); fd.close();
  SPIFFS.remove(src);
  Serial.printf("Moved '%s' → '%s'\n", argv[1], argv[2]);
}

void cmdCp(char** argv, uint8_t argc) {
  if (argc < 3) { Serial.println(F("Usage: cp <src> <dst>")); return; }
  String src = buildPath(argv[1]);
  String dst = buildPath(argv[2]);
  if (!SPIFFS.exists(src)) { Serial.println(RED "Source not found" RESET); return; }
  File fs_ = SPIFFS.open(src, FILE_READ);
  File fd  = SPIFFS.open(dst, FILE_WRITE);
  if (!fs_ || !fd) { Serial.println(RED "Copy failed" RESET); return; }
  size_t bytes = 0;
  while (fs_.available()) { fd.write(fs_.read()); bytes++; }
  fs_.close(); fd.close();
  Serial.printf("Copied %u bytes → '%s'\n", bytes, argv[2]);
}

void cmdDf(char** argv, uint8_t argc) {
  size_t total = SPIFFS.totalBytes();
  size_t used  = SPIFFS.usedBytes();
  size_t free_ = total - used;
  int pct = (used * 100) / total;
  int bar = (used * 30) / total;
  Serial.println(F("\n  " YELLOW "Filesystem (SPIFFS):" RESET));
  Serial.print  (F("  ["));
  for (int i = 0; i < 30; i++) Serial.print(i < bar ? GREEN "█" RESET : GRAY "░" RESET);
  Serial.printf ("] %d%%\n", pct);
  Serial.printf ("  Total: %u KB  Used: %u KB  Free: %u KB\n\n",
                 total/1024, used/1024, free_/1024);
}

// WiFi Commands
void cmdWifi(char** argv, uint8_t argc) {
  Serial.println(F("\n  " CYAN "WiFi Status:" RESET));
  Serial.printf("  Mode : %s\n",
    WiFi.getMode() == WIFI_STA ? "Station" :
    WiFi.getMode() == WIFI_AP  ? "Access Point" :
    WiFi.getMode() == WIFI_AP_STA ? "AP+Station" : "Off");
  if (wifiConnected) {
    Serial.printf("  SSID : %s\n", WiFi.SSID().c_str());
    Serial.printf("  IP   : %s\n", WiFi.localIP().toString().c_str());
    Serial.printf("  RSSI : %d dBm\n", WiFi.RSSI());
    Serial.printf("  MAC  : %s\n", WiFi.macAddress().c_str());
    Serial.printf("  GW   : %s\n", WiFi.gatewayIP().toString().c_str());
    Serial.printf("  DNS  : %s\n", WiFi.dnsIP().toString().c_str());
  }
  if (apActive) {
    Serial.printf("  AP   : %s  IP: %s  Clients: %d\n",
                  apSSID.c_str(), WiFi.softAPIP().toString().c_str(),
                  WiFi.softAPgetStationNum());
  }
  Serial.println();
}

void cmdWifiConnect(char** argv, uint8_t argc) {
  if (argc < 3) { Serial.println(F("Usage: wifi-connect <SSID> <PASSWORD>")); return; }
  Serial.printf("  Connecting to '%s'", argv[1]);
  WiFi.mode(WIFI_STA);
  WiFi.begin(argv[1], argv[2]);
  int retries = 0;
  while (WiFi.status() != WL_CONNECTED && retries < 30) {
    delay(500); Serial.print('.'); retries++;
  }
  if (WiFi.status() == WL_CONNECTED) {
    wifiConnected = true;
    staSSID = String(argv[1]);
    Serial.printf("\n  " GREEN "Connected! IP: %s" RESET "\n\n", WiFi.localIP().toString().c_str());
    klog(("WiFi connected: " + staSSID).c_str());
  } else {
    Serial.println(F("\n  " RED "Connection failed" RESET));
    WiFi.disconnect();
  }
}

void cmdWifiDisconnect(char** argv, uint8_t argc) {
  WiFi.disconnect(true);
  wifiConnected = false;
  Serial.println("  WiFi disconnected");
}

void cmdWifiAp(char** argv, uint8_t argc) {
  if (argc < 2) { Serial.println(F("Usage: wifi-ap <SSID> [PASSWORD]")); return; }
  apSSID = String(argv[1]);
  apPASS = (argc >= 3) ? String(argv[2]) : "";
  WiFi.mode(wifiConnected ? WIFI_AP_STA : WIFI_AP);
  bool ok = apPASS.length() > 0
              ? WiFi.softAP(apSSID.c_str(), apPASS.c_str())
              : WiFi.softAP(apSSID.c_str());
  apActive = ok;
  if (ok) Serial.printf(GREEN "  AP '%s' started  IP: %s\n" RESET,
                         apSSID.c_str(), WiFi.softAPIP().toString().c_str());
  else    Serial.println(RED "  AP failed" RESET);
}

void cmdWifiScan(char** argv, uint8_t argc) {
  Serial.println(F("  Scanning..."));
  int n = WiFi.scanNetworks();
  if (n == 0) { Serial.println(F("  No networks found")); return; }
  Serial.println(F("\n  " YELLOW "#  SSID                            RSSI  ENC" RESET));
  Serial.println(F("  " GRAY "───────────────────────────────────────────────" RESET));
  for (int i = 0; i < n; i++) {
    const char* enc = WiFi.encryptionType(i) == WIFI_AUTH_OPEN ? GREEN "Open" RESET : CYAN "WPA" RESET;
    Serial.printf("  %-2d %-32s %4d  %s\n", i + 1,
                  WiFi.SSID(i).c_str(), WiFi.RSSI(i), enc);
  }
  WiFi.scanDelete();
  Serial.println();
}

void cmdWifiPing(char** argv, uint8_t argc) {
  if (argc < 2) { Serial.println(F("Usage: wifi-ping <IP|host>")); return; }
  if (!wifiConnected) { Serial.println(YELLOW "Not connected to WiFi" RESET); return; }
  IPAddress ip;
  if (!ip.fromString(argv[1])) { Serial.println(RED "Invalid IP. DNS not supported in minimal mode." RESET); return; }
  Serial.printf("  Pinging %s:\n", argv[1]);
  for (int i = 0; i < 4; i++) {
    WiFiClient client;
    unsigned long t = millis();
    bool ok = client.connect(ip, 80);
    unsigned long rtt = millis() - t;
    client.stop();
    if (ok) Serial.printf("  seq=%d time=%lums " GREEN "reachable" RESET "\n", i, rtt);
    else    Serial.printf("  seq=%d " RED "no response" RESET "\n", i);
    delay(500);
  }
}

void cmdWifiHostname(char** argv, uint8_t argc) {
  if (argc >= 2) {
    WiFi.setHostname(argv[1]);
    Hostname = String(argv[1]);
    apSSID = Hostname + "_ap";
    Serial.printf("  Hostname set to '%s'\n", argv[1]);
  } else {
    Serial.printf("  Hostname: %s\n", WiFi.getHostname());
  }
}

void cmdWifiHttpStart(char** argv, uint8_t argc) {
  if (!wifiConnected && !apActive) { Serial.println(YELLOW "Connect WiFi first" RESET); return; }
  int port = (argc >= 2) ? safeAtoi(argv[1]) : 80;
  if (httpServer) { delete httpServer; httpServer = nullptr; }
  httpServer = new WebServer(port);
  httpServer->on("/", []() {
    String html = F("<!DOCTYPE html><html><head><title>KernelESP</title>"
      "<style>body{font-family:monospace;background:#0d0d0d;color:#0f0;padding:2em}"
      "h1{color:#0ff}pre{color:#fff;border:1px solid #0f0;padding:1em;}</style></head>"
      "<body><h1>KernelESP v1.1</h1><pre>Status: Online\nHost: kernelesp\n"
      "Uptime: ");
    html += (millis() - bootTime) / 1000;
    html += F("s\nFree RAM: ");
    html += ESP.getFreeHeap() / 1024;
    html += F(" KB\n</pre>"
      "<p>Control via Serial terminal.</p></body></html>");
    if (httpServer) httpServer->send(200, "text/html", html);
  });
  httpServer->begin();
  httpRunning = true;
  Serial.printf(GREEN "  HTTP server started on port %d\n  URL: http://%s/\n" RESET,
                port, wifiConnected ? WiFi.localIP().toString().c_str()
                                    : WiFi.softAPIP().toString().c_str());
}

void cmdWifiHttpStop(char** argv, uint8_t argc) {
  if (httpServer) { httpServer->stop(); delete httpServer; httpServer = nullptr; httpRunning = false; }
  Serial.println("  HTTP server stopped");
}

void cmdWifiMac(char** argv, uint8_t argc) {
  Serial.printf("  STA MAC: %s\n", WiFi.macAddress().c_str());
  Serial.printf("  AP  MAC: %s\n", WiFi.softAPmacAddress().c_str());
}

// Scripting
void runScriptStream(File& f) {
  String content;
  do {
    content = f.readStringUntil('\n');
    content.trim(); // strip \r and spaces
    if (content.length() > 0 && content[0] != '#') {
      Serial.printf(GRAY "  $ %s\n" RESET, content.c_str());
      char* buf = strdup(content.c_str());
      executeCommand(buf);
      free(buf);
      delay(20);
    }
  } while(f.position() < f.size());
}

void runScript(const char* text) {
  char* buf = (char*)malloc(strlen(text) + 2);
  if (!buf) { Serial.println(RED "malloc error" RESET); return; }
  strcpy(buf, text);

  char* cmd = strtok(buf, ";");
  int n = 0;
  while (cmd) {
    cmd = ltrim(cmd);
    int len = strlen(cmd);
    while (len > 0 && (cmd[len-1] == ' ' || cmd[len-1] == '\r' || cmd[len-1] == '\n')) cmd[--len] = '\0';
    if (len > 0 && cmd[0] != '#') {
      Serial.printf(GRAY "  [%d]" RESET " $ %s\n", ++n, cmd);
      executeCommand(cmd);
      delay(20);
    }
    cmd = strtok(nullptr, ";");
  }
  free(buf);
}

void cmdEval(char** argv, uint8_t argc) {
  if (argc < 2) { Serial.println(F("Usage: eval \"cmd1; cmd2; ...\"")); return; }
  String code = "";
  for (int i = 1; i < argc; i++) { if (i > 1) code += " "; code += argv[i]; }
  Serial.println(F(CYAN ">>> eval" RESET));
  runScript(code.c_str());
  Serial.println(F(CYAN ">>> done" RESET));
}

void cmdRun(char** argv, uint8_t argc) {
  if (argc < 2) { Serial.println(F("Usage: run <script_file>")); return; }
  String path = buildPath(argv[1]);
  File f = SPIFFS.open(path, FILE_READ);
  if (!f) { Serial.printf(RED "Script not found: %s\n" RESET, argv[1]); return; }
  Serial.printf(CYAN ">>> run %s" RESET "\n", argv[1]);
  runScriptStream(f);
  Serial.printf(CYAN ">>> done (%u bytes)" RESET "\n", (unsigned int)f.size());
  klog(("run " + path).c_str());
  f.close();
}

void cmdFor(char** argv, uint8_t argc) {
  if (argc < 3) { Serial.println(F("Usage: for <count> \"<cmd>\"")); return; }
  int count = constrain(safeAtoi(argv[1]), 1, 1000);
  String cmd = "";
  for (int i = 2; i < argc; i++) { if (i > 2) cmd += " "; cmd += argv[i]; }
  for (int i = 0; i < count; i++) {
    Serial.printf(GRAY "\r  [%d/%d]" RESET, i + 1, count);
    char* buf = strdup(cmd.c_str());
    executeCommand(buf);
    free(buf);
    delay(5);
  }
  Serial.println();
}

void cmdDelay(char** argv, uint8_t argc) {
  if (argc < 2) { Serial.println(F("Usage: delay <ms>")); return; }
  int ms = constrain(safeAtoi(argv[1]), 0, 60000);
  delay(ms);
}

// System Commands
void cmdFree(char** argv, uint8_t argc) {
  uint32_t heap    = ESP.getFreeHeap();
  uint32_t minHeap = ESP.getMinFreeHeap();
  uint32_t maxAlloc= ESP.getMaxAllocHeap();
  Serial.println(F("\n  " YELLOW "Memory:" RESET));
  Serial.printf("  Free heap      : %u bytes (%u KB)\n", heap, heap / 1024);
  Serial.printf("  Min free heap  : %u bytes\n", minHeap);
  Serial.printf("  Max alloc block: %u bytes\n", maxAlloc);
  Serial.printf("  PSRAM          : %u bytes\n", ESP.getFreePsram());
  cmdDf(argv, 0);
}

void cmdSysInfo(char** argv, uint8_t argc) {
  unsigned long up  = (millis() - bootTime) / 1000;
  uint8_t h = up / 3600, m = (up % 3600) / 60, s = up % 60;

  Serial.println(F("\n"
    CYAN  "  ██████╗ ███████╗██████╗ ██████╗ ██████╗ \n"
    BCYAN "  ██╔════╝██╔════╝██╔══██╗╚════██╗╚════██╗\n"
    CYAN  "  █████╗  ███████╗██████╔╝ █████╔╝ █████╔╝\n"
    CYAN  "  ██╔══╝  ╚════██║██╔═══╝  ╚═══██╗ ██╔═══╝\n"
    BCYAN "  ███████╗███████║██║      ███████╗███████║ \n"
    GRAY  "  ╚══════╝╚══════╝╚═╝      ╚══════╝╚══════╝" RESET "\n"
  ));

  Serial.printf("  " YELLOW "OS     " RESET ": KernelESP v1.1\n");
  Serial.printf("  " YELLOW "Host   " RESET ": %s\n", Hostname.c_str());
#ifdef ARDUINO_BOARD
  Serial.printf("  " YELLOW "Board  " RESET ": %s @ %d MHz\n", ARDUINO_BOARD, ESP.getCpuFreqMHz());
#else
  Serial.printf("  " YELLOW "CPU    " RESET ": Xtensa LX6 @ %d MHz\n", ESP.getCpuFreqMHz());
#endif
  Serial.printf("  " YELLOW "Chip   " RESET ": %s Rev%d Cores:%d\n", ESP.getChipModel(), ESP.getChipRevision(), ESP.getChipCores());
  Serial.printf("  " YELLOW "Flash  " RESET ": %u KB (mode:%d speed:%d MHz)\n",
                ESP.getFlashChipSize()/1024, ESP.getFlashChipMode(), ESP.getFlashChipSpeed()/1000000);
  Serial.printf("  " YELLOW "RAM    " RESET ": %u KB free / PSRAM: %u KB\n",
                ESP.getFreeHeap()/1024, ESP.getFreePsram()/1024);
  Serial.printf("  " YELLOW "SPIFFS " RESET ": %u / %u KB\n",
                SPIFFS.usedBytes()/1024, SPIFFS.totalBytes()/1024);
  Serial.printf("  " YELLOW "Uptime " RESET ": %dh %dm %ds\n", h, m, s);
  Serial.printf("  " YELLOW "WiFi   " RESET ": %s\n",
                wifiConnected ? (GREEN + WiFi.SSID() + "  " + WiFi.localIP().toString() + RESET).c_str()
                              : RED "Offline" RESET);
  Serial.println();
}

void cmdDmesg(char** argv, uint8_t argc) {
  Serial.println(F("\n  " YELLOW "Kernel Log:" RESET "\n"));
  for (uint8_t i = 0; i < dmesgCount; i++) {
    uint8_t idx = (dmesgHead - dmesgCount + i + DMESG_LINES) % DMESG_LINES;
    Serial.printf("  " GRAY "[%4lus]" RESET " %s\n", dmesgBuf[idx].ts, dmesgBuf[idx].msg);
  }
  Serial.println();
}

void cmdReboot(char** argv, uint8_t argc) {
  Serial.println(F("\n  Rebooting...\n"));
  delay(300);
  ESP.restart();
}

void cmdWhoami(char** argv, uint8_t argc) { Serial.println("root"); }
void cmdUname(char** argv, uint8_t argc)  { Serial.println("KernelESP v1.1 ESP32"); }
void cmdUptime(char** argv, uint8_t argc) {
  unsigned long t = (millis() - bootTime) / 1000;
  Serial.printf("up %dh %dm %ds\n", (int)(t/3600), (int)((t%3600)/60), (int)(t%60));
}
void cmdPwd(char** argv, uint8_t argc) { Serial.println(currentPath); }
void cmdEcho(char** argv, uint8_t argc) {
  for (int i = 1; i < argc; i++) { if (i > 1) Serial.print(' '); Serial.print(argv[i]); }
  Serial.println();
}
void cmdClear(char** argv, uint8_t argc) { showLogo(); }

void cmdWave(char** argv, uint8_t argc) {
  Serial.println(F("\n"
    CYAN "  ╭╮              ╭╮\n"
    CYAN "  ╭╯╰╮          ╭╯╰╮\n"
    CYAN " ╭╯  ╰╮        ╭╯  ╰╮\n"
    CYAN "╭╯    ╰╮──────╭╯    ╰╮\n"
    CYAN "╯      ╰╮    ╭╯      ╰\n" RESET
  ));
}

void cmdHelp(char** argv, uint8_t argc) {
  Serial.println(F("\n  " CYAN "KernelESP v1.1 Command Reference" RESET "\n"));

  Serial.println(F("  " GREEN "Hardware:" RESET));
  Serial.println(F("    pinmode <pin> <mode>          Set GPIO mode (input/output/pullup/pulldown/analog/touch/ledpwm/dac)"));
  Serial.println(F("    pins                          Show current pin configurations and capabilities"));
  Serial.println(F("    write   <pin> <HIGH|LOW>      Digital write"));
  Serial.println(F("    read    [pin]                 Digital read (all if no pin)"));
  Serial.println(F("    aread   [pin]                 ADC read (0-4095, 3.3V)"));
  Serial.println(F("    pwm     <pin> <0-255> [freq]  LEDC PWM output"));
  Serial.println(F("    dac     <pin> <0-255>         DAC voltage output"));
  Serial.println(F("    gpio    <pin> <on|off|toggle> Quick GPIO"));
  Serial.println(F("    tone    <pin> <hz> [ms]       Square wave tone"));
  Serial.println(F("    notone  [pin]                 Stop tone"));
  Serial.println(F("    tsense  [pin]                 Capacitive touch read"));
  Serial.println(F("    disco   [cycles] [speed]      LED show"));
  Serial.println(F("    morse   <pin> <MSG>           Morse code"));

  Serial.println(F("\n  " GREEN "Sensors:" RESET));
  Serial.println(F("    sensor                        All ADC channels with bar"));
  Serial.println(F("    scope   <pin> [n] [ms]        Oscilloscope plot"));
  Serial.println(F("    monitor <pin> <ms> [s]        Live pin monitor"));

  Serial.println(F("\n  " GREEN "Filesystem (SPIFFS — persistent):" RESET));
  Serial.println(F("    ls [dir]  cd <dir>  pwd  mkdir <name>  touch <name>"));
  Serial.println(F("    cat <f>   writefile <f> <text>  append <f> <text>"));
  Serial.println(F("    rm <name> [-r]  mv <src> <dst>  cp <src> <dst>  df"));

  Serial.println(F("\n  " GREEN "WiFi:" RESET));
  Serial.println(F("    wifi                          Status"));
  Serial.println(F("    wifi-scan                     Scan networks"));
  Serial.println(F("    wifi-connect <SSID> <PASS>    Connect"));
  Serial.println(F("    wifi-disconnect               Disconnect"));
  Serial.println(F("    wifi-ap <SSID> [PASS]         Soft Access Point"));
  Serial.println(F("    wifi-ping <IP>                Connectivity check"));
  Serial.println(F("    wifi-http-start [port]        Web server"));
  Serial.println(F("    wifi-http-stop                Stop web server"));
  Serial.println(F("    wifi-hostname [name]          Get/set hostname"));
  Serial.println(F("    wifi-mac                      Show MAC addresses\n"));

  Serial.println(F("\n  " GREEN "Scripting:" RESET));
  Serial.println(F("    eval \"cmd1; cmd2\"             Execute inline script"));
  Serial.println(F("    run  <script.sh>              Execute file script"));
  Serial.println(F("    for  <n> \"cmd\"                Loop n times"));
  Serial.println(F("    delay <ms>                    Wait"));

  Serial.println(F("\n  " GREEN "System:" RESET));
  Serial.println(F("    sysinfo / neofetch  uptime  free  df  dmesg"));
  Serial.println(F("    whoami  uname  echo <text>  clear  wave  reboot\n"));
}

// Main Command Router
void executeCommand(char* line) {
  line = ltrim(line);
  if (!line || strlen(line) == 0 || line[0] == '#') return;

  char lineCopy[CMD_LEN];
  strncpy(lineCopy, line, CMD_LEN - 1);
  lineCopy[CMD_LEN - 1] = '\0';

  uint8_t argc = 0;
  parseCommand(lineCopy, args, &argc);
  if (argc == 0) return;

  strlowerBuf(args[0]);
  const char* cmd = args[0];

  // Hardware
  if      (!strcmp(cmd,"pinmode"))                      cmdPinMode(args, argc);
  else if (!strcmp(cmd,"pins"))                         cmdPins(args, argc);
  else if (!strcmp(cmd,"write")  || !strcmp(cmd,"digitalwrite")) cmdDigitalWrite(args, argc);
  else if (!strcmp(cmd,"read")   || !strcmp(cmd,"digitalread"))  cmdDigitalRead(args, argc);
  else if (!strcmp(cmd,"aread")  || !strcmp(cmd,"analogread"))   cmdAnalogRead(args, argc);
  else if (!strcmp(cmd,"pwm"))                          cmdPWM(args, argc);
  else if (!strcmp(cmd,"dac"))                          cmdDAC(args, argc);
  else if (!strcmp(cmd,"gpio"))                         cmdGPIO(args, argc);
  else if (!strcmp(cmd,"tone"))                         cmdTone(args, argc);
  else if (!strcmp(cmd,"notone"))                       cmdNoTone(args, argc);
  else if (!strcmp(cmd,"tsense"))                       cmdTouch(args, argc);
  else if (!strcmp(cmd,"disco"))                        cmdDisco(args, argc);
  else if (!strcmp(cmd,"morse"))                        cmdMorse(args, argc);
  else if (!strcmp(cmd,"sensor"))                       cmdSensor(args, argc);
  else if (!strcmp(cmd,"scope"))                        cmdScope(args, argc);
  else if (!strcmp(cmd,"monitor"))                      cmdMonitor(args, argc);

  // Filesystem
  else if (!strcmp(cmd,"ls")    || !strcmp(cmd,"dir"))      cmdLS(args, argc);
  else if (!strcmp(cmd,"cd"))                               cmdCD(args, argc);
  else if (!strcmp(cmd,"pwd"))                              cmdPwd(args, argc);
  else if (!strcmp(cmd,"mkdir"))                            cmdMkdir(args, argc);
  else if (!strcmp(cmd,"touch"))                            cmdTouch2(args, argc);
  else if (!strcmp(cmd,"cat")   || !strcmp(cmd,"type"))     cmdCat(args, argc);
  else if (!strcmp(cmd,"writefile") || !strcmp(cmd,"write>")) cmdWrite(args, argc);
  else if (!strcmp(cmd,"append"))                           cmdWrite(args, argc);
  else if (!strcmp(cmd,"rm")    || !strcmp(cmd,"del"))      cmdRM(args, argc);
  else if (!strcmp(cmd,"mv"))                               cmdMv(args, argc);
  else if (!strcmp(cmd,"cp"))                               cmdCp(args, argc);
  else if (!strcmp(cmd,"df"))                               cmdDf(args, argc);
  else if (!strcmp(cmd,"echo"))                             cmdEcho(args, argc);

  // WiFi - Flattened Commands
  else if (!strcmp(cmd,"wifi"))                             cmdWifi(args, argc);
  else if (!strcmp(cmd,"wifi-connect") || !strcmp(cmd,"wifi-up")) cmdWifiConnect(args, argc);
  else if (!strcmp(cmd,"wifi-disconnect") || !strcmp(cmd,"wifi-down")) cmdWifiDisconnect(args, argc);
  else if (!strcmp(cmd,"wifi-ap"))                          cmdWifiAp(args, argc);
  else if (!strcmp(cmd,"wifi-scan"))                        cmdWifiScan(args, argc);
  else if (!strcmp(cmd,"wifi-ping"))                        cmdWifiPing(args, argc);
  else if (!strcmp(cmd,"wifi-hostname"))                    cmdWifiHostname(args, argc);
  else if (!strcmp(cmd,"wifi-http-start"))                  cmdWifiHttpStart(args, argc);
  else if (!strcmp(cmd,"wifi-http-stop"))                   cmdWifiHttpStop(args, argc);
  else if (!strcmp(cmd,"wifi-mac"))                         cmdWifiMac(args, argc);

  // Scripting
  else if (!strcmp(cmd,"eval")  || !strcmp(cmd,"exec"))     cmdEval(args, argc);
  else if (!strcmp(cmd,"run")   || !strcmp(cmd,"sh"))       cmdRun(args, argc);
  else if (!strcmp(cmd,"for")   || !strcmp(cmd,"loop"))     cmdFor(args, argc);
  else if (!strcmp(cmd,"delay") || !strcmp(cmd,"sleep"))    cmdDelay(args, argc);

  // System
  else if (!strcmp(cmd,"help")  || !strcmp(cmd,"?"))        cmdHelp(args, argc);
  else if (!strcmp(cmd,"sysinfo")|| !strcmp(cmd,"neofetch")) cmdSysInfo(args, argc);
  else if (!strcmp(cmd,"dmesg") || !strcmp(cmd,"log"))      cmdDmesg(args, argc);
  else if (!strcmp(cmd,"free")  || !strcmp(cmd,"mem"))      cmdFree(args, argc);
  else if (!strcmp(cmd,"uptime"))                           cmdUptime(args, argc);
  else if (!strcmp(cmd,"whoami"))                           cmdWhoami(args, argc);
  else if (!strcmp(cmd,"uname"))                            cmdUname(args, argc);
  else if (!strcmp(cmd,"clear") || !strcmp(cmd,"cls"))      cmdClear(args, argc);
  else if (!strcmp(cmd,"reboot")|| !strcmp(cmd,"reset"))    cmdReboot(args, argc);
  else if (!strcmp(cmd,"wave"))                             cmdWave(args, argc);

  else {
    Serial.printf(RED "'%s'" RESET " not found. Type " YELLOW "'help'" RESET "\n", cmd);
  }
}

// Setup
void setup() {
  Serial.begin(115200);
  bootTime = millis();

  // Brief boot flash
#ifdef LED_BUILTIN
  pinMode(LED_BUILTIN, OUTPUT);
  for (int i = 0; i < 6; i++) { digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN)); delay(60); }
  digitalWrite(LED_BUILTIN, LOW);
#else
  pinMode(2, OUTPUT);
  for (int i = 0; i < 6; i++) { digitalWrite(2, !digitalRead(2)); delay(60); }
  digitalWrite(2, LOW);
#endif

  initPins();
  initFilesystem();

  showLogo();

  klog("KernelESP v1.1 booted");
  klog("SPIFFS OK");
  klog("Serial @ 115200");

  // Run startup script if present
  if(SPIFFS.exists("/etc/rc")) {
    File f = SPIFFS.open("/etc/rc", FILE_READ);
    if(f) {
      runScriptStream(f);
      f.close();
    }
  }

  printPrompt();
}

// Loop
void loop() {
  if (httpRunning && httpServer) httpServer->handleClient();

  while (Serial.available()) {
    char c = Serial.read();

    if (c == '\r') continue; 

    if (c == '\n') {
      inputBuffer[inputLen] = '\0';
      if (inputLen > 0) {
        Serial.println();
        executeCommand(inputBuffer);
      }
      inputLen = 0;
      memset(inputBuffer, 0, CMD_LEN);
      printPrompt();

    } else if (c == 8 || c == 127) { 
      if (inputLen > 0) {
        inputLen--;
        Serial.print(F("\b \b"));
      }

    } else if (c == '\t') {
      Serial.print(F(GRAY "..." RESET));

    } else if (inputLen < CMD_LEN - 1 && c >= 32 && c < 127) {
      inputBuffer[inputLen++] = c;
      Serial.print(c); 
    }
  }
  delay(1);
}