diff --git a/packages/kbot/dist-in/commands/images.js b/packages/kbot/dist-in/commands/images.js index 672eb78b..3fa9363f 100644 --- a/packages/kbot/dist-in/commands/images.js +++ b/packages/kbot/dist-in/commands/images.js @@ -159,8 +159,10 @@ async function launchGuiAndGetPrompt(argv) { apiKey: apiKey || null, files: absoluteIncludes }; - tauriProcess.stdin?.write(JSON.stringify(configResponse) + '\n'); - logger.info('📤 Sent config response to GUI'); + const jsonString = JSON.stringify(configResponse); + logger.info('📤 About to write to stdin:', jsonString); + tauriProcess.stdin?.write(jsonString + '\n'); + logger.info('📤 Sent config response to GUI', configResponse); // Send image data for (const imagePath of absoluteIncludes) { try { @@ -467,4 +469,4 @@ export const imageCommand = async (argv) => { logger.error('Failed to parse options or generate image:', error.message, error.issues, error.stack); } }; -//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"images.js","sourceRoot":"","sources":["../../src/commands/images.ts"],"names":[],"mappings":"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"} \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"images.js","sourceRoot":"","sources":["../../src/commands/images.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/packages/kbot/dist/win-64/tauri-app.exe b/packages/kbot/dist/win-64/tauri-app.exe index bd812cbf..568db815 100644 Binary files a/packages/kbot/dist/win-64/tauri-app.exe and b/packages/kbot/dist/win-64/tauri-app.exe differ diff --git a/packages/kbot/gui/tauri-app/src-tauri/src/handlers.rs b/packages/kbot/gui/tauri-app/src-tauri/src/handlers.rs new file mode 100644 index 00000000..40eb5863 --- /dev/null +++ b/packages/kbot/gui/tauri-app/src-tauri/src/handlers.rs @@ -0,0 +1,222 @@ +use tauri::{Manager, Emitter}; +use serde::{Serialize, Deserialize}; +use dirs; + +use crate::{log_json, Counter, DebugMessages, DebugPayload}; + +#[derive(Serialize, Deserialize)] +pub struct Payload { + pub prompt: String, + pub files: Vec, + pub dst: String, +} + +#[derive(Serialize, Deserialize)] +pub struct IPCMessage { + #[serde(rename = "type")] + pub message_type: String, + pub data: serde_json::Value, + pub timestamp: Option, + pub id: Option, +} + +// Core command handlers +#[tauri::command] +pub fn submit_prompt(prompt: &str, files: Vec, dst: &str, window: tauri::Window) { + log_json("info", "submit_prompt command called", Some(serde_json::json!({ + "prompt": prompt, + "files": files, + "dst": dst + }))); + + let payload = Payload { + prompt: prompt.to_string(), + files, + dst: dst.to_string(), + }; + let json_payload = serde_json::to_string(&payload).unwrap(); + + log_json("info", "Sending JSON payload to stdout", Some(serde_json::json!({ + "payload_length": json_payload.len() + }))); + println!("{}", json_payload); + let _ = window.app_handle().exit(0); +} + +#[tauri::command] +pub fn log_error_to_console(error: &str) { + eprintln!("[WebView ERROR forwarded]: {}", error); +} + +#[tauri::command] +pub fn resolve_path_relative_to_home(absolute_path: String) -> Result { + let home_dir = dirs::home_dir().ok_or_else(|| "Could not find home directory".to_string())?; + let path_to_resolve = std::path::Path::new(&absolute_path); + let relative_path = pathdiff::diff_paths(path_to_resolve, home_dir) + .ok_or_else(|| "Failed to calculate relative path from home directory".to_string())?; + Ok(relative_path.to_string_lossy().to_string()) +} + +// Debug message handlers +#[tauri::command] +pub fn add_debug_message(message: String, level: String, data: Option, state: tauri::State<'_, DebugMessages>) -> Result<(), String> { + log_json(&level, &format!("Frontend: {}", message), data.clone()); + + let debug_payload = DebugPayload { + level, + message, + data, + }; + + let mut messages = state.0.lock().unwrap(); + messages.push(debug_payload); + + if messages.len() > 100 { + let len = messages.len(); + messages.drain(0..len - 100); + } + + Ok(()) +} + +#[tauri::command] +pub fn get_debug_messages(state: tauri::State<'_, DebugMessages>) -> Result, String> { + let messages = state.0.lock().unwrap(); + Ok(messages.clone()) +} + +#[tauri::command] +pub fn clear_debug_messages(state: tauri::State<'_, DebugMessages>) -> Result<(), String> { + let mut messages = state.0.lock().unwrap(); + messages.clear(); + Ok(()) +} + +// Counter handlers (legacy) +#[tauri::command] +pub fn increment_counter(state: tauri::State<'_, Counter>) -> Result { + let mut counter = state.0.lock().unwrap(); + *counter += 1; + Ok(*counter) +} + +#[tauri::command] +pub fn get_counter(state: tauri::State<'_, Counter>) -> Result { + let counter = state.0.lock().unwrap(); + Ok(*counter) +} + +#[tauri::command] +pub fn reset_counter(state: tauri::State<'_, Counter>) -> Result { + let mut counter = state.0.lock().unwrap(); + *counter = 0; + Ok(0) +} + +// IPC communication handlers +#[tauri::command] +pub fn send_ipc_message(message_type: String, data: serde_json::Value, _window: tauri::Window) -> Result<(), String> { + let ipc_message = IPCMessage { + message_type, + data, + timestamp: Some(std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .unwrap() + .as_millis() as u64), + id: Some(format!("msg_{}_{}", + std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .unwrap() + .as_millis(), + rand::random::())), + }; + + let json_message = serde_json::to_string(&ipc_message).unwrap(); + println!("{}", json_message); + + Ok(()) +} + +#[tauri::command] +pub fn send_message_to_stdout(message: String) -> Result<(), String> { + println!("{}", message); + Ok(()) +} + +// Image generation handlers +#[tauri::command] +pub fn generate_image_via_backend(prompt: String, files: Vec, dst: String) -> Result<(), String> { + let request = serde_json::json!({ + "type": "generate_request", + "prompt": prompt, + "files": files, + "dst": dst, + "timestamp": std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .unwrap() + .as_millis() + }); + + println!("{}", serde_json::to_string(&request).unwrap()); + + Ok(()) +} + +#[tauri::command] +pub fn request_config_from_images(_app: tauri::AppHandle) -> Result<(), String> { + let request = serde_json::json!({ + "type": "config_request", + "timestamp": std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .unwrap() + .as_millis() + }); + + println!("{}", serde_json::to_string(&request).unwrap()); + + Ok(()) +} + +#[tauri::command] +pub fn request_file_deletion(path: String) -> Result<(), String> { + let request = serde_json::json!({ + "type": "delete_request", + "path": path, + }); + + println!("{}", serde_json::to_string(&request).unwrap()); + + Ok(()) +} + +// Legacy direct handlers (not used via stdin) +#[tauri::command] +pub fn forward_config_to_frontend(prompt: Option, dst: Option, api_key: Option, files: Vec, app: tauri::AppHandle) -> Result<(), String> { + let config_data = serde_json::json!({ + "prompt": prompt, + "dst": dst, + "apiKey": api_key, + "files": files + }); + + if let Err(e) = app.emit("config-received", &config_data) { + return Err(format!("Failed to emit config: {}", e)); + } + + Ok(()) +} + +#[tauri::command] +pub fn forward_image_to_frontend(base64: String, mime_type: String, filename: String, app: tauri::AppHandle) -> Result<(), String> { + let image_data = serde_json::json!({ + "base64": base64, + "mimeType": mime_type, + "filename": filename + }); + + if let Err(e) = app.emit("image-received", &image_data) { + return Err(format!("Failed to emit image: {}", e)); + } + + Ok(()) +} diff --git a/packages/kbot/gui/tauri-app/src-tauri/src/lib.rs b/packages/kbot/gui/tauri-app/src-tauri/src/lib.rs index bbe1fa2e..099d8098 100644 --- a/packages/kbot/gui/tauri-app/src-tauri/src/lib.rs +++ b/packages/kbot/gui/tauri-app/src-tauri/src/lib.rs @@ -1,6 +1,10 @@ -use tauri::{Manager, Emitter}; +use tauri::Manager; use serde::{Serialize, Deserialize}; -use dirs; + +mod handlers; +mod stdin_processor; + +pub use handlers::*; #[derive(Serialize)] struct LogMessage { @@ -11,7 +15,7 @@ struct LogMessage { timestamp: u64, } -fn log_json(level: &str, message: &str, data: Option) { +pub fn log_json(level: &str, message: &str, data: Option) { let log_msg = LogMessage { level: level.to_string(), message: message.to_string(), @@ -24,298 +28,17 @@ fn log_json(level: &str, message: &str, data: Option) { eprintln!("{}", serde_json::to_string(&log_msg).unwrap_or_else(|_| format!("{{\"level\":\"error\",\"message\":\"Failed to serialize log message\"}}"))); } -struct Counter(std::sync::Mutex); -struct DebugMessages(std::sync::Mutex>); - -#[derive(Serialize, Deserialize)] -struct Payload { - prompt: String, - files: Vec, - dst: String, -} - -#[derive(Serialize, Deserialize)] -struct IPCMessage { - #[serde(rename = "type")] - message_type: String, - data: serde_json::Value, - timestamp: Option, - id: Option, -} - -#[derive(Serialize, Deserialize)] -struct CounterPayload { - count: u32, - message: Option, -} +// App state structures +pub struct Counter(pub std::sync::Mutex); +pub struct DebugMessages(pub std::sync::Mutex>); #[derive(Serialize, Deserialize, Clone)] -struct DebugPayload { - level: String, - message: String, - data: Option, +pub struct DebugPayload { + pub level: String, + pub message: String, + pub data: Option, } -#[derive(Serialize, Deserialize)] -struct ImagePayload { - base64: String, - #[serde(rename = "mimeType")] - mime_type: String, - filename: Option, -} - -// Learn more about Tauri commands at https://tauri.app/develop/calling-rust/ -#[tauri::command] -fn submit_prompt(prompt: &str, files: Vec, dst: &str, window: tauri::Window) { - log_json("info", "submit_prompt command called", Some(serde_json::json!({ - "prompt": prompt, - "files": files, - "dst": dst - }))); - - let payload = Payload { - prompt: prompt.to_string(), - files, - dst: dst.to_string(), - }; - let json_payload = serde_json::to_string(&payload).unwrap(); - - log_json("info", "Sending JSON payload to stdout", Some(serde_json::json!({ - "payload_length": json_payload.len() - }))); - println!("{}", json_payload); // The actual payload - ONLY this should go to stdout - let _ = window.app_handle().exit(0); -} - -#[tauri::command] -fn log_error_to_console(error: &str) { - eprintln!("[WebView ERROR forwarded]: {}", error); -} - -#[tauri::command] -fn resolve_path_relative_to_home(absolute_path: String) -> Result { - eprintln!("[RUST LOG]: resolve_path_relative_to_home command called."); - eprintln!("[RUST LOG]: - Received absolute path: {}", absolute_path); - - let home_dir = dirs::home_dir().ok_or_else(|| "Could not find home directory".to_string())?; - - let path_to_resolve = std::path::Path::new(&absolute_path); - - let relative_path = pathdiff::diff_paths(path_to_resolve, home_dir) - .ok_or_else(|| "Failed to calculate relative path from home directory".to_string())?; - - let result = relative_path.to_string_lossy().to_string(); - eprintln!("[RUST LOG]: - Resolved to path relative to home: {}", result); - Ok(result) -} - -#[tauri::command] -fn increment_counter(state: tauri::State<'_, Counter>) -> Result { - eprintln!("[RUST LOG]: increment_counter command called."); - let mut counter = state.0.lock().unwrap(); - *counter += 1; - let current_value = *counter; - eprintln!("[RUST LOG]: - Counter incremented to: {}", current_value); - Ok(current_value) -} - -#[tauri::command] -fn get_counter(state: tauri::State<'_, Counter>) -> Result { - eprintln!("[RUST LOG]: get_counter command called."); - let counter = state.0.lock().unwrap(); - let current_value = *counter; - eprintln!("[RUST LOG]: - Current counter value: {}", current_value); - Ok(current_value) -} - -#[tauri::command] -fn reset_counter(state: tauri::State<'_, Counter>) -> Result { - eprintln!("[RUST LOG]: reset_counter command called."); - let mut counter = state.0.lock().unwrap(); - *counter = 0; - eprintln!("[RUST LOG]: - Counter reset to: 0"); - Ok(0) -} - -#[tauri::command] -fn add_debug_message(message: String, level: String, data: Option, state: tauri::State<'_, DebugMessages>) -> Result<(), String> { - // Forward frontend debug messages to CLI via structured logging - log_json(&level, &format!("Frontend: {}", message), data.clone()); - - let debug_payload = DebugPayload { - level, - message, - data, - }; - - let mut messages = state.0.lock().unwrap(); - messages.push(debug_payload); - - // Keep only the last 100 messages to prevent memory issues - if messages.len() > 100 { - let len = messages.len(); - messages.drain(0..len - 100); - } - - Ok(()) -} - -#[tauri::command] -fn get_debug_messages(state: tauri::State<'_, DebugMessages>) -> Result, String> { - eprintln!("[RUST LOG]: get_debug_messages command called."); - let messages = state.0.lock().unwrap(); - let result = messages.clone(); - eprintln!("[RUST LOG]: - Returning {} debug messages", result.len()); - Ok(result) -} - -#[tauri::command] -fn clear_debug_messages(state: tauri::State<'_, DebugMessages>) -> Result<(), String> { - eprintln!("[RUST LOG]: clear_debug_messages command called."); - let mut messages = state.0.lock().unwrap(); - messages.clear(); - eprintln!("[RUST LOG]: - Debug messages cleared"); - Ok(()) -} - -#[tauri::command] -fn send_ipc_message(message_type: String, data: serde_json::Value, _window: tauri::Window) -> Result<(), String> { - eprintln!("[RUST LOG]: send_ipc_message command called."); - eprintln!("[RUST LOG]: - Type: {}", message_type); - eprintln!("[RUST LOG]: - Data: {}", data); - - let ipc_message = IPCMessage { - message_type, - data, - timestamp: Some(std::time::SystemTime::now() - .duration_since(std::time::UNIX_EPOCH) - .unwrap() - .as_millis() as u64), - id: Some(format!("msg_{}_{}", - std::time::SystemTime::now() - .duration_since(std::time::UNIX_EPOCH) - .unwrap() - .as_millis(), - rand::random::())), - }; - - let json_message = serde_json::to_string(&ipc_message).unwrap(); - eprintln!("[RUST LOG]: - Sending IPC message to stdout: {}", json_message); - println!("{}", json_message); - - Ok(()) -} - -#[tauri::command] -fn send_message_to_stdout(message: String) -> Result<(), String> { - eprintln!("[RUST LOG]: send_message_to_stdout command called."); - eprintln!("[RUST LOG]: - Message: {}", message); - - // Send directly to stdout (this will be captured by images.ts) - println!("{}", message); - - Ok(()) -} - -#[tauri::command] -fn generate_image_via_backend(prompt: String, files: Vec, dst: String) -> Result<(), String> { - eprintln!("[RUST LOG]: generate_image_via_backend called"); - eprintln!("[RUST LOG]: - Prompt: {}", prompt); - eprintln!("[RUST LOG]: - Files: {:?}", files); - eprintln!("[RUST LOG]: - Dst: {}", dst); - - // Send generation request to images.ts via stdout - let request = serde_json::json!({ - "type": "generate_request", - "prompt": prompt, - "files": files, - "dst": dst, - "timestamp": std::time::SystemTime::now() - .duration_since(std::time::UNIX_EPOCH) - .unwrap() - .as_millis() - }); - - println!("{}", serde_json::to_string(&request).unwrap()); - eprintln!("[RUST LOG]: Generation request sent to images.ts"); - - Ok(()) -} - -#[tauri::command] -fn request_config_from_images(_app: tauri::AppHandle) -> Result<(), String> { - eprintln!("[RUST LOG]: request_config_from_images called"); - - // Send request to images.ts via stdout - let request = serde_json::json!({ - "type": "config_request", - "timestamp": std::time::SystemTime::now() - .duration_since(std::time::UNIX_EPOCH) - .unwrap() - .as_millis() - }); - - println!("{}", serde_json::to_string(&request).unwrap()); - eprintln!("[RUST LOG]: Config request sent to images.ts"); - - Ok(()) -} - -#[tauri::command] -fn forward_config_to_frontend(prompt: Option, dst: Option, api_key: Option, files: Vec, app: tauri::AppHandle) -> Result<(), String> { - eprintln!("[RUST LOG]: forward_config_to_frontend called"); - - let config_data = serde_json::json!({ - "prompt": prompt, - "dst": dst, - "apiKey": api_key, - "files": files - }); - - if let Err(e) = app.emit("config-received", &config_data) { - eprintln!("[RUST LOG]: Failed to emit config-received: {}", e); - return Err(format!("Failed to emit config: {}", e)); - } - - eprintln!("[RUST LOG]: Config forwarded to frontend successfully"); - Ok(()) -} - -#[tauri::command] -fn forward_image_to_frontend(base64: String, mime_type: String, filename: String, app: tauri::AppHandle) -> Result<(), String> { - eprintln!("[RUST LOG]: forward_image_to_frontend called for {}", filename); - - let image_data = serde_json::json!({ - "base64": base64, - "mimeType": mime_type, - "filename": filename - }); - - if let Err(e) = app.emit("image-received", &image_data) { - eprintln!("[RUST LOG]: Failed to emit image-received: {}", e); - return Err(format!("Failed to emit image: {}", e)); - } - - eprintln!("[RUST LOG]: Image forwarded to frontend successfully"); - Ok(()) -} - -#[tauri::command] -fn request_file_deletion(path: String) -> Result<(), String> { - log_json("info", "request_file_deletion command called", Some(serde_json::json!({ - "path": path - }))); - - let request = serde_json::json!({ - "type": "delete_request", - "path": path, - }); - - println!("{}", serde_json::to_string(&request).unwrap()); - log_json("info", "Deletion request sent to images.ts", None); - - Ok(()) -} #[cfg_attr(mobile, tauri::mobile_entry_point)] pub fn run() { @@ -352,153 +75,9 @@ pub fn run() { } let app_handle = app.handle().clone(); - - // Test our new JSON logging - log_json("info", "Tauri app starting with improved logging", Some(serde_json::json!({ - "test": true, - "message": "This is a test of the new structured logging system" - }))); - - // Listen for stdin commands from images.ts - std::thread::spawn(move || { - use std::io::{self, BufRead, BufReader}; - let stdin = io::stdin(); - let reader = BufReader::new(stdin); - - log_json("info", "Stdin listener thread started", None); - - for line in reader.lines() { - if let Ok(line_content) = line { - if line_content.trim().is_empty() { - continue; - } - - // Log stdin command but hide binary data - if line_content.contains("\"base64\"") { - log_json("debug", "Received stdin command with base64 data", Some(serde_json::json!({ - "content_length": line_content.len() - }))); - } else { - log_json("debug", "Received stdin command", Some(serde_json::json!({ - "content": line_content - }))); - } - - // Parse command from images.ts - if let Ok(command) = serde_json::from_str::(&line_content) { - if let Some(cmd) = command.get("cmd").and_then(|v| v.as_str()) { - log_json("info", "Processing command", Some(serde_json::json!({ - "command": cmd - }))); - - match cmd { - "forward_config_to_frontend" => { - log_json("info", "Forwarding config to frontend", Some(serde_json::json!({ - "has_prompt": command.get("prompt").is_some(), - "has_dst": command.get("dst").is_some(), - "has_api_key": command.get("apiKey").is_some(), - "file_count": command.get("files").and_then(|f| f.as_array()).map(|a| a.len()).unwrap_or(0) - }))); - - let config_data = serde_json::json!({ - "prompt": command.get("prompt"), - "dst": command.get("dst"), - "apiKey": command.get("apiKey"), - "files": command.get("files") - }); - - if let Err(e) = app_handle.emit("config-received", &config_data) { - log_json("error", "Failed to emit config-received", Some(serde_json::json!({ - "error": e.to_string() - }))); - } else { - log_json("info", "Config emitted successfully to frontend", None); - } - } - "forward_image_to_frontend" => { - if let (Some(filename), Some(base64), Some(mime_type)) = ( - command.get("filename").and_then(|v| v.as_str()), - command.get("base64").and_then(|v| v.as_str()), - command.get("mimeType").and_then(|v| v.as_str()) - ) { - log_json("info", "Forwarding image to frontend", Some(serde_json::json!({ - "filename": filename, - "mime_type": mime_type, - "base64_size": base64.len() - }))); - let image_data = serde_json::json!({ - "base64": base64, - "mimeType": mime_type, - "filename": filename - }); - - if let Err(e) = app_handle.emit("image-received", &image_data) { - log_json("error", "Failed to emit image-received", Some(serde_json::json!({ - "error": e.to_string(), - "filename": filename - }))); - } else { - log_json("info", "Image emitted successfully", Some(serde_json::json!({ - "filename": filename - }))); - } - } - } - "generation_result" => { - eprintln!("[RUST LOG]: Forwarding generation result to frontend"); - if let Err(e) = app_handle.emit("generation-result", &command) { - eprintln!("[RUST LOG]: Failed to emit generation-result: {}", e); - } else { - eprintln!("[RUST LOG]: Generation result emitted successfully"); - } - } - "generation_error" => { - eprintln!("[RUST LOG]: Forwarding generation error to frontend"); - if let Err(e) = app_handle.emit("generation-error", &command) { - eprintln!("[RUST LOG]: Failed to emit generation-error: {}", e); - } else { - eprintln!("[RUST LOG]: Generation error emitted successfully"); - } - } - "generation_complete" => { - eprintln!("[RUST LOG]: Generation completed successfully"); - if let Err(e) = app_handle.emit("generation-complete", &command) { - eprintln!("[RUST LOG]: Failed to emit generation-complete: {}", e); - } else { - eprintln!("[RUST LOG]: Generation complete emitted successfully"); - } - } - "file_deleted_successfully" => { - if let Some(path) = command.get("path").and_then(|v| v.as_str()) { - eprintln!("[RUST LOG]: Received confirmation of file deletion: {}", path); - if let Err(e) = app_handle.emit("file-deleted-successfully", &serde_json::json!({ "path": path })) { - eprintln!("[RUST LOG]: Failed to emit file-deleted-successfully: {}", e); - } - } - } - "file_deletion_error" => { - if let (Some(path), Some(error)) = ( - command.get("path").and_then(|v| v.as_str()), - command.get("error").and_then(|v| v.as_str()) - ) { - eprintln!("[RUST LOG]: Received file deletion error for {}: {}", path, error); - if let Err(e) = app_handle.emit("file-deletion-error", &serde_json::json!({ "path": path, "error": error })) { - eprintln!("[RUST LOG]: Failed to emit file-deletion-error: {}", e); - } - } - } - _ => { - eprintln!("[RUST LOG]: Unknown command: {}", cmd); - } - } - } - } else { - eprintln!("[RUST LOG]: Failed to parse command as JSON"); - } - } - } - eprintln!("[RUST LOG]: Stdin listener thread ended"); - }); + + // Start stdin listener in separate module + stdin_processor::start_stdin_listener(app_handle); Ok(()) }) diff --git a/packages/kbot/gui/tauri-app/src-tauri/src/stdin_processor.rs b/packages/kbot/gui/tauri-app/src-tauri/src/stdin_processor.rs new file mode 100644 index 00000000..0642f496 --- /dev/null +++ b/packages/kbot/gui/tauri-app/src-tauri/src/stdin_processor.rs @@ -0,0 +1,158 @@ +use tauri::Emitter; +use std::io::{BufRead, BufReader}; + +use crate::log_json; + +pub fn start_stdin_listener(app_handle: tauri::AppHandle) { + std::thread::spawn(move || { + let stdin = std::io::stdin(); + let reader = BufReader::new(stdin); + + + for line in reader.lines() { + if let Ok(line_content) = line { + if line_content.trim().is_empty() { + continue; + } + + // Parse command from images.ts + if let Ok(command) = serde_json::from_str::(&line_content) { + if let Some(cmd) = command.get("cmd").and_then(|v| v.as_str()) { + log_json("info", "Processing command", Some(serde_json::json!({ + "command": cmd + }))); + + match cmd { + "forward_config_to_frontend" => { + handle_config_forward(&command, &app_handle); + } + "forward_image_to_frontend" => { + handle_image_forward(&command, &app_handle); + } + "generation_result" => { + if let Err(e) = app_handle.emit("generation-result", &command) { + log_json("error", "Failed to emit generation-result", Some(serde_json::json!({ + "error": e.to_string() + }))); + } + } + "generation_error" => { + if let Err(e) = app_handle.emit("generation-error", &command) { + log_json("error", "Failed to emit generation-error", Some(serde_json::json!({ + "error": e.to_string() + }))); + } + } + "generation_complete" => { + if let Err(e) = app_handle.emit("generation-complete", &command) { + log_json("error", "Failed to emit generation-complete", Some(serde_json::json!({ + "error": e.to_string() + }))); + } + } + "file_deleted_successfully" => { + if let Some(path) = command.get("path").and_then(|v| v.as_str()) { + if let Err(e) = app_handle.emit("file-deleted-successfully", &serde_json::json!({ "path": path })) { + log_json("error", "Failed to emit file-deleted-successfully", Some(serde_json::json!({ + "error": e.to_string() + }))); + } + } + } + "file_deletion_error" => { + if let (Some(path), Some(error)) = ( + command.get("path").and_then(|v| v.as_str()), + command.get("error").and_then(|v| v.as_str()) + ) { + if let Err(e) = app_handle.emit("file-deletion-error", &serde_json::json!({ "path": path, "error": error })) { + log_json("error", "Failed to emit file-deletion-error", Some(serde_json::json!({ + "error": e.to_string() + }))); + } + } + } + _ => { + log_json("warn", "Unknown command received", Some(serde_json::json!({ + "command": cmd + }))); + } + } + } + } else { + log_json("warn", "Failed to parse stdin as JSON", Some(serde_json::json!({ + "content_length": line_content.len() + }))); + } + } + } + + log_json("info", "Stdin listener thread ended", None); + }); +} + +fn handle_config_forward(command: &serde_json::Value, app_handle: &tauri::AppHandle) { + log_json("info", "Forwarding config to frontend", Some(serde_json::json!({ + "has_prompt": command.get("prompt").is_some(), + "has_dst": command.get("dst").is_some(), + "has_api_key": command.get("apiKey").is_some(), + "file_count": command.get("files").and_then(|f| f.as_array()).map(|a| a.len()).unwrap_or(0) + }))); + + // Extract values, handling both null and undefined + let prompt = command.get("prompt") + .and_then(|v| if v.is_null() { None } else { v.as_str().map(|s| s.to_string()) }); + let dst = command.get("dst") + .and_then(|v| if v.is_null() { None } else { v.as_str().map(|s| s.to_string()) }); + let api_key = command.get("apiKey") + .and_then(|v| if v.is_null() { None } else { v.as_str().map(|s| s.to_string()) }); + let files = command.get("files") + .and_then(|v| v.as_array()) + .map(|arr| arr.iter().filter_map(|f| f.as_str().map(|s| s.to_string())).collect::>()) + .unwrap_or_else(Vec::new); + + let config_data = serde_json::json!({ + "prompt": prompt, + "dst": dst, + "apiKey": api_key, + "files": files + }); + + if let Err(e) = app_handle.emit("config-received", &config_data) { + log_json("error", "Failed to emit config-received", Some(serde_json::json!({ + "error": e.to_string() + }))); + } else { + log_json("info", "Config emitted successfully to frontend", None); + } +} + +fn handle_image_forward(command: &serde_json::Value, app_handle: &tauri::AppHandle) { + if let (Some(filename), Some(base64), Some(mime_type)) = ( + command.get("filename").and_then(|v| v.as_str()), + command.get("base64").and_then(|v| v.as_str()), + command.get("mimeType").and_then(|v| v.as_str()) + ) { + log_json("info", "Forwarding image to frontend", Some(serde_json::json!({ + "filename": filename, + "mime_type": mime_type, + "base64_size": base64.len() + }))); + + let image_data = serde_json::json!({ + "base64": base64, + "mimeType": mime_type, + "filename": filename + }); + + if let Err(e) = app_handle.emit("image-received", &image_data) { + log_json("error", "Failed to emit image-received", Some(serde_json::json!({ + "error": e.to_string(), + "filename": filename + }))); + } else { + log_json("info", "Image emitted successfully", Some(serde_json::json!({ + "filename": filename + }))); + } + } +} diff --git a/packages/kbot/gui/tauri-app/src/App.tsx b/packages/kbot/gui/tauri-app/src/App.tsx index d3863ffc..82e0cfbc 100644 --- a/packages/kbot/gui/tauri-app/src/App.tsx +++ b/packages/kbot/gui/tauri-app/src/App.tsx @@ -26,7 +26,7 @@ function App() { const [apiKey, setApiKey] = useState(""); const [isDarkMode, setIsDarkMode] = useState(false); const [debugMessages, setDebugMessages] = useState([]); - const [showDebugPanel, setShowDebugPanel] = useState(true); // Default open for debugging + const [showDebugPanel, setShowDebugPanel] = useState(false); // Hidden in production // Initialize logging system and connect to UI useEffect(() => { @@ -140,10 +140,6 @@ function App() { } }; - // Legacy function for compatibility - just use log directly now - const addDebugMessage = (level: 'info' | 'warn' | 'error' | 'debug', message: string, data?: any) => { - log[level](message, data); - }; const addImageFromUrl = async (url: string) => { try { @@ -416,7 +412,7 @@ function App() { await generateImage(prompt, imagesToUse); // Don't clear prompt - let user iterate } else { - addDebugMessage('error', 'API key required for image generation'); + log.error('API key required for image generation'); } } @@ -591,7 +587,6 @@ function App() { {showDebugPanel && ( maxDepth) { + return '[Max depth reached]'; + } + + if (value === null || value === undefined) { + return value; + } + + if (typeof value !== 'object') { + return value; + } + + if (seen.has(value)) { + return '[Circular Reference]'; + } + + seen.add(value); + + if (Array.isArray(value)) { + return value.slice(0, 10).map((item, index) => { + if (index >= 10) return '[Truncated]'; + return serialize(item, depth + 1); + }); + } + + const result: any = {}; + const keys = Object.keys(value).slice(0, 20); // Limit keys + + for (const key of keys) { + try { + result[key] = serialize(value[key], depth + 1); + } catch (e) { + result[key] = '[Serialization Error]'; + } + } + + if (Object.keys(value).length > 20) { + result['[truncated]'] = `${Object.keys(value).length - 20} more keys...`; + } + + return result; + } + + try { + return JSON.stringify(serialize(obj, 0), null, 2); + } catch (e) { + return `[Serialization failed: ${e instanceof Error ? e.message : 'Unknown error'}]`; + } +} interface DebugPanelProps { debugMessages: any[]; - addDebugMessage: (level: 'info' | 'warn' | 'error' | 'debug', message: string, data?: any) => void; sendIPCMessage: (messageType: string, data: any) => void; clearDebugMessages: () => void; ipcInitialized: boolean; @@ -14,7 +69,6 @@ interface DebugPanelProps { const DebugPanel: React.FC = ({ debugMessages, - addDebugMessage, sendIPCMessage, clearDebugMessages, ipcInitialized, @@ -39,7 +93,7 @@ const DebugPanel: React.FC = ({ ? await tauriApi.path.join(dataDir, '.kbot-gui.json') : 'N/A'; - addDebugMessage('info', 'System Info & Store Paths', { + log.info('System Info & Store Paths', { platform: navigator.platform, userAgent: navigator.userAgent, isTauri: tauriApi.isTauri(), @@ -50,7 +104,7 @@ const DebugPanel: React.FC = ({ windowLocation: window.location.href }); } catch (error) { - addDebugMessage('error', 'Failed to get system info', { error: (error as Error).message }); + log.error('Failed to get system info', { error: (error as Error).message }); } }} className="glass-button text-sm px-4 py-2 rounded-lg" @@ -58,7 +112,7 @@ const DebugPanel: React.FC = ({ Test Info