feat: Introduce a Blockly-based visual rule editor with AST generation and add new assets for water button status.

public/waterButtonStatus/script.js

@@ -7,6 +7,7 @@ const CIRC = 2 * Math.PI * 52;  // ~326.73
 const glow = document.getElementById('glow');
 const durInput = document.getElementById('dur-input');
 const btnRun = document.getElementById('btn-run');
+const btnLearn = document.getElementById('btn-learn');
 const btnOpen = document.getElementById('btn-open');
 const btnClose = document.getElementById('btn-close');
 
@@ -45,10 +46,25 @@ const CIRC = 2 * Math.PI * 52;  // ~326.73
     if (durInput.value !== String(secs)) durInput.value = secs;
   }
 
-    // Disable controls while timer is running
+  // Disable controls while timer is running or learning
   const running = state.timerActive;
-    btnRun.disabled = running;
-    durInput.disabled = running;
+  const learning = state.countMode;
+  btnRun.disabled = running || learning;
+  durInput.disabled = running || learning;
+  btnOpen.disabled = running || learning;
+  btnClose.disabled = running || learning;
+
+  // Learn button toggles label and action
+  if (learning) {
+    btnLearn.textContent = '⏹ Stop Learn';
+    btnLearn.onclick = doStopLearn;
+    btnLearn.classList.add('active-learn');
+  } else {
+    btnLearn.textContent = '📐 Learn';
+    btnLearn.onclick = doLearn;
+    btnLearn.classList.remove('active-learn');
+  }
+  btnLearn.disabled = running;  // can't start learn while timer runs
 
   if (state.timerActive && state.timerStartedAt && state.timerEndsAt) {
     const total = state.timerEndsAt - state.timerStartedAt;
@@ -64,9 +80,12 @@ const CIRC = 2 * Math.PI * 52;  // ~326.73
     badgeTxt.textContent = 'Timer Running';
     glow.classList.add('active');
   } else if (state.countMode) {
+    const elapsed = state.countStart
+      ? Math.max(0, (Date.now() + serverOffset) - state.countStart)
+      : 0;
     ring.style.strokeDashoffset = CIRC;
-      cd.textContent = '⏱';
-      cd.className = 'countdown idle';
+    cd.textContent = fmt(elapsed);
+    cd.className = 'countdown';
     label.textContent = 'LEARNING';
     badge.className = 'badge counting';
     badgeTxt.textContent = 'Count Mode';
@@ -192,6 +211,10 @@ const CIRC = 2 * Math.PI * 52;  // ~326.73
 function doOpen() { apiPost('/api/open'); }
 function doClose() { apiPost('/api/close'); }
 
+async function doLearn() { await apiPost('/api/learn'); }
+async function doStopLearn() { await apiPost('/api/stop-learn'); }
+
+
 // Also save duration on Enter or blur
 durInput.addEventListener('change', () => {
   const secs = parseInt(durInput.value, 10);
@@ -199,3 +222,50 @@ const CIRC = 2 * Math.PI * 52;  // ~326.73
     apiPost('/api/duration', { seconds: secs });
   }
 });
+
+// ── Button online status ──
+const deviceDot = document.getElementById('device-dot');
+const deviceState = document.getElementById('device-state');
+const valveDot = document.getElementById('valve-dot');
+const valveState = document.getElementById('valve-state');
+
+function updateDeviceWidget(dot, stateEl, online) {
+  if (online === true) {
+    dot.className = 'device-dot online';
+    stateEl.className = 'device-state online';
+    stateEl.textContent = 'Online';
+  } else if (online === false) {
+    dot.className = 'device-dot offline';
+    stateEl.className = 'device-state offline';
+    stateEl.textContent = 'Offline';
+  } else {
+    dot.className = 'device-dot';
+    stateEl.className = 'device-state';
+    stateEl.textContent = 'Unknown';
+  }
+}
+
+async function pollButtonOnline() {
+  try {
+    const r = await fetch('/api/button-online');
+    const d = await r.json();
+    updateDeviceWidget(deviceDot, deviceState, d.online);
+  } catch {
+    updateDeviceWidget(deviceDot, deviceState, null);
+  }
+}
+
+async function pollValveOnline() {
+  try {
+    const r = await fetch('/api/valve-online');
+    const d = await r.json();
+    updateDeviceWidget(valveDot, valveState, d.online);
+  } catch {
+    updateDeviceWidget(valveDot, valveState, null);
+  }
+}
+
+pollButtonOnline();
+pollValveOnline();
+setInterval(pollButtonOnline, 10000);
+setInterval(pollValveOnline, 10000);

public/waterButtonStatus/style.css

@@ -1,6 +1,10 @@
 @import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap');
 
-  * { margin: 0; padding: 0; box-sizing: border-box; }
+* {
+  margin: 0;
+  padding: 0;
+  box-sizing: border-box;
+}
 
 :root {
   --bg: #0a0e1a;
@@ -151,8 +155,15 @@
 }
 
 @keyframes pulse-dot {
-    0%, 100% { opacity: 1; }
-    50% { opacity: 0.4; }
+
+  0%,
+  100% {
+    opacity: 1;
+  }
+
+  50% {
+    opacity: 0.4;
+  }
 }
 
 /* ── Info row ── */
@@ -263,6 +274,23 @@
   border-color: var(--red);
 }
 
+.btn.warning {
+  border-color: rgba(245, 158, 11, 0.35);
+  color: var(--orange);
+}
+
+.btn.warning:hover {
+  background: rgba(245, 158, 11, 0.15);
+  border-color: var(--orange);
+}
+
+.btn.warning.active-learn {
+  background: var(--orange);
+  border-color: transparent;
+  color: #000;
+  animation: pulse-dot 1s ease-in-out infinite;
+}
+
 .btn.success {
   border-color: rgba(34, 197, 94, 0.3);
 }
@@ -306,10 +334,104 @@
   text-align: right;
 }
 
-  .dur-input::-webkit-inner-spin-button { opacity: 0.3; }
+.dur-input::-webkit-inner-spin-button {
+  opacity: 0.3;
+}
 
 .dur-unit {
   font-size: 0.85rem;
   color: var(--text-dim);
   font-weight: 500;
 }
+
+/* ── Device Status Widgets ── */
+.devices-row {
+  display: flex;
+  gap: 0.6rem;
+  width: 100%;
+}
+
+.device-status {
+  flex: 1;
+  display: flex;
+  align-items: center;
+  gap: 0.9rem;
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: 16px;
+  padding: 0.7rem 1.2rem;
+  width: 100%;
+}
+
+.device-icon-wrap {
+  position: relative;
+  flex-shrink: 0;
+}
+
+.device-icon {
+  width: 48px;
+  height: 48px;
+  object-fit: contain;
+  border-radius: 10px;
+  display: block;
+  filter: drop-shadow(0 2px 6px rgba(0, 0, 0, 0.5));
+}
+
+.device-dot {
+  position: absolute;
+  bottom: -3px;
+  right: -3px;
+  width: 13px;
+  height: 13px;
+  border-radius: 50%;
+  border: 2px solid var(--bg);
+  background: var(--text-dim);
+  transition: background 0.4s ease, box-shadow 0.4s ease;
+}
+
+.device-dot.online {
+  background: var(--green);
+  box-shadow: 0 0 7px var(--green);
+  animation: pulse-dot 2s ease-in-out infinite;
+}
+
+.device-dot.offline {
+  background: var(--red);
+  box-shadow: 0 0 6px var(--red);
+}
+
+.device-info {
+  display: flex;
+  flex-direction: column;
+  gap: 0.15rem;
+}
+
+.device-name {
+  font-size: 0.9rem;
+  font-weight: 600;
+  color: var(--text);
+}
+
+.device-state {
+  font-size: 0.75rem;
+  font-weight: 500;
+  color: var(--text-dim);
+  text-transform: uppercase;
+  letter-spacing: 0.06em;
+  transition: color 0.4s ease;
+}
+
+.device-state.online {
+  color: var(--green);
+}
+
+.device-state.offline {
+  color: var(--red);
+}
+
+.device-desc {
+  font-size: 0.68rem;
+  color: var(--text-dim);
+  line-height: 1.35;
+  opacity: 0.75;
+}

rules/waterButtonLearnAndCall.js

@@ -301,6 +301,7 @@ export default {
 startStatusServer({
   getState,
   WATER_BUTTON_MAC,
+  REMOTE_SWITCH_MAC,
   setLight,
   persistedState,
   saveState

waterButtonStatusServer.js

@@ -6,16 +6,45 @@ const STATUS_PORT = 8082;
 export function startStatusServer({
     getState,
     WATER_BUTTON_MAC,
+    REMOTE_SWITCH_MAC,
     setLight,
     persistedState,
     saveState
 }) {
+    async function getButtonOnline() {
+        try {
+            const ctxGetState = global.__waterBotGetState;
+            if (!ctxGetState) return null;
+            const online = await ctxGetState(WATER_BUTTON_MAC, 'system', 'online');
+            // DB stores booleans as strings 'true'/'false'
+            if (online === true || online === 'true') return true;
+            if (online === false || online === 'false') return false;
+            return null;
+        } catch {
+            return null;
+        }
+    }
+
+    async function getValveOnline() {
+        try {
+            const ctxGetState = global.__waterBotGetState;
+            if (!ctxGetState) return null;
+            const online = await ctxGetState(REMOTE_SWITCH_MAC, 'system', 'online');
+            if (online === true || online === 'true') return true;
+            if (online === false || online === 'false') return false;
+            return null;
+        } catch {
+            return null;
+        }
+    }
+
     function getStatusJSON() {
         const state = getState(WATER_BUTTON_MAC);
         return {
             valveOpen: state.timer !== null || (!state.countMode && state.timer === null),
             timerActive: state.timer !== null,
             countMode: state.countMode,
+            countStart: state.countStart || null,
             storedDuration: state.storedDuration,
             timerStartedAt: state.timerStartedAt,
             timerEndsAt: state.timerEndsAt,
@@ -35,6 +64,31 @@ export function startStatusServer({
 <div class="container">
   <h1>💧 Water Timer</h1>
 
+  <div class="devices-row">
+    <div class="device-status">
+      <div class="device-icon-wrap">
+        <img src="/taster.png" class="device-icon" alt="Button">
+        <span class="device-dot" id="device-dot"></span>
+      </div>
+      <div class="device-info">
+        <span class="device-name">Button</span>
+        <span class="device-state" id="device-state">Checking…</span>
+        <span class="device-desc">Short press: run timer &middot; Long press: start learn, short press to stop</span>
+      </div>
+    </div>
+    <div class="device-status">
+      <div class="device-icon-wrap">
+        <img src="/valve.png" class="device-icon" alt="Valve">
+        <span class="device-dot" id="valve-dot"></span>
+      </div>
+      <div class="device-info">
+        <span class="device-name">Valve</span>
+        <span class="device-state" id="valve-state">Checking…</span>
+        <span class="device-desc">⚠️ Connect according to flow direction mark</span>
+      </div>
+    </div>
+  </div>
+
   <div class="ring-wrapper">
     <div class="glow" id="glow"></div>
     <svg class="ring-svg" viewBox="0 0 120 120">
@@ -66,6 +120,7 @@ export function startStatusServer({
         <span class="dur-unit">sec</span>
       </div>
       <button class="btn primary" id="btn-run" onclick="doRun()">▶ Run</button>
+      <button class="btn warning" id="btn-learn" onclick="doLearn()">📐 Learn</button>
     </div>
     <button class="btn success" id="btn-open" onclick="doOpen()">🔓 Open</button>
     <button class="btn danger" id="btn-close" onclick="doClose()">🔒 Close</button>
@@ -81,7 +136,7 @@ export function startStatusServer({
         try { global.__waterStatusServer.close(); } catch (e) { }
     }
 
-    const srv = http.createServer((req, res) => {
+    const srv = http.createServer(async (req, res) => {
         const url = new URL(req.url, `http://${req.headers.host}`);
 
         const jsonHeaders = {
@@ -102,6 +157,32 @@ export function startStatusServer({
             return;
         }
 
+        if (url.pathname === '/taster.png') {
+            res.writeHead(200, { 'Content-Type': 'image/png', 'Cache-Control': 'public, max-age=86400' });
+            res.end(fs.readFileSync(new URL('./public/waterButtonStatus/taster.png', import.meta.url)));
+            return;
+        }
+
+        if (url.pathname === '/api/button-online') {
+            const online = await getButtonOnline();
+            res.writeHead(200, jsonHeaders);
+            res.end(JSON.stringify({ online }));
+            return;
+        }
+
+        if (url.pathname === '/valve.png') {
+            res.writeHead(200, { 'Content-Type': 'image/png', 'Cache-Control': 'public, max-age=86400' });
+            res.end(fs.readFileSync(new URL('./public/waterButtonStatus/valve.png', import.meta.url)));
+            return;
+        }
+
+        if (url.pathname === '/api/valve-online') {
+            const online = await getValveOnline();
+            res.writeHead(200, jsonHeaders);
+            res.end(JSON.stringify({ online }));
+            return;
+        }
+
         if (url.pathname === '/api/status') {
             res.writeHead(200, jsonHeaders);
             res.end(JSON.stringify(getStatusJSON()));
@@ -114,17 +195,55 @@ export function startStatusServer({
             req.on('data', c => body += c);
             req.on('end', async () => {
                 const sendRPC = global.__waterBotRPC;
-
-                // Wait, inside the route we need `state` which uses `getState(WATER_BUTTON_MAC)`
-                // The original code did: const state = getState(WATER_BUTTON_MAC);
                 const state = getState(WATER_BUTTON_MAC);
 
+                // ── Learn / Stop-learn: work regardless of device connection ──
+                if (url.pathname === '/api/learn') {
+                    if (state.timer) { clearTimeout(state.timer); state.timer = null; }
+                    state.timerStartedAt = null;
+                    state.timerEndsAt = null;
+                    state.countMode = true;
+                    state.countStart = Date.now();
+                    if (sendRPC) {
+                        try { await setLight(sendRPC, WATER_BUTTON_MAC, false, 0); } catch (e) {
+                            console.warn('[WaterStatus] learn: setLight failed:', e.message);
+                        }
+                    }
+                    res.writeHead(200, jsonHeaders);
+                    res.end(JSON.stringify({ ok: true, action: 'learn' }));
+                    return;
+                }
+
+                if (url.pathname === '/api/stop-learn') {
+                    if (!state.countMode) {
+                        res.writeHead(200, jsonHeaders);
+                        res.end(JSON.stringify({ ok: true, action: 'stop-learn', skipped: true }));
+                        return;
+                    }
+                    const elapsed = Date.now() - (state.countStart || Date.now());
+                    state.countMode = false;
+                    state.countStart = 0;
+                    state.storedDuration = elapsed;
+                    persistedState[WATER_BUTTON_MAC] = { storedDuration: elapsed };
+                    saveState(persistedState);
+                    if (sendRPC) {
+                        try { await setLight(sendRPC, WATER_BUTTON_MAC, true, 95); } catch (e) {
+                            console.warn('[WaterStatus] stop-learn: setLight failed:', e.message);
+                        }
+                    }
+                    res.writeHead(200, jsonHeaders);
+                    res.end(JSON.stringify({ ok: true, action: 'stop-learn', storedDuration: elapsed }));
+                    return;
+                }
+
+                // ── All other commands require a live device connection ──
                 if (!sendRPC) {
                     res.writeHead(503, jsonHeaders);
                     res.end(JSON.stringify({ ok: false, error: 'Not ready — no device connection' }));
                     return;
                 }
 
+
                 try {
                     if (url.pathname === '/api/run') {
                         if (state.timer) { clearTimeout(state.timer); state.timer = null; }