d4c57b777a
All checks were successful
Build AppImage / build (push) Successful in 8m16s
Guard-Rails: Live-Feed mit Risiko-Badges, 3 Tabs, Ein-Klick-Freigabe D-Bus: 10 Desktop-Aktionen (Dolphin, Kate, Konsole, Firefox, Notify) Screenshot: Region/Vollbild via spectacle/scrot, Vorschau + Chat-Send Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
338 lines
13 KiB
Rust
338 lines
13 KiB
Rust
// Claude Desktop — Tauri Backend
|
|
// Hauptmodul für die Rust-Seite der App
|
|
|
|
use std::sync::{Arc, Mutex};
|
|
use tauri::{
|
|
Emitter, Manager,
|
|
menu::{Menu, MenuItem},
|
|
tray::{MouseButton, MouseButtonState, TrayIconBuilder, TrayIconEvent},
|
|
};
|
|
|
|
#[cfg(target_os = "linux")]
|
|
use webkit2gtk::WebViewExt;
|
|
|
|
mod audit;
|
|
mod claude;
|
|
mod clipboard;
|
|
mod commands;
|
|
mod context;
|
|
mod db;
|
|
mod guard;
|
|
mod hooks;
|
|
mod ide;
|
|
mod knowledge;
|
|
mod memory;
|
|
mod programs;
|
|
mod session;
|
|
mod teaching;
|
|
mod update;
|
|
mod voice;
|
|
mod chat_window;
|
|
|
|
/// Initialisiert die App
|
|
#[cfg_attr(mobile, tauri::mobile_entry_point)]
|
|
pub fn run() {
|
|
tauri::Builder::default()
|
|
.plugin(tauri_plugin_shell::init())
|
|
.plugin(tauri_plugin_dialog::init())
|
|
.plugin(tauri_plugin_global_shortcut::Builder::new().build())
|
|
.manage(Arc::new(Mutex::new(claude::ClaudeState::default())))
|
|
.manage(guard::GuardState::new(Mutex::new(guard::GuardRails::new())))
|
|
.manage::<hooks::HookState>(Arc::new(Mutex::new(hooks::HookManager::default())))
|
|
.manage::<clipboard::ClipboardState>(Arc::new(Mutex::new(clipboard::ClipboardWatcher::default())))
|
|
.manage::<ide::IdeState>(Arc::new(Mutex::new(ide::IdeConnector::default())))
|
|
// Phase 2.0: MySQL Pool als Managed State — wird einmal erstellt, von allen Knowledge-Commands geteilt
|
|
.manage::<knowledge::MysqlPoolState>(knowledge::create_managed_pool())
|
|
.invoke_handler(tauri::generate_handler![
|
|
// Claude SDK
|
|
claude::send_message,
|
|
claude::stop_all_agents,
|
|
claude::get_agent_status,
|
|
claude::set_model,
|
|
claude::get_available_models,
|
|
claude::get_current_model,
|
|
claude::set_agent_mode,
|
|
claude::get_agent_mode,
|
|
claude::init_sticky_context,
|
|
// Gedächtnis-System
|
|
memory::load_memory,
|
|
memory::get_sticky_memory_entries,
|
|
memory::save_memory_entry,
|
|
memory::delete_memory_entry,
|
|
memory::list_memory_entries,
|
|
memory::get_autoload_memory,
|
|
memory::save_pattern,
|
|
memory::detect_issue,
|
|
// Audit-Log
|
|
audit::get_audit_log,
|
|
audit::add_audit_entry,
|
|
audit::get_audit_stats,
|
|
// Guard-Rails
|
|
guard::check_action,
|
|
guard::add_permission,
|
|
guard::remove_permission,
|
|
guard::get_permissions,
|
|
guard::get_blocked_patterns,
|
|
// Datenbank
|
|
db::init_database,
|
|
db::get_db_stats,
|
|
// Settings
|
|
db::get_setting,
|
|
db::set_setting,
|
|
db::get_all_settings,
|
|
// Sessions
|
|
session::create_session,
|
|
session::update_session,
|
|
session::list_sessions,
|
|
session::get_session,
|
|
session::delete_session,
|
|
session::resume_session,
|
|
session::get_active_session,
|
|
session::set_claude_session_id,
|
|
session::update_session_stats,
|
|
// Messages
|
|
db::save_message,
|
|
db::load_messages,
|
|
db::clear_messages,
|
|
db::compact_session,
|
|
// Monitor-Events
|
|
db::save_monitor_event,
|
|
db::load_monitor_events,
|
|
db::load_monitor_events_by_type,
|
|
db::clear_all_monitor_events,
|
|
db::get_monitor_stats,
|
|
// Phase 2.0: Fehler-Tracking
|
|
db::track_error,
|
|
db::set_error_kb_pattern,
|
|
db::get_error_stats,
|
|
// Projekte
|
|
db::list_projects,
|
|
db::save_project,
|
|
db::delete_project,
|
|
db::switch_project,
|
|
// Wissensbasis (claude-db)
|
|
knowledge::search_knowledge,
|
|
knowledge::get_knowledge,
|
|
knowledge::save_knowledge,
|
|
knowledge::get_knowledge_categories,
|
|
knowledge::get_recent_knowledge,
|
|
knowledge::test_knowledge_connection,
|
|
knowledge::get_tool_hints,
|
|
knowledge::format_tool_hints,
|
|
// Phase 2.0: Proaktive Intelligenz
|
|
knowledge::extract_message_keywords,
|
|
knowledge::get_session_hints,
|
|
knowledge::auto_save_error_pattern,
|
|
// Phase 3: KB-Cache
|
|
knowledge::invalidate_kb_cache,
|
|
// Phase 3.1: Smart Hints v2 — Session-Management
|
|
knowledge::reset_kb_session,
|
|
knowledge::get_kb_session_status,
|
|
// Context-Management
|
|
context::get_sticky_context,
|
|
context::set_sticky_context,
|
|
context::remove_sticky_context,
|
|
context::get_project_context,
|
|
context::extract_context_before_compacting,
|
|
context::log_context_failure,
|
|
context::get_full_context,
|
|
context::list_sticky_context,
|
|
// Voice-Interface
|
|
voice::transcribe_audio,
|
|
voice::text_to_speech,
|
|
voice::check_voice_availability,
|
|
voice::get_tts_voices,
|
|
// Hook-System
|
|
hooks::list_hooks,
|
|
hooks::set_hook_enabled,
|
|
hooks::get_hook_executions,
|
|
hooks::fire_hook,
|
|
// IDE-Connector (VSCodium)
|
|
ide::ide_connect,
|
|
ide::ide_disconnect,
|
|
ide::ide_status,
|
|
ide::ide_call,
|
|
// Programm-Steuerung (D-Bus, Xvfb, Playwright-Info)
|
|
programs::dbus_call,
|
|
programs::dbus_list_services,
|
|
programs::dbus_list_actions,
|
|
programs::dbus_run_action,
|
|
programs::capture_screenshot,
|
|
programs::xvfb_start,
|
|
programs::xvfb_stop,
|
|
programs::xvfb_status,
|
|
programs::xvfb_screenshot,
|
|
programs::playwright_info,
|
|
// Schulungsmodus (Phase 15)
|
|
teaching::presentation_open,
|
|
teaching::presentation_close,
|
|
teaching::presentation_send_slide,
|
|
teaching::presentation_clear,
|
|
// Chat-Fenster (herauslösen)
|
|
chat_window::chat_window_open,
|
|
chat_window::chat_window_close,
|
|
// Auto-Update
|
|
update::check_for_update,
|
|
update::download_update,
|
|
update::apply_update,
|
|
update::apply_bundle_update,
|
|
update::get_current_version,
|
|
// Clipboard-Watch
|
|
clipboard::clipboard_watch_start,
|
|
clipboard::clipboard_watch_stop,
|
|
clipboard::clipboard_watch_status,
|
|
// Slash-Command Registry
|
|
commands::get_slash_commands,
|
|
])
|
|
.setup(|app| {
|
|
let handle = app.handle().clone();
|
|
|
|
println!("🤖 Claude Desktop gestartet");
|
|
|
|
// Datenbank initialisieren
|
|
let app_dir = app.path().app_data_dir()
|
|
.expect("Konnte App-Datenverzeichnis nicht ermitteln");
|
|
std::fs::create_dir_all(&app_dir).ok();
|
|
let db_path = app_dir.join("claude-desktop.db");
|
|
println!("📦 Datenbank: {:?}", db_path);
|
|
|
|
let db = db::Database::open(&db_path)
|
|
.expect("Datenbank konnte nicht geöffnet werden");
|
|
app.manage(Arc::new(Mutex::new(db)));
|
|
|
|
// Guard-Rails: permanente Permissions aus DB laden
|
|
{
|
|
let db_state = handle.state::<Arc<Mutex<db::Database>>>();
|
|
let guard_state = handle.state::<guard::GuardState>();
|
|
let db_lock = db_state.lock().unwrap();
|
|
let mut guard_lock = guard_state.lock().unwrap();
|
|
if let Ok(perms) = db_lock.load_permissions() {
|
|
for p in perms {
|
|
guard_lock.add_permission(p);
|
|
}
|
|
println!("🛡️ {} permanente Permissions geladen", guard_lock.get_all_permissions().len());
|
|
}
|
|
}
|
|
|
|
// Gedächtnis-System laden
|
|
tauri::async_runtime::spawn(async move {
|
|
println!("🧠 Initialisiere Gedächtnis-System...");
|
|
});
|
|
|
|
// Tray-Icon einrichten
|
|
let show_item = MenuItem::with_id(app, "show", "Fenster zeigen", true, None::<&str>)?;
|
|
let hide_item = MenuItem::with_id(app, "hide", "Minimieren", true, None::<&str>)?;
|
|
let quit_item = MenuItem::with_id(app, "quit", "Beenden", true, None::<&str>)?;
|
|
|
|
let tray_menu = Menu::with_items(app, &[&show_item, &hide_item, &quit_item])?;
|
|
|
|
// App-Icon für Tray verwenden
|
|
let icon = app.default_window_icon()
|
|
.cloned()
|
|
.expect("Kein App-Icon konfiguriert");
|
|
|
|
let tray_icon = TrayIconBuilder::new()
|
|
.icon(icon)
|
|
.menu(&tray_menu)
|
|
.show_menu_on_left_click(false)
|
|
.tooltip("Claude Desktop")
|
|
.on_menu_event(|app, event| {
|
|
match event.id.as_ref() {
|
|
"show" => {
|
|
if let Some(window) = app.get_webview_window("main") {
|
|
let _ = window.show();
|
|
let _ = window.set_focus();
|
|
}
|
|
}
|
|
"hide" => {
|
|
if let Some(window) = app.get_webview_window("main") {
|
|
let _ = window.hide();
|
|
}
|
|
}
|
|
"quit" => {
|
|
app.exit(0);
|
|
}
|
|
_ => {}
|
|
}
|
|
})
|
|
.on_tray_icon_event(|tray, event| {
|
|
// Doppelklick auf Tray-Icon zeigt das Fenster
|
|
if let TrayIconEvent::Click { button: MouseButton::Left, button_state: MouseButtonState::Up, .. } = event {
|
|
if let Some(window) = tray.app_handle().get_webview_window("main") {
|
|
let _ = window.show();
|
|
let _ = window.set_focus();
|
|
}
|
|
}
|
|
})
|
|
.build(app)?;
|
|
|
|
// Tray-Icon Handle speichern (optional für späteren Zugriff)
|
|
app.manage(tray_icon);
|
|
println!("🔲 Tray-Icon eingerichtet");
|
|
|
|
// Lock-Datei erstellen (Instanz-Schutz + Update-Safety)
|
|
update::create_lock_file();
|
|
|
|
// Global Hotkey: Super+C öffnet Claude-Eingabe von überall
|
|
{
|
|
use tauri_plugin_global_shortcut::GlobalShortcutExt;
|
|
let hotkey_handle = app.handle().clone();
|
|
let _ = app.global_shortcut().on_shortcut("Super+C", move |_app, _shortcut, event| {
|
|
if event.state == tauri_plugin_global_shortcut::ShortcutState::Pressed {
|
|
if let Some(window) = hotkey_handle.get_webview_window("main") {
|
|
let _ = window.show();
|
|
let _ = window.unminimize();
|
|
let _ = window.set_focus();
|
|
let _ = hotkey_handle.emit("focus-chat-input", ());
|
|
}
|
|
}
|
|
});
|
|
println!("⌨️ Global Hotkey registriert: Super+C");
|
|
}
|
|
|
|
// WebKitGTK: Mikrofon-/Kamera-Permissions automatisch erlauben
|
|
#[cfg(target_os = "linux")]
|
|
{
|
|
if let Some(window) = app.get_webview_window("main") {
|
|
window.with_webview(|webview| {
|
|
use webkit2gtk::PermissionRequestExt;
|
|
|
|
let wv: webkit2gtk::WebView = webview.inner().clone();
|
|
wv.connect_permission_request(|_wv, request: &webkit2gtk::PermissionRequest| {
|
|
println!("🎤 WebKit Permission-Request → erlaubt");
|
|
request.allow();
|
|
true // Signal handled
|
|
});
|
|
println!("🎤 WebKit Permission-Handler registriert");
|
|
}).ok();
|
|
}
|
|
}
|
|
|
|
// Phase 3: Bridge sofort beim App-Start starten (kein Cold-Start bei erster Nachricht)
|
|
let bridge_handle = app.handle().clone();
|
|
tauri::async_runtime::spawn(async move {
|
|
match claude::start_bridge(&bridge_handle) {
|
|
Ok(()) => println!("🔌 Bridge beim Start initialisiert (warm)"),
|
|
Err(e) => println!("⚠️ Bridge-Start beim App-Start fehlgeschlagen: {} (wird bei erster Nachricht erneut versucht)", e),
|
|
}
|
|
});
|
|
|
|
Ok(())
|
|
})
|
|
.build(tauri::generate_context!())
|
|
.expect("Fehler beim Erstellen der App")
|
|
.run(|_app_handle, event| {
|
|
// Lock-Datei bei App-Beendigung aufräumen
|
|
if let tauri::RunEvent::Exit = event {
|
|
update::remove_lock_file();
|
|
println!("🔒 Lock-Datei aufgeräumt, App beendet.");
|
|
}
|
|
// Bei Fenster-Schließen: Lock entfernen falls App komplett beendet wird
|
|
if let tauri::RunEvent::WindowEvent {
|
|
event: tauri::WindowEvent::CloseRequested { .. },
|
|
..
|
|
} = event {
|
|
// Lock wird beim tatsächlichen Exit entfernt (RunEvent::Exit oben)
|
|
}
|
|
});
|
|
}
|