verteilen-core 1.3.21 → 1.3.23

package/dist/plugins/i18n.d.ts

@@ -147,6 +147,9 @@ export declare const i18nDefaultData: {
                 "delete-job-confirm": string;
                 "delete-task": string;
                 "delete-task-confirm": string;
+                "create-service": string;
+                "delete-service": string;
+                "delete-service-confirm": string;
             };
             toolbar: {
                 server: string;
@@ -283,6 +286,7 @@ export declare const i18nDefaultData: {
                 "job-count": string;
                 hidden: string;
                 runtime: string;
+                value: string;
             };
             codehint: {
                 v_path: string;
@@ -359,6 +363,7 @@ export declare const i18nDefaultData: {
             selectall: string;
             unselectall: string;
             project: string;
+            service: string;
             task: string;
             job: string;
             database: string;
@@ -571,6 +576,9 @@ export declare const i18nDefaultData: {
                 "delete-job-confirm": string;
                 "delete-task": string;
                 "delete-task-confirm": string;
+                "create-service": string;
+                "delete-service": string;
+                "delete-service-confirm": string;
             };
             toolbar: {
                 server: string;
@@ -707,6 +715,7 @@ export declare const i18nDefaultData: {
                 "job-count": string;
                 hidden: string;
                 runtime: string;
+                value: string;
             };
             codehint: {
                 v_path: string;
@@ -783,6 +792,7 @@ export declare const i18nDefaultData: {
             selectall: string;
             unselectall: string;
             project: string;
+            service: string;
             task: string;
             job: string;
             database: string;
@@ -998,6 +1008,9 @@ export declare const i18n: import("vue-i18n").I18n<{
             "delete-job-confirm": string;
             "delete-task": string;
             "delete-task-confirm": string;
+            "create-service": string;
+            "delete-service": string;
+            "delete-service-confirm": string;
         };
         toolbar: {
             server: string;
@@ -1134,6 +1147,7 @@ export declare const i18n: import("vue-i18n").I18n<{
             "job-count": string;
             hidden: string;
             runtime: string;
+            value: string;
         };
         codehint: {
             v_path: string;
@@ -1210,6 +1224,7 @@ export declare const i18n: import("vue-i18n").I18n<{
         selectall: string;
         unselectall: string;
         project: string;
+        service: string;
         task: string;
         job: string;
         database: string;
@@ -1422,6 +1437,9 @@ export declare const i18n: import("vue-i18n").I18n<{
             "delete-job-confirm": string;
             "delete-task": string;
             "delete-task-confirm": string;
+            "create-service": string;
+            "delete-service": string;
+            "delete-service-confirm": string;
         };
         toolbar: {
             server: string;
@@ -1558,6 +1576,7 @@ export declare const i18n: import("vue-i18n").I18n<{
             "job-count": string;
             hidden: string;
             runtime: string;
+            value: string;
         };
         codehint: {
             v_path: string;
@@ -1634,6 +1653,7 @@ export declare const i18n: import("vue-i18n").I18n<{
         selectall: string;
         unselectall: string;
         project: string;
+        service: string;
         task: string;
         job: string;
         database: string;

package/dist/server/detail/console_handle.d.ts

@@ -0,0 +1,20 @@
+import { ExecutePair, ExecuteProxy, ExecuteState, FeedBack, Job, Database, Project, Record, Task } from "../../interface";
+export declare class Console_Handler {
+    receivedPack: (model: ExecutePair, record: Record) => boolean;
+}
+export declare class Console_Proxy {
+    model: ExecutePair;
+    constructor(_model: ExecutePair);
+    get execute_proxy(): ExecuteProxy;
+    execute_project_start: (d: [Project, number]) => void;
+    execute_project_finish: (d: [Project, number]) => void;
+    execute_task_start: (d: [Task, number]) => void;
+    execute_task_finish: (d: Task) => void;
+    execute_subtask_start: (d: [Task, number, string]) => void;
+    execute_subtask_update: (d: [Task, number, string, ExecuteState]) => void;
+    execute_subtask_end: (d: [Task, number, string]) => void;
+    execute_job_start: (d: [Job, number, string]) => void;
+    execute_job_finish: (d: [Job, number, string, number]) => void;
+    feedback_message: (d: FeedBack) => void;
+    update_runtime_database: (d: Database) => void;
+}

package/dist/server/detail/console_handle.js

@@ -0,0 +1,244 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Console_Proxy = exports.Console_Handler = void 0;
+const interface_1 = require("../../interface");
+class Console_Handler {
+    receivedPack = (model, record) => {
+        const pass = model.manager.Register();
+        if (pass == -1) {
+            model.record.running = false;
+            model.record.stop = true;
+            return false;
+        }
+        model.record.projects = record.projects;
+        model.record.nodes = record.nodes;
+        model.record.project_state = model.record.projects.map(x => {
+            return {
+                uuid: x.uuid,
+                state: interface_1.ExecuteState.NONE
+            };
+        });
+        model.record.project_index = pass;
+        model.record.project = record.projects[pass].uuid;
+        model.record.task_index = 0;
+        model.record.task_state = model.record.projects[0].tasks.map(x => {
+            return {
+                uuid: x.uuid,
+                state: interface_1.ExecuteState.NONE
+            };
+        });
+        model.record.task_state[0].state = interface_1.ExecuteState.RUNNING;
+        model.record.task_detail = [];
+        const task = model.record.projects[model.record.project_index]?.tasks[model.record.task_index];
+        const count = task.cronjob ? (task?.jobs.length ?? 0) : 1;
+        for (let i = 0; i < count; i++) {
+            model.record.task_detail.push({
+                index: i,
+                node: "",
+                message: [],
+                state: interface_1.ExecuteState.NONE
+            });
+        }
+        model.manager.Update();
+        return true;
+    };
+}
+exports.Console_Handler = Console_Handler;
+class Console_Proxy {
+    model;
+    constructor(_model) {
+        this.model = _model;
+    }
+    get execute_proxy() {
+        const d = {
+            executeProjectStart: (data) => { this.execute_project_start(data); },
+            executeProjectFinish: (data) => { this.execute_project_finish(data); },
+            executeTaskStart: (data) => { this.execute_task_start(data); },
+            executeTaskFinish: (data) => { this.execute_task_finish(data); },
+            executeSubtaskStart: (data) => { this.execute_subtask_start(data); },
+            executeSubtaskUpdate: (data) => { this.execute_subtask_update(data); },
+            executeSubtaskFinish: (data) => { this.execute_subtask_end(data); },
+            executeJobStart: (data) => { this.execute_job_start(data); },
+            executeJobFinish: (data) => { this.execute_job_finish(data); },
+            feedbackMessage: (data) => { this.feedback_message(data); },
+            updateDatabase: (data) => { this.update_runtime_database(data); }
+        };
+        return d;
+    }
+    execute_project_start = (d) => {
+        const index = d[1];
+        if (index == -1)
+            return;
+        this.model.record.project = d[0].uuid;
+        this.model.record.project_index = index;
+        this.model.record.project_state[index].state = interface_1.ExecuteState.RUNNING;
+        this.model.record.task_state = this.model.record.projects[index].tasks.map(x => {
+            return {
+                uuid: x.uuid,
+                state: interface_1.ExecuteState.NONE
+            };
+        });
+        this.model.record.task_detail = [];
+        const task = this.model.record.projects[this.model.record.project_index]?.tasks[this.model.record.task_index];
+        const count = task.cronjob ? (task?.jobs.length ?? 0) : 1;
+        for (let i = 0; i < count; i++) {
+            this.model.record.task_detail.push({
+                index: i,
+                node: "",
+                message: [],
+                state: interface_1.ExecuteState.NONE
+            });
+        }
+        console.log("project start: ", this.model.record.projects.length, index);
+    };
+    execute_project_finish = (d) => {
+        if (this.model.record.process_type >= 1) {
+            this.model.record.running = false;
+            this.model.record.stop = true;
+        }
+        const index = d[1];
+        const size = this.model.record.projects.length;
+        if (index == -1)
+            return;
+        this.model.record.project = "";
+        this.model.record.project_state[index].state = interface_1.ExecuteState.FINISH;
+        this.model.record.para = undefined;
+        console.log("project finish: ", this.model.record.projects.length, index);
+        if (index == size - 1) {
+            this.model.record.command.push(['clean']);
+        }
+    };
+    execute_task_start = (d) => {
+        if (this.model.record.project_index == -1)
+            return;
+        const index = this.model.record.projects[this.model.record.project_index].tasks.findIndex(x => x.uuid == d[0].uuid);
+        if (index == -1)
+            return;
+        this.model.record.useCron = d[0].cronjob;
+        this.model.record.task = d[0].uuid;
+        this.model.record.task_index = index;
+        this.model.record.task_state[index].state = interface_1.ExecuteState.RUNNING;
+        for (let i = 0; i < index; i++)
+            this.model.record.task_state[i].state = interface_1.ExecuteState.FINISH;
+        for (let i = index + 1; i < this.model.record.task_state.length; i++)
+            this.model.record.task_state[i].state = interface_1.ExecuteState.NONE;
+        this.model.record.task_detail = [];
+        const p = this.model.record.projects[this.model.record.project_index];
+        const t = p.tasks[this.model.record.task_index];
+        const count = this.model.manager.get_task_state_count(t);
+        for (let i = 0; i < count; i++) {
+            this.model.record.task_detail.push({
+                index: i,
+                node: "",
+                message: [],
+                state: interface_1.ExecuteState.NONE
+            });
+        }
+    };
+    execute_task_finish = (d) => {
+        if (this.model.record.process_type == 2) {
+            this.model.record.running = false;
+            this.model.record.stop = true;
+        }
+        if (this.model.record.project_index == -1)
+            return;
+        const index = this.model.record.projects[this.model.record.project_index].tasks.findIndex(x => x.uuid == d.uuid);
+        if (index == -1)
+            return;
+        this.model.record.useCron = false;
+        this.model.record.task = "";
+        this.model.record.task_state[index].state = interface_1.ExecuteState.FINISH;
+        if (index + 1 < this.model.record.task_state.length - 1) {
+            this.model.record.task_state[index + 1].state = interface_1.ExecuteState.RUNNING;
+        }
+    };
+    execute_subtask_start = (d) => {
+        try {
+            this.model.record.task_detail[d[1]].node = d[2] ?? '';
+            this.model.record.task_detail[d[1]].state = interface_1.ExecuteState.RUNNING;
+        }
+        catch (error) {
+            console.error(`execute_subtask_start`, error.message);
+        }
+    };
+    execute_subtask_update = (d) => {
+        if (this.model.record.task_detail.length > d[1]) {
+            this.model.record.task_detail[d[1]].node = d[2];
+            this.model.record.task_detail[d[1]].state = d[3];
+        }
+        else {
+            console.error(`subtask_start ${d[1]} is out of range: ${this.model.record.task_detail.length}`);
+        }
+    };
+    execute_subtask_end = (d) => {
+        try {
+            this.model.record.task_detail[d[1]].state = interface_1.ExecuteState.FINISH;
+        }
+        catch (error) {
+            console.error(`execute_subtask_end`, error.message);
+        }
+    };
+    execute_job_start = (d) => {
+        if (this.model.record.project_index == -1)
+            return;
+        if (!this.model.record.useCron) {
+            this.model.record.task_detail[0].node = d[2];
+        }
+    };
+    execute_job_finish = (d) => {
+        if (d[3] == 1) {
+            const task = this.model.record.projects[this.model.record.project_index].tasks[this.model.record.task_index];
+            const index = task.jobs.findIndex(x => x.uuid == d[0].uuid);
+            if (index != -1 && task.jobs[index].category == interface_1.JobCategory.Condition) {
+                const cr = task.jobs[index].number_args[0];
+                if (cr == interface_1.ConditionResult.None)
+                    return;
+                this.model.record.command.push(['stop']);
+                let timer;
+                timer = setInterval(() => {
+                    if (this.model.record.running == false) {
+                        clearInterval(timer);
+                        const state = (cr == interface_1.ConditionResult.ThrowTask || cr == interface_1.ConditionResult.ThrowProject) ? interface_1.ExecuteState.ERROR : interface_1.ExecuteState.SKIP;
+                        const target = this.model.record.task_detail[d[1]];
+                        if (target != undefined) {
+                            target.state = state;
+                        }
+                        if (cr == interface_1.ConditionResult.Pause)
+                            return;
+                        if (cr == interface_1.ConditionResult.SkipProject || cr == interface_1.ConditionResult.ThrowProject) {
+                            this.model.record.command.push(['skip', 0, state]);
+                            if (this.model.record.project.length > 0) {
+                                if (this.model.record.process_type == 0) {
+                                    this.model.record.command.push(['execute', this.model.record.process_type]);
+                                }
+                            }
+                        }
+                        else if (cr == interface_1.ConditionResult.SkipTask || cr == interface_1.ConditionResult.ThrowTask) {
+                            this.model.record.command.push(['skip', 1, state]);
+                            if (this.model.record.project.length > 0) {
+                                if (this.model.record.process_type == 0) {
+                                    this.model.record.command.push(['execute', this.model.record.process_type]);
+                                }
+                            }
+                        }
+                    }
+                }, 1000);
+            }
+        }
+    };
+    feedback_message = (d) => {
+        if (d.index == undefined || d.index == -1)
+            return;
+        const container = this.model.record.task_detail[d.index];
+        if (container != undefined) {
+            container.message.push(d.message);
+            if (container.message.length > interface_1.MESSAGE_LIMIT) {
+                container.message.shift();
+            }
+        }
+    };
+    update_runtime_database = (d) => {
+        this.model.record.para = d;
+    };
+}
+exports.Console_Proxy = Console_Proxy;

package/dist/server/detail/log_handle.d.ts

@@ -0,0 +1,23 @@
+import { ExecutePair, ExecuteProxy, ExecuteState, FeedBack, Job, Log, Database, Preference, Project, Task } from "../../interface";
+export declare class Log_Proxy {
+    model: ExecutePair;
+    logs: Log;
+    preference: Preference;
+    private task_index;
+    private uuid;
+    private get target_log();
+    constructor(_model: ExecutePair, _log: Log, _preference: Preference);
+    get execute_proxy(): ExecuteProxy;
+    execute_project_start: (d: [Project, number]) => Promise<void>;
+    execute_project_finish: (d: [Project, number]) => void;
+    execute_task_start: (d: [Task, number]) => void;
+    execute_task_finish: (d: Task) => void;
+    execute_subtask_start: (d: [Task, number, string]) => void;
+    execute_subtask_update: (d: [Task, number, string, ExecuteState]) => void;
+    execute_subtask_end: (d: [Task, number, string]) => void;
+    execute_job_start: (d: [Job, number, string]) => void;
+    execute_job_finish: (d: [Job, number, string, number]) => void;
+    feedback_message: (d: FeedBack) => void;
+    update_runtime_database: (d: Database) => void;
+    getnewname: (name: string) => Promise<string>;
+}

package/dist/server/detail/log_handle.js

@@ -0,0 +1,224 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Log_Proxy = void 0;
+const uuid_1 = require("uuid");
+const interface_1 = require("../../interface");
+const fs = __importStar(require("fs"));
+class Log_Proxy {
+    model;
+    logs;
+    preference;
+    task_index = 0;
+    uuid = '';
+    get target_log() {
+        return this.logs.logs.find(x => x.uuid == this.uuid);
+    }
+    constructor(_model, _log, _preference) {
+        this.model = _model;
+        this.logs = _log;
+        this.preference = _preference;
+    }
+    get execute_proxy() {
+        const d = {
+            executeProjectStart: (data) => { this.execute_project_start(data); },
+            executeProjectFinish: (data) => { this.execute_project_finish(data); },
+            executeTaskStart: (data) => { this.execute_task_start(data); },
+            executeTaskFinish: (data) => { this.execute_task_finish(data); },
+            executeSubtaskStart: (data) => { this.execute_subtask_start(data); },
+            executeSubtaskUpdate: (data) => { this.execute_subtask_update(data); },
+            executeSubtaskFinish: (data) => { this.execute_subtask_end(data); },
+            executeJobStart: (data) => { this.execute_job_start(data); },
+            executeJobFinish: (data) => { this.execute_job_finish(data); },
+            feedbackMessage: (data) => { this.feedback_message(data); },
+            updateDatabase: (data) => { this.update_runtime_database(data); }
+        };
+        return d;
+    }
+    execute_project_start = async (d) => {
+        const target = this.model.record.projects[this.model.record.project_index];
+        const title = await this.getnewname(target.title);
+        this.uuid = (0, uuid_1.v6)();
+        const newlog = {
+            uuid: this.uuid,
+            filename: title,
+            dirty: true,
+            output: this.preference.log,
+            project: target,
+            state: interface_1.ExecuteState.RUNNING,
+            start_timer: Date.now(),
+            database: d[0].database,
+            end_timer: 0,
+            logs: target.tasks.map(x => {
+                return {
+                    start_timer: 0,
+                    end_timer: 0,
+                    task_state: {
+                        uuid: x.uuid,
+                        state: interface_1.ExecuteState.NONE
+                    },
+                    task_detail: []
+                };
+            })
+        };
+        this.logs.logs = [newlog].concat(this.logs.logs);
+    };
+    execute_project_finish = (d) => {
+        if (this.target_log == undefined)
+            return;
+        this.target_log.state = interface_1.ExecuteState.FINISH;
+        this.target_log.end_timer = Date.now();
+        this.target_log.dirty = true;
+    };
+    execute_task_start = (d) => {
+        if (this.target_log == undefined)
+            return;
+        const index = this.target_log.project.tasks.findIndex(x => x.uuid == d[0].uuid);
+        if (index == -1)
+            return;
+        this.task_index = index;
+        this.target_log.logs[this.task_index].task_detail = [];
+        const p = this.model.record.projects[this.model.record.project_index];
+        const t = p.tasks[this.task_index];
+        const count = this.model.manager.get_task_state_count(t);
+        for (let i = 0; i < count; i++) {
+            this.target_log.logs[this.task_index].task_detail.push({
+                index: i,
+                node: "",
+                message: [],
+                state: interface_1.ExecuteState.NONE
+            });
+        }
+        if (this.target_log.logs.length > this.task_index) {
+            this.target_log.logs[this.task_index].task_state.state = interface_1.ExecuteState.RUNNING;
+            this.target_log.logs[this.task_index].start_timer = Date.now();
+            this.target_log.dirty = true;
+        }
+    };
+    execute_task_finish = (d) => {
+        if (this.target_log == undefined)
+            return;
+        if (this.target_log.logs.length > this.task_index) {
+            this.target_log.logs[this.task_index].task_state.state = interface_1.ExecuteState.FINISH;
+            this.target_log.logs[this.task_index].end_timer = Date.now();
+            this.target_log.dirty = true;
+        }
+    };
+    execute_subtask_start = (d) => {
+        if (this.target_log == undefined)
+            return;
+        if (this.target_log.logs[this.task_index].task_detail.length > d[1]) {
+            this.target_log.logs[this.task_index].task_detail[d[1]].state = interface_1.ExecuteState.RUNNING;
+            this.target_log.dirty = true;
+        }
+    };
+    execute_subtask_update = (d) => {
+        if (this.target_log == undefined)
+            return;
+        if (this.target_log.logs[this.task_index].task_detail.length > d[1]) {
+            this.target_log.logs[this.task_index].task_detail[d[1]].state = d[3];
+            this.target_log.dirty = true;
+        }
+    };
+    execute_subtask_end = (d) => {
+        if (this.target_log == undefined)
+            return;
+        if (this.target_log.logs[this.task_index].task_detail.length > d[1]) {
+            this.target_log.logs[this.task_index].task_detail[d[1]].state = interface_1.ExecuteState.FINISH;
+            this.target_log.dirty = true;
+        }
+    };
+    execute_job_start = (d) => {
+    };
+    execute_job_finish = (d) => {
+        if (this.target_log == undefined)
+            return;
+        if (d[3] == 1) {
+            const currentLog = this.target_log;
+            const task = currentLog.project.tasks[this.task_index];
+            const index = task.jobs.findIndex(x => x.uuid == d[0].uuid);
+            if (index != -1 && task.jobs[index].category == interface_1.JobCategory.Condition) {
+                const cr = task.jobs[index].number_args[0];
+                if (cr == interface_1.ConditionResult.None)
+                    return;
+                const state = (cr == interface_1.ConditionResult.ThrowTask || cr == interface_1.ConditionResult.ThrowProject) ? interface_1.ExecuteState.ERROR : interface_1.ExecuteState.SKIP;
+                const target = this.model.record.task_detail[d[1]];
+                if (target != undefined) {
+                    target.state = state;
+                }
+                currentLog.logs[this.task_index].task_state.state = state;
+                if (cr == interface_1.ConditionResult.Pause)
+                    return;
+                if (cr == interface_1.ConditionResult.SkipProject || cr == interface_1.ConditionResult.ThrowProject) {
+                    currentLog.state = state;
+                }
+            }
+        }
+    };
+    feedback_message = (d) => {
+        if (this.target_log == undefined)
+            return;
+        if (d.index == undefined || d.index == -1)
+            return;
+        if (this.target_log == undefined)
+            return;
+        if (this.target_log.logs[this.task_index].task_detail.length > d.index) {
+            this.target_log.logs[this.task_index].task_detail[d.index].message.push(d.message);
+            this.target_log.dirty = true;
+        }
+        else {
+            console.warn("Try access message by index but failed: ", d);
+        }
+    };
+    update_runtime_database = (d) => {
+        if (this.target_log != undefined) {
+            this.target_log.database = d;
+            this.target_log.dirty = true;
+        }
+    };
+    getnewname = async (name) => {
+        const root = "data/log";
+        let count = 0;
+        let filename = name;
+        let p = `${root}/${filename}`;
+        while (fs.existsSync(p + ".json")) {
+            count = count + 1;
+            filename = `${name} ${count}`;
+            p = `${root}/${filename}`;
+        }
+        return filename;
+    };
+}
+exports.Log_Proxy = Log_Proxy;

package/dist/server/detail.d.ts

@@ -1,6 +1,8 @@
-import { BusAnalysis, Execute_SocketManager, ExecutePair, ExecuteProxy, ExecuteRecord, ExecuteState, Messager, Preference, Record, ShellFolder, Single, UtilServer_Console, WebsocketPack } from "../interface";
+import { BusAnalysis, ExecutePair, ExecuteProxy, ExecuteRecord, ExecuteState, Messager, Preference, Record, ShellFolder, Single, WebsocketPack } from "../interface";
 import { PluginFeedback } from "./server";
 import { MemoryData, RecordIOBase } from './io';
+import { Console_Handler } from './detail/console_handle';
+import { WebsocketManager } from '../script/socket_manager';
 export interface BackendAction {
     memory: MemoryData;
     GetPreference: (uuid?: string) => Preference;
@@ -30,8 +32,8 @@ export interface ServerDetailEvent {
 }
 export declare class ServerDetail {
     execute_manager: Array<ExecutePair>;
-    console: UtilServer_Console.Util_Server_Console;
-    websocket_manager: Execute_SocketManager.WebsocketManager | undefined;
+    console: Console_Handler;
+    websocket_manager: WebsocketManager | undefined;
     shellBind: Map<any, any>;
     loader: RecordIOBase | undefined;
     backend: BackendAction;
@@ -47,7 +49,6 @@ export declare class ServerDetail {
     Analysis: (d: BusAnalysis) => void;
     shellReply: (data: Single, p?: WebsocketPack) => void;
     folderReply: (data: ShellFolder, p?: WebsocketPack) => void;
-    console_update: () => any[];
     resource_start: (socket: any, uuid: string) => void;
     resource_end: (socket: any, uuid: string) => void;
     plugin_info: (socket: any, uuid: string) => void;
@@ -68,5 +69,6 @@ export declare class ServerDetail {
     console_clean: (socket: any, uuid: string) => void;
     console_skip: (socket: any, uuid: string, forward: boolean, type: number, state?: ExecuteState) => void;
     console_skip2: (socket: any, uuid: string, v: number) => void;
+    console_update: () => any[];
     CombineProxy: (eps: Array<ExecuteProxy>) => ExecuteProxy;
 }