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

public/waterButtonStatus/script.js

@@ -1,201 +1,271 @@
 const CIRC = 2 * Math.PI * 52;  // ~326.73
-  const ring  = document.getElementById('ring');
+const ring = document.getElementById('ring');
-  const cd    = document.getElementById('countdown');
+const cd = document.getElementById('countdown');
-  const label = document.getElementById('label');
+const label = document.getElementById('label');
-  const badge = document.getElementById('badge');
+const badge = document.getElementById('badge');
-  const badgeTxt = document.getElementById('badge-text');
+const badgeTxt = document.getElementById('badge-text');
-  const glow  = document.getElementById('glow');
+const glow = document.getElementById('glow');
-  const durInput = document.getElementById('dur-input');
+const durInput = document.getElementById('dur-input');
-  const btnRun  = document.getElementById('btn-run');
+const btnRun = document.getElementById('btn-run');
-  const btnOpen = document.getElementById('btn-open');
+const btnLearn = document.getElementById('btn-learn');
-  const btnClose = document.getElementById('btn-close');
+const btnOpen = document.getElementById('btn-open');
+const btnClose = document.getElementById('btn-close');
 
-  function fmt(ms) {
+function fmt(ms) {
-    if (ms <= 0) return '0.0';
+  if (ms <= 0) return '0.0';
-    const totalSec = ms / 1000;
+  const totalSec = ms / 1000;
-    if (totalSec < 60) return totalSec.toFixed(1);
+  if (totalSec < 60) return totalSec.toFixed(1);
-    const m = Math.floor(totalSec / 60);
+  const m = Math.floor(totalSec / 60);
-    const s = Math.floor(totalSec % 60);
+  const s = Math.floor(totalSec % 60);
-    return m + ':' + String(s).padStart(2, '0');
+  return m + ':' + String(s).padStart(2, '0');
+}
+
+function fmtDur(ms) {
+  const s = (ms / 1000).toFixed(1);
+  return s + 's';
+}
+
+let state = null;
+let serverOffset = 0; // server time - client time
+
+async function poll() {
+  try {
+    const r = await fetch('/api/status');
+    state = await r.json();
+    // Compute clock offset so countdown works even with clock skew
+    serverOffset = state.now - Date.now();
+  } catch (e) { /* retry next tick */ }
+}
+
+function render() {
+  if (!state) return;
+
+  // Sync duration input if user isn't editing it
+  if (document.activeElement !== durInput) {
+    const secs = Math.round(state.storedDuration / 1000);
+    if (durInput.value !== String(secs)) durInput.value = secs;
   }
 
-  function fmtDur(ms) {
+  // Disable controls while timer is running or learning
-    const s = (ms / 1000).toFixed(1);
+  const running = state.timerActive;
-    return s + 's';
+  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;
+    const serverNow = Date.now() + serverOffset;
+    const remaining = Math.max(0, state.timerEndsAt - serverNow);
+    const progress = total > 0 ? remaining / total : 0;
+
+    ring.style.strokeDashoffset = CIRC * (1 - progress);
+    cd.textContent = fmt(remaining);
+    cd.className = 'countdown';
+    label.textContent = 'REMAINING';
+    badge.className = 'badge running';
+    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 = fmt(elapsed);
+    cd.className = 'countdown';
+    label.textContent = 'LEARNING';
+    badge.className = 'badge counting';
+    badgeTxt.textContent = 'Count Mode';
+    glow.classList.remove('active');
+  } else {
+    ring.style.strokeDashoffset = CIRC;
+    cd.textContent = '—';
+    cd.className = 'countdown idle';
+    label.textContent = 'IDLE';
+    badge.className = 'badge closed';
+    badgeTxt.textContent = 'Idle';
+    glow.classList.remove('active');
+  }
+}
+
+// Quindar tones via Web Audio API
+let audioCtx = null;
+let endBeeped = false;
+let wasTimerActive = false;
+
+function playTone(freq) {
+  if (!audioCtx) audioCtx = new (window.AudioContext || window.webkitAudioContext)();
+  const t = audioCtx.currentTime;
+  const osc = audioCtx.createOscillator();
+  const gain = audioCtx.createGain();
+  osc.type = 'sine';
+  osc.frequency.value = freq;
+  gain.gain.setValueAtTime(0.3, t);
+  gain.gain.setValueAtTime(0.3, t + 0.24);
+  gain.gain.linearRampToValueAtTime(0, t + 0.25);
+  osc.connect(gain);
+  gain.connect(audioCtx.destination);
+  osc.start(t);
+  osc.stop(t + 0.25);
+}
+
+function checkBeep() {
+  if (!state) return;
+  const active = state.timerActive && state.timerStartedAt && state.timerEndsAt;
+
+  // Start tone (2525 Hz) when timer begins
+  if (active && !wasTimerActive) {
+    playTone(2525);
+    endBeeped = false;
   }
 
-  let state = null;
+  // End tone (2475 Hz) at 10s remaining
-  let serverOffset = 0; // server time - client time
+  if (active) {
-
+    const serverNow = Date.now() + serverOffset;
-  async function poll() {
+    const remaining = Math.max(0, state.timerEndsAt - serverNow);
-    try {
+    if (remaining <= 10000 && remaining > 0 && !endBeeped) {
-      const r = await fetch('/api/status');
+      endBeeped = true;
-      state = await r.json();
+      playTone(2475);
-      // Compute clock offset so countdown works even with clock skew
-      serverOffset = state.now - Date.now();
-    } catch(e) { /* retry next tick */ }
-  }
-
-  function render() {
-    if (!state) return;
-
-    // Sync duration input if user isn't editing it
-    if (document.activeElement !== durInput) {
-      const secs = Math.round(state.storedDuration / 1000);
-      if (durInput.value !== String(secs)) durInput.value = secs;
     }
+  } else {
+    endBeeped = false;
+  }
 
-    // Disable controls while timer is running
+  wasTimerActive = !!active;
-    const running = state.timerActive;
+}
-    btnRun.disabled = running;
-    durInput.disabled = running;
 
-    if (state.timerActive && state.timerStartedAt && state.timerEndsAt) {
+// ── Wake Lock ──
-      const total = state.timerEndsAt - state.timerStartedAt;
+let wakeLock = null;
-      const serverNow = Date.now() + serverOffset;
+let lockAcquired = false;
-      const remaining = Math.max(0, state.timerEndsAt - serverNow);
-      const progress = total > 0 ? remaining / total : 0;
 
-      ring.style.strokeDashoffset = CIRC * (1 - progress);
+async function requestWakeLock() {
-      cd.textContent = fmt(remaining);
+  try {
-      cd.className = 'countdown';
+    if ('wakeLock' in navigator && !wakeLock) {
-      label.textContent = 'REMAINING';
+      wakeLock = await navigator.wakeLock.request('screen');
-      badge.className = 'badge running';
+      wakeLock.addEventListener('release', () => { wakeLock = null; });
-      badgeTxt.textContent = 'Timer Running';
-      glow.classList.add('active');
-    } else if (state.countMode) {
-      ring.style.strokeDashoffset = CIRC;
-      cd.textContent = '⏱';
-      cd.className = 'countdown idle';
-      label.textContent = 'LEARNING';
-      badge.className = 'badge counting';
-      badgeTxt.textContent = 'Count Mode';
-      glow.classList.remove('active');
-    } else {
-      ring.style.strokeDashoffset = CIRC;
-      cd.textContent = '—';
-      cd.className = 'countdown idle';
-      label.textContent = 'IDLE';
-      badge.className = 'badge closed';
-      badgeTxt.textContent = 'Idle';
-      glow.classList.remove('active');
     }
+  } catch (e) { console.error('Wake Lock error:', e); }
+}
+
+function releaseWakeLock() {
+  if (wakeLock) { wakeLock.release().catch(() => { }); wakeLock = null; }
+}
+
+document.addEventListener('visibilitychange', () => {
+  if (document.visibilityState === 'visible' && lockAcquired) requestWakeLock();
+});
+
+function checkWakeLock() {
+  if (!state) return;
+  const active = state.timerActive || state.countMode;
+  if (active && !lockAcquired) {
+    requestWakeLock();
+    lockAcquired = true;
+  } else if (!active && lockAcquired) {
+    releaseWakeLock();
+    lockAcquired = false;
   }
+}
 
-  // Quindar tones via Web Audio API
+// Poll server every 2s, render locally at 20fps for smooth countdown
-  let audioCtx = null;
+poll();
-  let endBeeped = false;
+setInterval(poll, 2000);
-  let wasTimerActive = false;
+setInterval(() => { render(); checkBeep(); checkWakeLock(); }, 50);
 
-  function playTone(freq) {
+// ── Control actions ──
-    if (!audioCtx) audioCtx = new (window.AudioContext || window.webkitAudioContext)();
+async function apiPost(path, body = {}) {
-    const t = audioCtx.currentTime;
+  try {
-    const osc = audioCtx.createOscillator();
+    const r = await fetch(path, {
-    const gain = audioCtx.createGain();
+      method: 'POST',
-    osc.type = 'sine';
+      headers: { 'Content-Type': 'application/json' },
-    osc.frequency.value = freq;
+      body: JSON.stringify(body)
-    gain.gain.setValueAtTime(0.3, t);
+    });
-    gain.gain.setValueAtTime(0.3, t + 0.24);
+    const d = await r.json();
-    gain.gain.linearRampToValueAtTime(0, t + 0.25);
+    if (!d.ok) console.error('API error:', d.error);
-    osc.connect(gain);
+    await poll();
-    gain.connect(audioCtx.destination);
+  } catch (e) { console.error('API call failed:', e); }
-    osc.start(t);
+}
-    osc.stop(t + 0.25);
+
+async function doRun() {
+  // Save duration first if changed
+  const secs = parseInt(durInput.value, 10);
+  if (secs > 0 && secs <= 300) {
+    await apiPost('/api/duration', { seconds: secs });
   }
+  await apiPost('/api/run');
+}
 
-  function checkBeep() {
+function doOpen() { apiPost('/api/open'); }
-    if (!state) return;
+function doClose() { apiPost('/api/close'); }
-    const active = state.timerActive && state.timerStartedAt && state.timerEndsAt;
 
-    // Start tone (2525 Hz) when timer begins
+async function doLearn() { await apiPost('/api/learn'); }
-    if (active && !wasTimerActive) {
+async function doStopLearn() { await apiPost('/api/stop-learn'); }
-      playTone(2525);
-      endBeeped = false;
-    }
 
-    // End tone (2475 Hz) at 10s remaining
-    if (active) {
-      const serverNow = Date.now() + serverOffset;
-      const remaining = Math.max(0, state.timerEndsAt - serverNow);
-      if (remaining <= 10000 && remaining > 0 && !endBeeped) {
-        endBeeped = true;
-        playTone(2475);
-      }
-    } else {
-      endBeeped = false;
-    }
 
-    wasTimerActive = !!active;
+// Also save duration on Enter or blur
+durInput.addEventListener('change', () => {
+  const secs = parseInt(durInput.value, 10);
+  if (secs > 0 && secs <= 300) {
+    apiPost('/api/duration', { seconds: secs });
   }
+});
 
-  // ── Wake Lock ──
+// ── Button online status ──
-  let wakeLock = null;
+const deviceDot = document.getElementById('device-dot');
-  let lockAcquired = false;
+const deviceState = document.getElementById('device-state');
-  
+const valveDot = document.getElementById('valve-dot');
-  async function requestWakeLock() {
+const valveState = document.getElementById('valve-state');
-    try {
+
-      if ('wakeLock' in navigator && !wakeLock) {
+function updateDeviceWidget(dot, stateEl, online) {
-        wakeLock = await navigator.wakeLock.request('screen');
+  if (online === true) {
-        wakeLock.addEventListener('release', () => { wakeLock = null; });
+    dot.className = 'device-dot online';
-      }
+    stateEl.className = 'device-state online';
-    } catch(e) { console.error('Wake Lock error:', e); }
+    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';
   }
-  
+}
-  function releaseWakeLock() {
+
-    if (wakeLock) { wakeLock.release().catch(()=>{}); wakeLock = null; }
+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);
   }
-  
+}
-  document.addEventListener('visibilitychange', () => {
+
-    if (document.visibilityState === 'visible' && lockAcquired) requestWakeLock();
+async function pollValveOnline() {
-  });
+  try {
-  
+    const r = await fetch('/api/valve-online');
-  function checkWakeLock() {
+    const d = await r.json();
-    if (!state) return;
+    updateDeviceWidget(valveDot, valveState, d.online);
-    const active = state.timerActive || state.countMode;
+  } catch {
-    if (active && !lockAcquired) {
+    updateDeviceWidget(valveDot, valveState, null);
-      requestWakeLock();
-      lockAcquired = true;
-    } else if (!active && lockAcquired) {
-      releaseWakeLock();
-      lockAcquired = false;
-    }
   }
+}
 
-  // Poll server every 2s, render locally at 20fps for smooth countdown
+pollButtonOnline();
-  poll();
+pollValveOnline();
-  setInterval(poll, 2000);
+setInterval(pollButtonOnline, 10000);
-  setInterval(() => { render(); checkBeep(); checkWakeLock(); }, 50);
+setInterval(pollValveOnline, 10000);
-
-  // ── Control actions ──
-  async function apiPost(path, body = {}) {
-    try {
-      const r = await fetch(path, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(body)
-      });
-      const d = await r.json();
-      if (!d.ok) console.error('API error:', d.error);
-      await poll();
-    } catch(e) { console.error('API call failed:', e); }
-  }
-
-  async function doRun() {
-    // Save duration first if changed
-    const secs = parseInt(durInput.value, 10);
-    if (secs > 0 && secs <= 300) {
-      await apiPost('/api/duration', { seconds: secs });
-    }
-    await apiPost('/api/run');
-  }
-
-  function doOpen()  { apiPost('/api/open'); }
-  function doClose() { apiPost('/api/close'); }
-
-  // Also save duration on Enter or blur
-  durInput.addEventListener('change', () => {
-    const secs = parseInt(durInput.value, 10);
-    if (secs > 0 && secs <= 300) {
-      apiPost('/api/duration', { seconds: secs });
-    }
-  });

public/waterButtonStatus/style.css

@@ -1,315 +1,437 @@
 @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 {
+:root {
-    --bg: #0a0e1a;
+  --bg: #0a0e1a;
-    --surface: #131829;
+  --surface: #131829;
-    --border: rgba(255,255,255,0.06);
+  --border: rgba(255, 255, 255, 0.06);
-    --text: #e2e8f0;
+  --text: #e2e8f0;
-    --text-dim: #64748b;
+  --text-dim: #64748b;
-    --blue: #3b82f6;
+  --blue: #3b82f6;
-    --cyan: #06b6d4;
+  --cyan: #06b6d4;
-    --green: #22c55e;
+  --green: #22c55e;
-    --red: #ef4444;
+  --red: #ef4444;
-    --orange: #f59e0b;
+  --orange: #f59e0b;
-  }
+}
 
-  body {
+body {
-    font-family: 'Inter', -apple-system, sans-serif;
+  font-family: 'Inter', -apple-system, sans-serif;
-    background: var(--bg);
+  background: var(--bg);
-    color: var(--text);
+  color: var(--text);
-    min-height: 100dvh;
+  min-height: 100dvh;
-    display: flex;
+  display: flex;
-    flex-direction: column;
+  flex-direction: column;
-    align-items: center;
+  align-items: center;
-    justify-content: center;
+  justify-content: center;
-    padding: 1.5rem;
+  padding: 1.5rem;
-    overflow: hidden;
+  overflow: hidden;
-  }
+}
 
-  .container {
+.container {
-    width: 100%;
+  width: 100%;
-    max-width: 380px;
+  max-width: 380px;
-    display: flex;
+  display: flex;
-    flex-direction: column;
+  flex-direction: column;
-    align-items: center;
+  align-items: center;
-    gap: 2rem;
+  gap: 2rem;
-  }
+}
 
-  h1 {
+h1 {
-    font-size: 1.1rem;
+  font-size: 1.1rem;
-    font-weight: 600;
+  font-weight: 600;
-    letter-spacing: 0.05em;
+  letter-spacing: 0.05em;
-    text-transform: uppercase;
+  text-transform: uppercase;
-    color: var(--text-dim);
+  color: var(--text-dim);
-  }
+}
 
-  /* ── Progress Ring ── */
+/* ── Progress Ring ── */
-  .ring-wrapper {
+.ring-wrapper {
-    position: relative;
+  position: relative;
-    width: 260px;
+  width: 260px;
-    height: 260px;
+  height: 260px;
-  }
+}
 
-  .ring-svg {
+.ring-svg {
-    width: 100%;
+  width: 100%;
-    height: 100%;
+  height: 100%;
-    transform: rotate(-90deg);
+  transform: rotate(-90deg);
-  }
+}
 
-  .ring-bg {
+.ring-bg {
-    fill: none;
+  fill: none;
-    stroke: var(--border);
+  stroke: var(--border);
-    stroke-width: 8;
+  stroke-width: 8;
-  }
+}
 
-  .ring-fg {
+.ring-fg {
-    fill: none;
+  fill: none;
-    stroke: url(#grad);
+  stroke: url(#grad);
-    stroke-width: 8;
+  stroke-width: 8;
-    stroke-linecap: round;
+  stroke-linecap: round;
-    transition: stroke-dashoffset 0.4s ease;
+  transition: stroke-dashoffset 0.4s ease;
-  }
+}
 
-  .ring-center {
+.ring-center {
-    position: absolute;
+  position: absolute;
-    inset: 0;
+  inset: 0;
-    display: flex;
+  display: flex;
-    flex-direction: column;
+  flex-direction: column;
-    align-items: center;
+  align-items: center;
-    justify-content: center;
+  justify-content: center;
-    gap: 0.3rem;
+  gap: 0.3rem;
-  }
+}
 
-  .countdown {
+.countdown {
-    font-size: 3.2rem;
+  font-size: 3.2rem;
-    font-weight: 700;
+  font-weight: 700;
-    font-variant-numeric: tabular-nums;
+  font-variant-numeric: tabular-nums;
-    line-height: 1;
+  line-height: 1;
-    background: linear-gradient(135deg, var(--blue), var(--cyan));
+  background: linear-gradient(135deg, var(--blue), var(--cyan));
-    -webkit-background-clip: text;
+  -webkit-background-clip: text;
-    -webkit-text-fill-color: transparent;
+  -webkit-text-fill-color: transparent;
-    background-clip: text;
+  background-clip: text;
-  }
+}
 
-  .countdown.idle {
+.countdown.idle {
-    font-size: 1.6rem;
+  font-size: 1.6rem;
-    background: none;
+  background: none;
-    -webkit-text-fill-color: var(--text-dim);
+  -webkit-text-fill-color: var(--text-dim);
-  }
+}
 
-  .countdown-label {
+.countdown-label {
-    font-size: 0.75rem;
+  font-size: 0.75rem;
-    font-weight: 500;
+  font-weight: 500;
-    text-transform: uppercase;
+  text-transform: uppercase;
-    letter-spacing: 0.1em;
+  letter-spacing: 0.1em;
-    color: var(--text-dim);
+  color: var(--text-dim);
-  }
+}
 
-  /* ── Status Badge ── */
+/* ── Status Badge ── */
-  .badge {
+.badge {
-    display: inline-flex;
+  display: inline-flex;
-    align-items: center;
+  align-items: center;
-    gap: 0.5rem;
+  gap: 0.5rem;
-    padding: 0.6rem 1.4rem;
+  padding: 0.6rem 1.4rem;
-    border-radius: 100px;
+  border-radius: 100px;
-    font-size: 0.85rem;
+  font-size: 0.85rem;
-    font-weight: 600;
+  font-weight: 600;
-    letter-spacing: 0.02em;
+  letter-spacing: 0.02em;
-    border: 1px solid var(--border);
+  border: 1px solid var(--border);
-    background: var(--surface);
+  background: var(--surface);
-  }
+}
 
-  .badge .dot {
+.badge .dot {
-    width: 10px;
+  width: 10px;
-    height: 10px;
+  height: 10px;
-    border-radius: 50%;
+  border-radius: 50%;
-    flex-shrink: 0;
+  flex-shrink: 0;
-  }
+}
 
-  .badge.running .dot {
+.badge.running .dot {
-    background: var(--cyan);
+  background: var(--cyan);
-    box-shadow: 0 0 8px var(--cyan);
+  box-shadow: 0 0 8px var(--cyan);
-    animation: pulse-dot 1.5s ease-in-out infinite;
+  animation: pulse-dot 1.5s ease-in-out infinite;
-  }
+}
 
-  .badge.open .dot {
+.badge.open .dot {
-    background: var(--green);
+  background: var(--green);
-    box-shadow: 0 0 8px var(--green);
+  box-shadow: 0 0 8px var(--green);
-  }
+}
 
-  .badge.closed .dot {
+.badge.closed .dot {
-    background: var(--red);
+  background: var(--red);
-    box-shadow: 0 0 6px var(--red);
+  box-shadow: 0 0 6px var(--red);
-  }
+}
 
-  .badge.counting .dot {
+.badge.counting .dot {
-    background: var(--orange);
+  background: var(--orange);
-    box-shadow: 0 0 8px var(--orange);
+  box-shadow: 0 0 8px var(--orange);
-    animation: pulse-dot 0.8s ease-in-out infinite;
+  animation: pulse-dot 0.8s ease-in-out infinite;
-  }
+}
 
-  @keyframes pulse-dot {
+@keyframes pulse-dot {
-    0%, 100% { opacity: 1; }
-    50% { opacity: 0.4; }
-  }
 
-  /* ── Info row ── */
+  0%,
-  .info {
+  100% {
-    display: flex;
-    gap: 1.5rem;
-  }
-
-  .info-item {
-    text-align: center;
-  }
-
-  .info-value {
-    font-size: 1.3rem;
-    font-weight: 600;
-    font-variant-numeric: tabular-nums;
-  }
-
-  .info-label {
-    font-size: 0.7rem;
-    color: var(--text-dim);
-    text-transform: uppercase;
-    letter-spacing: 0.08em;
-    margin-top: 0.15rem;
-  }
-
-  /* ── Glow effect behind ring ── */
-  .glow {
-    position: absolute;
-    inset: 20px;
-    border-radius: 50%;
-    background: radial-gradient(circle, rgba(6,182,212,0.12) 0%, transparent 70%);
-    opacity: 0;
-    transition: opacity 0.6s ease;
-    pointer-events: none;
-  }
-
-  .glow.active {
     opacity: 1;
   }
 
-  /* ── Controls ── */
+  50% {
-  .controls {
+    opacity: 0.4;
-    display: flex;
-    gap: 0.6rem;
-    width: 100%;
-    justify-content: center;
-    flex-wrap: wrap;
   }
+}
 
-  .run-container {
+/* ── Info row ── */
-    display: flex;
+.info {
-    width: 100%;
+  display: flex;
-    gap: 0.6rem;
+  gap: 1.5rem;
-  }
+}
 
-  #btn-run {
+.info-item {
-    flex-grow: 1;
+  text-align: center;
-    font-size: 1.4rem;
+}
-    padding: 1.2rem;
-  }
 
-  .btn {
+.info-value {
-    display: inline-flex;
+  font-size: 1.3rem;
-    align-items: center;
+  font-weight: 600;
-    justify-content: center;
+  font-variant-numeric: tabular-nums;
-    gap: 0.4rem;
+}
-    padding: 0.65rem 1.2rem;
-    border-radius: 12px;
-    border: 1px solid var(--border);
-    background: var(--surface);
-    color: var(--text);
-    font-family: inherit;
-    font-size: 0.82rem;
-    font-weight: 600;
-    cursor: pointer;
-    transition: all 0.15s ease;
-    user-select: none;
-    -webkit-tap-highlight-color: transparent;
-  }
 
-  .btn:hover {
+.info-label {
-    background: rgba(59,130,246,0.12);
+  font-size: 0.7rem;
-    border-color: var(--blue);
+  color: var(--text-dim);
-  }
+  text-transform: uppercase;
+  letter-spacing: 0.08em;
+  margin-top: 0.15rem;
+}
 
-  .btn:active {
+/* ── Glow effect behind ring ── */
-    transform: scale(0.96);
+.glow {
-  }
+  position: absolute;
+  inset: 20px;
+  border-radius: 50%;
+  background: radial-gradient(circle, rgba(6, 182, 212, 0.12) 0%, transparent 70%);
+  opacity: 0;
+  transition: opacity 0.6s ease;
+  pointer-events: none;
+}
 
-  .btn.primary {
+.glow.active {
-    background: linear-gradient(135deg, var(--blue), var(--cyan));
+  opacity: 1;
-    border-color: transparent;
+}
-    color: #fff;
-  }
 
-  .btn.primary:hover {
+/* ── Controls ── */
-    filter: brightness(1.15);
+.controls {
-    background: linear-gradient(135deg, var(--blue), var(--cyan));
+  display: flex;
-  }
+  gap: 0.6rem;
+  width: 100%;
+  justify-content: center;
+  flex-wrap: wrap;
+}
 
-  .btn.danger {
+.run-container {
-    border-color: rgba(239,68,68,0.3);
+  display: flex;
-  }
+  width: 100%;
+  gap: 0.6rem;
+}
 
-  .btn.danger:hover {
+#btn-run {
-    background: rgba(239,68,68,0.15);
+  flex-grow: 1;
-    border-color: var(--red);
+  font-size: 1.4rem;
-  }
+  padding: 1.2rem;
+}
 
-  .btn.success {
+.btn {
-    border-color: rgba(34,197,94,0.3);
+  display: inline-flex;
-  }
+  align-items: center;
+  justify-content: center;
+  gap: 0.4rem;
+  padding: 0.65rem 1.2rem;
+  border-radius: 12px;
+  border: 1px solid var(--border);
+  background: var(--surface);
+  color: var(--text);
+  font-family: inherit;
+  font-size: 0.82rem;
+  font-weight: 600;
+  cursor: pointer;
+  transition: all 0.15s ease;
+  user-select: none;
+  -webkit-tap-highlight-color: transparent;
+}
 
-  .btn.success:hover {
+.btn:hover {
-    background: rgba(34,197,94,0.15);
+  background: rgba(59, 130, 246, 0.12);
-    border-color: var(--green);
+  border-color: var(--blue);
-  }
+}
 
-  .btn:disabled {
+.btn:active {
-    opacity: 0.45;
+  transform: scale(0.96);
-    pointer-events: none;
+}
-  }
 
-  .dur-input-group {
+.btn.primary {
-    display: flex;
+  background: linear-gradient(135deg, var(--blue), var(--cyan));
-    align-items: center;
+  border-color: transparent;
-    gap: 0.4rem;
+  color: #fff;
-    background: var(--surface);
+}
-    border: 1px solid var(--border);
-    border-radius: 12px;
-    padding: 0 0.8rem;
-    transition: border-color 0.15s ease;
-  }
 
-  .dur-input-group:focus-within {
+.btn.primary:hover {
-    border-color: var(--blue);
+  filter: brightness(1.15);
-  }
+  background: linear-gradient(135deg, var(--blue), var(--cyan));
+}
 
-  .dur-input {
+.btn.danger {
-    width: 64px;
+  border-color: rgba(239, 68, 68, 0.3);
-    background: transparent;
+}
-    border: none;
-    color: var(--text);
-    font-family: inherit;
-    font-size: 1.2rem;
-    font-weight: 600;
-    font-variant-numeric: tabular-nums;
-    padding: 0.8rem 0;
-    outline: none;
-    text-align: right;
-  }
 
-  .dur-input::-webkit-inner-spin-button { opacity: 0.3; }
+.btn.danger:hover {
+  background: rgba(239, 68, 68, 0.15);
+  border-color: var(--red);
+}
 
-  .dur-unit {
+.btn.warning {
-    font-size: 0.85rem;
+  border-color: rgba(245, 158, 11, 0.35);
-    color: var(--text-dim);
+  color: var(--orange);
-    font-weight: 500;
+}
-  }
+
+.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);
+}
+
+.btn.success:hover {
+  background: rgba(34, 197, 94, 0.15);
+  border-color: var(--green);
+}
+
+.btn:disabled {
+  opacity: 0.45;
+  pointer-events: none;
+}
+
+.dur-input-group {
+  display: flex;
+  align-items: center;
+  gap: 0.4rem;
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: 12px;
+  padding: 0 0.8rem;
+  transition: border-color 0.15s ease;
+}
+
+.dur-input-group:focus-within {
+  border-color: var(--blue);
+}
+
+.dur-input {
+  width: 64px;
+  background: transparent;
+  border: none;
+  color: var(--text);
+  font-family: inherit;
+  font-size: 1.2rem;
+  font-weight: 600;
+  font-variant-numeric: tabular-nums;
+  padding: 0.8rem 0;
+  outline: none;
+  text-align: right;
+}
+
+.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

@@ -18,6 +18,7 @@
 import fs from 'fs';
 import path from 'path';
 import { startStatusServer } from '../waterButtonStatusServer.js';
+import { startTelegramBot } from '../waterButtonTelegramBot.js';
 import { fileURLToPath } from 'url';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -29,15 +30,8 @@ const WATER_BUTTON_MAC = '08A6F773510C';
 const REMOTE_SWITCH_MAC = 'CC8DA243B0A0';
 
 // Telegram
-const BOT_TOKEN = process.env.WATER_VALVE_TELEGRAM_TOKEN;
-const BOT_PASSWORD = process.env.WATER_VALVE_TELEGRAM_PASSWORD;
-const TELEGRAM_API = `https://api.telegram.org/bot${BOT_TOKEN}`;
-const AUTH_FILE = path.join(__dirname, 'telegram_authorized_users.json');
 
-// Generation counter — incremented on each hot reload to stop the old poll loop
+
-const BOT_GEN = Date.now();
-if (!global.__waterBotGen) global.__waterBotGen = 0;
-global.__waterBotGen = BOT_GEN;
 
 // sendRPC / getState persisted across hot reloads via globals (populated on first ctx event)
 if (!global.__waterBotRPC) global.__waterBotRPC = null;
@@ -96,277 +90,15 @@ function getState(mac) {
   return deviceState.get(mac);
 }
 
-// ── Telegram auth ─────────────────────────────────────────────────────────────
 
-function loadAuthorizedUsers() {
+startTelegramBot({
-  try {
+  getState,
-    if (fs.existsSync(AUTH_FILE)) {
+  WATER_BUTTON_MAC,
-      return new Set(JSON.parse(fs.readFileSync(AUTH_FILE, 'utf8')));
+  REMOTE_SWITCH_MAC,
-    }
+  setLight,
-  } catch (err) {
+  persistedState,
-    console.error('[TelegramBot] Error loading authorized users:', err);
+  saveState
-  }
+});
-  return new Set();
-}
-
-function saveAuthorizedUsers(users) {
-  try {
-    fs.writeFileSync(AUTH_FILE, JSON.stringify([...users], null, 2));
-  } catch (err) {
-    console.error('[TelegramBot] Error saving authorized users:', err);
-  }
-}
-
-const authorizedUsers = loadAuthorizedUsers();
-
-// ── Telegram bot ──────────────────────────────────────────────────────────────
-
-async function telegramRequest(method, params = {}) {
-  const res = await fetch(`${TELEGRAM_API}/${method}`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify(params)
-  });
-  return res.json();
-}
-
-function menuKeyboard(durSec) {
-  return {
-    keyboard: [
-      [{ text: '🔓 Open valve' }, { text: '🔒 Close valve' }],
-      [{ text: `💧 Run timer (${durSec}s)` }, { text: '📊 Status' }]
-    ],
-    resize_keyboard: true,
-    persistent: true
-  };
-}
-
-async function getConnectionStatus() {
-  try {
-    const getState = global.__waterBotGetState;
-    if (!getState) return '❓ Button\n❓ Valve';
-    const [buttonOnline, valveOnline] = await Promise.all([
-      getState(WATER_BUTTON_MAC, 'system', 'online'),
-      getState(REMOTE_SWITCH_MAC, 'system', 'online')
-    ]);
-    const btn = buttonOnline === true ? '✅' : buttonOnline === false ? '❌ OFFLINE' : '❓';
-    const vlv = valveOnline === true ? '✅' : valveOnline === false ? '❌ OFFLINE' : '❓';
-    return `${btn} Button\n${vlv} Valve`;
-  } catch {
-    return '❓ Button\n❓ Valve';
-  }
-}
-
-async function reply(chatId, text, durSec) {
-  const connStatus = await getConnectionStatus();
-  return telegramRequest('sendMessage', {
-    chat_id: chatId,
-    text: `${connStatus}\n\n${text}`,
-    reply_markup: menuKeyboard(durSec)
-  });
-}
-
-async function sendMessage(chatId, text) {
-  return telegramRequest('sendMessage', { chat_id: chatId, text });
-}
-
-function parseDuration(raw) {
-  if (!raw) return null;
-  if (raw.endsWith('m')) return Math.round(parseFloat(raw) * 60000);
-  if (raw.endsWith('s')) return Math.round(parseFloat(raw) * 1000);
-  const ms = parseInt(raw, 10);
-  return isNaN(ms) ? null : ms;
-}
-
-async function handleBotMessage(msg) {
-  const chatId = msg.chat.id;
-  const text = (msg.text || '').trim();
-  const parts = text.split(/\s+/);
-  // Strip @botname suffix that Telegram adds in groups
-  const cmd = parts[0].toLowerCase().split('@')[0];
-
-  // ── Authorization gate ───────────────────────────────────────────────────
-  if (!authorizedUsers.has(chatId)) {
-    if (text === BOT_PASSWORD) {
-      authorizedUsers.add(chatId);
-      saveAuthorizedUsers(authorizedUsers);
-      console.log(`[TelegramBot] New authorized user: ${chatId} (${msg.from?.username || msg.from?.first_name || 'unknown'})`);
-      const state = getState(WATER_BUTTON_MAC);
-      await reply(chatId, 'Access granted. Use the buttons below or type a number (seconds) to set the duration.', (state.storedDuration / 1000).toFixed(1));
-    } else {
-      await sendMessage(chatId, 'Please enter the password to use this bot.');
-    }
-    return;
-  }
-
-  const state = getState(WATER_BUTTON_MAC);
-  const durSec = (state.storedDuration / 1000).toFixed(1);
-
-  // ── Plain number → set duration in seconds ───────────────────────────────
-  const numericMatch = text.match(/^(\d+(?:\.\d+)?)$/);
-  if (numericMatch) {
-    const ms = Math.round(parseFloat(numericMatch[1]) * 1000);
-    if (ms <= 0 || ms > 300000) {
-      await reply(chatId, 'Duration must be between 1 and 300 seconds.', durSec);
-      return;
-    }
-    state.storedDuration = ms;
-    persistedState[WATER_BUTTON_MAC] = { storedDuration: ms };
-    saveState(persistedState);
-    const newSec = (ms / 1000).toFixed(1);
-    await reply(chatId, `Duration set to ${newSec}s.`, newSec);
-    return;
-  }
-
-  // ── Menu button labels map to commands ───────────────────────────────────
-  const buttonMap = {
-    '🔓 open valve': '/open',
-    '🔒 close valve': '/close',
-    '📊 status': '/status'
-  };
-  // Run timer button label includes dynamic duration — match by prefix
-  const normalised = text.toLowerCase();
-  const resolvedCmd = buttonMap[normalised]
-    || (normalised.startsWith('💧 run timer') ? '/run' : cmd);
-
-  if (resolvedCmd === '/start' || resolvedCmd === '/help') {
-    await reply(chatId,
-      `💧 Water valve bot\n\n` +
-      `Use the buttons below, or:\n` +
-      `/open — Open valve\n` +
-      `/close — Close valve\n` +
-      `/run — Open then close after ${durSec}s\n` +
-      `/duration <value> — Set timer (e.g. 30s, 2m, 10000)\n` +
-      `<number> — Set duration in seconds (e.g. 45)\n` +
-      `/status — Current status`,
-      durSec
-    );
-    return;
-  }
-
-  if (resolvedCmd === '/status') {
-    await reply(chatId,
-      `Status:\n` +
-      `• Duration: ${state.storedDuration}ms (${durSec}s)\n` +
-      `• Count mode: ${state.countMode}\n` +
-      `• Timer active: ${state.timer !== null}`,
-      durSec
-    );
-    return;
-  }
-
-  if (resolvedCmd === '/duration') {
-    if (!parts[1]) {
-      await reply(chatId,
-        `Current duration: ${durSec}s\n` +
-        `Type a number (seconds) or use /duration <value>\n` +
-        `Examples: 30  /duration 30s  /duration 2m`,
-        durSec
-      );
-      return;
-    }
-    const ms = parseDuration(parts[1]);
-    if (!ms || ms <= 0 || ms > 300000) {
-      await reply(chatId, 'Invalid duration. Use e.g. 30s, 2m, or seconds 1–300.', durSec);
-      return;
-    }
-    state.storedDuration = ms;
-    persistedState[WATER_BUTTON_MAC] = { storedDuration: ms };
-    saveState(persistedState);
-    const newSec = (ms / 1000).toFixed(1);
-    await reply(chatId, `Duration set to ${newSec}s.`, newSec);
-    return;
-  }
-
-  const sendRPC = global.__waterBotRPC;
-  if (!sendRPC) {
-    await reply(chatId, 'Not ready yet — waiting for first device event. Try again in a moment.', durSec);
-    return;
-  }
-
-  if (resolvedCmd === '/open') {
-    if (state.timer) { clearTimeout(state.timer); state.timer = null; }
-    state.countMode = false;
-    state.timerStartedAt = null;
-    state.timerEndsAt = null;
-    await setLight(sendRPC, WATER_BUTTON_MAC, false, 0);  // light off = switch on = valve open
-    await reply(chatId, 'Valve opened.', durSec);
-
-  } else if (resolvedCmd === '/close') {
-    if (state.timer) { clearTimeout(state.timer); state.timer = null; }
-    state.countMode = false;
-    state.timerStartedAt = null;
-    state.timerEndsAt = null;
-    await setLight(sendRPC, WATER_BUTTON_MAC, true, 95);  // light on = switch off = valve closed
-    await reply(chatId, 'Valve closed.', durSec);
-
-  } else if (resolvedCmd === '/run') {
-    if (state.timer) { clearTimeout(state.timer); state.timer = null; }
-    state.countMode = false;
-    await setLight(sendRPC, WATER_BUTTON_MAC, false, 0);  // open valve
-    const duration = state.storedDuration;
-    state.timerStartedAt = Date.now();
-    state.timerEndsAt = Date.now() + duration;
-    await reply(chatId, `Valve opened. Closing in ${(duration / 1000).toFixed(1)}s…`, durSec);
-
-    state.timer = setTimeout(async () => {
-      try {
-        const rpc = global.__waterBotRPC;
-        if (rpc) await setLight(rpc, WATER_BUTTON_MAC, true, 95);  // close valve
-        state.timer = null;
-        state.timerStartedAt = null;
-        state.timerEndsAt = null;
-        await reply(chatId, 'Timer elapsed — valve closed.', (getState(WATER_BUTTON_MAC).storedDuration / 1000).toFixed(1));
-      } catch (err) {
-        console.error('[TelegramBot] Timer callback error:', err);
-      }
-    }, duration);
-
-  } else {
-    await reply(chatId, 'Unknown command. Use the buttons below or send /help.', durSec);
-  }
-}
-
-async function botLoop() {
-  console.log(`[TelegramBot] Starting (gen ${BOT_GEN})`);
-  let offset = 0;
-
-  while (BOT_GEN === global.__waterBotGen) {
-    try {
-      const data = await telegramRequest('getUpdates', {
-        offset,
-        timeout: 25,
-        allowed_updates: ['message']
-      });
-
-      if (!data.ok) {
-        await sleep(5000);
-        continue;
-      }
-
-      for (const update of data.result || []) {
-        offset = update.update_id + 1;
-        if (update.message) {
-          handleBotMessage(update.message).catch(err =>
-            console.error('[TelegramBot] Handler error:', err)
-          );
-        }
-      }
-    } catch (err) {
-      console.error('[TelegramBot] Polling error:', err.message);
-      await sleep(5000);
-    }
-  }
-
-  console.log(`[TelegramBot] Stopped (gen ${BOT_GEN} superseded)`);
-}
-
-// Start long-polling immediately (non-blocking)
-if (BOT_TOKEN) {
-  botLoop().catch(err => console.error('[TelegramBot] Fatal error:', err));
-} else {
-  console.error('[TelegramBot] WATER_VALVE_TELEGRAM_TOKEN not set in .env — bot disabled');
-}
 
 // ── Rule export ───────────────────────────────────────────────────────────────
 
@@ -569,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 = {
@@ -90,19 +145,45 @@ export function startStatusServer({
             'Access-Control-Allow-Origin': '*'
         };
 
-            if (url.pathname === '/style.css') {
+        if (url.pathname === '/style.css') {
-      res.writeHead(200, { 'Content-Type': 'text/css' });
+            res.writeHead(200, { 'Content-Type': 'text/css' });
-      res.end(fs.readFileSync(new URL('./public/waterButtonStatus/style.css', import.meta.url)));
+            res.end(fs.readFileSync(new URL('./public/waterButtonStatus/style.css', import.meta.url)));
-      return;
+            return;
-    }
+        }
 
-    if (url.pathname === '/script.js') {
+        if (url.pathname === '/script.js') {
-      res.writeHead(200, { 'Content-Type': 'application/javascript' });
+            res.writeHead(200, { 'Content-Type': 'application/javascript' });
-      res.end(fs.readFileSync(new URL('./public/waterButtonStatus/script.js', import.meta.url)));
+            res.end(fs.readFileSync(new URL('./public/waterButtonStatus/script.js', import.meta.url)));
-      return;
+            return;
-    }
+        }
 
-    if (url.pathname === '/api/status') {
+        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()));
             return;
@@ -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; }

waterButtonTelegramBot.js

@@ -0,0 +1,301 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const AUTH_FILE = path.join(__dirname, 'telegram_authorized_users.json');
+const BOT_TOKEN = process.env.WATER_VALVE_TELEGRAM_TOKEN;
+const BOT_PASSWORD = process.env.WATER_VALVE_TELEGRAM_PASSWORD;
+const TELEGRAM_API = `https://api.telegram.org/bot${BOT_TOKEN}`;
+const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+
+
+// Generation counter — incremented on each hot reload to stop the old poll loop
+const BOT_GEN = Date.now();
+if (!global.__waterBotGen) global.__waterBotGen = 0;
+global.__waterBotGen = BOT_GEN;
+
+export function startTelegramBot({
+  getState,
+  WATER_BUTTON_MAC,
+  REMOTE_SWITCH_MAC,
+  setLight,
+  persistedState,
+  saveState
+}) {
+  // ── Telegram auth ─────────────────────────────────────────────────────────────
+
+  function loadAuthorizedUsers() {
+    try {
+      if (fs.existsSync(AUTH_FILE)) {
+        return new Set(JSON.parse(fs.readFileSync(AUTH_FILE, 'utf8')));
+      }
+    } catch (err) {
+      console.error('[TelegramBot] Error loading authorized users:', err);
+    }
+    return new Set();
+  }
+
+  function saveAuthorizedUsers(users) {
+    try {
+      fs.writeFileSync(AUTH_FILE, JSON.stringify([...users], null, 2));
+    } catch (err) {
+      console.error('[TelegramBot] Error saving authorized users:', err);
+    }
+  }
+
+  const authorizedUsers = loadAuthorizedUsers();
+
+  // ── Telegram bot ──────────────────────────────────────────────────────────────
+
+  async function telegramRequest(method, params = {}) {
+    const res = await fetch(`${TELEGRAM_API}/${method}`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(params)
+    });
+    return res.json();
+  }
+
+  function menuKeyboard(durSec) {
+    return {
+      keyboard: [
+        [{ text: '🔓 Open valve' }, { text: '🔒 Close valve' }],
+        [{ text: `💧 Run timer (${durSec}s)` }, { text: '📊 Status' }]
+      ],
+      resize_keyboard: true,
+      persistent: true
+    };
+  }
+
+  async function getConnectionStatus() {
+    try {
+      const getState = global.__waterBotGetState;
+      if (!getState) return '❓ Button\n❓ Valve';
+      const [buttonOnline, valveOnline] = await Promise.all([
+        getState(WATER_BUTTON_MAC, 'system', 'online'),
+        getState(REMOTE_SWITCH_MAC, 'system', 'online')
+      ]);
+      const btn = buttonOnline === true ? '✅' : buttonOnline === false ? '❌ OFFLINE' : '❓';
+      const vlv = valveOnline === true ? '✅' : valveOnline === false ? '❌ OFFLINE' : '❓';
+      return `${btn} Button\n${vlv} Valve`;
+    } catch {
+      return '❓ Button\n❓ Valve';
+    }
+  }
+
+  async function reply(chatId, text, durSec) {
+    const connStatus = await getConnectionStatus();
+    return telegramRequest('sendMessage', {
+      chat_id: chatId,
+      text: `${connStatus}\n\n${text}`,
+      reply_markup: menuKeyboard(durSec)
+    });
+  }
+
+  async function sendMessage(chatId, text) {
+    return telegramRequest('sendMessage', { chat_id: chatId, text });
+  }
+
+  function parseDuration(raw) {
+    if (!raw) return null;
+    if (raw.endsWith('m')) return Math.round(parseFloat(raw) * 60000);
+    if (raw.endsWith('s')) return Math.round(parseFloat(raw) * 1000);
+    const ms = parseInt(raw, 10);
+    return isNaN(ms) ? null : ms;
+  }
+
+  async function handleBotMessage(msg) {
+    const chatId = msg.chat.id;
+    const text = (msg.text || '').trim();
+    const parts = text.split(/\s+/);
+    // Strip @botname suffix that Telegram adds in groups
+    const cmd = parts[0].toLowerCase().split('@')[0];
+
+    // ── Authorization gate ───────────────────────────────────────────────────
+    if (!authorizedUsers.has(chatId)) {
+      if (text === BOT_PASSWORD) {
+        authorizedUsers.add(chatId);
+        saveAuthorizedUsers(authorizedUsers);
+        console.log(`[TelegramBot] New authorized user: ${chatId} (${msg.from?.username || msg.from?.first_name || 'unknown'})`);
+        const state = getState(WATER_BUTTON_MAC);
+        await reply(chatId, 'Access granted. Use the buttons below or type a number (seconds) to set the duration.', (state.storedDuration / 1000).toFixed(1));
+      } else {
+        await sendMessage(chatId, 'Please enter the password to use this bot.');
+      }
+      return;
+    }
+
+    const state = getState(WATER_BUTTON_MAC);
+    const durSec = (state.storedDuration / 1000).toFixed(1);
+
+    // ── Plain number → set duration in seconds ───────────────────────────────
+    const numericMatch = text.match(/^(\d+(?:\.\d+)?)$/);
+    if (numericMatch) {
+      const ms = Math.round(parseFloat(numericMatch[1]) * 1000);
+      if (ms <= 0 || ms > 300000) {
+        await reply(chatId, 'Duration must be between 1 and 300 seconds.', durSec);
+        return;
+      }
+      state.storedDuration = ms;
+      persistedState[WATER_BUTTON_MAC] = { storedDuration: ms };
+      saveState(persistedState);
+      const newSec = (ms / 1000).toFixed(1);
+      await reply(chatId, `Duration set to ${newSec}s.`, newSec);
+      return;
+    }
+
+    // ── Menu button labels map to commands ───────────────────────────────────
+    const buttonMap = {
+      '🔓 open valve': '/open',
+      '🔒 close valve': '/close',
+      '📊 status': '/status'
+    };
+    // Run timer button label includes dynamic duration — match by prefix
+    const normalised = text.toLowerCase();
+    const resolvedCmd = buttonMap[normalised]
+      || (normalised.startsWith('💧 run timer') ? '/run' : cmd);
+
+    if (resolvedCmd === '/start' || resolvedCmd === '/help') {
+      await reply(chatId,
+        `💧 Water valve bot\n\n` +
+        `Use the buttons below, or:\n` +
+        `/open — Open valve\n` +
+        `/close — Close valve\n` +
+        `/run — Open then close after ${durSec}s\n` +
+        `/duration <value> — Set timer (e.g. 30s, 2m, 10000)\n` +
+        `<number> — Set duration in seconds (e.g. 45)\n` +
+        `/status — Current status`,
+        durSec
+      );
+      return;
+    }
+
+    if (resolvedCmd === '/status') {
+      await reply(chatId,
+        `Status:\n` +
+        `• Duration: ${state.storedDuration}ms (${durSec}s)\n` +
+        `• Count mode: ${state.countMode}\n` +
+        `• Timer active: ${state.timer !== null}`,
+        durSec
+      );
+      return;
+    }
+
+    if (resolvedCmd === '/duration') {
+      if (!parts[1]) {
+        await reply(chatId,
+          `Current duration: ${durSec}s\n` +
+          `Type a number (seconds) or use /duration <value>\n` +
+          `Examples: 30  /duration 30s  /duration 2m`,
+          durSec
+        );
+        return;
+      }
+      const ms = parseDuration(parts[1]);
+      if (!ms || ms <= 0 || ms > 300000) {
+        await reply(chatId, 'Invalid duration. Use e.g. 30s, 2m, or seconds 1–300.', durSec);
+        return;
+      }
+      state.storedDuration = ms;
+      persistedState[WATER_BUTTON_MAC] = { storedDuration: ms };
+      saveState(persistedState);
+      const newSec = (ms / 1000).toFixed(1);
+      await reply(chatId, `Duration set to ${newSec}s.`, newSec);
+      return;
+    }
+
+    const sendRPC = global.__waterBotRPC;
+    if (!sendRPC) {
+      await reply(chatId, 'Not ready yet — waiting for first device event. Try again in a moment.', durSec);
+      return;
+    }
+
+    if (resolvedCmd === '/open') {
+      if (state.timer) { clearTimeout(state.timer); state.timer = null; }
+      state.countMode = false;
+      state.timerStartedAt = null;
+      state.timerEndsAt = null;
+      await setLight(sendRPC, WATER_BUTTON_MAC, false, 0);  // light off = switch on = valve open
+      await reply(chatId, 'Valve opened.', durSec);
+
+    } else if (resolvedCmd === '/close') {
+      if (state.timer) { clearTimeout(state.timer); state.timer = null; }
+      state.countMode = false;
+      state.timerStartedAt = null;
+      state.timerEndsAt = null;
+      await setLight(sendRPC, WATER_BUTTON_MAC, true, 95);  // light on = switch off = valve closed
+      await reply(chatId, 'Valve closed.', durSec);
+
+    } else if (resolvedCmd === '/run') {
+      if (state.timer) { clearTimeout(state.timer); state.timer = null; }
+      state.countMode = false;
+      await setLight(sendRPC, WATER_BUTTON_MAC, false, 0);  // open valve
+      const duration = state.storedDuration;
+      state.timerStartedAt = Date.now();
+      state.timerEndsAt = Date.now() + duration;
+      await reply(chatId, `Valve opened. Closing in ${(duration / 1000).toFixed(1)}s…`, durSec);
+
+      state.timer = setTimeout(async () => {
+        try {
+          const rpc = global.__waterBotRPC;
+          if (rpc) await setLight(rpc, WATER_BUTTON_MAC, true, 95);  // close valve
+          state.timer = null;
+          state.timerStartedAt = null;
+          state.timerEndsAt = null;
+          await reply(chatId, 'Timer elapsed — valve closed.', (getState(WATER_BUTTON_MAC).storedDuration / 1000).toFixed(1));
+        } catch (err) {
+          console.error('[TelegramBot] Timer callback error:', err);
+        }
+      }, duration);
+
+    } else {
+      await reply(chatId, 'Unknown command. Use the buttons below or send /help.', durSec);
+    }
+  }
+
+  async function botLoop() {
+    console.log(`[TelegramBot] Starting (gen ${BOT_GEN})`);
+    let offset = 0;
+
+    while (BOT_GEN === global.__waterBotGen) {
+      try {
+        const data = await telegramRequest('getUpdates', {
+          offset,
+          timeout: 25,
+          allowed_updates: ['message']
+        });
+
+        if (!data.ok) {
+          await sleep(5000);
+          continue;
+        }
+
+        for (const update of data.result || []) {
+          offset = update.update_id + 1;
+          if (update.message) {
+            handleBotMessage(update.message).catch(err =>
+              console.error('[TelegramBot] Handler error:', err)
+            );
+          }
+        }
+      } catch (err) {
+        console.error('[TelegramBot] Polling error:', err.message);
+        await sleep(5000);
+      }
+    }
+
+    console.log(`[TelegramBot] Stopped (gen ${BOT_GEN} superseded)`);
+  }
+
+  // Start long-polling immediately (non-blocking)
+  if (BOT_TOKEN) {
+    botLoop().catch(err => console.error('[TelegramBot] Fatal error:', err));
+  } else {
+    console.error('[TelegramBot] WATER_VALVE_TELEGRAM_TOKEN not set in .env — bot disabled');
+  }
+
+
+}