verteilen-core 1.2.4 → 1.2.7

package/dist/client/os.js

@@ -0,0 +1,197 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientOS = void 0;
+const child_process_1 = require("child_process");
+const tree_kill_1 = __importDefault(require("tree-kill"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const interface_1 = require("../interface");
+class ClientOS {
+    messager;
+    messager_log;
+    tag;
+    runtime;
+    children = [];
+    constructor(_tag, _runtime, _messager, _messager_log) {
+        this.tag = _tag;
+        this.runtime = _runtime;
+        this.messager = _messager;
+        this.messager_log = _messager_log;
+    }
+    file_copy = (data) => {
+        this.messager(`[OS Action] File copy, ${data.from} => ${data.to}`, this.tag());
+        fs.copyFileSync(data.from, data.to);
+    };
+    dir_copy = (data) => {
+        this.messager(`[OS Action] Folder copy, ${data.from} => ${data.to}`, this.tag());
+        fs.cpSync(data.from, data.to, { recursive: true, force: true });
+    };
+    file_delete = (data) => {
+        this.messager(`[OS Action] File delete, ${data.path}`, this.tag());
+        fs.rmSync(data.path);
+    };
+    dir_delete = (data) => {
+        this.messager(`[OS Action] Folder delete, ${data.path}`, this.tag());
+        fs.rmSync(data.path, { recursive: true, force: true });
+    };
+    rename = (data) => {
+        this.messager(`[OS Action] File or dir rename, ${data.from} => ${data.to}`, this.tag());
+        fs.renameSync(data.from, data.to);
+    };
+    fs_exist = (data) => {
+        const v = fs.existsSync(data.path);
+        this.messager(`[OS Action] Check path exists, ${data.path}`, this.tag());
+        return v;
+    };
+    fs_dir_exist = (data) => {
+        const p = this.fs_exist(data);
+        if (!p)
+            return false;
+        const stat = fs.statSync(data.path);
+        return stat.isDirectory();
+    };
+    fs_file_exist = (data) => {
+        const p = this.fs_exist(data);
+        if (!p)
+            return false;
+        const stat = fs.statSync(data.path);
+        return stat.isFile();
+    };
+    dir_files = (data) => {
+        const r = fs.readdirSync(data.path, { withFileTypes: true }).filter(x => x.isFile()).map(x => x.name);
+        return r;
+    };
+    dir_dirs = (data) => {
+        const r = fs.readdirSync(data.path, { withFileTypes: true }).filter(x => x.isDirectory()).map(x => x.name);
+        return r;
+    };
+    dir_create = (data) => {
+        this.messager(`[OS Action] Create folder, ${data.path}`, this.tag());
+        fs.mkdirSync(data.path, { recursive: true });
+    };
+    file_write = (data) => {
+        this.messager(`[OS Action] Create file, ${data.from}`, this.tag());
+        fs.writeFileSync(data.from, data.to);
+    };
+    file_read = (data) => {
+        return fs.readFileSync(data.path).toString();
+    };
+    stopall = () => {
+        this.children.forEach(x => {
+            x.stdin.write('q');
+            x.stdin.end();
+            (0, tree_kill_1.default)(x.pid, 'SIGKILL');
+        });
+        this.children = [];
+    };
+    lib_command = async (command, args) => {
+        const cc = process.platform == "win32" ? command : "./" + command;
+        return this.command(cc, args, path.join(os.homedir(), interface_1.DATA_FOLDER, "exe"));
+    };
+    command = async (command, args, cwd) => {
+        this.messager_log(`[OS Action] Command cwd: ${cwd}`, this.tag());
+        this.messager_log(`[OS Action] Command command: ${command}`, this.tag());
+        this.messager_log(`[OS Action] Command args: ${args}`, this.tag());
+        return new Promise((resolve, reject) => {
+            const child = (0, child_process_1.spawn)(command, args.split(' '), {
+                cwd: cwd,
+                shell: true,
+                stdio: ['pipe', 'pipe', 'pipe']
+            });
+            child.stdin.setDefaultEncoding('utf8');
+            child.on('spawn', () => {
+                this.children.push(child);
+                this.messager_log(`[Command] Spawn process`, this.tag());
+            });
+            child.on('error', (err) => {
+                this.messager_log(`[Command] Error: ${err}`, this.tag());
+                reject(`Error ${err}`);
+            });
+            child.on('exit', (code, signal) => {
+                this.messager_log(`[Command] Process Exit: ${code}`, this.tag());
+            });
+            child.on('message', (message, sendHandle) => {
+                this.messager_log(`[Command] : ${message.toString()}`, this.tag());
+            });
+            child.on('close', (code, signal) => {
+                this.messager_log(`[Command] Process Close: ${code}`, this.tag());
+                const index = this.children.findIndex(x => x.pid == child.pid);
+                if (index != -1)
+                    this.children.splice(index, 1);
+                resolve(`Successfully ${code}`);
+            });
+            child.stdout.setEncoding('utf8');
+            child.stdout.on('data', (chunk) => {
+                this.messager_log(`[Command Info] : ${chunk.toString()}`, this.tag());
+            });
+            child.stderr.setEncoding('utf8');
+            child.stderr.on('data', (chunk) => {
+                this.messager_log(`[Command Error] : ${chunk.toString()}`, this.tag());
+            });
+        });
+    };
+    command_sync = async (command, args, cwd) => {
+        return this.command(command, args, cwd);
+    };
+    command_exec = (command, args, cwd) => {
+        this.messager_log(`[OS Action] Command cwd: ${cwd}`, this.tag());
+        this.messager_log(`[OS Action] Command command: ${command}`, this.tag());
+        this.messager_log(`[OS Action] Command args: ${args}`, this.tag());
+        const child = (0, child_process_1.exec)(`${command} ${args}`, {
+            cwd: cwd
+        });
+        child.on('spawn', () => {
+            this.messager_log(`[Command] Spawn process`, this.tag());
+        });
+        child.on('error', (err) => {
+            this.messager_log(`[Command] Error: ${err}`, this.tag());
+        });
+        child.on('exit', (code, signal) => {
+            this.messager_log(`[Command] Process Exit: ${code}`, this.tag());
+        });
+        child.on('message', (message, sendHandle) => {
+            this.messager_log(`[Command] : ${message.toString()}`, this.tag());
+        });
+        child.on('close', (code, signal) => {
+            this.messager_log(`[Command] Process Close: ${code}`, this.tag());
+        });
+    };
+}
+exports.ClientOS = ClientOS;

package/dist/client/resource.d.ts

@@ -0,0 +1,7 @@
+import { ResourceType } from "../interface";
+import { SystemLoad } from "../interface/struct";
+export declare class ClientResource {
+    is_query: boolean;
+    Query: (src?: SystemLoad | undefined, type?: ResourceType) => Promise<SystemLoad>;
+    private create_new;
+}

package/dist/client/resource.js

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientResource = void 0;
+const systeminformation_1 = __importDefault(require("systeminformation"));
+const interface_1 = require("../interface");
+class ClientResource {
+    is_query = false;
+    Query = async (src = undefined, type = interface_1.ResourceType.ALL) => {
+        this.is_query = true;
+        const result = src != undefined ? src : this.create_new();
+        const _system = (type & interface_1.ResourceType.SYSTEM) == interface_1.ResourceType.SYSTEM ? systeminformation_1.default.system() : undefined;
+        const _cpu = systeminformation_1.default.cpu();
+        const _ram = systeminformation_1.default.mem();
+        const _battery = systeminformation_1.default.battery();
+        const _load = systeminformation_1.default.currentLoad();
+        const _os = systeminformation_1.default.osInfo();
+        const _gpu = systeminformation_1.default.graphics();
+        const _disk = systeminformation_1.default.fsSize();
+        const _net = systeminformation_1.default.networkStats();
+        this.is_query = false;
+        return await Promise.all([_system, _cpu, _ram, _battery, _load, _os, _gpu, _disk, _net]).then(x => {
+            const system = x[0];
+            const cpu = x[1];
+            const ram = x[2];
+            const battery = x[3];
+            const load = x[4];
+            const os = x[5];
+            const gpu = x[6];
+            const disk = x[7];
+            const net = x[8];
+            if (system != undefined) {
+                result.system_name = `${system.manufacturer} ${system.model}`;
+                result.virtual = system.virtual;
+            }
+            if (os != undefined) {
+                result.platform = process.platform;
+                result.arch = process.arch;
+                result.hostname = os.hostname;
+            }
+            if (cpu != undefined) {
+                result.cpu_name = `${cpu.manufacturer} ${cpu.brand} ${cpu.speed}`;
+                result.cpu_core = cpu.cores;
+            }
+            if (load != undefined) {
+                result.cpu_usage = load.currentLoadGuest + load.currentLoadIrq + load.currentLoadSystem + load.currentLoad + load.currentLoadSteal + load.currentLoadNice;
+            }
+            if (ram != undefined) {
+                result.ram_usage = ram.used;
+                result.ram_free = ram.free;
+                result.ram_total = ram.total;
+            }
+            if (battery != undefined) {
+                result.battery = battery.hasBattery ? battery.percent : 1;
+                result.charging = battery.isCharging;
+            }
+            if (gpu != undefined) {
+                result.gpu = gpu.controllers.map(x => ({
+                    gpu_name: `${x.vendor} ${x.model}`
+                }));
+            }
+            if (disk != undefined) {
+                result.disk = disk.map(x => ({
+                    disk_name: x.fs,
+                    disk_type: x.type,
+                    disk_free: x.available,
+                    disk_total: x.size,
+                    disk_usage: x.used,
+                    disk_percentage: x.use,
+                }));
+            }
+            if (net != undefined) {
+                result.net = net.map(x => ({
+                    net_name: x.iface,
+                    download: x.rx_sec,
+                    upload: x.tx_sec
+                }));
+            }
+            result.pid_usage = process.pid;
+            return result;
+        });
+    };
+    create_new = () => {
+        return {
+            system_name: '',
+            virtual: false,
+            platform: '',
+            arch: '',
+            hostname: '',
+            cpu_name: '',
+            cpu_core: 0,
+            cpu_usage: 0,
+            ram_usage: 0,
+            ram_free: 0,
+            ram_total: 0,
+            battery: 0,
+            charging: false,
+            gpu: [],
+            disk: [],
+            net: [],
+            pid_usage: 0
+        };
+    };
+}
+exports.ClientResource = ClientResource;

package/dist/client/shell.d.ts

@@ -0,0 +1,16 @@
+import WebSocket from 'ws';
+import { Messager } from "../interface";
+import { Client } from "./client";
+export declare class ClientShell {
+    private messager;
+    private messager_log;
+    private os;
+    private shell_workers;
+    constructor(_messager: Messager, _messager_log: Messager, _client: Client);
+    open_shell: (data: number, source: WebSocket) => void;
+    enter_shell: (input: string, source: WebSocket) => void;
+    close_shell: (data: number, source: WebSocket) => void;
+    close_shell_all: (data: number) => void;
+    shell_folder: (data: string, source: WebSocket) => void;
+    disconnect: (source: WebSocket) => void;
+}

package/dist/client/shell.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientShell = void 0;
+const child_process_1 = require("child_process");
+const os_1 = require("./os");
+class ClientShell {
+    messager;
+    messager_log;
+    os;
+    shell_workers = [];
+    constructor(_messager, _messager_log, _client) {
+        this.os = new os_1.ClientOS(() => "SHELL", () => "", _messager, _messager_log);
+        this.messager = _messager;
+        this.messager_log = _messager_log;
+    }
+    open_shell = (data, source) => {
+        if (this.shell_workers.find(x => x[0] == source)) {
+            this.messager_log(`[Shell] Error the source already open the shell`);
+            return;
+        }
+        const program = process.platform === "win32" ? 'cmd' : 'bash';
+        const child = (0, child_process_1.spawn)(program, [], {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            shell: true,
+            windowsHide: true,
+            env: {
+                ...process.env,
+            }
+        });
+        this.shell_workers.push([source, child]);
+        let t = "";
+        const workerFeedback = (str) => {
+            for (let i = 0; i < str.length; i++) {
+                if (str[i] == '\n') {
+                    const data = {
+                        data: t
+                    };
+                    const d = {
+                        name: "shell_reply",
+                        data: data
+                    };
+                    source.send(JSON.stringify(d));
+                    t = "";
+                }
+                else {
+                    t += str[i];
+                }
+            }
+        };
+        child.on('exit', (code, signal) => {
+            const index = this.shell_workers.findIndex(x => x[0] == source);
+            if (index != -1)
+                this.shell_workers.splice(index, 1);
+        });
+        child.on('message', (message, sendHandle) => {
+            workerFeedback(message.toString());
+        });
+        child.stdout.setEncoding('utf8');
+        child.stdout.on('data', (chunk) => {
+            workerFeedback(chunk.toString());
+        });
+        child.stderr.setEncoding('utf8');
+        child.stderr.on('data', (chunk) => {
+            workerFeedback(chunk.toString());
+        });
+    };
+    enter_shell = (input, source) => {
+        const p = this.shell_workers.find(x => x[0] == source);
+        if (p == undefined) {
+            this.messager_log(`[Shell] Cannot find shell instance`);
+            return;
+        }
+        p[1].stdin?.write(input + '\n');
+        if (process.platform == 'win32')
+            p[1].stdin?.write("echo %cd%" + '\n');
+        else
+            p[1].stdin?.write("pwd" + '\n');
+    };
+    close_shell = (data, source) => {
+        const p = this.shell_workers.find(x => x[0] == source);
+        if (p == undefined) {
+            this.messager_log(`[Shell] Cannot find shell instance`);
+            return;
+        }
+        p[1].kill();
+    };
+    close_shell_all = (data) => {
+        this.shell_workers.forEach(p => {
+            if (p == undefined) {
+                this.messager_log(`[Shell] Cannot find shell instance`);
+                return;
+            }
+            p[1].kill();
+        });
+    };
+    shell_folder = (data, source) => {
+        if (data.length == 0) {
+            data = process.cwd();
+        }
+        if (!this.os.fs_dir_exist({ path: data })) {
+            data = process.cwd();
+        }
+        const d = {
+            path: data,
+            cwd: process.cwd(),
+            folders: this.os.dir_dirs({ path: data }),
+            files: this.os.dir_files({ path: data })
+        };
+        const h = {
+            name: "shell_folder_reply",
+            data: d
+        };
+        source.send(JSON.stringify(h));
+    };
+    disconnect = (source) => {
+        const p = this.shell_workers.find(x => x[0] == source);
+        if (p == undefined)
+            return;
+        p[1].kill();
+    };
+}
+exports.ClientShell = ClientShell;

package/dist/computed.d.ts

@@ -0,0 +1,13 @@
+export * as ClientAnalysis from './client/analysis';
+export * as Client from './client/client';
+export * as ClientCluster from './client/cluster';
+export * as ClientExecute from './client/execute';
+export * as ClientJobExecute from './client/job_execute';
+export * as ClientJobParameter from './client/job_database';
+export * as ClientHttp from './client/http';
+export * as ClientJavascript from './client/javascript';
+export * as ClientOS from './client/os';
+export * as ClientParameter from './client/database';
+export * as ClientResource from './client/resource';
+export * as ClientShell from './client/shell';
+export * as Execute_WebhookServerManager from './script/webhook_server_manager';

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './computed';
+export * from './interface';
+export * from './server';

package/dist/index.js

@@ -14,6 +14,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./src/computed"), exports);
-__exportStar(require("./src/interface"), exports);
-__exportStar(require("./src/server"), exports);
+__exportStar(require("./computed"), exports);
+__exportStar(require("./interface"), exports);
+__exportStar(require("./server"), exports);

package/dist/interface/base.d.ts

@@ -0,0 +1,70 @@
+import { DataType, DataTypeBase } from "./enum";
+import { ACLType, LocalPermission as LocalPermission } from "./server";
+export interface DatabaseConfigTrigger {
+    types: Array<DataTypeBase>;
+}
+export interface DatabaseContainer {
+    name: string;
+    meta?: any;
+    config?: DatabaseConfigTrigger;
+    type: DataType;
+    hidden: boolean;
+    runtimeOnly: boolean;
+    value: any;
+}
+export interface Property {
+    name: string;
+    expression: string;
+    deep?: number;
+}
+export interface Database {
+    uuid: string;
+    title: string;
+    canWrite: boolean;
+    containers: Array<DatabaseContainer>;
+    permission?: LocalPermission;
+}
+export interface Job {
+    index?: number;
+    uuid: string;
+    runtime_uuid?: string;
+    category: number;
+    type: number;
+    script: string;
+    string_args: Array<string>;
+    number_args: Array<number>;
+    boolean_args: Array<boolean>;
+    id_args: Array<boolean>;
+    permission?: LocalPermission;
+}
+export interface Task {
+    uuid: string;
+    title: string;
+    description: string;
+    setupjob: boolean;
+    cronjob: boolean;
+    cronjobKey: string;
+    multi: boolean;
+    multiKey: string;
+    properties: Array<Property>;
+    jobs: Array<Job>;
+    permission?: LocalPermission;
+}
+export interface Project {
+    owner?: string;
+    uuid: string;
+    title: string;
+    description?: string;
+    database_uuid: string;
+    database?: Database;
+    task: Array<Task>;
+    permission?: LocalPermission;
+    acl?: ACLType;
+}
+export interface Node {
+    uuid: string;
+    parent?: string;
+    url: string;
+    permission?: LocalPermission;
+    acl?: ACLType;
+}

package/dist/interface/bus.d.ts

@@ -0,0 +1,90 @@
+import { Job, Database, Project, Task } from "./base";
+import { ExecuteState } from "./enum";
+import { ExecutionLog, Log, Preference } from "./record";
+import { Login } from "./server";
+import { FeedBack, Header, Setter, ShellFolder, Single, WebsocketPack } from "./struct";
+import { NodeTable } from "./table";
+import { ToastData } from "./ui";
+type Handler<T = unknown> = (event: T) => void;
+export type Messager = (msg: string, tag?: string) => void;
+export type Messager_log = (msg: string, tag?: string, meta?: string) => void;
+export interface BusAnalysis {
+    name: string;
+    h: Header;
+    c: WebsocketPack | undefined;
+}
+export interface Rename {
+    oldname: string;
+    newname: string;
+}
+export interface RawSend {
+    name: string;
+    token?: string;
+    data: any;
+}
+export interface EmitterProxy<T> {
+    on<Key extends keyof T>(type: T, handler: Handler<T[Key]>): void;
+    off<Key extends keyof T>(type: T, handler: Handler<T[Key]>): void;
+    emit<Key extends keyof T>(type: T, handler: T[Key]): void;
+}
+export interface ExecuteProxy {
+    executeProjectStart: (data: [Project, number]) => void;
+    executeProjectFinish: (data: [Project, number]) => void;
+    executeTaskStart: (data: [Task, number]) => void;
+    executeTaskFinish: (data: Task) => void;
+    executeSubtaskStart: (data: [Task, number, string]) => void;
+    executeSubtaskUpdate: (data: [Task, number, string, ExecuteState]) => void;
+    executeSubtaskFinish: (data: [Task, number, string]) => void;
+    executeJobStart: (data: [Job, number, string]) => void;
+    executeJobFinish: (data: [Job, number, string, number]) => void;
+    feedbackMessage: (data: FeedBack) => void;
+    updateDatabase: (data: Database) => void;
+}
+export interface NodeProxy {
+    shellReply: (data: Single, w?: WebsocketPack) => void;
+    folderReply: (data: ShellFolder, w?: WebsocketPack) => void;
+}
+export type BusType = {
+    setting: void;
+    guide: void;
+    makeToast: ToastData;
+    modeSelect: boolean;
+    createProject: void;
+    updateProject: void;
+    recoverProject: Project;
+    recoverDatabase: Database;
+    relogin: void;
+    loginGuest: void;
+    login: Login;
+    logout: void;
+    updateTask: void;
+    updateJob: void;
+    updateDatabase: void;
+    selectDatabase: string;
+    updateLocate: void;
+    updateNode: Array<NodeTable>;
+    updateCurrent: ExecutionLog;
+    updateLog: Log;
+    updateHandle: void;
+    slowUpdateHandle: void;
+    shellReply: Single;
+    folderReply: ShellFolder;
+    feedbackMessage: FeedBack;
+    savePreference: Preference;
+    renameScript: Rename;
+    deleteScript: string;
+    analysis: BusAnalysis;
+    debuglog: string;
+    hotkey: string;
+    isExpress: boolean;
+    delay: Setter;
+    system: Setter;
+};
+export type BusWebType = {
+    raw_send: RawSend;
+    locate: string;
+    load_preference: string;
+    load_cookie: void;
+    get_token: string;
+};
+export {};