verteilen-core 1.2.4 → 1.2.6

package/dist/src/client/resource.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -16,103 +7,101 @@ exports.ClientResource = void 0;
 const systeminformation_1 = __importDefault(require("systeminformation"));
 const interface_1 = require("../interface");
 class ClientResource {
-    constructor() {
+    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;
-        this.Query = (...args_1) => __awaiter(this, [...args_1], void 0, function* (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 yield 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;
-            });
+        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;
         });
-        this.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
-            };
+    };
+    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/src/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/src/client/shell.js

@@ -4,115 +4,119 @@ 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.shell_workers = [];
-        this.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;
+        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,
             }
-            const program = process.platform === "win32" ? 'cmd' : 'bash';
-            const child = (0, child_process_1.spawn)(program, [], {
-                stdio: ['pipe', 'pipe', 'pipe'],
-                shell: true,
-                windowsHide: true,
-                env: Object.assign({}, 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];
-                    }
+        });
+        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());
-            });
-        };
-        this.enter_shell = (input, source) => {
-            var _a, _b, _c;
-            const p = this.shell_workers.find(x => x[0] == source);
-            if (p == undefined) {
-                this.messager_log(`[Shell] Cannot find shell instance`);
-                return;
             }
-            (_a = p[1].stdin) === null || _a === void 0 ? void 0 : _a.write(input + '\n');
-            if (process.platform == 'win32')
-                (_b = p[1].stdin) === null || _b === void 0 ? void 0 : _b.write("echo %cd%" + '\n');
-            else
-                (_c = p[1].stdin) === null || _c === void 0 ? void 0 : _c.write("pwd" + '\n');
         };
-        this.close_shell = (data, source) => {
-            const p = this.shell_workers.find(x => x[0] == source);
+        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 })
         };
-        this.close_shell_all = (data) => {
-            this.shell_workers.forEach(p => {
-                if (p == undefined) {
-                    this.messager_log(`[Shell] Cannot find shell instance`);
-                    return;
-                }
-                p[1].kill();
-            });
+        const h = {
+            name: "shell_folder_reply",
+            data: d
         };
-        this.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));
-        };
-        this.disconnect = (source) => {
-            const p = this.shell_workers.find(x => x[0] == source);
-            if (p == undefined)
-                return;
-            p[1].kill();
-        };
-        this.os = new os_1.ClientOS(() => "SHELL", () => "", _messager, _messager_log);
-        this.messager = _messager;
-        this.messager_log = _messager_log;
-    }
+        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/src/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/src/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/src/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 {};