clawdesk-tauri

Tauri 2.0 desktop application crate. Wraps the ClawDesk backend into a native desktop app with a web-based UI. Defines IPC commands that bridge the frontend to the Rust backend and manages the application lifecycle.

Dependencies

Internal: clawdesk-types, clawdesk-gateway, clawdesk-domain, clawdesk-storage, clawdesk-sochdb, clawdesk-providers, clawdesk-channels, clawdesk-agents

External: tauri, tokio, serde, arc-swap, tracing

Modules

Module	Description
commands	Tauri #[tauri::command] IPC handlers
state	AppState setup and lifecycle
events	Tauri event emission for streaming responses

Key Types

/// Application state shared across all IPC commands
pub struct AppState {
    pub pipeline: Arc<Pipeline>,
    pub session_store: Arc<dyn SessionStore>,
    pub conversation_store: Arc<dyn ConversationStore>,
    pub config: Arc<ArcSwap<AppConfig>>,
    pub provider_registry: Arc<ProviderRegistry>,
    pub channel_registry: Arc<ChannelRegistry>,
}

/// Tauri app builder
pub fn run() {
    tauri::Builder::default()
        .manage(AppState::initialize())
        .invoke_handler(tauri::generate_handler![
            commands::create_session,
            commands::list_sessions,
            commands::get_session,
            commands::delete_session,
            commands::send_message,
            commands::send_message_streaming,
            commands::get_messages,
            commands::cancel_stream,
            commands::get_config,
            commands::update_config,
            commands::get_models,
            commands::get_channels,
            commands::get_health,
            commands::get_metrics,
            commands::compact_session,
        ])
        .run(tauri::generate_context!())
        .expect("error running tauri application");
}

IPC Commands

#[tauri::command]
async fn send_message(
    state: State<'_, AppState>,
    session_id: String,
    content: String,
) -> Result<MessageResponse, String> {
    let session = state.session_store
        .get(&SessionId::from(session_id))
        .await
        .map_err(|e| e.to_string())?
        .ok_or("Session not found")?;

    let message = Message::user(&content);
    let response = state.pipeline
        .process(&session, &message, /* ... */)
        .await
        .map_err(|e| e.to_string())?;

    Ok(response.into())
}

#[tauri::command]
async fn send_message_streaming(
    state: State<'_, AppState>,
    app: AppHandle,
    session_id: String,
    content: String,
) -> Result<(), String> {
    // Emit stream events to the frontend
    app.emit("stream-start", StartPayload { .. })?;

    // ... stream chunks ...
    app.emit("stream-chunk", ChunkPayload { content, index })?;

    app.emit("stream-end", EndPayload { .. })?;
    Ok(())
}

Development

cd crates/clawdesk-tauri

# Install frontend dependencies
pnpm install

# Start development mode (hot-reload)
cargo tauri dev

# Build for production
cargo tauri build

info

See the Tauri IPC Commands API reference for the complete list of commands and their TypeScript interfaces.