feat(dashboard): block snapshot when no provider configured, show banner

Razortype · Razortype · commit f3dc1916ccb2 · 2026-05-18T13:09:18.000+03:00
New Rust command is_provider_ready: pure config check (no network call)
against the active provider. Checks DB provider_has_key flag for API-key
providers, model selection for all, and endpoint for Ollama. Returns
ready + reason string + active_provider id.

Dashboard: on mount + window focus, invokes is_provider_ready and stores
result. When not ready, shows an amber banner (severity-medium colors)
between TopBar and tabs with the reason, "Configure in Settings" helper
text, and a direct link to /settings. Snapshot button gains snapshotBlocked
prop via TopBar; when blocked: disabled, muted style, tooltip "Configure
an AI provider first".

Auto-snapshot useEffect now calls is_provider_ready before mutating;
skips the snapshot (and discards the flag) if provider not ready.

Onboarding completeWithSnapshot: checks is_provider_ready before setting
the sessionStorage flag; if not ready, falls through to complete() so
user lands on Dashboard with the banner explaining the next step.

TopBar: new snapshotBlocked? prop threads the disabled state without
changing the button's visibility.
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
@@ -520,6 +520,79 @@ fn read_bytes_freed_from_audit_log() -> u64 {
     total
 }
 
+// ── Provider readiness check ─────────────────────────────────────────────────
+
+#[derive(serde::Serialize)]
+struct ProviderReadiness {
+    ready: bool,
+    reason: Option<String>,
+    active_provider: String,
+}
+
+#[tauri::command]
+async fn is_provider_ready(db: State<'_, Db>) -> Result<ProviderReadiness, String> {
+    let db = db.inner().clone();
+    tokio::task::spawn_blocking(move || -> Result<ProviderReadiness, String> {
+        let config = provider_config::ProviderConfig::load(&db)
+            .map_err(|e: crate::error::AppError| e.to_string())?;
+        let active = config.active_provider.clone();
+        let active_str = active.as_str().to_string();
+
+        let has_key = if active.keychain_account().is_some() {
+            let flag_key = format!("provider_has_key:{}", active.as_str());
+            db.get_setting(&flag_key)
+                .map(|v| v.as_deref() == Some("1"))
+                .unwrap_or(false)
+        } else {
+            true
+        };
+
+        let (ready, reason) = match active {
+            provider_config::ProviderId::ClaudeCli => (true, None),
+            provider_config::ProviderId::AnthropicApi => {
+                if !has_key {
+                    (false, Some("Anthropic API key not set".to_string()))
+                } else if config.anthropic_api.model.is_empty() {
+                    (false, Some("Anthropic model not selected".to_string()))
+                } else {
+                    (true, None)
+                }
+            }
+            provider_config::ProviderId::OpenAi => {
+                if !has_key {
+                    (false, Some("OpenAI API key not set".to_string()))
+                } else if config.openai.model.is_empty() {
+                    (false, Some("OpenAI model not selected".to_string()))
+                } else {
+                    (true, None)
+                }
+            }
+            provider_config::ProviderId::Gemini => {
+                if !has_key {
+                    (false, Some("Gemini API key not set".to_string()))
+                } else if config.gemini.model.is_empty() {
+                    (false, Some("Gemini model not selected".to_string()))
+                } else {
+                    (true, None)
+                }
+            }
+            provider_config::ProviderId::Ollama => {
+                if config.ollama.endpoint.is_empty() {
+                    (false, Some("Ollama endpoint not set".to_string()))
+                } else if config.ollama.model.is_empty() {
+                    (false, Some("Ollama model not selected".to_string()))
+                } else {
+                    (true, None)
+                }
+            }
+        };
+
+        Ok(ProviderReadiness { ready, reason, active_provider: active_str })
+    })
+    .await
+    .map_err(|e| e.to_string())?
+}
+
 // ── First-run onboarding commands ────────────────────────────────────────────
 
 #[tauri::command]
@@ -751,6 +824,7 @@ pub fn run() {
             probe_automation_permission,
             probe_full_disk_access,
             open_system_settings_pane,
+            is_provider_ready,
         ])
         .run(tauri::generate_context!())
         .expect("error while running tauri application");
diff --git a/src/components/TopBar.tsx b/src/components/TopBar.tsx
@@ -9,6 +9,7 @@ interface TopBarProps {
   activeSnapshotId?: number | null;
   findingCount?: number | null;
   isAnalyzing?: boolean;
+  snapshotBlocked?: boolean;
   onTakeSnapshot?: () => void;
   onReAnalyze?: () => void;
 }
@@ -26,6 +27,7 @@ export default function TopBar({
   activeSnapshotId = null,
   findingCount = null,
   isAnalyzing = false,
+  snapshotBlocked = false,
   onTakeSnapshot,
   onReAnalyze,
 }: TopBarProps) {
@@ -108,17 +110,18 @@ export default function TopBar({
         {onTakeSnapshot && (
           <button
             onClick={onTakeSnapshot}
-            disabled={isAnalyzing}
+            disabled={isAnalyzing || snapshotBlocked}
+            title={snapshotBlocked ? "Configure an AI provider first" : undefined}
             style={{
-              background: isAnalyzing ? "var(--color-text-muted)" : "var(--color-accent)",
-              color: isAnalyzing ? "var(--color-text-disabled)" : "#1a1a26",
+              background: (isAnalyzing || snapshotBlocked) ? "var(--color-text-muted)" : "var(--color-accent)",
+              color: (isAnalyzing || snapshotBlocked) ? "var(--color-text-disabled)" : "#1a1a26",
               border: "none",
               borderRadius: "6px",
               padding: "6px 14px",
               fontFamily: "var(--font-sans)",
               fontSize: "12px",
               fontWeight: 500,
-              cursor: isAnalyzing ? "not-allowed" : "pointer",
+              cursor: (isAnalyzing || snapshotBlocked) ? "not-allowed" : "pointer",
             }}
           >
             {isAnalyzing ? "Analyzing…" : "Take snapshot"}
diff --git a/src/pages/Dashboard.tsx b/src/pages/Dashboard.tsx
@@ -1,7 +1,10 @@
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import { invoke } from "@tauri-apps/api/core";
+import { getCurrentWindow } from "@tauri-apps/api/window";
 import { useState, useEffect, useRef, useCallback } from "react";
+import { Link } from "react-router-dom";
 import { toast } from "sonner";
+import { AlertTriangle } from "lucide-react";
 import type { Finding } from "../types/finding";
 import type { AuditTokenUsage, PersistenceEntry, Snapshot } from "../types/snapshot";
 import type { ProviderConfig } from "../types/provider";
@@ -103,6 +106,43 @@ export default function Dashboard() {
       .catch(() => {});
   }, []);
 
+  const [providerReady, setProviderReady] = useState<{
+    ready: boolean;
+    reason: string | null;
+    active_provider: string;
+  } | null>(null);
+
+  function checkProviderReady() {
+    invoke<{ ready: boolean; reason: string | null; active_provider: string }>(
+      "is_provider_ready"
+    )
+      .then(setProviderReady)
+      .catch(() => {});
+  }
+
+  useEffect(() => {
+    checkProviderReady();
+  }, []);
+
+  // Re-check readiness whenever the window regains focus (user may have updated Settings).
+  useEffect(() => {
+    let unlisten: (() => void) | null = null;
+    let cancelled = false;
+    getCurrentWindow()
+      .onFocusChanged(({ payload: focused }) => {
+        if (focused && !cancelled) checkProviderReady();
+      })
+      .then((fn) => {
+        if (cancelled) fn();
+        else unlisten = fn;
+      })
+      .catch(() => {});
+    return () => {
+      cancelled = true;
+      unlisten?.();
+    };
+  }, []);
+
   const latestIdQuery = useQuery<number | null>({
     queryKey: ["latest_snapshot_id"],
     queryFn: () => invoke<number | null>("latest_snapshot_id"),
@@ -187,11 +227,19 @@ export default function Dashboard() {
 
   const hasRunAutoSnapshot = useRef(false);
   useEffect(() => {
-    if (!hasRunAutoSnapshot.current && sessionStorage.getItem("mscope_auto_snapshot") === "1") {
-      hasRunAutoSnapshot.current = true;
-      sessionStorage.removeItem("mscope_auto_snapshot");
-      runFullScan.mutate();
-    }
+    if (hasRunAutoSnapshot.current) return;
+    const flag = sessionStorage.getItem("mscope_auto_snapshot");
+    sessionStorage.removeItem("mscope_auto_snapshot");
+    if (!flag) return;
+    const ts = parseInt(flag, 10);
+    if (Number.isNaN(ts) || Date.now() - ts > 5000) return;
+    invoke<{ ready: boolean }>("is_provider_ready")
+      .then(({ ready }) => {
+        if (!ready) return;
+        hasRunAutoSnapshot.current = true;
+        runFullScan.mutate();
+      })
+      .catch(() => {});
   // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
 
@@ -339,9 +387,61 @@ export default function Dashboard() {
         activeSnapshotId={activeSnapshotId}
         findingCount={findings?.length ?? null}
         isAnalyzing={isAnalyzing}
+        snapshotBlocked={providerReady !== null && !providerReady.ready}
         onTakeSnapshot={() => runFullScan.mutate()}
         onReAnalyze={() => reAnalyze.mutate()}
       />
+      {providerReady !== null && !providerReady.ready && (
+        <div
+          style={{
+            display: "flex",
+            alignItems: "center",
+            gap: "10px",
+            padding: "8px 20px",
+            background: "var(--color-severity-medium-bg)",
+            borderBottom: "1px solid var(--color-border-divider)",
+            flexShrink: 0,
+          }}
+        >
+          <AlertTriangle size={14} style={{ color: "var(--color-severity-medium-fg)", flexShrink: 0 }} />
+          <span
+            style={{
+              flex: 1,
+              fontSize: "var(--text-xs)",
+              fontFamily: "var(--font-mono)",
+              color: "var(--color-severity-medium-fg)",
+            }}
+          >
+            {providerReady.reason}
+            <span
+              style={{
+                color: "var(--color-text-muted)",
+                marginLeft: "8px",
+                fontFamily: "var(--font-sans)",
+              }}
+            >
+              Configure in Settings to enable analysis.
+            </span>
+          </span>
+          <Link
+            to="/settings"
+            style={{
+              fontSize: "var(--text-xs)",
+              fontFamily: "var(--font-sans)",
+              fontWeight: 500,
+              color: "var(--color-accent)",
+              textDecoration: "none",
+              padding: "3px 10px",
+              background: "var(--color-accent-glow)",
+              borderRadius: "var(--radius-sm)",
+              border: "1px solid var(--color-accent-muted)",
+              flexShrink: 0,
+            }}
+          >
+            Configure
+          </Link>
+        </div>
+      )}
       <TabBar
         active={active}
         onChange={setActive}
diff --git a/src/pages/Onboarding.tsx b/src/pages/Onboarding.tsx
@@ -434,7 +434,10 @@ export default function Onboarding({ onComplete }: OnboardingProps) {
   }
 
   async function completeWithSnapshot() {
-    sessionStorage.setItem("mscope_auto_snapshot", "1");
+    const readiness = await invoke<{ ready: boolean }>("is_provider_ready").catch(() => ({ ready: false }));
+    if (readiness.ready) {
+      sessionStorage.setItem("mscope_auto_snapshot", String(Date.now()));
+    }
     await complete();
   }
 
diff --git a/src/pages/Settings.tsx b/src/pages/Settings.tsx
@@ -335,6 +335,7 @@ function SectionDeveloper() {
   async function handleReset() {
     setResetting(true);
     try {
+      sessionStorage.removeItem("mscope_auto_snapshot");
       await invoke("reset_app_state");
       toast.success("App state reset");
       navigate("/");

Original file line number	Diff line number	Diff line change
`@@ -434,7 +434,10 @@ export default function Onboarding({ onComplete }: OnboardingProps) {`
`434`	`434`	`}`
`435`	`435`
`436`	`436`	`async function completeWithSnapshot() {`
`437`		`- sessionStorage.setItem("mscope_auto_snapshot", "1");`
	`437`	`+ const readiness = await invoke<{ ready: boolean }>("is_provider_ready").catch(() => ({ ready: false }));`
	`438`	`+ if (readiness.ready) {`
	`439`	`+ sessionStorage.setItem("mscope_auto_snapshot", String(Date.now()));`
	`440`	`+ }`
`438`	`441`	`await complete();`
`439`	`442`	`}`
`440`	`443`