Track bundled vendor runtime sources

vendor/aigcpanel/electron/mapi/server/api.ts

@@ -0,0 +1,464 @@
+import { net } from "electron";
+import { Client, handle_file } from "@gradio/client";
+import { platformArch, platformName, platformUUID } from "../../lib/env";
+import { Events } from "../event/main";
+import { Apps } from "../app";
+import { Files } from "../file/main";
+import fs from "node:fs";
+import User, { UserApi } from "../user/main";
+import { EncodeUtil, MemoryMapCacheUtil } from "../../lib/util";
+import { ServerContext, ServerFunctionDataType } from "./type";
+import { UploadUtil } from "../../lib/upload";
+import { Log } from "../log/main";
+
+type RequestOptionType = {
+    method?: "POST" | "GET";
+    timeout?: number;
+    headers?: Record<string, string>;
+    responseType?: "json" | "text";
+    retry?: number;
+    retryTimes?: number;
+    retryInterval?: number;
+};
+
+const request = async (url, data?: {}, option?: RequestOptionType) => {
+    option = Object.assign(
+        {
+            method: "GET",
+            timeout: 60 * 1000,
+            headers: {
+                "Content-Type": "application/json",
+            },
+            responseType: "json" as "json",
+            retry: 0,
+            retryTimes: 0,
+            retryInterval: 5,
+        },
+        option,
+    );
+    if (option["method"] === "GET") {
+        url += "?";
+        for (let key in data) {
+            url += `${key}=${data[key]}&`;
+        }
+    }
+    return new Promise((resolve, reject) => {
+        const req = net.request({
+            url,
+            method: option["method"],
+            headers: option["headers"],
+        });
+        req.on("response", (response) => {
+            let body = "";
+            response.on("data", (chunk) => {
+                body += chunk.toString();
+            });
+            response.on("end", () => {
+                if ("json" === option["responseType"]) {
+                    try {
+                        resolve(JSON.parse(body));
+                    } catch (e) {
+                        if (
+                            option.retry > 0 &&
+                            option.retryTimes < option.retry
+                        ) {
+                            option.retryTimes++;
+                            Log.info(
+                                "request",
+                                `retry ${option.retryTimes} ${url}`,
+                            );
+                            setTimeout(() => {
+                                request(url, data, option)
+                                    .then(resolve)
+                                    .catch(reject);
+                            }, option.retryInterval * 1000);
+                        } else {
+                            resolve({
+                                code: -1,
+                                msg: `ResponseError: ${body}`,
+                            });
+                        }
+                    }
+                } else {
+                    resolve(body);
+                }
+            });
+        });
+        req.on("error", (err) => {
+            if (option.retry > 0 && option.retryTimes < option.retry) {
+                option.retryTimes++;
+                Log.info("request", `retry ${option.retryTimes} ${url}`);
+                setTimeout(() => {
+                    request(url, data, option).then(resolve).catch(reject);
+                }, option.retryInterval * 1000);
+            } else {
+                reject(err);
+            }
+        });
+        if (option["method"] === "POST") {
+            req.write(JSON.stringify(data));
+        }
+        req.end();
+    });
+};
+
+const requestPost = async (url, data?: {}, option?: RequestOptionType) => {
+    option = Object.assign(
+        {
+            method: "POST",
+        },
+        option,
+    );
+    return request(url, data, option);
+};
+
+const requestGet = async (url, data?: {}, option?: RequestOptionType) => {
+    option = Object.assign(
+        {
+            method: "GET",
+        },
+        option,
+    );
+    return request(url, data, option);
+};
+
+const requestPostSuccess = async (
+    url,
+    data?: {},
+    option?: RequestOptionType,
+) => {
+    const res = await requestPost(url, data, option);
+    if (res["code"] === 0) {
+        return res;
+    }
+    throw new Error(res["msg"]);
+};
+
+const requestUrlFileToLocal = async (url, path) => {
+    return new Promise((resolve, reject) => {
+        const req = net.request(url);
+        req.on("response", (response) => {
+            const file = fs.createWriteStream(path);
+            // @ts-ignore
+            response.pipe(file);
+            file.on("finish", () => {
+                file.close();
+                resolve("x");
+            });
+        });
+        req.on("error", (err) => {
+            reject(err);
+        });
+        req.end();
+    });
+};
+
+const requestEventSource = async (
+    url: string,
+    param: any,
+    option?: {
+        method?: "POST" | "GET";
+        headers?: Record<string, string>;
+        onMessage: (data: any) => void;
+        onEnd?: () => void;
+    },
+) => {
+    option = Object.assign(
+        {
+            method: "POST",
+            headers: {},
+            onMessage: (data: any) => {
+                console.log("onMessage", data);
+            },
+            onEnd: () => {
+                console.log("onEnd");
+            },
+        },
+        option,
+    );
+    // return new Promise((resolve, reject) => {
+    //     const req = net.request({
+    //         url,
+    //         method: option.method,
+    //         headers: {
+    //             'Content-Type': 'application/json',
+    //             ...option.headers,
+    //         },
+    //     })
+    //     req.on('response', (response) => {
+    //         console.log('response', response)
+    //         let buffer = ''
+    //         response.on('data', (chunk) => {
+    //             console.log('response.data', chunk)
+    //             buffer += chunk.toString()
+    //             const lines = buffer.split("\n")
+    //             buffer = lines.pop()
+    //             for (const line of lines) {
+    //                 if (line.startsWith("data: ")) {
+    //                     const data = line.slice(6)
+    //                     if ('[END]' === data) {
+    //                         option.onEnd()
+    //                         return;
+    //                     }
+    //                     const eventData = line.slice(6).trim();
+    //                     option.onMessage(EncodeUtil.base64Decode(eventData))
+    //                 }
+    //             }
+    //         })
+    //         response.on('end', () => {
+    //             resolve(undefined)
+    //         })
+    //     })
+    //     req.on('error', (err) => {
+    //         reject(err)
+    //     })
+    //     req.end()
+    // });
+    const response = await net.fetch(url, {
+        method: option.method,
+        headers: {
+            "Content-Type": "application/json",
+            ...option.headers,
+        },
+        body: JSON.stringify(param || {}),
+    });
+    if (!response.ok) {
+        throw new Error(`HTTP error! Status: ${response.status}`);
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+            break;
+        }
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop();
+        // console.log('fetchEventSource', JSON.stringify(buffer))
+        for (const line of lines) {
+            // console.log('line', JSON.stringify(line))
+            if (line.startsWith("data: ")) {
+                const data = line.slice(6);
+                if ("[END]" === data) {
+                    option.onEnd();
+                    return;
+                }
+                const eventData = line.slice(6).trim();
+                option.onMessage(EncodeUtil.base64Decode(eventData));
+            }
+        }
+    }
+};
+
+const env = async () => {
+    const result = {};
+    result["AIGCPANEL_SERVER_API_TOKEN"] = await User.getApiToken();
+    result["AIGCPANEL_SERVER_UUID"] = platformUUID();
+    return result;
+};
+
+const sleep = async (ms) => {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+};
+
+const launcherCancel = async (context: ServerContext) => {
+    const ret = (await requestPost(`${context.url()}cancel`, {})) as any;
+    // console.log('cancel', JSON.stringify(ret))
+    if (ret.code) {
+        throw new Error(`cancel ${ret.msg}`);
+    }
+};
+
+const launcherSubmitAndQuery = async (
+    context: ServerContext,
+    data: ServerFunctionDataType,
+    option?: {
+        timeout: number;
+    },
+): Promise<{
+    result: {
+        [key: string]: any;
+    };
+    endTime: number;
+}> => {
+    option = Object.assign(
+        {
+            timeout: 24 * 3600,
+        },
+        option,
+    );
+    const submitRet = (await requestPost(
+        `${context.url()}submit`,
+        data,
+    )) as any;
+    // console.log('submitRet', JSON.stringify(submitRet))
+    if (submitRet.code) {
+        throw new Error(`submit ${submitRet.msg}`);
+    }
+    const launcherResult = {
+        result: {} as {
+            [key: string]: any;
+        },
+        endTime: null,
+    };
+    const totalWait = Math.ceil(option.timeout / 5);
+    for (let i = 0; i < totalWait; i++) {
+        if (i >= totalWait - 1) {
+            throw new Error("timeout");
+        }
+        await sleep(5000);
+        const queryRet = (await requestPost(
+            `${context.url()}query`,
+            {
+                token: submitRet.data.token,
+            },
+            {
+                retry: 3,
+            },
+        )) as any;
+        // console.log('queryRet', JSON.stringify(queryRet))
+        if (queryRet.code) {
+            throw new Error(queryRet.msg);
+        }
+        let logs = queryRet.data.logs;
+        if (logs) {
+            logs = EncodeUtil.base64Decode(logs);
+            if (logs) {
+                await Files.appendText(context.ServerInfo.logFile, logs);
+                const result = extractResultFromLogs(data.id, logs);
+                if (result) {
+                    launcherResult.result = Object.assign(
+                        launcherResult.result,
+                        result,
+                    );
+                    context.send("taskResult", { id: data.id, result });
+                }
+            }
+        }
+        if (queryRet.data.status === "running") {
+            continue;
+        } else if (queryRet.data.status === "success") {
+            launcherResult.endTime = Date.now();
+            await Files.appendText(context.ServerInfo.logFile, "success");
+        } else {
+            let msg = "请在模型日志中查看错误日志";
+            if (launcherResult.result && launcherResult.result.msg) {
+                msg = launcherResult.result.msg;
+            }
+            throw `运行错误：${msg}`;
+        }
+        break;
+    }
+    return launcherResult;
+};
+
+const launcherPrepareConfigJson = async (data: any) => {
+    const configJson = await Files.temp("json");
+    await Files.write(configJson, JSON.stringify(data), { isDataPath: false });
+    return configJson;
+};
+
+const launcherSubmitConfigJsonAndQuery = async (
+    context: ServerContext,
+    configData: any,
+) => {
+    if (!("setting" in configData)) {
+        configData.setting = context.ServerInfo.setting;
+    }
+    const configJsonPath = await launcherPrepareConfigJson(configData);
+    const result = await launcherSubmitAndQuery(context, {
+        id: configData.id,
+        result: {},
+        entryPlaceholders: {
+            CONFIG: configJsonPath,
+        },
+        root: context.ServerInfo.localPath,
+    });
+    await Files.deletes(configJsonPath, { isDataPath: false });
+    return result;
+};
+
+const extractResultFromLogs = (dataId: string, logs: string) => {
+    let result = null;
+    logs.split("\n").forEach((line) => {
+        // regex AigcPanelRunResult[VideoGen_121][xxxxx=]
+        const match = line.match(
+            new RegExp(`AigcPanelRunResult\\[${dataId}\\]\\[(.*?)\\]`),
+        );
+        // console.log('match', {_data, match})
+        if (match) {
+            const matchResult = JSON.parse(EncodeUtil.base64Decode(match[1]));
+            result = Object.assign(result || {}, matchResult);
+        }
+    });
+    return result;
+};
+
+const availablePort = async (
+    port: number,
+    setting: {
+        port?: number;
+    },
+) => {
+    setting = setting || {};
+    if (port) {
+        return port;
+    }
+    if (setting["port"]) {
+        port = parseInt(setting["port"] as any);
+    } else if (!port || !(await Apps.isPortAvailable(port))) {
+        port = await Apps.availablePort(50617);
+    }
+    return port;
+};
+
+const pathSep = () => {
+    return process.platform === "win32" ? ";" : ":";
+};
+
+const getPathEnv = (addition: string | string[] = null) => {
+    let p = process.env["PATH"] || "";
+    if (addition) {
+        const sep = pathSep();
+        if (typeof addition === "string") {
+            addition = [addition];
+        }
+        for (let path of addition) {
+            if (p.indexOf(path) === -1) {
+                p = `${path}${sep}${p}`;
+            }
+        }
+    }
+    return p;
+};
+
+export default {
+    GradioClient: Client,
+    GradioHandleFile: handle_file,
+    event: Events,
+    file: Files,
+    app: Apps,
+    request,
+    requestPost,
+    requestGet,
+    requestPostSuccess,
+    requestUrlFileToLocal,
+    requestEventSource,
+    platformName: platformName(),
+    platformArch: platformArch(),
+    env,
+    sleep,
+    base64Encode: EncodeUtil.base64Encode,
+    base64Decode: EncodeUtil.base64Decode,
+    launcherCancel,
+    launcherSubmitAndQuery,
+    launcherPrepareConfigJson,
+    launcherSubmitConfigJsonAndQuery,
+    extractResultFromLogs,
+    availablePort,
+    getPathEnv,
+};

vendor/aigcpanel/electron/mapi/server/error.ts

@@ -0,0 +1,24 @@
+export const mapError = (e) => {
+    let msg = e;
+    if (e instanceof Error) {
+        msg = [e.message, e.stack].join("\n");
+    } else if (typeof e !== "string") {
+        msg = e.toString();
+    }
+    const map = {
+        // 'fetch error': '网络错误',
+    };
+    for (let key in map) {
+        if (msg.includes(key)) {
+            let error = map[key];
+            // regex PluginReleaseDocFormatError:-11
+            const regex = new RegExp(`${key}:(-?\\d+)`);
+            const match = msg.match(regex);
+            if (match) {
+                error += `(${match[1]})`;
+            }
+            return error;
+        }
+    }
+    return msg;
+};

vendor/aigcpanel/electron/mapi/server/main.ts

@@ -0,0 +1,269 @@
+import ServerApi from "./api";
+import { ipcMain } from "electron";
+import { Log } from "../log/main";
+import { mapError } from "./error";
+import { AigcServer } from "../../aigcserver";
+import { SendType, ServerContext, ServerInfo } from "./type";
+import { Files } from "../file/main";
+import { getGpuInfo } from "../../lib/env-main";
+import { EnumServerType } from "../../../src/types/Server";
+
+ipcMain.handle("server:listGpus", async (event) => {
+    return await getGpuInfo();
+});
+
+let runningServerCount = 0;
+ipcMain.handle(
+    "server:runningServerCount",
+    async (event, count: number | null) => {
+        if (count === null) {
+            return runningServerCount;
+        }
+        // console.log('runningServerCount', count)
+        runningServerCount = count;
+        return runningServerCount;
+    },
+);
+const getRunningServerCount = () => {
+    return runningServerCount;
+};
+
+const serverModule: {
+    [key: string]: ServerContext;
+} = {};
+
+const init = () => {};
+
+const getModule = async (
+    serverInfo: ServerInfo,
+    option?: {
+        throwException: boolean;
+    },
+): Promise<ServerContext> => {
+    option = Object.assign(
+        {
+            throwException: true,
+        },
+        option,
+    );
+    // console.log('getModule', serverInfo)
+    if (!serverModule[serverInfo.localPath]) {
+        try {
+            if (serverInfo.name.startsWith("Cloud")) {
+                const server = new AigcServer["Cloud"]();
+                server.type = "buildIn";
+                server.ServerApi = ServerApi;
+                await server.init();
+                serverModule[serverInfo.localPath] = server;
+            } else if (serverInfo.name in AigcServer) {
+                const server = AigcServer[serverInfo.name] as ServerContext;
+                server.type = "buildIn";
+                server.ServerApi = ServerApi;
+                await server.init();
+                serverModule[serverInfo.localPath] = server;
+            } else if (serverInfo.type === EnumServerType.REMOTE) {
+                const server = new AigcServer["RemoteServer"](serverInfo);
+                server.type = "buildIn";
+                server.ServerApi = ServerApi;
+                await server.init();
+                serverModule[serverInfo.localPath] = server;
+            } else {
+                const serverPath = `${serverInfo.localPath}/server.js`;
+                const configPath = `${serverInfo.localPath}/config.json`;
+
+                let server = null;
+                if (
+                    await Files.exists(serverPath, {
+                        isDataPath: false,
+                    })
+                ) {
+                    const module = await import(`file://${serverPath}`);
+                    server = module.default;
+                }
+                if (
+                    !server &&
+                    (await Files.exists(configPath, {
+                        isDataPath: false,
+                    }))
+                ) {
+                    const configContent = await Files.read(configPath, {
+                        isDataPath: false,
+                    });
+                    try {
+                        const config = JSON.parse(configContent);
+                        if (config.entry === "__EasyServer__") {
+                            server = new AigcServer["EasyServer"](config);
+                        } else {
+                            throw `ServerEntryNotFound : ${config.entry}`;
+                        }
+                    } catch (e) {
+                        throw `ConfigParseError : ${configPath}`;
+                    }
+                }
+                if (!server) {
+                    throw `ServerFileNotFound : ${serverPath}`;
+                }
+                server.type = "custom";
+                server.ServerApi = ServerApi;
+                if (server.init) {
+                    await server.init();
+                }
+                server.send = (type: SendType, data: any) => {
+                    server.ServerApi.event.sendChannel(
+                        server.ServerInfo.eventChannelName,
+                        { type, data },
+                    );
+                };
+                server.sendLog = (data: any) => {
+                    server.ServerApi.file.appendText(
+                        server.ServerInfo.logFile,
+                        data,
+                        { isDataPath: true },
+                    );
+                };
+                serverModule[serverInfo.localPath] = server;
+            }
+        } catch (e) {
+            if (!option.throwException) {
+                return null;
+            }
+            const error = mapError(e);
+            Log.error("mapi.server.getModule.error", error);
+            throw error;
+        }
+    }
+    // console.log('getModule', serverInfo, serverModule[serverInfo.localPath])
+    serverModule[serverInfo.localPath].ServerInfo = serverInfo;
+    return serverModule[serverInfo.localPath];
+};
+
+ipcMain.handle("server:isSupport", async (event, serverInfo: ServerInfo) => {
+    try {
+        const module = await getModule(serverInfo, {
+            throwException: false,
+        });
+        return !!module;
+    } catch (e) {
+        return false;
+    }
+});
+
+ipcMain.handle("server:start", async (event, serverInfo: ServerInfo) => {
+    const module = await getModule(serverInfo);
+    try {
+        return await module.start();
+    } catch (e) {
+        const error = mapError(e);
+        Log.error("mapi.server.start.error", error);
+        throw error;
+    }
+});
+
+ipcMain.handle("server:ping", async (event, serverInfo: ServerInfo) => {
+    const module = await getModule(serverInfo);
+    try {
+        return await module.ping();
+    } catch (e) {
+        const error = mapError(e);
+        Log.error("mapi.server.ping.error", error);
+        throw error;
+    }
+    return false;
+});
+
+ipcMain.handle("server:stop", async (event, serverInfo: ServerInfo) => {
+    const module = await getModule(serverInfo);
+    try {
+        return await module.stop();
+    } catch (e) {
+        const error = mapError(e);
+        Log.error("mapi.server.stop.error", error);
+        throw error;
+    }
+});
+
+ipcMain.handle("server:cancel", async (event, serverInfo: ServerInfo) => {
+    const module = await getModule(serverInfo);
+    try {
+        return await module.cancel();
+    } catch (e) {
+        const error = mapError(e);
+        Log.error("mapi.server.cancel.error", error);
+        throw error;
+    }
+});
+
+ipcMain.handle("server:deletes", async (event, serverInfo: ServerInfo) => {
+    if (serverModule[serverInfo.localPath]) {
+        delete serverModule[serverInfo.localPath];
+    }
+    return true;
+});
+
+ipcMain.handle("server:config", async (event, serverInfo: ServerInfo) => {
+    const module = await getModule(serverInfo);
+    try {
+        return await module.config();
+    } catch (e) {
+        const error = mapError(e);
+        Log.error("mapi.server.config.error", error);
+        throw error;
+    }
+});
+
+ipcMain.handle(
+    "server:callFunction",
+    async (
+        event,
+        serverInfo: ServerInfo,
+        method: string,
+        data: any,
+        option: any,
+    ) => {
+        // console.log('getModule.before', serverInfo, method)
+        const module = await getModule(serverInfo);
+        // console.log('getModule.end', serverInfo, method, module)
+        const func = module[method];
+        if (!func) {
+            throw new Error(`MethodNotFound : ${method}`);
+        }
+        try {
+            return await func.bind(module)(data, option || {});
+        } catch (e) {
+            const error = mapError(e);
+            Log.error("mapi.server.callFunction.error", {
+                type: typeof e,
+                error,
+                serverInfo,
+                method,
+                data,
+                option,
+            });
+            return {
+                code: -1,
+                msg: error,
+            };
+        }
+    },
+);
+
+export default {
+    init,
+};
+
+export const ServerMain = {
+    getRunningServerCount,
+    callFunction: async (
+        serverInfo: ServerInfo,
+        method: string,
+        data: any,
+        option?: any,
+    ) => {
+        const module = await getModule(serverInfo);
+        const func = module[method];
+        if (!func) {
+            throw new Error(`MethodNotFound: ${method}`);
+        }
+        return await func.bind(module)(data, option || {});
+    },
+};

vendor/aigcpanel/electron/mapi/server/render.ts

@@ -0,0 +1,89 @@
+import { ipcRenderer } from "electron";
+import { ServerInfo } from "./type";
+
+const listGpus = async () => {
+    return ipcRenderer.invoke("server:listGpus");
+};
+
+const runningServerCount = async (count: number | null) => {
+    return ipcRenderer.invoke("server:runningServerCount", count);
+};
+
+const isSupport = async (serverInfo: ServerInfo) => {
+    return ipcRenderer.invoke("server:isSupport", serverInfo);
+};
+
+const start = async (serverInfo: ServerInfo) => {
+    return ipcRenderer.invoke("server:start", serverInfo);
+};
+
+const ping = async (serverInfo: ServerInfo) => {
+    return ipcRenderer.invoke("server:ping", serverInfo);
+};
+
+const stop = async (serverInfo: ServerInfo) => {
+    return ipcRenderer.invoke("server:stop", serverInfo);
+};
+
+const cancel = async (serverInfo: ServerInfo) => {
+    return ipcRenderer.invoke("server:cancel", serverInfo);
+};
+
+const deletes = async (serverInfo: ServerInfo) => {
+    return ipcRenderer.invoke("server:deletes", serverInfo);
+};
+
+const config = async (serverInfo: ServerInfo) => {
+    return ipcRenderer.invoke("server:config", serverInfo);
+};
+
+const callFunction = async (
+    serverInfo: ServerInfo,
+    method: string,
+    data: any,
+    option: any,
+) => {
+    return ipcRenderer.invoke(
+        "server:callFunction",
+        serverInfo,
+        method,
+        data,
+        option,
+    );
+};
+
+const callFunctionWithException = async (
+    serverInfo: ServerInfo,
+    method: string,
+    data: any,
+    option: any,
+) => {
+    try {
+        return ipcRenderer.invoke(
+            "server:callFunction",
+            serverInfo,
+            method,
+            data,
+            option,
+        );
+    } catch (e) {
+        return {
+            code: -1,
+            msg: e + "",
+        };
+    }
+};
+
+export default {
+    listGpus,
+    runningServerCount,
+    isSupport,
+    start,
+    ping,
+    stop,
+    cancel,
+    deletes,
+    config,
+    callFunction,
+    callFunctionWithException,
+};

vendor/aigcpanel/electron/mapi/server/type.ts

@@ -0,0 +1,61 @@
+import api from "./api";
+import { EnumServerType } from "../../../src/types/Server";
+
+export type ServerApiType = typeof api;
+
+export type SendType =
+    | never
+    // 服务
+    | "starting"
+    | "stopping"
+    | "stopped"
+    | "success"
+    | "error"
+    // 其他
+    | "action"
+    // 任务
+    | "taskRunning"
+    | "taskResult"
+    | "taskStatus";
+
+export type ServerInfo = {
+    type: EnumServerType;
+    localPath: string;
+    name: string;
+    version: string;
+    setting: {
+        [key: string]: any;
+    };
+    logFile: string;
+    eventChannelName: string;
+    config: any;
+};
+
+export type ServerContext = {
+    ServerApi: ServerApiType | null;
+    ServerInfo: ServerInfo | null;
+
+    send: (type: SendType, data: any) => void;
+
+    init: () => Promise<void>;
+    start: () => Promise<void>;
+    cancel: () => Promise<void>;
+    stop: () => Promise<void>;
+    url: () => string;
+    ping: () => Promise<boolean>;
+    config: () => Promise<any>;
+
+    [key: string]: any;
+};
+
+export type ServerFunctionDataType = {
+    id: string;
+    result: {
+        [key: string]: any;
+    };
+    [key: string]: any;
+};
+
+export type ServerFunctionOptionType = {
+    [key: string]: any;
+};