bizydraft 0.1.0__py3-none-any.whl

bizydraft/__init__.py

@@ -0,0 +1,6 @@
+
+from .hijack_nodes import hijack_nodes
+
+__all__ = [
+    "hijack_nodes",
+]

bizydraft/hijack_nodes.py

@@ -0,0 +1,27 @@
+from loguru import logger
+
+try:
+    from nodes import NODE_CLASS_MAPPINGS, LoadImage
+except ImportError:
+    logger.error(
+        "failed to import ComfyUI nodes modules, ensure PYTHONPATH is set correctly. (export PYTHONPATH=$PYTHONPATH:/path/to/ComfyUI)"
+    )
+    exit(1)
+
+class BizyDraftLoadImage(LoadImage):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    @classmethod
+    def VALIDATE_INPUTS(s, image, *args, **kwargs):
+        return True
+
+
+def hijack_nodes():
+    if "LoadImage" in NODE_CLASS_MAPPINGS:
+        del NODE_CLASS_MAPPINGS["LoadImage"]
+    NODE_CLASS_MAPPINGS["LoadImage"] = BizyDraftLoadImage
+    
+    logger.info(
+        "[BizyDraft] Hijacked LoadImage node to BizyDraftLoadImage."
+    )

bizydraft/hijack_routes.py

@@ -0,0 +1,165 @@
+import math
+import os
+import asyncio
+import mimetypes
+import uuid
+
+from aiohttp import web, ClientSession, ClientTimeout
+from loguru import logger
+
+try:
+    from server import PromptServer
+    import execution
+
+    comfy_server = PromptServer.instance
+except ImportError:
+    logger.error(
+        "failed to import ComfyUI modules, ensure PYTHONPATH is set correctly. (export PYTHONPATH=$PYTHONPATH:/path/to/ComfyUI)"
+    )
+    exit(1)
+
+
+BIZYDRAFT_MAX_FILE_SIZE = int(
+    os.getenv("BIZYDRAFT_MAX_FILE_SIZE", 100 * 1024 * 1024)
+)  # 100MB
+BIZYDRAFT_REQUEST_TIMEOUT = int(
+    os.getenv("BIZYDRAFT_REQUEST_TIMEOUT", 20 * 60)
+)  # 20分钟
+BIZYDRAFT_CHUNK_SIZE = int(os.getenv("BIZYDRAFT_CHUNK_SIZE", 1024 * 16))  # 16KB
+
+
+async def view_image(request, old_handler):
+    logger.debug(
+        f"Received request for /view with query: {request.rel_url.query}"
+    )
+    if "filename" not in request.rel_url.query:
+        logger.warning("'filename' not provided in query string, returning 404")
+        return web.Response(status=404, text="'filename' not provided in query string")
+
+    filename = request.rel_url.query["filename"]
+    subfolder = request.rel_url.query.get("subfolder", "")
+
+    if not filename.startswith(("http://", "https://")) and not subfolder.startswith(
+        ("http://", "https://")
+    ):
+        logger.warning(f"Invalid filename format: {filename}, only URLs are supported")
+        return web.Response(
+            status=400, text="Invalid filename format(only url supported)"
+        )
+
+    try:
+        filename = (
+            f"{subfolder}/{filename}"
+            if not filename.startswith(("http://", "https://"))
+            else filename
+        )  # preview 3d request: https://host:port/api/view?filename=filename.glb&type=output&subfolder=https://bizyair-dev.oss-cn-shanghai.aliyuncs.com/outputs&rand=0.5763957215362988
+
+        content_type, _ = mimetypes.guess_type(filename)
+        if content_type and any(x in content_type for x in ("image", "video")):
+            return web.HTTPFound(filename)
+
+        timeout = ClientTimeout(total=BIZYDRAFT_REQUEST_TIMEOUT)
+        async with ClientSession(timeout=timeout) as session:
+            async with session.get(filename) as resp:
+                resp.raise_for_status()
+                content_length = int(resp.headers.get("Content-Length", 0))
+                if content_length > BIZYDRAFT_MAX_FILE_SIZE:
+                    logger.warning(
+                        f"File size {human_readable_size(content_length)} exceeds limit {human_readable_size(BIZYDRAFT_MAX_FILE_SIZE)}"
+                    )
+                    return web.Response(
+                        status=413,
+                        text=f"File size exceeds limit ({human_readable_size(BIZYDRAFT_MAX_FILE_SIZE)})",
+                    )
+
+                headers = {
+                    "Content-Disposition": f'attachment; filename="{uuid.uuid4()}"',
+                    "Content-Type": "application/octet-stream",
+                }
+
+                proxy_response = web.StreamResponse(headers=headers)
+                await proxy_response.prepare(request)
+
+                total_bytes = 0
+                async for chunk in resp.content.iter_chunked(BIZYDRAFT_CHUNK_SIZE):
+                    total_bytes += len(chunk)
+                    if total_bytes > BIZYDRAFT_MAX_FILE_SIZE:
+                        await proxy_response.write(b"")
+                        return web.Response(
+                            status=413,
+                            text=f"File size exceeds limit during streaming ({human_readable_size(BIZYDRAFT_MAX_FILE_SIZE)})",
+                        )
+                    await proxy_response.write(chunk)
+
+                return proxy_response
+
+    except asyncio.TimeoutError:
+        return web.Response(
+            status=504,
+            text=f"Request timed out (max {BIZYDRAFT_REQUEST_TIMEOUT//60} minutes)",
+        )
+    except Exception as e:
+        return web.Response(
+            status=502, text=f"Failed to fetch remote resource: {str(e)}"
+        )
+
+
+def human_readable_size(size_bytes):
+    if size_bytes == 0:
+        return "0B"
+    size_name = ("B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB")
+    i = int(math.floor(math.log(size_bytes, 1024)))
+    p = math.pow(1024, i)
+    s = round(size_bytes / p, 2)
+    return f"{s} {size_name[i]}"
+
+
+async def post_prompt(request):
+    json_data = await request.json()
+    logger.debug(f"Received POST request to /prompt with data: {json_data}")
+    json_data = comfy_server.trigger_on_prompt(json_data)
+
+    if "prompt" in json_data:
+        prompt = json_data["prompt"]
+        valid = execution.validate_prompt(prompt)
+        if valid[0]:
+            response = {
+                "prompt_id": None,
+                "number": None,
+                "node_errors": valid[3],
+            }
+            return web.json_response(response)
+        else:
+            return web.json_response(
+                {"error": valid[1], "node_errors": valid[3]}, status=400
+            )
+    else:
+        error = {
+            "type": "no_prompt",
+            "message": "No prompt provided",
+            "details": "No prompt provided",
+            "extra_info": {},
+        }
+        return web.json_response({"error": error, "node_errors": {}}, status=400)
+
+
+def hijack_routes():
+    routes = comfy_server.routes
+    for idx, route in enumerate(routes._items):
+        if route.path == "/view" and route.method == "GET":
+            old_handler = route.handler
+
+            async def new_handler(request):
+                return await view_image(request, old_handler)
+
+            routes._items[idx] = web.get("/view", new_handler)
+            routes._items[idx].kwargs.clear()
+            logger.info(
+                "Hijacked /view route to handle image, video and 3D streaming"
+            )
+            break
+    for idx, route in enumerate(routes._items):
+        if route.path == "/prompt" and route.method == "POST":
+            routes._items[idx] = web.post("/prompt", post_prompt)
+            logger.info("Hijacked /prompt route to handle prompt validation but not execution")
+            break

bizydraft/resp.py

@@ -0,0 +1,17 @@
+from aiohttp import web
+
+
+def JsonResponse(http_status_code, data):
+    return web.json_response(
+        data,
+        status=http_status_code,
+        content_type="application/json",
+    )
+
+
+def OKResponse():
+    return JsonResponse(200, {"message": "success", "data": {}})
+
+
+def ErrResponse(err_code):
+    return JsonResponse(err_code, {"message": "", "data": {}})

bizydraft/server.py

@@ -0,0 +1,41 @@
+import os
+
+from loguru import logger
+
+try:
+    from server import PromptServer
+except ImportError:
+    logger.error(
+        "Failed to import ComfyUI server modules, ensure PYTHONPATH is set correctly. (export PYTHONPATH=$PYTHONPATH:/path/to/ComfyUI)"
+    )
+    exit(1)
+
+
+from .resp import OKResponse, ErrResponse
+
+_API_PREFIX = "bizyair"
+_SERVER_MODE_HC_FLAG = True
+
+BIZYAIR_MAGIC_STRING = os.getenv("BIZYAIR_MAGIC_STRING", "QtDtsxAc8JI1bTb7")
+
+
+class BizyDraftServer:
+    def __init__(self):
+        BizyDraftServer.instance = self
+        self.prompt_server = PromptServer.instance
+        self.setup_routes()
+
+    def setup_routes(self):
+        @self.prompt_server.routes.get(f"/{_API_PREFIX}/are_you_alive")
+        async def are_you_alive(request):
+            if _SERVER_MODE_HC_FLAG:
+                return OKResponse()
+            return ErrResponse(500)
+
+        @self.prompt_server.routes.post(
+            f"/{_API_PREFIX}/are_you_alive_{BIZYAIR_MAGIC_STRING}"
+        )
+        async def toggle_are_you_alive(request):
+            global _SERVER_MODE_HC_FLAG
+            _SERVER_MODE_HC_FLAG = not _SERVER_MODE_HC_FLAG
+            return OKResponse()

bizydraft/static/js/handleStyle.js

@@ -0,0 +1,49 @@
+import { app } from "../../scripts/app.js";
+import { $el } from "../../scripts/ui.js";
+const styleMenus = `
+    .p-panel-content-container{
+        display: none;
+    }
+    // .side-tool-bar-container.small-sidebar{
+    //     display: none;
+    // }
+    .comfyui-menu.flex.items-center{
+        display: none;
+    }
+    .p-dialog-mask.p-overlay-mask.p-overlay-mask-enter.p-dialog-bottomright{
+        display: none !important;
+    }
+    body .bizyair-comfy-floating-button{
+        display: none;
+    }
+    .bizy-select-title-container{
+        display: none;
+    }
+    .p-button.p-component.p-button-outlined.p-button-sm{
+        display: none;
+    }
+    .workflow-tabs-container{
+        display: none;
+    }
+    body .comfyui-body-bottom{
+        display: none;
+    }
+    #comfyui-body-bottom{
+        display: none;
+    }
+    .p-dialog-mask.p-overlay-mask.p-overlay-mask-enter{
+        display: none !important;
+    }
+`
+app.registerExtension({
+    name: "comfy.BizyAir.Style",
+    async setup() {
+        $el("style", {
+            textContent: styleMenus,
+            parent: document.head,
+        });
+        window.addEventListener('load', () => {
+           document.querySelector('[data-pc-section=mask]').style.display = 'none'
+        });
+    },
+});

bizydraft/static/js/hookLoadImage.js

@@ -0,0 +1,99 @@
+import { app } from "../../scripts/app.js";
+import { fileToOss } from "./uploadFile.js";
+import { getCookie } from './tool.js';
+
+app.registerExtension({
+    name: "bizyair.image.to.oss",
+    async beforeRegisterNodeDef(nodeType, nodeData) {
+        if (nodeData.name === 'LoadImage') {
+            nodeType.prototype.onNodeCreated = async function() {
+                // const apiHost = 'http://localhost:3000/api'
+                const apiHost = 'https://uat87.bizyair.cn/api'
+                const getData = async () => {
+                    const res = await fetch(`${apiHost}/community/commit_input_resource?${
+                        new URLSearchParams({
+                            url: '',
+                            ext: '',
+                            current: 1,
+                            page_size: 100
+
+                        }).toString()
+                    }`, {
+                        method: 'GET',
+                        headers: {
+                            'Content-Type': 'application/json',
+                            'Authorization': `Bearer ${getCookie('bizy_token')}`
+                        }
+                    })
+                    const {data} = await res.json()
+                    const list = data.data.data.list || []
+                    const image_list = list.filter(item => item.name).map(item => {
+                        return {
+                            url: item.url,
+                            name: item.name
+                        }
+                        // return item.url
+                    })
+                    const image_widget = this.widgets.find(w => w.name === 'image');
+                    
+                    const node = this;
+
+                    image_widget.options.values = image_list.map(item => item.name);
+                    
+                    // image_widget.value = image_list[0].url;
+                    // image_widget.value = image_list[0];
+                    if (image_list[0] && image_list[0].url) {
+                        previewImage(node, decodeURIComponent(image_list[0].url))
+                    }
+                    image_widget.callback = function(e) {
+                        const image_url = decodeURIComponent(image_list.find(item => item.name === e).url);
+                        previewImage(node, image_url)
+                    }
+                }
+                getData()
+                
+
+                const upload_widget = this.widgets.find(w => w.name === 'upload');
+                upload_widget.callback = async function() {
+                    const input = document.createElement('input');
+                    input.type = 'file';
+                    input.accept = 'image/*';
+                    input.onchange = async (e) => {
+                        const file = e.target.files[0];
+                        await fileToOss(file);
+
+                        getData()
+                    }
+                    input.click();
+                }
+            }
+        }
+    }
+})
+
+function previewImage(node, image_url) {
+    const img = new Image();
+    img.onload = function() {
+        node.imgs = [img];
+        if (node.graph) {
+            node.graph.setDirtyCanvas(true);
+        } else {
+            console.warn('[BizyAir] 无法访问graph对象进行重绘');
+        }
+        const imageOutputStore = 
+            node.nodeOutputStore || 
+            window.app?.nodeOutputStore || 
+            app?.nodeOutputStore;
+            
+        if (imageOutputStore) {
+            console.log('[BizyAir] 设置节点输出数据');
+            imageOutputStore.setNodeOutputs(node, image_url, { isAnimated: false });
+        } else {
+            console.warn('[BizyAir] 未找到nodeOutputStore');
+        }
+    };
+    img.onerror = function(err) {
+        console.error('[BizyAir] 图片加载失败:', image_url, err);
+    };
+    img.src = image_url;
+}

bizydraft/static/js/main.js

@@ -0,0 +1,5 @@
+// 主入口文件，导入所有模块
+import "./hookLoadImage.js";
+import "./hookSaveImage.js";
+import "./postEvent.js";
+import "./handleStyle.js";

bizydraft/static/js/postEvent.js

@@ -0,0 +1,412 @@
+import { app } from "../../scripts/app.js";
+// import { $el } from "../../scripts/ui.js";
+
+// import { WebSocketClient } from './socket.js';
+
+
+
+app.registerExtension({
+    name: "comfy.BizyAir.Socket",
+
+    dispatchCustomEvent(type, detail) {
+        app.api.dispatchCustomEvent(type, detail);
+    },
+
+    customSocket(callback, customUrl) {
+        const url = customUrl || app.api.socket.url;
+        // const clientId = 'e07abdf5f465462f8dc43ca0812e9284';
+        // const socket = new WebSocket(url + "?clientId=" + sessionStorage.getItem("clientId"));
+        // const socket = new WebSocket(url + "?clientId=" + clientId);
+        const socket = new WebSocket(url);
+
+        const dispatchCustomEvent = this.dispatchCustomEvent;
+
+        socket.onmessage = function (event) {
+            try {
+                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;
+                        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}`
+                            );
+                    }
+                } else {
+                    const msg = JSON.parse(event.data);
+                    switch (msg.type) {
+                        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
+                                socket.clientId = clientId;
+                            }
+                            dispatchCustomEvent('status', msg.data.status ?? null);
+                            break;
+                        case 'executing':
+                            // msg.data.prompt_id && (msg.data.prompt_id = '');
+
+                            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 '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}`);
+                            }
+                    }
+                }
+            } catch (error) {
+                console.warn('Unhandled message:', event.data, error);
+            }
+        };
+
+        socket.registeredTypes = new Set();
+        socket.reportedUnknownMessageTypes = new Set();
+
+        // 替换app.api.socket
+        app.api.socket = socket;
+
+        if (typeof callback === 'function') {
+            callback(socket);
+        }
+
+        return socket;
+    },
+
+    startSocket(callback) {
+        if (app.api.socket.readyState === WebSocket.CLOSED || app.api.socket.readyState === WebSocket.CLOSING) {
+            return this.customSocket(callback);
+        }
+        return app.api.socket;
+    },
+
+    closeSocket() {
+        if (app.api.socket && (app.api.socket.readyState === WebSocket.OPEN || app.api.socket.readyState === WebSocket.CONNECTING)) {
+            app.api.socket.close();
+            return true;
+        }
+        return false;
+    },
+
+    changeSocketUrl(newUrl, callback) {
+        this.closeSocket();
+        const clientId = sessionStorage.getItem("clientId");
+        const socket = new WebSocket(newUrl + "?clientId=" + clientId + "&a=1");
+        const send = app.api.socket.send;
+        const onopen = app.api.socket.onopen;
+        const onmessage = app.api.socket.onmessage;
+        const onerror = app.api.socket.onerror;
+        const onclose = app.api.socket.onclose;
+
+        app.api.socket = socket;
+        app.api.socket.send = send;
+        app.api.socket.onopen = onopen;
+        app.api.socket.onmessage = onmessage;
+        app.api.socket.onerror = onerror;
+        app.api.socket.onclose = onclose;
+
+        if (typeof callback === 'function') {
+            callback(socket);
+        }
+
+        return socket;
+    },
+
+    sendSocketMessage(message) {
+        if (app.api.socket && app.api.socket.readyState === WebSocket.OPEN) {
+            app.api.socket.send(typeof message === 'string' ? message : JSON.stringify(message));
+            return true;
+        }
+        return false;
+    },
+
+    sendPrompt(prompt) {
+        app.queuePrompt(prompt);
+    },
+    getCookie(name) {
+        const value = `; ${document.cookie}`;
+        const parts = value.split(`; ${name}=`);
+        if (parts.length === 2) return parts.pop().split(';').shift();
+    },
+    // doSendSocket() {
+    //     const socket = new WebSocketClient(`/w/v1/comfy/draft/ws?clientId=${sessionStorage.getItem("clientId")
+    //         }&userId=${this.getCookie("user_id")
+    //         }`);
+    //     const customSocket = this.customSocket.bind(this);
+    //     socket.on('message', (message) => {
+    //         let data = JSON.parse(message.data);
+    //         if (data.status == "Running") {
+    //             customSocket(() => {}, data.wsUrl);
+    //         }
+    //     });
+    // },
+
+
+    async setup() {
+        const customSocket = this.customSocket.bind(this);
+        const startSocket = this.startSocket.bind(this);
+        const closeSocket = this.closeSocket.bind(this);
+        const changeSocketUrl = this.changeSocketUrl.bind(this);
+        const sendSocketMessage = this.sendSocketMessage.bind(this);
+        // let iTimer = null;
+
+        // // 直接检查一次
+        // const initialUserId = this.getCookie("user_id");
+        // if (initialUserId) {
+        //     // 初始检查到 userId
+        //     this.doSendSocket();
+        // }
+
+        // // 使用定时器监听cookie变化
+        // let lastCookieValue = this.getCookie("user_id");
+        // iTimer = setInterval(() => {
+        //     const currentCookieValue = this.getCookie("user_id");
+        //     if (currentCookieValue && currentCookieValue !== lastCookieValue) {
+        //         // 检测到 cookie user_id 变化
+        //         lastCookieValue = currentCookieValue;
+        //         this.doSendSocket();
+        //         clearInterval(iTimer);
+        //     }
+        // }, 300); // 每秒检查一次
+
+        const methods = {
+            customSocket: function (params) {
+                const callback = params.callback ? new Function('socket', params.callback) : null;
+                const socket = customSocket(callback, params.url);
+                window.parent.postMessage({
+                    type: 'functionResult',
+                    method: 'customSocket',
+                    result: '自定义socket执行结果'
+                }, '*');
+                return socket;
+            },
+
+            startSocket: function (params) {
+                const callback = params.callback ? new Function('socket', params.callback) : null;
+                const socket = startSocket(callback);
+                window.parent.postMessage({
+                    type: 'functionResult',
+                    method: 'startSocket',
+                    result: 'Socket连接已启动'
+                }, '*');
+                return socket;
+            },
+
+            closeSocket: function () {
+                const result = closeSocket();
+                window.parent.postMessage({
+                    type: 'functionResult',
+                    method: 'closeSocket',
+                    result: result ? 'Socket连接已关闭' : 'Socket连接关闭失败或已关闭'
+                }, '*');
+                return result;
+            },
+
+            changeSocketUrl: function (params) {
+                if (!params.url) {
+                    console.error('缺少url参数');
+                    return false;
+                }
+                const callback = params.callback ? new Function('socket', params.callback) : null;
+                const socket = changeSocketUrl(params.url, callback);
+                window.parent.postMessage({
+                    type: 'functionResult',
+                    method: 'changeSocketUrl',
+                    result: 'Socket URL已更改为' + params.url
+                }, '*');
+                return socket;
+            },
+
+            sendSocketMessage: function (params) {
+                if (!params.message) {
+                    console.error('缺少message参数');
+                    return false;
+                }
+                const result = sendSocketMessage(params.message);
+                window.parent.postMessage({
+                    type: 'functionResult',
+                    method: 'sendSocketMessage',
+                    result: result ? '消息发送成功' : '消息发送失败'
+                }, '*');
+                return result;
+            },
+
+            clearCanvas: function () {
+                app.graph.clear();
+                window.parent.postMessage({
+                    type: 'functionResult',
+                    method: 'clearCanvas',
+                    result: true
+                }, '*');
+                return true;
+            },
+
+            loadWorkflow: function (params) {
+                app.graph.clear();
+                if (params.json.version) {
+                    app.loadGraphData(params.json);
+                } else {
+                    app.loadApiJson(params.json, 'bizyair');
+                }
+                console.log("-----------loadWorkflow-----------", params.json)
+                window.parent.postMessage({
+                    type: 'functionResult',
+                    method: 'loadWorkflow',
+                    result: true
+                }, '*');
+                return true;
+            },
+
+            saveWorkflow: async function () {
+                const graph = await app.graphToPrompt();
+                window.parent.postMessage({
+                    type: 'functionResult',
+                    method: 'saveWorkflow',
+                    result: graph.workflow
+                }, '*');
+                return graph.workflow;
+            },
+            getWorkflow: async function () {
+                const graph = await app.graphToPrompt();
+                window.parent.postMessage({
+                    type: 'functionResult',
+                    method: 'getWorkflow',
+                    result: graph.workflow
+                }, '*');
+                return graph.workflow;
+            },
+            saveApiJson: async function (params) {
+                const graph = await app.graphToPrompt();
+                window.parent.postMessage({
+                    type: 'functionResult',
+                    method: 'saveApiJson',
+                    result: graph.output
+                }, '*');
+                return graph.output;
+            },
+            getClientId: function () {
+                const clientId = sessionStorage.getItem("clientId");
+                window.parent.postMessage({
+                    type: 'functionResult',
+                    method: 'getClientId',
+                    result: clientId
+                }, '*');
+                return clientId;
+            },
+            runWorkflow: async function () {
+                const graph = await app.graphToPrompt();
+                const res = await app.queuePrompt(graph.output);
+                console.log("-----------queuePrompt-----------", res)
+                const clientId = sessionStorage.getItem("clientId");
+                window.parent.postMessage({
+                    type: 'functionResult',
+                    method: 'runWorkflow',
+                    result: {
+                        clientId: clientId,
+                        jsonWorkflow: graph.output,
+                        workflow: graph.workflow
+                    }
+                }, '*');
+                return true;
+            },
+            setCookie: function (params) {
+                const setCookie = (name, value, days) => {
+                    let expires = "";
+                    if (days) {
+                        const date = new Date();
+                        date.setTime(date.getTime() + (days * 24 * 60 * 60 * 1000));
+                        expires = "; expires=" + date.toUTCString();
+                    }
+                    document.cookie = name + "=" + (value || "") + expires + "; path=/";
+                };
+                console.log("-----------setCookie-----------", params)
+                setCookie(params.name, params.value, params.days);
+                // window.parent.postMessage({
+                //     type: 'functionResult',
+                //     method: 'setCookie',
+                //     result: true
+                // }, '*');
+                return true;
+            },
+            fitView: function () {
+                // window.app.canvas.ds.offset = [0, 0];
+                // window.app.canvas.ds.scale = 1;
+                // window.app.canvas.setDirty(true, true);
+                app.canvas.fitViewToSelectionAnimated()
+
+                window.parent.postMessage({
+                    type: 'functionResult',
+                    method: 'fitView',
+                    result: true
+                }, '*');
+                return true;
+            }
+        };
+
+        window.addEventListener('message', function (event) {
+            if (event.data && event.data.type === 'callMethod') {
+                const methodName = event.data.method;
+                const params = event.data.params || {};
+
+                if (methods[methodName]) {
+                    methods[methodName](params);
+                } else {
+                    console.error('方法不存在:', methodName);
+                }
+            }
+        });
+        window.parent.postMessage({ type: 'iframeReady' }, '*');
+    }
+});

bizydraft/static/js/socket.js

@@ -0,0 +1,120 @@
+export class WebSocketClient {
+  constructor(url, protocols) {
+
+    const host = 'uat-api.bizyair.cn';
+    
+    if (url.startsWith('ws://') || url.startsWith('wss://')) {
+      this.url = url;
+    } else {
+      this.url = `${location.protocol == 'http:' ? 'wss' : 'wss'}://${host}${url}`
+    }
+    this.protocols = protocols
+    this.reconnectDelay = 1000
+    this.maxReconnectDelay = 30000
+    this.keepAliveInterval = 10000
+    this.ws = null
+    this.keepAliveTimer = null
+    this.reconnectTimer = null
+
+    this.connect()
+  }
+
+  connect() {
+    this.ws = new WebSocket(this.url, this.protocols)
+    this.ws.onopen = () => {
+      this.onOpen()
+    }
+
+    this.ws.onmessage = (message) => {
+      if (message.data !== 'pong') {
+        this.onMessage(message)
+      }
+    }
+
+    this.ws.onerror = (error) => {
+      this.onError(error)
+    }
+
+    this.ws.onclose = () => {
+      console.warn('The WebSocket connection has been closed and is ready to be reconnected')
+      this.onClose()
+      this.scheduleReconnect()
+    }
+  }
+
+  startKeepAlive() {
+    if (this.keepAliveTimer) return
+
+    this.keepAliveTimer = setInterval(() => {
+      if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+        this.ws.send('ping')
+      }
+    }, this.keepAliveInterval)
+  }
+
+  stopKeepAlive() {
+    if (this.keepAliveTimer) {
+      clearInterval(this.keepAliveTimer)
+      this.keepAliveTimer = null
+    }
+  }
+
+  scheduleReconnect() {
+    if (this.reconnectTimer) return
+
+    this.reconnectTimer = setTimeout(() => {
+      console.log(`Attempt to reconnect...`)
+      this.connect()
+      this.reconnectTimer = null
+
+      this.reconnectDelay = Math.min(this.reconnectDelay * 2, this.maxReconnectDelay)
+    }, this.reconnectDelay)
+  }
+
+  onOpen() {
+    this.reconnectDelay = 2000
+    this.startKeepAlive()
+  }
+
+  onMessage(message) {
+    message
+    // const data = JSON.parse(message.data);
+    // if (data === 'pong') {
+    //   // Do nothing
+    // } else {
+    //   console.log('message:', data);
+    // }
+  }
+
+  onError(error) {
+    console.error('WebSocket Error: ', error)
+  }
+
+  onClose() {
+    this.stopKeepAlive()
+  }
+
+  close() {
+    if (this.ws) {
+      this.ws.close()
+    }
+    this.stopKeepAlive()
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer)
+      this.reconnectTimer = null
+    }
+  }
+
+  on(event, callback) {
+    if (event === 'message') {
+      this.onMessage = callback;
+    } else if (event === 'open') {
+      this.onOpen = callback;
+    } else if (event === 'error') {
+      this.onError = callback;
+    } else if (event === 'close') {
+      this.onClose = callback;
+    }
+    return this;
+  }
+}

bizydraft/static/js/tool.js

@@ -0,0 +1,6 @@
+export function getCookie(name) {
+    const value = `; ${document.cookie}`;
+    const parts = value.split(`; ${name}=`);
+    if (parts.length === 2) return parts.pop().split(';').shift();
+    return null;
+}

bizydraft/static/js/uploadFile.js

@@ -0,0 +1,165 @@
+import { getCookie } from './tool.js';
+export async function fileToOss(file) {
+  try {
+
+    // 检查token是否存在
+    const apiHost = 'https://uat87.bizyair.cn/api'
+    // const apiHost = 'http://localhost:3000/api'
+    const authToken = getCookie('bizy_token')
+    console.log(authToken)
+    if (!authToken) {
+      throw new Error('未找到认证Token，请先登录');
+    }
+    
+    // 获取上传凭证
+    const uploadToken = await fetch(`${apiHost}/community/upload_token?file_name=${encodeURIComponent(file.name)}&file_type=inputs`, {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${authToken}`
+      }
+    });
+    
+    // 检查响应状态
+    if (!uploadToken.ok) {
+      const errorText = await uploadToken.text();
+      console.error('获取上传凭证失败:', uploadToken.status, errorText);
+      throw new Error(`获取上传凭证失败: ${uploadToken.status} ${uploadToken.statusText}`);
+    }
+    
+    const {data} = await uploadToken.json();
+    console.log('上传凭证响应:', data);
+    
+    // 使用STS凭证上传
+    const ossConfig = {
+      accessKeyId: data.data.file.access_key_id,
+      accessKeySecret: data.data.file.access_key_secret,
+      securityToken: data.data.file.security_token,
+      bucket: data.data.storage.bucket,
+      region: data.data.storage.region,
+      objectKey: data.data.file.object_key
+    };
+    
+    console.log('OSS配置:', ossConfig);
+    
+    // 改用官方推荐的表单上传方式
+    const formData = new FormData();
+    
+    // 构建Policy
+    const expiration = new Date();
+    expiration.setHours(expiration.getHours() + 1); // Policy过期时间1小时
+    
+    const policyObj = {
+      expiration: expiration.toISOString(),
+      conditions: [
+        // 文件大小限制
+        ['content-length-range', 0, 1048576000], // 最大1000MB
+        // 指定允许的文件名前缀
+        ['starts-with', '$key', ossConfig.objectKey.split('/')[0]]
+      ]
+    };
+    
+    // Policy Base64编码
+    const policy = btoa(JSON.stringify(policyObj));
+    console.log('Policy:', policy);
+    
+    // 构建表单字段
+    formData.append('key', ossConfig.objectKey);
+    formData.append('OSSAccessKeyId', ossConfig.accessKeyId);
+    formData.append('policy', policy);
+    formData.append('success_action_status', '200');
+    
+    // 如果有临时token，需要添加
+    if (ossConfig.securityToken) {
+      formData.append('x-oss-security-token', ossConfig.securityToken);
+    }
+    
+    // 计算签名 - 阿里云官方要求使用HMAC-SHA1
+    const signature = await hmacSha1(policy, ossConfig.accessKeySecret);
+    console.log('计算的签名:', signature);
+    formData.append('signature', signature);
+    
+    // 最后添加文件内容
+    formData.append('file', file);
+    
+    // OSS服务端点
+    const host = `https://${ossConfig.bucket}.${ossConfig.region}.aliyuncs.com`;
+    console.log('上传地址:', host);
+    
+    // 开始上传
+    const uploadResponse = await fetch(host, {
+      method: 'POST',
+      body: formData
+    });
+    
+    // 检查响应
+    if (!uploadResponse.ok) {
+      const errorText = await uploadResponse.text();
+      console.error('上传失败:', uploadResponse.status, errorText);
+      throw new Error(`上传失败: ${uploadResponse.status} ${uploadResponse.statusText}`);
+    }
+    
+    // 构建公开访问URL
+    const fileUrl = `${host}/${ossConfig.objectKey}`;
+
+    // 提交资源
+    await fetch(`${apiHost}/community/commit_input_resource`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${authToken}`
+      },
+      body: JSON.stringify({
+        object_key: data.data.file.object_key,
+        name: file.name,
+      })
+    })
+    return {
+      url: fileUrl,
+      ossTokenFile: data.data.file,
+      ossTokenStorage: data.data.storage
+    };
+  } catch (error) {
+    console.error('文件上传到OSS失败:', error);
+    
+    throw error;
+  }
+}
+
+// 使用标准的HMAC-SHA1签名算法
+async function hmacSha1(message, key) {
+  // 使用浏览器原生的SubtleCrypto API
+  const encoder = new TextEncoder();
+  const keyData = encoder.encode(key);
+  const messageData = encoder.encode(message);
+  
+  // 导入密钥
+  const cryptoKey = await window.crypto.subtle.importKey(
+    'raw',
+    keyData,
+    { name: 'HMAC', hash: 'SHA-1' },
+    false,
+    ['sign']
+  );
+  
+  // 计算签名
+  const signature = await window.crypto.subtle.sign(
+    'HMAC',
+    cryptoKey,
+    messageData
+  );
+  
+  // 转换为Base64编码
+  const base64Signature = arrayBufferToBase64(signature);
+  return base64Signature;
+}
+
+// 将ArrayBuffer转换为Base64字符串
+function arrayBufferToBase64(buffer) {
+  const bytes = new Uint8Array(buffer);
+  let binary = '';
+  for (let i = 0; i < bytes.byteLength; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+}

bizydraft-0.1.0.dist-info/METADATA

@@ -0,0 +1,3 @@
+Metadata-Version: 2.4
+Name: bizydraft
+Version: 0.1.0

bizydraft-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+bizydraft/__init__.py,sha256=qV8OhBrI5PgWcmvkYd5E0L2IiYjtbDSK3zyWpKspv0w,74
+bizydraft/hijack_nodes.py,sha256=CrvATjtlfgvlCcd-7TawWCBlVwBVvsnNCFgGgccuLb8,752
+bizydraft/hijack_routes.py,sha256=rXCtb9T0eZ2FCV9DymkIV9xlXGcgNU86lcxFubGRvxw,6152
+bizydraft/resp.py,sha256=8INvKOe5Dgai3peKfqKjrhUoYeuXWXn358w30-_cY-A,369
+bizydraft/server.py,sha256=wbpK_fJVgnvYHQieZvFN_TCvrdyN5Rsmv0DL9waoIXU,1166
+bizydraft/static/js/handleStyle.js,sha256=RJbDRZMeb3_32JqPfOzxnZGVONb-WnXYrQDxIeu0Miw,1263
+bizydraft/static/js/hookLoadImage.js,sha256=cEaqedTnngieI-Kb0PVgLor1nVDkFQx1_7AiurwtRwI,3878
+bizydraft/static/js/main.js,sha256=cZ-7wR9T8aNLzIrTjc-g9xVZf7z6TXWl1zhP_wXSSVo,150
+bizydraft/static/js/postEvent.js,sha256=4PVl929jU1m3ooKA1lFXNWgv62mtKAFnhqbsHVBUYi8,16488
+bizydraft/static/js/socket.js,sha256=iNxbUPSQluIlx1x0MIVL7UJ35BXqLH7Z2s8vmfmbyyc,2643
+bizydraft/static/js/tool.js,sha256=IlDVjddodT9DtfdIGiIzSIKdxbUMztDLQ4jI0uFJCwk,206
+bizydraft/static/js/uploadFile.js,sha256=7PXMYRlgxgDWFFbsaasjf3TelsW6r9mD1TFTjQI6X0E,4957
+bizydraft-0.1.0.dist-info/METADATA,sha256=XouCMG6uu1cvKr8HJvUTPpx4EqAtJMlgYfBXmC2d2tE,53
+bizydraft-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+bizydraft-0.1.0.dist-info/top_level.txt,sha256=XtoBq6hjZhXIM7aas4GtPDtAiKo8FdLzMABXW8qqQ8M,10
+bizydraft-0.1.0.dist-info/RECORD,,

bizydraft-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

bizydraft-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+bizydraft