feat(dashboards): add refresh/auto-refresh, TV kiosk mode, and AI-evaluated alerts

Add manual + auto-refresh (30s/5m/1h) to the dashboard workspace and viewer,
backed by a new reload() method on DashboardArtifact that forces a genuine
iframe remount via a key bump. Add TV/kiosk mode to the public share route
(?kiosk=1, chrome-less + auto-refresh) with multi-dashboard cycling
(?tokens=...&advance=...) that skips password-protected dashboards rather
than stalling on an unattended gate; ShareMenu surfaces a ready-made kiosk
link once a dashboard is public.

Add natural-language dashboard alerts (dashboard_alerts table, V114
migration): a per-dashboard condition evaluated on a schedule by a bounded
DeepSQL agent session (fresh, tool-scoped, forced YES/NO + grounded reason),
ticked every minute by one db-scheduler recurring task rather than one task
per alert. Fired alerts dispatch through new EmailService/WebhookService
methods with a per-alert cooldown, and run as whoever created them since
there's no ambient "system" identity for a background job. Server-side
validation rejects a blank condition on create/update.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

Author: notSumit25

CLAUDE.md

@@ -141,7 +141,10 @@ Dashboards are **generated by the embedded DeepSQL Agent acting as a coding agen
 - **Sharing**: both share types render a standalone read-only `DashboardViewer` (title + `DashboardArtifact` with an injected `queryFn`). Internal link `/dashboard-view/:id` (auth) uses the authed broker; public link `/share/dashboard/:token` (permitAll) uses `PublicDashboardController` (`GET /api/public/dashboards/{token}` + `/query`), which resolves only while `saved_dashboards.is_public` is true (revoke = flip it) and runs read-only + connection-scoped. `share_token`/`is_public` are set only via `POST|DELETE /api/saved-dashboards/{id}/share` (access-checked), never a general update. `ShareMenu.jsx` drives the UI. The public query path has its own nginx `dashq` limiter.
 - **Organization** (search/folders/favorites): `SavedDashboardController`'s search/folder/favorite endpoints existed for a while with no UI consumer. `DashboardsHome.jsx` now wires all of it — a search box (client-side filter over name/description), folder chips derived from `GET /connection/{id}/folders` with a per-card "move to folder" popover (`PUT /saved-dashboards/{id}` with `folder: ""` to clear — `updateDashboard` treats `null` as "field omitted" so blank is the explicit clear signal, same convention as `setSharePassword`), and a favorite star toggle (`POST /{id}/favorite`) with optimistic UI update.
 - **Clone**: `POST /saved-dashboards/{id}/clone` (`SavedDashboardService.cloneDashboard`) duplicates a dashboard's config/chat/tags/folder into a fresh row — not shared, not favorited. Exposed as a copy icon on each `DashboardsHome.jsx` card.
-- **Version history**: every real overwrite of `dashboardConfig` (agent build via `completeBuildTurn`, manual Source-tab edit via `updateDashboard`, or a restore) snapshots the *previous* config into `dashboard_versions` (`V113__create_dashboard_versions.sql`) before overwriting, tagged with a trigger (`AGENT_BUILD`/`MANUAL_EDIT`/`RESTORE`) — capped at 50 snapshots per dashboard, oldest pruned first. `GET /{id}/versions` lists them newest-first; `POST /{id}/versions/{versionId}/restore` swaps a snapshot back in as current (itself snapshotting whatever was live, so a restore is undoable too). `DashboardWorkspace.jsx`'s canvas toolbar has a History panel (reusing the Queries panel's layout) listing versions with a Restore button, disabled while a build is in flight to avoid racing the agent's own write.
+- **Version history**: every real overwrite of `dashboardConfig` (agent build via `completeBuildTurn`, manual Source-tab edit via `updateDashboard`, or a restore) snapshots the *previous* config into `dashboard_versions` (`V113__create_dashboard_versions.sql`) before overwriting, tagged with a trigger (`AGENT_BUILD`/`MANUAL_EDIT`/`RESTORE`) — capped at 50 snapshots per dashboard, oldest pruned first. `GET /{id}/versions` lists them newest-first; `POST /{id}/versions/{versionId}/restore` swaps a snapshot back in as current (itself snapshotting whatever was live, so a restore is undoable too) and **dedupes**: after a restore, the restored row plus any other row with byte-identical `dashboard_config` are deleted, since that content is now "Current," not history — otherwise a restore-edit-restore cycle piles up an alternating chain of duplicate snapshots. `DashboardWorkspace.jsx`'s History panel shows a lightweight diff summary per entry (title/widget-count/size delta computed client-side, not a real line diff — the agent rewrites large chunks even for small logical changes) plus a Preview modal that renders that version's HTML live via `DashboardArtifact`.
+- **Refresh**: `DashboardArtifact`'s `useImperativeHandle` exposes `reload()`, which bumps an internal `reloadEpoch` state used as the `<iframe>`'s `key` — forcing a genuine remount (and re-running every widget's `deepsql.query()` call) even when `html` is referentially unchanged, which changing `html`/`srcDoc` alone can't guarantee. `DashboardWorkspace.jsx`'s canvas toolbar has a manual Refresh button plus an auto-refresh interval dropdown (Off/30s/5m/1h) that calls it on a timer, paused while a build is in flight (a completing build already replaces the iframe). `DashboardViewer.jsx` (both share surfaces) takes the same `autoRefreshMs` optionally, plus `hideChrome` for kiosk mode.
+- **TV/kiosk mode**: `PublicDashboardPage.jsx` reads `?kiosk=1&refresh=<seconds>` (chrome-less + auto-refresh, floor 10s) and `?tokens=tokA,tokB&advance=<seconds>` (cycles through multiple public share tokens, dwelling `advance` seconds each — the route's own `:token` is always the first slide). A password-protected dashboard mid-cycle is skipped (there's no one there to type a password) rather than parking the whole kiosk on a gate. `ShareMenu.jsx` surfaces a ready-made kiosk link (`?kiosk=1&refresh=60`) once a dashboard is public and unprotected.
+- **Alerts**: `dashboard_alerts` (`V114__create_dashboard_alerts.sql`) holds a natural-language condition per dashboard (e.g. "alert if the error rate exceeds 5% in the last hour"), evaluated on a schedule by `DashboardAlertService.evaluate()` — a **bounded agent session** (fresh `ensureSession`, no tools beyond `execute_sql`/schema lookups, a short task prompt asking for exactly `YES`/`NO` + a one-sentence reason grounded in a real query result) reusing the same agent plumbing as dashboard generation, just for a one-line answer instead of a whole HTML document. `DashboardAlertTaskConfig` registers one db-scheduler recurring task (`dashboard-alert-tick`, every minute) that evaluates whichever alerts are actually due per `DashboardAlertRepository.findDue` (each alert has its own `checkIntervalMinutes`) rather than one scheduled task per alert. A fired alert dispatches through `EmailService.sendDashboardAlert`/`WebhookService.sendDashboardAlert` (new methods, same pattern as the existing growth/slow-query alert methods) gated by a per-alert `cooldownMinutes` so a condition that stays true doesn't re-fire every tick. The alert runs **as whoever created it** (`createdByUsername`, captured at creation time) — there's no ambient "system" identity for a background job, and running every alert as an arbitrary admin would let one user's alert read data through someone else's access grant. `DashboardAlertController` is the CRUD surface (`/saved-dashboards/{id}/alerts`); `DashboardWorkspace.jsx`'s toolbar has an Alerts panel (composer + per-alert enable/disable/delete, last-check verdict shown inline).
 
 ## LLM Providers
 

backend/src/main/java/com/dbaagent/controller/DashboardAlertController.java

@@ -0,0 +1,100 @@
+package com.dbaagent.controller;
+
+import com.dbaagent.model.DashboardAlert;
+import com.dbaagent.model.SavedDashboard;
+import com.dbaagent.service.DashboardAlertService;
+import com.dbaagent.service.SavedDashboardService;
+import com.dbaagent.service.security.AccessControlService;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+/** CRUD for per-dashboard natural-language alerts — see DashboardAlertService for evaluation. */
+@RestController
+@RequestMapping("/saved-dashboards/{dashboardId}/alerts")
+@RequiredArgsConstructor
+@Slf4j
+public class DashboardAlertController {
+
+    private final DashboardAlertService alertService;
+    private final SavedDashboardService savedDashboardService;
+    private final AccessControlService accessControlService;
+
+    @PostMapping
+    public ResponseEntity<Map<String, Object>> create(@PathVariable UUID dashboardId, @RequestBody DashboardAlert draft) {
+        try {
+            SavedDashboard dashboard = requireDashboard(dashboardId);
+            accessControlService.assertCanManageConnectionContent(dashboard.getConnectionId());
+            String username = accessControlService.requireCurrentUsername();
+            DashboardAlert created = alertService.createAlert(dashboardId, username, draft);
+            return ResponseEntity.status(HttpStatus.CREATED).body(Map.of("success", true, "alert", created));
+        } catch (IllegalArgumentException e) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).body(Map.of("success", false, "message", e.getMessage()));
+        } catch (org.springframework.web.server.ResponseStatusException e) {
+            throw e;
+        } catch (Exception e) {
+            log.error("Error creating dashboard alert", e);
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(Map.of("success", false, "message", "Failed to create alert"));
+        }
+    }
+
+    @GetMapping
+    public ResponseEntity<Map<String, Object>> list(@PathVariable UUID dashboardId) {
+        try {
+            SavedDashboard dashboard = requireDashboard(dashboardId);
+            accessControlService.assertCanReadConnectionContent(dashboard.getConnectionId());
+            List<DashboardAlert> alerts = alertService.getAlertsForDashboard(dashboardId);
+            return ResponseEntity.ok(Map.of("success", true, "alerts", alerts));
+        } catch (IllegalArgumentException e) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).body(Map.of("success", false, "message", e.getMessage()));
+        } catch (org.springframework.web.server.ResponseStatusException e) {
+            throw e;
+        } catch (Exception e) {
+            log.error("Error listing dashboard alerts", e);
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(Map.of("success", false, "message", "Failed to fetch alerts"));
+        }
+    }
+
+    @PutMapping("/{alertId}")
+    public ResponseEntity<Map<String, Object>> update(@PathVariable UUID dashboardId, @PathVariable UUID alertId, @RequestBody DashboardAlert updates) {
+        try {
+            SavedDashboard dashboard = requireDashboard(dashboardId);
+            accessControlService.assertCanManageConnectionContent(dashboard.getConnectionId());
+            DashboardAlert updated = alertService.updateAlert(alertId, updates);
+            return ResponseEntity.ok(Map.of("success", true, "alert", updated));
+        } catch (IllegalArgumentException e) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).body(Map.of("success", false, "message", e.getMessage()));
+        } catch (org.springframework.web.server.ResponseStatusException e) {
+            throw e;
+        } catch (Exception e) {
+            log.error("Error updating dashboard alert", e);
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(Map.of("success", false, "message", "Failed to update alert"));
+        }
+    }
+
+    @DeleteMapping("/{alertId}")
+    public ResponseEntity<Map<String, Object>> delete(@PathVariable UUID dashboardId, @PathVariable UUID alertId) {
+        try {
+            SavedDashboard dashboard = requireDashboard(dashboardId);
+            accessControlService.assertCanManageConnectionContent(dashboard.getConnectionId());
+            alertService.deleteAlert(alertId);
+            return ResponseEntity.ok(Map.of("success", true));
+        } catch (org.springframework.web.server.ResponseStatusException e) {
+            throw e;
+        } catch (Exception e) {
+            log.error("Error deleting dashboard alert", e);
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(Map.of("success", false, "message", "Failed to delete alert"));
+        }
+    }
+
+    private SavedDashboard requireDashboard(UUID dashboardId) {
+        return savedDashboardService.getDashboardById(dashboardId)
+            .orElseThrow(() -> new IllegalArgumentException("Dashboard not found"));
+    }
+}

backend/src/main/java/com/dbaagent/model/DashboardAlert.java

@@ -0,0 +1,96 @@
+package com.dbaagent.model;
+
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import org.hibernate.annotations.CreationTimestamp;
+import org.hibernate.annotations.UpdateTimestamp;
+
+import java.time.LocalDateTime;
+import java.util.UUID;
+
+@Entity
+@Table(name = "dashboard_alerts", indexes = {
+    @Index(name = "idx_dashboard_alerts_dashboard_id", columnList = "dashboardId"),
+    @Index(name = "idx_dashboard_alerts_due", columnList = "isEnabled, lastCheckedAt")
+})
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public class DashboardAlert {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.UUID)
+    private UUID id;
+
+    @Column(nullable = false)
+    private UUID dashboardId;
+
+    @Column(nullable = false)
+    private String connectionId;
+
+    // The alert runs as whoever created it (their agent profile/session) — there is
+    // no ambient "system" identity to fall back to for a background job, and running
+    // it as an arbitrary admin would let anyone's alert read data through someone
+    // else's access grant.
+    @Column(nullable = false)
+    private String createdByUsername;
+
+    // Natural-language threshold, e.g. "alert if error_rate exceeds 5% in the last hour".
+    @Column(nullable = false, columnDefinition = "TEXT")
+    private String conditionText;
+
+    // Comma-separated subset of: in-app, email, webhook.
+    @Column(nullable = false, length = 255)
+    private String channels = "in-app";
+
+    @Column(length = 1000)
+    private String emailRecipients;
+
+    @Column(length = 1000)
+    private String webhookUrl;
+
+    @Column(nullable = false)
+    private Boolean isEnabled = true;
+
+    @Column(nullable = false)
+    private Integer checkIntervalMinutes = 15;
+
+    // Minimum time between two firings, independent of check interval — a condition
+    // that stays true for hours should page once, not every 15 minutes.
+    @Column(nullable = false)
+    private Integer cooldownMinutes = 60;
+
+    @Column
+    private LocalDateTime lastCheckedAt;
+
+    @Column
+    private LocalDateTime lastFiredAt;
+
+    @Column(length = 16)
+    private String lastVerdict;
+
+    @Column(columnDefinition = "TEXT")
+    private String lastReason;
+
+    @Column(columnDefinition = "TEXT")
+    private String lastError;
+
+    @CreationTimestamp
+    @Column(nullable = false, updatable = false)
+    private LocalDateTime createdAt;
+
+    @UpdateTimestamp
+    @Column(nullable = false)
+    private LocalDateTime updatedAt;
+
+    @PrePersist
+    @PreUpdate
+    void applyDefaults() {
+        if (isEnabled == null) isEnabled = true;
+        if (checkIntervalMinutes == null) checkIntervalMinutes = 15;
+        if (cooldownMinutes == null) cooldownMinutes = 60;
+        if (channels == null || channels.isBlank()) channels = "in-app";
+    }
+}

backend/src/main/java/com/dbaagent/repository/DashboardAlertRepository.java

@@ -0,0 +1,28 @@
+package com.dbaagent.repository;
+
+import com.dbaagent.model.DashboardAlert;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.stereotype.Repository;
+
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.UUID;
+
+@Repository
+public interface DashboardAlertRepository extends JpaRepository<DashboardAlert, UUID> {
+
+    List<DashboardAlert> findByDashboardIdOrderByCreatedAtDesc(UUID dashboardId);
+
+    // Due = enabled AND (never checked OR its own interval has elapsed since the last
+    // check). Computed in SQL rather than pulled into Java so a growing alert count
+    // never means pulling every row into memory just to filter most of them out.
+    // The now::timestamp cast is required — without it, Postgres can't resolve
+    // whether the parameter or the (timestamp - interval) expression should drive
+    // the comparison's type and rejects the query with "operator does not exist:
+    // timestamp without time zone <= interval".
+    @Query(value = "SELECT * FROM dashboard_alerts WHERE is_enabled = true "
+        + "AND (last_checked_at IS NULL OR last_checked_at <= CAST(:now AS timestamp) - (check_interval_minutes * INTERVAL '1 minute'))",
+        nativeQuery = true)
+    List<DashboardAlert> findDue(LocalDateTime now);
+}