tauri: wire diagnostics/fixes/onboarding/templates/send/bot IPC commands desktop src-tauri:

  - New commands: bot.rs, diagnostics.rs, fixes.rs, heartbeat.rs,
    onboarding.rs, send.rs, sessions.rs, templates.rs — all delegate to the springtaled HTTP API.
  - New runtime_guard.rs: ensures daemon is running before IPC calls.
  - state.rs: refactored to hold runtime connection + guard state.
  - lib.rs: register all new commands in the Tauri handler.
  - Existing commands (agent, authors, canvas, config, connectors, data,
    events, formations, memory, panic, rules, safety, travel, vault)  updated for consistent error handling and new API shapes.

  desktop frontend:
  - New ipc/: diagnostics.ts, fixes.ts, onboarding.ts, send.ts, templates.ts.
  - provider.ts + App.tsx: integrate new IPC surfaces.

  dashboard:
  - provider.ts: HTTP provider gains the new endpoint wrappers.

  packages:
  - types/operations.ts: shared TypeScript types for the new operations.
  - types/index.ts + dashboard/types.ts: re-exports and DataProvider interface expanded.

Author: radicalkjax

tauri/apps/dashboard/src/provider.ts

@@ -5,7 +5,11 @@
  * response envelopes ({ connectors: [...] } → [...]).
  */
 import type { DataProvider } from "@springtale/ui";
-import type { ConnectorSchema, EventEntry, AvailableConnector } from "@springtale/types";
+import type {
+  ConnectorSchema, EventEntry, AvailableConnector,
+  Report, PlatformForm, ApplyReport, Template, WriteReport,
+  FixGuide, FixOutcome, SendRequest, SendOutcome,
+} from "@springtale/types";
 import type { RuleSummary, FormationInfo } from "@springtale/ui";
 import { get, post, put, del, getBaseUrl, getToken } from "./api/client";
 import { subscribeToEvents } from "./api/events";
@@ -149,5 +153,45 @@ export function createWebProvider(): DataProvider {
       if (!token) return () => {};
       return subscribeToCanvasUpdates(getBaseUrl(), token, callback);
     },
+
+    // Diagnostics
+    async runDiagnostics() {
+      return get<Report>("/diagnostics");
+    },
+
+    // Onboarding
+    async listOnboardingPlatforms() {
+      const data = await get<{ platforms: PlatformForm[] }>("/onboarding/platforms");
+      return data.platforms ?? [];
+    },
+    async applyOnboarding(platform, answers) {
+      return post<ApplyReport>("/onboarding/apply", { platform, answers });
+    },
+
+    // Templates
+    async listTemplates() {
+      const data = await get<{ templates: Template[] }>("/templates");
+      return data.templates ?? [];
+    },
+    async writeTemplate(name) {
+      return post<WriteReport>("/templates/write", { name });
+    },
+
+    // Error fixes
+    async listFixes() {
+      const data = await get<{ guides: FixGuide[] }>("/fixes");
+      return data.guides ?? [];
+    },
+    async getFix(id) {
+      return get<FixGuide>(`/fixes/${id}`);
+    },
+    async applyFix(id) {
+      return post<FixOutcome>(`/fixes/${id}/apply`);
+    },
+
+    // Cross-channel send
+    async sendMessage(req) {
+      return post<SendOutcome>("/send", req);
+    },
   };
 }

tauri/apps/desktop/src-tauri/Cargo.lock

@@ -1,13 +1,16 @@
 use tauri::State;
 
+use crate::runtime_guard::require_runtime;
 use crate::state::AppState;
 
 /// List aggregated agent states (rules + events + autonomy).
 #[tauri::command]
 pub async fn list_agent_states(
     state: State<'_, AppState>,
 ) -> Result<Vec<springtale_runtime::operations::agent::AgentState>, String> {
-    springtale_runtime::operations::agent::list_agent_states(&state.runtime)
+    let guard = require_runtime(&state.runtime).await?;
+    let rt = guard.as_ref().unwrap();
+    springtale_runtime::operations::agent::list_agent_states(rt)
         .await
         .map_err(|e| e.to_string())
 }
@@ -18,7 +21,9 @@ pub async fn get_autonomy(
     state: State<'_, AppState>,
     name: String,
 ) -> Result<String, String> {
-    springtale_runtime::operations::agent::get_autonomy(&*state.runtime.store, &name)
+    let guard = require_runtime(&state.runtime).await?;
+    let rt = guard.as_ref().unwrap();
+    springtale_runtime::operations::agent::get_autonomy(&*rt.store, &name)
         .await
         .map_err(|e| e.to_string())
 }
@@ -30,7 +35,9 @@ pub async fn set_autonomy(
     name: String,
     level: String,
 ) -> Result<(), String> {
-    springtale_runtime::operations::agent::set_autonomy(&*state.runtime.store, &name, &level)
+    let guard = require_runtime(&state.runtime).await?;
+    let rt = guard.as_ref().unwrap();
+    springtale_runtime::operations::agent::set_autonomy(&*rt.store, &name, &level)
         .await
         .map_err(|e| e.to_string())
 }
@@ -42,7 +49,9 @@ pub async fn step_autonomy(
     name: String,
     direction: springtale_runtime::operations::agent::AutonomyDirection,
 ) -> Result<String, String> {
-    springtale_runtime::operations::agent::step_autonomy(&*state.runtime.store, &name, direction)
+    let guard = require_runtime(&state.runtime).await?;
+    let rt = guard.as_ref().unwrap();
+    springtale_runtime::operations::agent::step_autonomy(&*rt.store, &name, direction)
         .await
         .map_err(|e| e.to_string())
 }

tauri/apps/desktop/src-tauri/src/commands/agent.rs

@@ -1,18 +1,14 @@
 use tauri::State;
 
+use crate::runtime_guard::require_runtime;
 use crate::state::AppState;
 
 /// List all trusted authors.
 #[tauri::command]
-pub async fn list_authors(
-    state: State<'_, AppState>,
-) -> Result<serde_json::Value, String> {
-    let configs = state
-        .runtime
-        .store
-        .list_config()
-        .await
-        .map_err(|e| e.to_string())?;
+pub async fn list_authors(state: State<'_, AppState>) -> Result<serde_json::Value, String> {
+    let guard = require_runtime(&state.runtime).await?;
+    let rt = guard.as_ref().unwrap();
+    let configs = rt.store.list_config().await.map_err(|e| e.to_string())?;
 
     let authors: Vec<serde_json::Value> = configs
         .into_iter()
@@ -36,32 +32,29 @@ pub async fn add_author(
     name: String,
     pubkey: String,
 ) -> Result<(), String> {
-    // Validate pubkey is valid hex and 32 bytes
+    let guard = require_runtime(&state.runtime).await?;
+    let rt = guard.as_ref().unwrap();
+
     let bytes = hex::decode(&pubkey).map_err(|e| format!("invalid pubkey hex: {e}"))?;
     if bytes.len() != 32 {
         return Err("pubkey must be 32 bytes (64 hex chars)".into());
     }
 
     let key = format!("trusted-author:{name}");
     let value = serde_json::json!({ "pubkey": pubkey }).to_string();
-    state
-        .runtime
-        .store
+    rt.store
         .set_config(&key, &value)
         .await
         .map_err(|e| e.to_string())
 }
 
 /// Remove a trusted author.
 #[tauri::command]
-pub async fn remove_author(
-    state: State<'_, AppState>,
-    name: String,
-) -> Result<(), String> {
+pub async fn remove_author(state: State<'_, AppState>, name: String) -> Result<(), String> {
+    let guard = require_runtime(&state.runtime).await?;
+    let rt = guard.as_ref().unwrap();
     let key = format!("trusted-author:{name}");
-    state
-        .runtime
-        .store
+    rt.store
         .delete_config(&key)
         .await
         .map_err(|e| e.to_string())

tauri/apps/desktop/src-tauri/src/commands/authors.rs

@@ -0,0 +1,44 @@
+use tauri::State;
+
+use crate::runtime_guard::require_runtime;
+use crate::state::AppState;
+
+/// Get bot status: running state, connector/rule/formation counts.
+#[tauri::command]
+pub async fn bot_status(state: State<'_, AppState>) -> Result<serde_json::Value, String> {
+    let guard = require_runtime(&state.runtime).await?;
+    let rt = guard.as_ref().unwrap();
+
+    let registry = rt.registry.read().await;
+    let connector_count = registry.list().len();
+    drop(registry);
+
+    let engine = rt.engine.read().await;
+    let rule_count = engine.list_rules().len();
+    drop(engine);
+
+    let formation_count = rt
+        .store
+        .list_formations()
+        .await
+        .map(|f| f.len())
+        .unwrap_or(0);
+
+    Ok(serde_json::json!({
+        "running": true,
+        "connectors": connector_count,
+        "rules": rule_count,
+        "formations": formation_count,
+    }))
+}
+
+/// Get bot memory stats (session count).
+#[tauri::command]
+pub async fn bot_memory(state: State<'_, AppState>) -> Result<serde_json::Value, String> {
+    let guard = require_runtime(&state.runtime).await?;
+    let rt = guard.as_ref().unwrap();
+    let sessions = rt.store.list_sessions().await.map_err(|e| e.to_string())?;
+    Ok(serde_json::json!({
+        "session_count": sessions.len(),
+    }))
+}

tauri/apps/desktop/src-tauri/src/commands/bot.rs

@@ -2,22 +2,27 @@ use tauri::State;
 
 use springtale_core::canvas::{CanvasState, CanvasUpdate};
 
+use crate::runtime_guard::require_runtime;
 use crate::state::AppState;
 
 /// Get computed connection graph.
 #[tauri::command]
 pub async fn get_connections(
     state: State<'_, AppState>,
 ) -> Result<Vec<springtale_runtime::operations::canvas::Connection>, String> {
-    springtale_runtime::operations::canvas::compute_connections(&state.runtime)
+    let guard = require_runtime(&state.runtime).await?;
+    let rt = guard.as_ref().unwrap();
+    springtale_runtime::operations::canvas::compute_connections(rt)
         .await
         .map_err(|e| e.to_string())
 }
 
 /// Get the current canvas state snapshot.
 #[tauri::command]
 pub async fn get_canvas_state(state: State<'_, AppState>) -> Result<CanvasState, String> {
-    Ok(springtale_runtime::operations::canvas::get_canvas(&state.runtime).await)
+    let guard = require_runtime(&state.runtime).await?;
+    let rt = guard.as_ref().unwrap();
+    Ok(springtale_runtime::operations::canvas::get_canvas(rt).await)
 }
 
 /// Apply a canvas update.
@@ -26,5 +31,7 @@ pub async fn update_canvas(
     state: State<'_, AppState>,
     update: CanvasUpdate,
 ) -> Result<CanvasState, String> {
-    Ok(springtale_runtime::operations::canvas::update_canvas(&state.runtime, update).await)
+    let guard = require_runtime(&state.runtime).await?;
+    let rt = guard.as_ref().unwrap();
+    Ok(springtale_runtime::operations::canvas::update_canvas(rt, update).await)
 }

tauri/apps/desktop/src-tauri/src/commands/canvas.rs

@@ -1,5 +1,6 @@
 use tauri::State;
 
+use crate::runtime_guard::require_runtime;
 use crate::state::AppState;
 
 /// Get a config value by key.
@@ -8,7 +9,9 @@ pub async fn get_config(
     state: State<'_, AppState>,
     key: String,
 ) -> Result<serde_json::Value, String> {
-    springtale_runtime::operations::config::get_config(&*state.runtime.store, &key)
+    let guard = require_runtime(&state.runtime).await?;
+    let rt = guard.as_ref().unwrap();
+    springtale_runtime::operations::config::get_config(&*rt.store, &key)
         .await
         .map_err(|e| e.to_string())
 }
@@ -20,7 +23,9 @@ pub async fn set_config(
     key: String,
     value: serde_json::Value,
 ) -> Result<(), String> {
-    springtale_runtime::operations::config::set_config(&*state.runtime.store, &key, value)
+    let guard = require_runtime(&state.runtime).await?;
+    let rt = guard.as_ref().unwrap();
+    springtale_runtime::operations::config::set_config(&*rt.store, &key, value)
         .await
         .map_err(|e| e.to_string())
 }
@@ -30,7 +35,9 @@ pub async fn set_config(
 pub async fn list_config(
     state: State<'_, AppState>,
 ) -> Result<Vec<(String, serde_json::Value)>, String> {
-    springtale_runtime::operations::config::list_config(&*state.runtime.store)
+    let guard = require_runtime(&state.runtime).await?;
+    let rt = guard.as_ref().unwrap();
+    springtale_runtime::operations::config::list_config(&*rt.store)
         .await
         .map_err(|e| e.to_string())
 }
@@ -41,7 +48,9 @@ pub async fn set_ai_adapter(
     state: State<'_, AppState>,
     config: serde_json::Value,
 ) -> Result<(), String> {
-    springtale_runtime::operations::config::set_ai_adapter(&state.runtime, config)
+    let guard = require_runtime(&state.runtime).await?;
+    let rt = guard.as_ref().unwrap();
+    springtale_runtime::operations::config::set_ai_adapter(rt, config)
         .await
         .map_err(|e| e.to_string())
 }
@@ -53,7 +62,9 @@ pub async fn set_connector_config(
     name: String,
     config: serde_json::Value,
 ) -> Result<(), String> {
-    springtale_runtime::operations::config::set_connector_config(&state.runtime, &name, config)
+    let guard = require_runtime(&state.runtime).await?;
+    let rt = guard.as_ref().unwrap();
+    springtale_runtime::operations::config::set_connector_config(rt, &name, config)
         .await
         .map_err(|e| e.to_string())
 }
@@ -65,7 +76,9 @@ pub async fn configure_ai_adapter(
     target: String,
     config: serde_json::Value,
 ) -> Result<(), String> {
-    springtale_runtime::operations::config::configure_ai_adapter(&state.runtime, &target, config)
+    let guard = require_runtime(&state.runtime).await?;
+    let rt = guard.as_ref().unwrap();
+    springtale_runtime::operations::config::configure_ai_adapter(rt, &target, config)
         .await
         .map_err(|e| e.to_string())
 }
@@ -77,7 +90,9 @@ pub async fn upsert_connector_config(
     name: String,
     config: serde_json::Value,
 ) -> Result<bool, String> {
-    springtale_runtime::operations::config::upsert_connector_config(&state.runtime, &name, config)
+    let guard = require_runtime(&state.runtime).await?;
+    let rt = guard.as_ref().unwrap();
+    springtale_runtime::operations::config::upsert_connector_config(rt, &name, config)
         .await
         .map_err(|e| e.to_string())
 }
@@ -88,7 +103,9 @@ pub async fn toggle_formation_guard(
     state: State<'_, AppState>,
     formation_id: String,
 ) -> Result<bool, String> {
-    springtale_runtime::operations::config::toggle_formation_guard(&state.runtime, &formation_id)
+    let guard = require_runtime(&state.runtime).await?;
+    let rt = guard.as_ref().unwrap();
+    springtale_runtime::operations::config::toggle_formation_guard(rt, &formation_id)
         .await
         .map_err(|e| e.to_string())
 }