fix: 修复bug

apps/desktop/src-tauri/src/app_state.rs

@@ -78,13 +78,7 @@ impl AppState {
     pub fn initialize_database(&self) -> anyhow::Result<()> {
         println!("开始初始化数据库连接...");
 
-        // 暂时使用单连接模式，避免锁竞争问题
-        // TODO: 在解决 SQLite 锁问题后重新启用连接池
-        let database = Arc::new(Database::new()?);
-        println!("使用单连接模式初始化数据库");
-
-        // 连接池模式代码（暂时注释）
-        /*
+        // 优先使用连接池模式，因为ComfyUI Repository需要连接池
         let database = match Database::new_with_pool() {
             Ok(db) => {
                 println!("连接池模式初始化成功");
@@ -92,10 +86,10 @@ impl AppState {
             },
             Err(e) => {
                 eprintln!("连接池模式初始化失败: {}, 回退到单连接模式", e);
+                println!("⚠️ 警告: 使用单连接模式，ComfyUI功能可能受限");
                 Arc::new(Database::new()?)
             }
         };
-        */
 
         let project_repository = ProjectRepository::new(database.clone())?;
         let material_repository = MaterialRepository::new(database.clone())?;

apps/desktop/src-tauri/src/data/repositories/comfyui_repository.rs

@@ -24,14 +24,15 @@ impl ComfyUIRepository {
         Self { database }
     }
 
-    /// 获取数据库连接（使用连接池）
+    /// 获取数据库连接（优先使用连接池）
     fn get_connection(&self) -> Result<crate::infrastructure::database::ConnectionHandle> {
-        // 强制使用连接池，如果没有连接池则报错
-        if !self.database.has_pool() {
-            return Err(anyhow!("ComfyUI Repository 必须使用连接池模式，请启用连接池"));
+        // 优先使用连接池，如果没有连接池则使用普通连接
+        if self.database.has_pool() {
+            self.database.get_best_connection()
+        } else {
+            warn!("ComfyUI Repository 使用单连接模式，性能可能受限");
+            self.database.get_best_connection()
         }
-
-        self.database.get_best_connection()
     }
 
     /// 执行数据库操作的辅助方法
@@ -47,10 +48,17 @@ impl ComfyUIRepository {
     pub fn initialize(&self) -> Result<()> {
         // ComfyUI表现在通过主数据库的migration系统创建
         // 这里只需要确保连接可用
-        self.with_connection(|_conn| {
+        match self.with_connection(|_conn| {
             info!("ComfyUI 数据仓库初始化完成");
             Ok(())
-        })
+        }) {
+            Ok(result) => Ok(result),
+            Err(e) => {
+                warn!("ComfyUI 数据仓库初始化警告: {}", e);
+                // 即使连接有问题，也不阻止应用启动
+                Ok(())
+            }
+        }
     }
 
     // ==================== 工作流相关操作 ====================

apps/desktop/src-tauri/src/lib.rs

@@ -621,6 +621,7 @@ pub fn run() {
             commands::comfyui_v2_commands::comfyui_v2_search_workflows,
             commands::comfyui_v2_commands::comfyui_v2_export_workflows,
             commands::comfyui_v2_commands::comfyui_v2_import_workflows,
+            commands::comfyui_v2_commands::comfyui_v2_debug_list_workflows,
             // ComfyUI V2 模板命令
             commands::comfyui_v2_template_commands::comfyui_v2_create_template,
             commands::comfyui_v2_template_commands::comfyui_v2_list_templates,

apps/desktop/src-tauri/src/presentation/commands/comfyui_v2_commands.rs

@@ -621,25 +621,54 @@ pub async fn comfyui_v2_update_workflow(
     }
 }
 
+/// 删除工作流请求
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct DeleteWorkflowRequest {
+    #[serde(rename = "workflowId")]
+    pub workflow_id: String,
+}
+
 /// 删除工作流（实际删除模板，因为模板和工作流是同一概念）
 #[tauri::command]
 pub async fn comfyui_v2_delete_workflow(
-    workflow_id: String,
+    request: DeleteWorkflowRequest,
     state: State<'_, AppState>,
 ) -> Result<String, String> {
-    info!("Command: comfyui_v2_delete_workflow - {}", workflow_id);
+    info!("Command: comfyui_v2_delete_workflow - {}", request.workflow_id);
 
     let service_manager = get_service_manager(&state).await?;
     let template_engine = service_manager.get_template_engine().await
         .map_err(|e| format!("获取模板引擎失败: {}", e))?;
 
     // 删除模板（模板和工作流是同一概念）
-    template_engine.delete_template(&workflow_id).await
+    template_engine.delete_template(&request.workflow_id).await
         .map_err(|e| format!("删除工作流失败: {}", e))?;
 
     Ok("工作流删除成功".to_string())
 }
 
+/// 调试：列出所有工作流
+#[tauri::command]
+pub async fn comfyui_v2_debug_list_workflows(
+    state: State<'_, AppState>,
+) -> Result<Vec<WorkflowResponse>, String> {
+    info!("Command: comfyui_v2_debug_list_workflows");
+
+    let service_manager = get_service_manager(&state).await?;
+    let repository = service_manager.get_repository();
+
+    // 获取所有工作流（包括禁用的）
+    let workflows = repository.list_workflows(false)
+        .map_err(|e| format!("获取工作流列表失败: {}", e))?;
+
+    let workflow_responses: Vec<WorkflowResponse> = workflows.into_iter()
+        .map(|workflow| convert_workflow_model(&workflow))
+        .collect();
+
+    info!("找到 {} 个工作流", workflow_responses.len());
+    Ok(workflow_responses)
+}
+
 /// 批量删除工作流
 #[tauri::command]
 pub async fn comfyui_v2_batch_delete_workflows(

apps/desktop/src/services/comfyuiV2Service.ts

@@ -124,11 +124,17 @@ export interface ExecutionV2 {
 export interface ExecuteWorkflowRequest {
   workflow_id: string;
   parameters?: any;
+  timeout_seconds?: number;
+  priority?: number;
+  wait_for_completion?: boolean;
 }
 
 export interface ExecuteTemplateRequest {
   template_id: string;
   parameters: any;
+  timeout_seconds?: number;
+  priority?: number;
+  wait_for_completion?: boolean;
 }
 
 // ==================== 实时事件类型 ====================
@@ -355,13 +361,27 @@ export class ComfyUIV2Service {
    */
   static async deleteWorkflow(id: string): Promise<string> {
     try {
-      return await invoke<string>('comfyui_v2_delete_workflow', { id });
+      return await invoke<string>('comfyui_v2_delete_workflow', {
+        request: { workflowId: id }
+      });
     } catch (error) {
       console.error('Failed to delete workflow:', error);
       throw new Error(`删除工作流失败: ${error}`);
     }
   }
 
+  /**
+   * 调试：列出所有工作流
+   */
+  static async debugListWorkflows(): Promise<WorkflowResponse[]> {
+    try {
+      return await invoke<WorkflowResponse[]>('comfyui_v2_debug_list_workflows');
+    } catch (error) {
+      console.error('Failed to debug list workflows:', error);
+      throw new Error(`获取调试工作流列表失败: ${error}`);
+    }
+  }
+
   /**
    * 搜索工作流
    */

apps/desktop/src/store/comfyuiV2Store.ts

@@ -459,14 +459,14 @@ export const useComfyUIV2Store = create<ComfyUIV2Store>()(
     executeWorkflow: async (request: any) => {
       try {
         const execution = await ComfyUIV2Service.executeWorkflow(request);
-        set(state => ({ 
+        set(state => ({
           executions: [execution, ...state.executions],
           currentExecution: execution
         }));
-        
+
         // 注册执行映射以便实时跟踪
         await ComfyUIV2Service.registerExecutionMapping(execution.prompt_id, execution.id);
-        
+
         return execution;
       } catch (error) {
         console.error('Failed to execute workflow:', error);
@@ -474,6 +474,51 @@ export const useComfyUIV2Store = create<ComfyUIV2Store>()(
       }
     },
 
+    // ==================== 调试功能 ====================
+
+    createTestWorkflow: async () => {
+      try {
+        // 创建一个简单的测试工作流
+        const testWorkflow = {
+          name: `测试工作流_${Date.now()}`,
+          description: '用于测试的简单工作流',
+          workflow_json: {
+            "1": {
+              "inputs": {
+                "text": "Hello, ComfyUI!"
+              },
+              "class_type": "CLIPTextEncode",
+              "_meta": {
+                "title": "CLIP Text Encode (Prompt)"
+              }
+            }
+          },
+          tags: ['test', 'debug']
+        };
+
+        const result = await ComfyUIV2Service.createWorkflow(testWorkflow);
+
+        // 刷新工作流列表
+        await get().loadWorkflows();
+
+        return result;
+      } catch (error) {
+        console.error('Failed to create test workflow:', error);
+        throw error;
+      }
+    },
+
+    debugListWorkflows: async () => {
+      try {
+        const workflows = await ComfyUIV2Service.debugListWorkflows();
+        console.log('调试工作流列表:', workflows);
+        return workflows;
+      } catch (error) {
+        console.error('Failed to debug list workflows:', error);
+        throw error;
+      }
+    },
+
     executeTemplate: async (request: any) => {
       try {
         const execution = await ComfyUIV2Service.executeTemplate(request);