bizydraft 0.2.31__py3-none-any.whl → 0.2.78.dev20251117024007__py3-none-any.whl

bizydraft/static/js/postEvent.js

@@ -21,47 +21,77 @@ app.registerExtension({
     pingTimeoutTimer: null, // ping超时计时器
 
     /**
-     * 开始心跳检测
+     * 为特定socket开始心跳检测（每个socket独立的心跳）
      */
-    startPing() {
-        this.stopPing();
-
-        if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
+    startPingForSocket(socket) {
+        if (!socket || socket.readyState !== WebSocket.OPEN) {
             return;
         }
 
+        // 在socket对象上存储心跳状态
+        socket.pongReceived = false;
         // 立即发送一次ping消息
-        this.pongReceived = false;
-        this.socket.send('ping');
+        socket.send('ping');
 
         // 设置ping超时检测
-        this.pingTimeoutTimer = setTimeout(() => {
-            if (!this.pongReceived) {
-                this.stopPing();
-                this.reconnect();
+        socket.pingTimeoutTimer = setTimeout(() => {
+            if (!socket.pongReceived && socket.readyState === WebSocket.OPEN) {
+                console.log('心跳检测超时，关闭此连接');
+                this.stopPingForSocket(socket);
+                socket.close();
             }
         }, this.pingTimeout);
 
         // 设置定时发送ping
-        this.pingTimer = setInterval(() => {
-            if (this.socket && this.socket.readyState === WebSocket.OPEN) {
-                this.pongReceived = false;
-                this.socket.send('ping');
+        socket.pingTimer = setInterval(() => {
+            if (socket.readyState === WebSocket.OPEN) {
+                socket.pongReceived = false;
+                socket.send('ping');
                 // 设置ping超时检测
-                this.pingTimeoutTimer = setTimeout(() => {
+                socket.pingTimeoutTimer = setTimeout(() => {
                     // 如果没有收到pong响应
-                    if (!this.pongReceived) {
-                        console.log('心跳检测超时，重新连接WebSocket');
-                        this.stopPing();
-                        this.reconnect();
+                    if (!socket.pongReceived) {
+                        console.log('心跳检测超时，关闭此连接');
+                        this.stopPingForSocket(socket);
+                        socket.close();
                     }
                 }, this.pingTimeout);
             } else {
-                this.stopPing();
+                this.stopPingForSocket(socket);
             }
         }, this.pingInterval);
     },
 
+    /**
+     * 停止特定socket的心跳检测
+     */
+    stopPingForSocket(socket) {
+        if (!socket) return;
+
+        if (socket.pingTimer) {
+            clearInterval(socket.pingTimer);
+            socket.pingTimer = null;
+        }
+
+        if (socket.pingTimeoutTimer) {
+            clearTimeout(socket.pingTimeoutTimer);
+            socket.pingTimeoutTimer = null;
+        }
+    },
+
+    /**
+     * 开始心跳检测（保留向后兼容）
+     */
+    startPing() {
+        this.stopPing();
+
+        if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
+            return;
+        }
+        // 使用新的socket专用心跳方法
+        this.startPingForSocket(this.socket);
+    },
+
     /**
      * 停止心跳检测
      */
@@ -102,8 +132,6 @@ app.registerExtension({
         // 标记为连接中
         this.isConnecting = true;
 
-        // 先关闭现有连接
-        this.closeSocket();
 
         const url = customUrl || app.api.socket.url;
         console.log('创建WebSocket连接:', url);
@@ -117,172 +145,219 @@ app.registerExtension({
                 console.log('WebSocket连接已打开');
                 // 清除连接中标志
                 self.isConnecting = false;
-                // 存储为单例
+                // 存储为单例（最新的连接）
                 self.socket = socket;
                 // 替换app.api.socket
                 app.api.socket = socket;
-                // 开始心跳检测
-                self.startPing();
+                // 为这个socket启动独立的心跳检测
+                self.startPingForSocket(socket);
             };
 
             socket.onmessage = function (event) {
                 try {
+                    // 从 WebSocket URL 中提取 taskId
+                    let taskIdFromUrl = null;
+                    try {
+                        const urlParams = new URLSearchParams(socket.url.split('?')[1]);
+                        taskIdFromUrl = urlParams.get('taskId');
+                        if (taskIdFromUrl) {
+                            taskIdFromUrl = parseInt(taskIdFromUrl, 10);
+                        }
+                        console.log('taskIdFromUrl:', taskIdFromUrl);
+                    } catch (e) {
+                        console.warn('无法从 WebSocket URL 中提取 taskId:', e);
+                    }
                     // 处理心跳响应
                     if (event.data === 'pong') {
-                        // 标记收到pong响应
-                        self.pongReceived = true;
+                        // 标记此socket收到pong响应
+                        socket.pongReceived = true;
                         return;
                     }
                     if (event.data instanceof ArrayBuffer) {
-                        const view = new DataView(event.data);
-                        const eventType = view.getUint32(0);
-
-                        let imageMime;
-                        switch (eventType) {
-                            case 3:
-                                const decoder = new TextDecoder();
-                                const data = event.data.slice(4);
-                                const nodeIdLength = view.getUint32(4);
-                                dispatchCustomEvent('progress_text', {
-                                    nodeId: decoder.decode(data.slice(4, 4 + nodeIdLength)),
-                                    text: decoder.decode(data.slice(4 + nodeIdLength))
-                                });
-                                break;
+                      const view = new DataView(event.data)
+                      const eventType = view.getUint32(0)
+
+                      let imageMime
+                      switch (eventType) {
+                        case 3:
+                          const decoder = new TextDecoder()
+                          const data = event.data.slice(4)
+                          const nodeIdLength = view.getUint32(4)
+                          dispatchCustomEvent('progress_text', {
+                            nodeId: decoder.decode(data.slice(4, 4 + nodeIdLength)),
+                            text: decoder.decode(data.slice(4 + nodeIdLength))
+                          })
+                          break
+                        case 1:
+                          const imageType = view.getUint32(4)
+                          const imageData = event.data.slice(8)
+                          switch (imageType) {
+                            case 2:
+                              imageMime = 'image/png'
+                              break
                             case 1:
-                                const imageType = view.getUint32(4);
-                                const imageData = event.data.slice(8);
-                                switch (imageType) {
-                                    case 2:
-                                        imageMime = 'image/png';
-                                        break;
-                                    case 1:
-                                    default:
-                                        imageMime = 'image/jpeg';
-                                        break;
-                                }
-                                const imageBlob = new Blob([imageData], {
-                                    type: imageMime
-                                });
-                                dispatchCustomEvent('b_preview', imageBlob);
-                                break;
                             default:
-                                throw new Error(
-                                    `Unknown binary websocket message of type ${eventType}`
-                                );
-                        }
+                              imageMime = 'image/jpeg'
+                              break
+                          }
+                          const imageBlob = new Blob([imageData], {
+                            type: imageMime
+                          })
+                          dispatchCustomEvent('b_preview', imageBlob)
+                          break
+                        case 4:
+                          // PREVIEW_IMAGE_WITH_METADATA
+                          const decoder4 = new TextDecoder()
+                          const metadataLength = view.getUint32(4)
+                          const metadataBytes = event.data.slice(8, 8 + metadataLength)
+                          const metadata = JSON.parse(decoder4.decode(metadataBytes))
+                          const imageData4 = event.data.slice(8 + metadataLength)
+
+                          let imageMime4 = metadata.image_type
+
+                          const imageBlob4 = new Blob([imageData4], {
+                            type: imageMime4
+                          })
+
+                          // Dispatch enhanced preview event with metadata
+                          dispatchCustomEvent('b_preview_with_metadata', {
+                            blob: imageBlob4,
+                            nodeId: metadata.node_id,
+                            displayNodeId: metadata.display_node_id,
+                            parentNodeId: metadata.parent_node_id,
+                            realNodeId: metadata.real_node_id,
+                            promptId: metadata.prompt_id
+                          })
+
+                          // Also dispatch legacy b_preview for backward compatibility
+                          dispatchCustomEvent('b_preview', imageBlob4)
+                          break
+                        default:
+                          throw new Error(
+                            `Unknown binary websocket message of type ${eventType}`
+                          )
+                      }
                     } else {
-                        // 检测[DONE]消息
-                        if (event.data === '[DONE]') {
-                            console.log('收到[DONE]消息，任务已完成，停止心跳并关闭连接');
-                            self.taskRunning = false;
-                            self.stopPing();
-                            self.closeSocket(1000);
-                            return;
+                            // 检测[DONE]消息
+                    if (event.data === '[DONE]') {
+                        console.log('收到[DONE]消息，任务已完成，停止心跳并关闭连接');
+                        self.taskRunning = false;
+                        self.stopPingForSocket(socket);
+                        if (socket.readyState === WebSocket.OPEN) {
+                            socket.close(1000);
+                        }
+                        return;
+                    }
+                      const msg = JSON.parse(event.data)
+                        // 发送进度信息，添加从 URL 中提取的 taskId
+                        if (msg.progress_info) {
+                            const progressData = { ...msg.progress_info };
+                            if (taskIdFromUrl && !progressData.task_id) {
+                                progressData.task_id = taskIdFromUrl;
+                            }
+                            window.parent.postMessage({
+                                type: 'functionResult',
+                                method: 'progress_info_change',
+                                result: progressData
+                            }, '*');
                         }
 
-                        const msg = JSON.parse(event.data);
-                        window.parent.postMessage({
+                      switch (msg.type) {
+                        case 'load_start':
+                        case 'load_end':
+                        case 'prompt_id':
+                          // 发送准备状态信息，添加从 URL 中提取的 taskId
+                          const preparingData = { ...msg };
+                          if (taskIdFromUrl) {
+                            preparingData.task_id = taskIdFromUrl;
+                            console.log(`🔗 [WebSocket] 添加 task_id=${taskIdFromUrl} 到 ${msg.type} 消息`);
+                          }
+                          window.parent.postMessage({
                             type: 'functionResult',
-                            method: 'progress_info_change',
-                            result: msg.progress_info
-                        }, '*');
-                        switch (msg.type) {
-                            case 'load_start':
-                            case 'load_end':
-                            case 'prompt_id':
-                                window.parent.postMessage({
-                                    type: 'functionResult',
-                                    method: 'preparingStatus',
-                                    result: msg
-                                }, '*')
-                            case 'status':
-                                if (msg.data.sid) {
-                                    const clientId = msg.data.sid;
-                                    window.name = clientId;
-                                    sessionStorage.setItem('clientId', clientId);
-                                    socket.clientId = clientId;
-                                }
-                                dispatchCustomEvent('status', msg.data.status ?? null);
-                                break;
-                            case 'executing':
-                                dispatchCustomEvent(
-                                    'executing',
-                                    msg.data.display_node || msg.data.node
+                            method: 'preparingStatus',
+                            result: preparingData
+                          }, '*')
+                          break
+                        case 'status':
+                          if (msg.data.sid) {
+                            const clientId = msg.data.sid
+                            window.name = clientId // use window name so it isnt reused when duplicating tabs
+                            sessionStorage.setItem('clientId', clientId) // store in session storage so duplicate tab can load correct workflow
+                          }
+                          dispatchCustomEvent('status', msg.data.status ?? null)
+                          break
+                        case 'executing':
+                          dispatchCustomEvent(
+                            'executing',
+                            msg.data.display_node || msg.data.node
+                          )
+                          break
+                        case 'execution_start':
+                        case 'execution_error':
+                        case 'execution_interrupted':
+                        case 'execution_cached':
+                        case 'execution_success':
+                        case 'progress':
+                        case 'progress_state':
+                        case 'executed':
+                        case 'graphChanged':
+                        case 'promptQueued':
+                        case 'logs':
+                        case 'b_preview':
+                          if (msg.data.balance_not_enough) {
+                              window.parent.postMessage({
+                                  type: "functionResult",
+                                  method: "balanceNotEnough",
+                                  result: true,
+                              }, "*");
+                          }
+                          dispatchCustomEvent(msg.type, msg.data)
+                          break
+                        case 'feature_flags':
+                          // Store server feature flags
+                          this.serverFeatureFlags = msg.data
+                          console.log(
+                            'Server feature flags received:',
+                            this.serverFeatureFlags
+                          )
+                          break
+                        default:
+                            const registeredTypes = socket.registeredTypes || new Set();
+                            const reportedUnknownMessageTypes = socket.reportedUnknownMessageTypes || new Set();
+
+                            if (registeredTypes.has(msg.type)) {
+                                app.dispatchEvent(
+                                    new CustomEvent(msg.type, { detail: msg.data })
                                 );
-                                break;
-                            case 'execution_success':
-                            case 'execution_cached':
-                                // 检查任务是否完成
-                                if (msg.data.completed) {
-                                    self.taskRunning = false;
-                                }
-                                dispatchCustomEvent(msg.type, msg.data);
-                                break;
-                            case 'error':
-                                self.taskRunning = false;
-                                dispatchCustomEvent('execution_error', {
-                                    exception_message: msg.data.error_message || 'Unknown error',
-                                    traceback: ['Manual error triggered'],
-                                    executed: [],
-                                    prompt_id: 'manual',
-                                    node_id: '0',
-                                    node_type: 'RunError',
-                                });
-                                break;
-                            case 'execution_error':
-                            case 'execution_interrupted':
-                                self.taskRunning = false;
-                                dispatchCustomEvent(msg.type, msg.data);
-                                break;
-                            case 'execution_start':
-                                self.taskRunning = true;
-                                dispatchCustomEvent(msg.type, msg.data);
-                                break;
-                            case 'progress':
-                            case 'executed':
-                            case 'graphChanged':
-                            case 'promptQueued':
-                            case 'logs':
-                            case 'b_preview':
-                                dispatchCustomEvent(msg.type, msg.data);
-                                break;
-                            default:
-                                const registeredTypes = socket.registeredTypes || new Set();
-                                const reportedUnknownMessageTypes = socket.reportedUnknownMessageTypes || new Set();
-
-                                if (registeredTypes.has(msg.type)) {
-                                    app.dispatchEvent(
-                                        new CustomEvent(msg.type, { detail: msg.data })
-                                    );
-                                } else if (!reportedUnknownMessageTypes.has(msg.type)) {
-                                    reportedUnknownMessageTypes.add(msg.type);
-                                    console.warn(`Unknown message type ${msg.type}`);
-                                }
-                        }
+                            } else if (!reportedUnknownMessageTypes.has(msg.type)) {
+                                reportedUnknownMessageTypes.add(msg.type);
+                                console.warn(`Unknown message type ${msg.type}`);
+                            }
+                      }
                     }
-                } catch (error) {
-                    console.warn('Unhandled message:', event.data, error);
-                }
+                  } catch (error) {
+                    console.warn('Unhandled message:', event.data, error)
+                  }
             };
 
             socket.onerror = function(error) {
                 console.log('WebSocket 错误:', error);
                 // 清除连接中标志
                 self.isConnecting = false;
-                // 停止心跳
-                self.stopPing();
+                // 停止此socket的心跳检测
+                self.stopPingForSocket(socket);
             };
 
             socket.onclose = function(event) {
                 console.log('WebSocket 连接已关闭, 状态码:', event.code, event.reason);
                 // 清除连接中标志
                 self.isConnecting = false;
-                // 清理单例引用
+                // 停止此socket的心跳检测
+                self.stopPingForSocket(socket);
+                // 清理单例引用（如果这是当前活跃的socket）
                 if (self.socket === socket) {
                     self.socket = null;
                 }
-                // 停止心跳
-                self.stopPing();
             };
 
             socket.registeredTypes = new Set();
@@ -435,7 +510,9 @@ app.registerExtension({
 
         const customErrorStyles = new Map()
 
-
+        // 用于节流的时间戳
+        let lastRunWorkflowTime = 0;
+        const THROTTLE_TIME = 2000; // 2秒
 
         // 方法映射
         const methods = {
@@ -505,9 +582,31 @@ app.registerExtension({
                 }, '*');
                 return graph.workflow;
             },
+            getWorkflowNotSave: async function () {
+                const graph = await app.graphToPrompt();
+                // 规范化工作流，移除不影响逻辑的视觉字段，避免颜色等样式变化影响校验
+                const normalizeWorkflow = (workflow) => {
+                    const json = JSON.stringify(workflow, (key, value) => {
+                        if (key === 'color' || key === 'bgcolor' || key === 'extra') return undefined;
+                        return value;
+                    });
+                    return JSON.parse(json);
+                };
+                const normalized = normalizeWorkflow(graph.workflow);
+                window.parent.postMessage({
+                    type: 'functionResult',
+                    method: 'getWorkflowNotSave',
+                    result: normalized
+                }, '*');
+                return normalized;
+            },
             // 新增：获取 workflow 和 output
             getWorkflowWithOutput: async function () {
                 const graph = await app.graphToPrompt();
+                for (const key in graph.output) {
+                    graph.output[key]._meta.id = Number(key);
+                    graph.output[key]._meta.class_type =graph.output[key].class_type
+                }
                 window.parent.postMessage({
                     type: 'functionResult',
                     method: 'getWorkflowWithOutput',
@@ -558,7 +657,7 @@ app.registerExtension({
                         })
                     });
                     const resPromptJson = await resPrompt.json();
-                    if (resPromptJson.error) {
+                    if (resPromptJson.error && resPromptJson.node_id) {
                         this.openCustomError({
                             nodeId: resPromptJson.node_id,
                             nodeType: resPromptJson.node_type,
@@ -587,18 +686,10 @@ app.registerExtension({
                     }
 
                     if (Object.keys(resPromptJson.node_errors).length) return
-                    graph.workflow.nodes.forEach(node => {
-                        for (const key in graph.output) {
-                            if (graph.output[key].class_type === node.type) {
-                                if (!graph.output[key]._meta) {
-                                    graph.output[key]._meta = {};
-                                }
-                                graph.output[key]._meta.id = node.id;
-                                break; // 找到匹配的就跳出循环
-                            }
-                        }
-                    });
-
+                    for (const key in graph.output) {
+                        graph.output[key]._meta.id = Number(key);
+                        graph.output[key]._meta.class_type = graph.output[key].class_type;
+                    }
                     for (let i in graph.output) {
                         if (graph.output[i].class_type == 'LoadImage') {
                             graph.output[i].inputs.image = graph.output[i].inputs.image.replace('pasted/http', 'http')
@@ -644,6 +735,11 @@ app.registerExtension({
 
                 return true;
             },
+            removeCookie: function (params) {
+                const expires = new Date(0).toUTCString();
+                document.cookie = params.name + "=; expires=" + expires + "; path=/";
+                return true;
+            },
             fitView: function () {
                 app.canvas.fitViewToSelectionAnimated()
                 window.parent.postMessage({
@@ -938,6 +1034,33 @@ app.registerExtension({
                 window.saveOriginalNodeColors(params.workflowId);
             }
         };
+
+        // 监听 Ctrl+Enter 快捷键执行工作流
+        document.addEventListener('keydown', (event) => {
+            if (event.ctrlKey && event.key === 'Enter') {
+                event.preventDefault();
+
+                // 节流：检查距离上次执行是否已经过了2秒
+                const now = Date.now();
+                if (now - lastRunWorkflowTime < THROTTLE_TIME) {
+                    console.log('触发频率过高，请稍后再试');
+                    return;
+                }
+
+                // 更新上次执行时间
+                lastRunWorkflowTime = now;
+
+                if (methods.runWorkflow) {
+                    window.parent.postMessage({
+                        type: 'functionResult',
+                        method: 'ctrlEnter',
+                        result: true
+                    }, '*');
+                    methods.runWorkflow();
+                }
+            }
+        });
+
         window.addEventListener('message', function (event) {
             if (event.data && event.data.type === 'callMethod') {
                 const methodName = event.data.method;
@@ -977,5 +1100,6 @@ app.registerExtension({
                 detail: e.detail
             }));
         })
+
     }
 });

bizydraft/static/js/tool.js

@@ -4,7 +4,8 @@ const loadNodeList = [
     'LoadAudio',
     'LoadVideo',
     'Load3D',
-    'VHS_LoadVideo'
+    'VHS_LoadVideo',
+    'VHS_LoadAudioUpload'
 ]
 const extMap = {
     'LoadImage': '.png,.jpg,.jpeg,.webp,.gif,.svg,.ico,.bmp,.tiff,.tif,.heic,.heif',
@@ -12,6 +13,8 @@ const extMap = {
     'LoadAudio': '.mp3,.wav,.ogg,.m4a,.aac,.flac,.wma,.m4r',
     'LoadVideo': '.mp4,.mov,.avi,.mkv,.webm,.flv,.wmv,.m4v',
     'Load3D': '.glb,.gltf,.fbx,.obj,.dae,.ply,.stl',
+    'VHS_LoadAudioUpload': '.mp3,.wav,.ogg,.m4a,.aac,.flac,.wma,.m4r',
+    "VHS_LoadVideo": '.mp4,.mov,.avi,.mkv,.webm,.flv,.wmv,.m4v',
 }
 export function getCookie(name) {
     const value = `; ${document.cookie}`;