update

wangenius · wangenius · commit f21e0a29f1d7 · 2025-04-18T22:46:54.000+08:00
diff --git a/src-tauri/src/plugins/chat.rs b/src-tauri/src/plugins/chat.rs
@@ -1,17 +1,15 @@
+use base64::Engine;
 use futures_util::StreamExt;
 use once_cell::sync::Lazy;
 use reqwest::header::{HeaderMap, HeaderValue, AUTHORIZATION, CONTENT_TYPE};
 use std::collections::HashMap;
 use std::sync::Mutex;
 use tauri::{Emitter, Runtime};
 use tokio::sync::{mpsc, oneshot};
-use base64::Engine;
 
 static CANCEL_CHANNELS: Lazy<Mutex<HashMap<String, oneshot::Sender<()>>>> =
     Lazy::new(|| Mutex::new(HashMap::new()));
 
-
-
 #[tauri::command]
 pub async fn chat_stream<R: Runtime>(
     window: tauri::Window<R>,
@@ -42,7 +40,10 @@ pub async fn chat_stream<R: Runtime>(
         .await
         .map_err(|e| {
             println!("请求发送失败: {}", e);
-            window.clone().emit(&format!("chat-stream-error-{}", request_id), e.to_string()).unwrap();
+            window
+                .clone()
+                .emit(&format!("chat-stream-error-{}", request_id), e.to_string())
+                .unwrap();
             e.to_string()
         })?;
 
@@ -134,10 +135,7 @@ pub async fn image_generate(
         AUTHORIZATION,
         HeaderValue::from_str(&format!("Bearer {}", api_key)).map_err(|e| e.to_string())?,
     );
-    headers.insert(
-        "X-DashScope-Async",
-        HeaderValue::from_static("enable"),
-    );
+    headers.insert("X-DashScope-Async", HeaderValue::from_static("enable"));
 
     println!("正在发送图像生成请求到: {}", api_url);
     let response = client
@@ -154,7 +152,10 @@ pub async fn image_generate(
     if !response.status().is_success() {
         let status = response.status();
         let error_text = response.text().await.map_err(|e| e.to_string())?;
-        println!("图像生成请求失败，状态码: {}, 错误信息: {}", status, error_text);
+        println!(
+            "图像生成请求失败，状态码: {}, 错误信息: {}",
+            status, error_text
+        );
         return Err(format!("请求失败: {} - {}", status, error_text));
     }
 
@@ -163,10 +164,7 @@ pub async fn image_generate(
 }
 
 #[tauri::command]
-pub async fn image_result(
-    api_url: String,
-    api_key: String,
-) -> Result<serde_json::Value, String> {
+pub async fn image_result(api_url: String, api_key: String) -> Result<serde_json::Value, String> {
     let client = reqwest::Client::builder()
         .build()
         .map_err(|e| e.to_string())?;
@@ -192,12 +190,15 @@ pub async fn image_result(
     if !response.status().is_success() {
         let status = response.status();
         let error_text = response.text().await.map_err(|e| e.to_string())?;
-        println!("获取图像生成结果失败，状态码: {}, 错误信息: {}", status, error_text);
+        println!(
+            "获取图像生成结果失败，状态码: {}, 错误信息: {}",
+            status, error_text
+        );
         return Err(format!("请求失败: {} - {}", status, error_text));
     }
 
     let mut response_json: serde_json::Value = response.json().await.map_err(|e| e.to_string())?;
-    
+
     // 如果任务成功完成，获取图片并转换为base64
     if let Some(output) = response_json.get("output") {
         if let Some(task_status) = output.get("task_status") {
@@ -211,19 +212,24 @@ pub async fn image_result(
                                 .send()
                                 .await
                                 .map_err(|e| e.to_string())?;
-                            
-                            let image_bytes = image_response.bytes().await.map_err(|e| e.to_string())?;
-                            
+
+                            let image_bytes =
+                                image_response.bytes().await.map_err(|e| e.to_string())?;
+
                             // 转换为base64
-                            let base64_image = base64::engine::general_purpose::STANDARD.encode(&image_bytes);
+                            let base64_image =
+                                base64::engine::general_purpose::STANDARD.encode(&image_bytes);
                             let data_url = format!("data:image/png;base64,{}", base64_image);
-                            
+
                             // 创建新的结果对象
                             if let Some(output) = response_json.get_mut("output") {
                                 if let Some(results) = output.get_mut("results") {
                                     if let Some(first_result) = results.get_mut(0) {
                                         if let Some(obj) = first_result.as_object_mut() {
-                                            obj.insert("base64".to_string(), serde_json::Value::String(data_url));
+                                            obj.insert(
+                                                "base64".to_string(),
+                                                serde_json::Value::String(data_url),
+                                            );
                                         }
                                     }
                                 }
@@ -234,6 +240,6 @@ pub async fn image_result(
             }
         }
     }
-    
+
     Ok(response_json)
 }
diff --git a/src/assets/variables.css b/src/assets/variables.css
@@ -10,6 +10,10 @@
   font-family: "harmony";
 }
 
+[data-font=mono] * {
+  font-family: "mono";
+}
+
 .mono {
   font-family: "mono" !important;
 }
diff --git a/src/page/workflow/nodes/PluginNode.tsx b/src/page/workflow/nodes/PluginNode.tsx
@@ -167,6 +167,7 @@ export class PluginNodeExecutor extends NodeExecutor {
       const pluginResult = await (
         await ToolPlugin.get(plugin.props.id)
       ).execute(pluginConfig.tool, processedArgs);
+      console.log("pluginResult", pluginResult);
 
       if (!pluginResult) {
         throw new Error("Plugin execution result is empty");
diff --git a/src/skills/instance/image.ts b/src/skills/instance/image.ts
@@ -0,0 +1,130 @@
+import { ImageManager } from "@/resources/Image";
+import { SkillManager } from "../SkillManager";
+import { gen } from "@/utils/generator";
+import { readFile, writeFile } from "@tauri-apps/plugin-fs";
+
+/** 将本地图片转换为base64 */
+SkillManager.register("imageLoading", {
+  name: "图片加载",
+  description: "将本地图片连接转换为base64放到数据库中, 并返回图片id",
+  params: {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "图片绝对路径",
+      },
+    },
+    required: ["path"],
+  },
+  execute: async (params: Record<string, any>) => {
+    const { path } = params;
+    const id = gen.id();
+
+    try {
+      // 读取文件内容
+      const binaryData = await readFile(path);
+
+      // 将二进制数据转换为base64
+      const base64String = btoa(
+        new Uint8Array(binaryData).reduce(
+          (data, byte) => data + String.fromCharCode(byte),
+          "",
+        ),
+      );
+
+      // 根据文件扩展名确定内容类型
+      const fileExt = path.split(".").pop()?.toLowerCase() || "";
+      let contentType = "image/png"; // 默认
+
+      // 常见图片格式的MIME类型映射
+      const mimeTypes: Record<string, string> = {
+        jpg: "image/jpeg",
+        jpeg: "image/jpeg",
+        png: "image/png",
+        gif: "image/gif",
+        bmp: "image/bmp",
+        webp: "image/webp",
+        svg: "image/svg+xml",
+      };
+
+      if (fileExt in mimeTypes) {
+        contentType = mimeTypes[fileExt];
+      }
+
+      // 构建完整的Data URL
+      const dataUrl = `data:${contentType};base64,${base64String}`;
+
+      // 保存图片到数据库
+      await ImageManager.setImage(id, dataUrl, contentType);
+
+      return id;
+    } catch (error) {
+      console.error("图片加载失败:", error);
+      throw new Error(`图片加载失败: ${error}`);
+    }
+  },
+});
+
+SkillManager.register("imageSave", {
+  name: "图片保存",
+  description: "将图片ID对应的图片保存到本地, 并返回图片路径",
+  params: {
+    type: "object",
+    properties: {
+      id: {
+        type: "string",
+        description: "图片ID",
+      },
+      path: {
+        type: "string",
+        description: "图片绝对路径，不包含扩展名",
+      },
+    },
+    required: ["id", "path"],
+  },
+  execute: async (params: Record<string, any>) => {
+    const { id, path } = params;
+
+    try {
+      // 从ImageManager获取图片数据
+      const imageData = await ImageManager.getImageBody(id);
+      if (!imageData) {
+        throw new Error(`未找到ID为${id}的图片`);
+      }
+      let mimeType = "image/png";
+      let fileExtension = "png";
+      // 从DataURL中提取MIME类型
+      const mimeMatch = imageData.match(/^data:([^;]+);/);
+      if (mimeMatch && mimeMatch[1]) {
+        mimeType = mimeMatch[1];
+        // 从MIME类型提取扩展名
+        const extMap: Record<string, string> = {
+          "image/jpeg": "jpg",
+          "image/png": "png",
+          "image/gif": "gif",
+          "image/bmp": "bmp",
+          "image/webp": "webp",
+          "image/svg+xml": "svg",
+        };
+        fileExtension = extMap[mimeType] || "png";
+      }
+
+      // 提取Base64数据并转换为二进制数组
+      const base64Data = imageData.replace(/^data:[^;]+;base64,/, "");
+      const binaryData = new Uint8Array(
+        atob(base64Data)
+          .split("")
+          .map((char) => char.charCodeAt(0)),
+      );
+
+      // 使用writeFile保存二进制数据
+      await writeFile(path + "." + fileExtension, binaryData);
+
+      return `图片已成功保存到: ${path}`;
+    } catch (error) {
+      console.error("图片保存失败:", error);
+      throw new Error(`图片保存失败: ${error}`);
+    }
+  },
+});
diff --git a/src/skills/instance/index.ts b/src/skills/instance/index.ts
@@ -1 +1,2 @@
 import "./Search";
+import "./image";

Original file line number	Diff line number	Diff line change
`@@ -10,6 +10,10 @@`
`10`	`10`	`font-family: "harmony";`
`11`	`11`	`}`
`12`	`12`
	`13`	`+[data-font=mono] * {`
	`14`	`+ font-family: "mono";`
	`15`	`+}`
	`16`	`+`
`13`	`17`	`.mono {`
`14`	`18`	`font-family: "mono" !important;`
`15`	`19`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1 +1,2 @@`
`1`	`1`	`import "./Search";`
	`2`	`+import "./image";`