@pheem49/mint 1.9.0 → 1.10.0

package/crates/mint-core/src/api_server.rs

@@ -4,6 +4,7 @@ use std::{
     process::{Command, Stdio},
 };
 
+use base64::{Engine as _, engine::general_purpose::STANDARD as BASE64};
 use serde::Deserialize;
 use serde_json::{Value, json};
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
@@ -11,23 +12,48 @@ use tokio::net::TcpListener;
 
 use crate::{
     AgentProgress, ApprovalOutcome, ChatRequest, ChatResponse, DEFAULT_CONVERSATION_ID,
-    ImageGenRequest, MemoryStore, MintConfig, config_path, create_folder, find_paths,
-    generate_images, list_saved_pictures, load_config, orchestrate_agent_loop,
-    orchestrate_chat_stream_with_fallback, orchestrate_chat_with_fallback, save_chat_images,
-    save_config, weather,
+    ImageGenRequest, MemoryStore, MintConfig, VideoGenRequest, config_path, create_folder,
+    find_paths, generate_images, generate_video, list_saved_pictures, load_config,
+    orchestrate_agent_loop, orchestrate_chat_stream_with_fallback, orchestrate_chat_with_fallback,
+    save_chat_images, save_config, weather,
 };
 
 const MAX_API_REQUEST_BYTES: usize = 32 * 1024 * 1024;
 
+pub(crate) fn log_api_req(method: &str, route: &str, status: &str, info: Option<&str>) {
+    let timestamp = chrono::Local::now().format("%H:%M:%S");
+    let status_str = if status.starts_with('2') {
+        format!("\x1b[32m{}\x1b[0m", status)
+    } else if status.starts_with('4') || status.starts_with('5') {
+        format!("\x1b[1;31m{}\x1b[0m", status)
+    } else {
+        format!("\x1b[33m{}\x1b[0m", status)
+    };
+    if let Some(detail) = info {
+        println!(
+            "\x1b[90m[{}]\x1b[0m \x1b[1;36m[API]\x1b[0m \x1b[1m{}\x1b[0m {} -> {} \x1b[90m({})\x1b[0m",
+            timestamp, method, route, status_str, detail
+        );
+    } else {
+        println!(
+            "\x1b[90m[{}]\x1b[0m \x1b[1;36m[API]\x1b[0m \x1b[1m{}\x1b[0m {} -> {}",
+            timestamp, method, route, status_str
+        );
+    }
+}
+
+pub(crate) fn log_api_err(context: &str, error: &dyn std::fmt::Display) {
+    let timestamp = chrono::Local::now().format("%H:%M:%S");
+    eprintln!(
+        "\x1b[90m[{}]\x1b[0m \x1b[1;31m[ERROR]\x1b[0m \x1b[1;33m{}\x1b[0m: {}",
+        timestamp, context, error
+    );
+}
+
 pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
     let addr = SocketAddr::from(([0, 0, 0, 0], port));
     let listener = TcpListener::bind(addr).await?;
-    println!("\x1b[36m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\x1b[0m");
-    println!(
-        "\x1b[32m       Mint Local API Server running at http://{}\x1b[0m",
-        addr
-    );
-    println!("\x1b[36m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\x1b[0m");
+    // API server banner removed to prevent duplicate output
 
     // Start background messaging bridges (Telegram, Discord, Slack)
     crate::start_channels();
@@ -125,6 +151,19 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
 
             let (route, query) = path.split_once('?').unwrap_or((path, ""));
 
+            if route.starts_with("/api/")
+                && !route.starts_with("/api/pictures/")
+                && !route.starts_with("/api/thumbnails/")
+                && route != "/api/chat"
+                && route != "/api/chat-stream"
+                && route != "/api/image-generate"
+                && route != "/api/video-generate"
+                && route != "/api/action"
+                && route != "/api/config"
+            {
+                log_api_req(method, route, "200 OK", None);
+            }
+
             match (method, route) {
                 ("GET", "/api/status") => {
                     let config = load_config().unwrap_or_default();
@@ -230,6 +269,48 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
                     )
                     .await;
                 }
+                ("GET", "/api/learned-skills") => {
+                    let mut skills = match MemoryStore::open_default() {
+                        Ok(m) => m.learned_skills(100).unwrap_or_default(),
+                        Err(_) => Vec::new(),
+                    };
+
+                    if let Some(home) = dirs::home_dir() {
+                        let global_agents_path =
+                            home.join(".gemini").join("config").join("AGENTS.md");
+                        crate::skills::load_agent_rules_file(&global_agents_path, &mut skills);
+
+                        let global_skills_path =
+                            home.join(".config").join("mint").join("mint-skills");
+                        crate::skills::load_skills_from_dir(&global_skills_path, &mut skills);
+                    }
+
+                    if let Ok(current_dir) = std::env::current_dir() {
+                        let workspace_agents_path1 = current_dir.join(".agents").join("AGENTS.md");
+                        crate::skills::load_agent_rules_file(&workspace_agents_path1, &mut skills);
+                        let workspace_agents_path2 = current_dir.join("AGENTS.md");
+                        crate::skills::load_agent_rules_file(&workspace_agents_path2, &mut skills);
+
+                        let workspace_skills_path1 = current_dir.join(".agents").join("skills");
+                        crate::skills::load_skills_from_dir(&workspace_skills_path1, &mut skills);
+                        let workspace_skills_path2 = current_dir.join("skills");
+                        crate::skills::load_skills_from_dir(&workspace_skills_path2, &mut skills);
+                    }
+
+                    let mut unique_skills = std::collections::BTreeMap::new();
+                    for s in skills {
+                        unique_skills.insert(s.name.clone(), s);
+                    }
+
+                    let list: Vec<_> = unique_skills.into_values().collect();
+                    send_json_response(
+                        socket,
+                        "200 OK",
+                        &serde_json::to_string(&list).unwrap_or_default(),
+                    )
+                    .await;
+                    return;
+                }
                 ("GET", "/api/profile") => {
                     let key = query_param(query, "key").unwrap_or_default();
                     if let Ok(memory) = MemoryStore::open_default() {
@@ -265,6 +346,35 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
                     )
                     .await;
                 }
+                ("POST", "/api/active-model") => {
+                    #[derive(Deserialize)]
+                    struct ActiveModelReq {
+                        provider: String,
+                        model: Option<String>,
+                    }
+                    if let Ok(req) = serde_json::from_str::<ActiveModelReq>(body)
+                        && let Ok(mut config) = load_config()
+                    {
+                        if let Ok(display_name) =
+                            config.set_active_model(&req.provider, req.model.as_deref())
+                        {
+                            send_json_response(
+                                socket,
+                                "200 OK",
+                                &serde_json::json!({ "status": "ok", "displayName": display_name })
+                                    .to_string(),
+                            )
+                            .await;
+                            return;
+                        }
+                    }
+                    send_json_response(
+                        socket,
+                        "500 Internal Server Error",
+                        "{\"status\":\"error\"}",
+                    )
+                    .await;
+                }
                 ("POST", "/api/interactions/clear") => {
                     if let Ok(memory) = MemoryStore::open_default() {
                         let chat_id = query_param(query, "chatId")
@@ -286,6 +396,7 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
                     struct ApiSaveInteraction {
                         chat_id: String,
                         user_text: String,
+                        ai_text: Option<String>,
                         provider: String,
                         model: String,
                     }
@@ -295,7 +406,7 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
                             match memory.add_interaction_for_chat(
                                 &req.chat_id,
                                 &req.user_text,
-                                "",
+                                req.ai_text.as_deref().unwrap_or(""),
                                 &req.provider,
                                 &req.model,
                             ) {
@@ -389,6 +500,22 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
                         }
                     }
                 }
+                ("GET", route) if route.starts_with("/api/thumbnails/") => {
+                    let filename = percent_decode(route.trim_start_matches("/api/thumbnails/"));
+                    match thumbnail_bytes(&filename) {
+                        Ok((mime_type, bytes)) => {
+                            send_binary_response(socket, "200 OK", &mime_type, &bytes).await
+                        }
+                        Err(_) => {
+                            send_json_response(
+                                socket,
+                                "404 Not Found",
+                                "{\"error\":\"thumbnail not found\"}",
+                            )
+                            .await
+                        }
+                    }
+                }
                 ("GET", "/api/config") => {
                     let config = load_config().unwrap_or_default();
                     if let Ok(json_str) = serde_json::to_string(&config) {
@@ -458,6 +585,71 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
                         .await;
                     }
                 }
+                ("POST", "/api/uploads") => {
+                    // Accept raw body bytes and optional filename query param.
+                    // Body is the raw file bytes (client should POST the file as the request body).
+                    let filename_param = query_param(query, "filename");
+                    let header_end_idx = header_end as usize;
+                    // extract raw bytes for body
+                    let body_bytes = &request_bytes[header_end_idx + 4..];
+
+                    if body_bytes.is_empty() {
+                        send_json_response(socket, "400 Bad Request", "{\"error\":\"empty body\"}")
+                            .await;
+                        return;
+                    }
+
+                    // Determine mime type from filename or fallback to video/mp4
+                    let (mime_type, _extension) = filename_param
+                        .as_deref()
+                        .and_then(|f| f.rsplit_once('.'))
+                        .map(|(_, ext)| {
+                            let e = ext.to_ascii_lowercase();
+                            match e.as_str() {
+                                "mp4" => ("video/mp4", "mp4"),
+                                "webm" => ("video/webm", "webm"),
+                                "mov" => ("video/quicktime", "mov"),
+                                "mkv" => ("video/x-matroska", "mkv"),
+                                "avi" => ("video/x-msvideo", "avi"),
+                                _ => ("application/octet-stream", "bin"),
+                            }
+                        })
+                        .unwrap_or(("video/mp4", "mp4"));
+
+                    // Build data URI and reuse save_chat_images helper to persist and index file
+                    let encoded = BASE64.encode(body_bytes);
+                    let data_uri = format!("data:{};base64,{}", mime_type, encoded);
+                    match save_chat_images(
+                        vec![data_uri],
+                        Some("upload".into()),
+                        Some("uploaded".into()),
+                    ) {
+                        Ok(saved) => {
+                            if let Some(entry) = saved.into_iter().next() {
+                                let res_json = json!({ "url": format!("/api/pictures/{}", entry.filename), "filename": entry.filename });
+                                send_json_response(socket, "200 OK", &res_json.to_string()).await;
+                                return;
+                            }
+                        }
+                        Err(err) => {
+                            let err_json = json!({ "error": err.to_string() });
+                            send_json_response(
+                                socket,
+                                "500 Internal Server Error",
+                                &err_json.to_string(),
+                            )
+                            .await;
+                            return;
+                        }
+                    }
+                    send_json_response(
+                        socket,
+                        "500 Internal Server Error",
+                        "{\"error\":\"failed to save upload\"}",
+                    )
+                    .await;
+                }
+
                 ("POST", "/api/chat") => {
                     #[derive(Deserialize)]
                     #[serde(rename_all = "camelCase")]
@@ -467,6 +659,7 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
                         chat_id: Option<String>,
                         image_data_uri: Option<String>,
                         audio_data_uri: Option<String>,
+                        video_data_uri: Option<String>,
                         document_attachment: Option<crate::chat::DocumentAttachment>,
                         agent_id: Option<String>,
                     }
@@ -479,6 +672,7 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
                             chat_id: req.chat_id,
                             image_data_uri: req.image_data_uri,
                             audio_data_uri: req.audio_data_uri,
+                            video_data_uri: req.video_data_uri,
                             document_attachment: req.document_attachment,
                             workspace_path: None,
                             agent_id: req.agent_id,
@@ -486,6 +680,7 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
                         let mut chat_req =
                             chat_req.with_document_context(&config).unwrap_or(chat_req);
                         let sent_image = chat_req.image_data_uri.clone();
+                        let sent_video = chat_req.video_data_uri.clone();
                         let sent_message = chat_req.message.clone();
 
                         let response = if let Some(clean_message) =
@@ -505,6 +700,12 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
 
                         match response {
                             Ok(resp) => {
+                                log_api_req(
+                                    "POST",
+                                    "/api/chat",
+                                    "200 OK",
+                                    Some(&format!("Model: {}", config.ai_provider)),
+                                );
                                 if let Some(image) = sent_image {
                                     let _ = save_chat_images(
                                         image
@@ -512,6 +713,16 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
                                             .map(str::to_owned)
                                             .collect::<Vec<_>>(),
                                         Some("web".into()),
+                                        Some(sent_message.clone()),
+                                    );
+                                }
+                                if let Some(video) = sent_video {
+                                    let _ = save_chat_images(
+                                        video
+                                            .split_whitespace()
+                                            .map(str::to_owned)
+                                            .collect::<Vec<_>>(),
+                                        Some("web".into()),
                                         Some(sent_message),
                                     );
                                 }
@@ -521,7 +732,7 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
                                 }
                             }
                             Err(e) => {
-                                eprintln!("API Chat error: {:?}", e);
+                                log_api_err("API /api/chat error", &e);
                                 let err_json = serde_json::json!({
                                     "provider": "error",
                                     "model": "error",
@@ -571,6 +782,7 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
                         chat_id: Option<String>,
                         image_data_uri: Option<String>,
                         audio_data_uri: Option<String>,
+                        video_data_uri: Option<String>,
                         document_attachment: Option<crate::chat::DocumentAttachment>,
                         agent_id: Option<String>,
                     }
@@ -583,6 +795,7 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
                             chat_id: req.chat_id,
                             image_data_uri: req.image_data_uri,
                             audio_data_uri: req.audio_data_uri,
+                            video_data_uri: req.video_data_uri,
                             document_attachment: req.document_attachment,
                             workspace_path: None,
                             agent_id: req.agent_id,
@@ -590,6 +803,7 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
                         let mut chat_req =
                             chat_req.with_document_context(&config).unwrap_or(chat_req);
                         let sent_image = chat_req.image_data_uri.clone();
+                        let sent_video = chat_req.video_data_uri.clone();
                         let sent_message = chat_req.message.clone();
 
                         let is_chat = if let Some(clean_message) =
@@ -666,6 +880,15 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
 
                                         match result {
                                             Ok((response, _)) => {
+                                                log_api_req(
+                                                    "POST",
+                                                    "/api/chat-stream",
+                                                    "200 OK",
+                                                    Some(&format!(
+                                                        "Provider: {}",
+                                                        config_clone.ai_provider
+                                                    )),
+                                                );
                                                 if let Ok(json_val) =
                                                     serde_json::to_string(&serde_json::json!({
                                                         "type": "done",
@@ -676,7 +899,7 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
                                                 }
                                             }
                                             Err(e) => {
-                                                eprintln!("API Chat Stream error: {:?}", e);
+                                                log_api_err("API /api/chat-stream error", &e);
                                                 let err_json = serde_json::json!({
                                                     "type": "done",
                                                     "response": {
@@ -722,6 +945,7 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
                                     let chat_id_str = chat_id.clone().unwrap_or_default();
                                     let message = chat_req.message.clone();
                                     let image_data_uri = chat_req.image_data_uri.clone();
+                                    let video_data_uri = chat_req.video_data_uri.clone();
                                     let agent_id = chat_req.agent_id.clone();
 
                                     let join_handle = tokio::spawn(async move {
@@ -730,6 +954,7 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
                                             &message,
                                             &root,
                                             image_data_uri,
+                                            video_data_uri,
                                             chat_id.as_deref(),
                                             agent_id.as_deref(),
                                             fast_mode,
@@ -807,6 +1032,16 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
                                         .map(str::to_owned)
                                         .collect::<Vec<_>>(),
                                     Some("web".into()),
+                                    Some(sent_message.clone()),
+                                );
+                            }
+                            if let Some(video) = sent_video {
+                                let _ = save_chat_images(
+                                    video
+                                        .split_whitespace()
+                                        .map(str::to_owned)
+                                        .collect::<Vec<_>>(),
+                                    Some("web".into()),
                                     Some(sent_message),
                                 );
                             }
@@ -836,6 +1071,12 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
                         /// Which image provider to use (overrides config.image_gen_provider).
                         #[serde(default)]
                         provider: Option<String>,
+                        #[serde(default)]
+                        image_data_uri: Option<String>,
+                        #[serde(default)]
+                        mask_data_uri: Option<String>,
+                        #[serde(default)]
+                        mode: Option<String>,
                     }
 
                     if let Ok(req) = serde_json::from_str::<ImageGenApiRequest>(body) {
@@ -847,9 +1088,18 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
                             num_images: req.num_images,
                             model: req.model,
                             provider: req.provider,
+                            image_data_uri: req.image_data_uri,
+                            mask_data_uri: req.mask_data_uri,
+                            mode: req.mode,
                         };
                         match generate_images(&config, &gen_request).await {
                             Ok(result) => {
+                                log_api_req(
+                                    "POST",
+                                    "/api/image-generate",
+                                    "200 OK",
+                                    Some(&format!("Provider: {}", result.provider)),
+                                );
                                 let data_uris: Vec<String> = result
                                     .images
                                     .iter()
@@ -877,6 +1127,7 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
                                 send_json_response(socket, "200 OK", &response.to_string()).await;
                             }
                             Err(e) => {
+                                log_api_err("API /api/image-generate error", &e);
                                 let err = json!({ "error": e.to_string() });
                                 send_json_response(
                                     socket,
@@ -895,6 +1146,98 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
                         .await;
                     }
                 }
+                ("POST", "/api/video-generate") => {
+                    #[derive(serde::Deserialize)]
+                    #[serde(rename_all = "camelCase")]
+                    struct VideoGenApiRequest {
+                        prompt: String,
+                        #[serde(default)]
+                        negative_prompt: Option<String>,
+                        #[serde(default)]
+                        aspect_ratio: Option<String>,
+                        #[serde(default)]
+                        duration: Option<u32>,
+                        #[serde(default)]
+                        model: Option<String>,
+                        #[serde(default)]
+                        provider: Option<String>,
+                    }
+
+                    if let Ok(req) = serde_json::from_str::<VideoGenApiRequest>(body) {
+                        let config = load_config().unwrap_or_default();
+                        let gen_request = VideoGenRequest {
+                            prompt: req.prompt.clone(),
+                            negative_prompt: req.negative_prompt,
+                            aspect_ratio: req.aspect_ratio.unwrap_or_else(|| "16:9".to_string()),
+                            duration: req.duration.unwrap_or(5),
+                            model: req.model,
+                            provider: req.provider.unwrap_or_else(|| "veo".to_string()),
+                        };
+                        match generate_video(&config, &gen_request).await {
+                            Ok(result) => {
+                                let mut response =
+                                    serde_json::to_value(&result).unwrap_or(json!({}));
+                                if let Some(videos) =
+                                    response.get_mut("videos").and_then(|v| v.as_array_mut())
+                                {
+                                    for picture in videos {
+                                        let filename = picture
+                                            .get("filename")
+                                            .and_then(|f| f.as_str())
+                                            .map(|s| s.to_string());
+                                        if let Some(filename) = filename {
+                                            picture.as_object_mut().unwrap().insert(
+                                                "url".to_string(),
+                                                json!(format!("/api/pictures/{}", filename)),
+                                            );
+                                        }
+                                        let id = picture
+                                            .get("id")
+                                            .and_then(|i| i.as_str())
+                                            .map(|s| s.to_string());
+                                        if let Some(id) = id {
+                                            let has_thumb = picture.get("thumbnailPath").is_some()
+                                                || picture.get("thumbnailUrl").is_some();
+                                            if has_thumb {
+                                                picture.as_object_mut().unwrap().insert(
+                                                    "thumbnailUrl".to_string(),
+                                                    json!(format!(
+                                                        "/api/thumbnails/{}.thumb.png",
+                                                        id
+                                                    )),
+                                                );
+                                            }
+                                        }
+                                    }
+                                }
+                                log_api_req(
+                                    "POST",
+                                    "/api/video-generate",
+                                    "200 OK",
+                                    Some(&format!("Provider: {}", result.provider)),
+                                );
+                                send_json_response(socket, "200 OK", &response.to_string()).await;
+                            }
+                            Err(e) => {
+                                log_api_err("API /api/video-generate error", &e);
+                                let err = json!({ "error": e.to_string() });
+                                send_json_response(
+                                    socket,
+                                    "500 Internal Server Error",
+                                    &err.to_string(),
+                                )
+                                .await;
+                            }
+                        }
+                    } else {
+                        send_json_response(
+                            socket,
+                            "400 Bad Request",
+                            "{\"error\":\"invalid video generation request body\"}",
+                        )
+                        .await;
+                    }
+                }
                 ("GET", "/api/image-gen/providers") => {
                     let config = load_config().unwrap_or_default();
                     let mut available: Vec<String> = Vec::new();
@@ -947,6 +1290,7 @@ async fn run_web_agent_loop(
         &request.message,
         &root,
         request.image_data_uri.clone(),
+        request.video_data_uri.clone(),
         request.chat_id.as_deref(),
         request.agent_id.as_deref(),
         fast_mode,
@@ -1125,6 +1469,25 @@ fn picture_bytes(filename: &str) -> Result<(String, Vec<u8>), String> {
     Ok((picture.mime_type, bytes))
 }
 
+fn thumbnail_bytes(filename: &str) -> Result<(String, Vec<u8>), String> {
+    if filename.contains('/') || filename.contains('\\') || filename.contains("..") {
+        return Err("invalid thumbnail path".into());
+    }
+    let id = filename
+        .strip_suffix(".thumb.png")
+        .ok_or_else(|| "invalid thumbnail name".to_string())?;
+    let picture = list_saved_pictures()
+        .map_err(|error| error.to_string())?
+        .into_iter()
+        .find(|entry| entry.id == id)
+        .ok_or_else(|| "picture not found".to_string())?;
+    let thumb_path = picture
+        .thumbnail_path
+        .ok_or_else(|| "thumbnail not found".to_string())?;
+    let bytes = std::fs::read(&thumb_path).map_err(|error| error.to_string())?;
+    Ok(("image/png".to_string(), bytes))
+}
+
 fn query_param(query: &str, key: &str) -> Option<String> {
     query.split('&').find_map(|pair| {
         let (name, value) = pair.split_once('=')?;