@bigtyphoon/melo 1.7.6

package/lib/util/pathUtil.ts

@@ -0,0 +1,132 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as Constants from './constants';
+import { RemoteServerCode } from '../index';
+import { DIR } from './constants';
+
+/**
+ * Get relative path
+ *
+ * @param  {String} path full path
+ * @return {String} relative path
+ */
+export function getRelativePath(path: string) {
+    return path.replace(process.cwd(), '')
+}
+
+/**
+ * Get system remote service path
+ *
+ * @param  {String} role server role: frontend, backend
+ * @return {String}      path string if the path exist else null
+ */
+export function getSysRemotePath(role: string) {
+    let p = path.join(__dirname, '/../common/remote/', role);
+    return fs.existsSync(p) ? p : null;
+}
+
+/**
+ * Get user remote service path
+ *
+ * @param  {String} appBase    application base path
+ * @param  {String} serverType server type
+ * @return {String}            path string if the path exist else null
+ */
+export function getUserRemotePath(appBase: string, serverType: string) {
+    let p = path.join(appBase, '/app/servers/', serverType, Constants.DIR.REMOTE);
+    return fs.existsSync(p) ? p : null;
+}
+
+/**
+ * Get user remote cron path
+ *
+ * @param  {String} appBase    application base path
+ * @param  {String} serverType server type
+ * @return {String}            path string if the path exist else null
+ */
+export function getCronPath(appBase: string, serverType: string) {
+    let p = path.join(appBase, '/app/servers/', serverType, Constants.DIR.CRON);
+    return fs.existsSync(p) ? p : null;
+}
+
+/**
+ * List all the subdirectory names of user remote directory
+ * which hold the codes for all the server types.
+ *
+ * @param  {String} appBase application base path
+ * @return {Array}         all the subdiretory name under servers/
+ */
+export function listUserRemoteDir(appBase: string) {
+    let base = path.join(appBase, '/app/servers/');
+    let files = fs.readdirSync(base);
+    return files.filter(function (fn) {
+        if (fn.charAt(0) === '.') {
+            return false;
+        }
+
+        return fs.statSync(path.join(base, fn)).isDirectory();
+    });
+}
+
+/**
+ * Compose remote path record
+ *
+ * @param  {String} namespace  remote path namespace, such as: 'sys', 'user'
+ * @param  {String} serverType
+ * @param  {String} path       remote service source path
+ * @param  {Boolean} relativePath       convert path to relative path
+ * @return {Object}            remote path record
+ */
+export function remotePathRecord(namespace: string, serverType: string, path: string, relativePath?: boolean): RemoteServerCode {
+    if (relativePath) {
+        path = getRelativePath(path);
+    }
+    return { namespace: namespace, serverType: serverType, path: path };
+}
+
+/**
+ * Get handler path
+ *
+ * @param  {String} appBase    application base path
+ * @param  {String} serverType server type
+ * @return {String}            path string if the path exist else null
+ */
+export function getHandlerPath(appBase: string, serverType: string) {
+    let p = path.join(appBase, '/app/servers/', serverType, Constants.DIR.HANDLER);
+    return fs.existsSync(p) ? p : null;
+}
+
+/**
+ * Get admin script root path.
+ *
+ * @param  {String} appBase application base path
+ * @return {String}         script path string
+ */
+export function getScriptPath(appBase: string) {
+    return path.join(appBase, Constants.DIR.SCRIPT);
+}
+
+/**
+ * Get logs path.
+ *
+ * @param  {String} appBase application base path
+ * @return {String}         logs path string
+ */
+export function getLogPath(appBase: string) {
+    return path.join(appBase, Constants.DIR.LOG);
+}
+
+export function getPluginRemotePath(basePath: string) {
+    let p = path.join(basePath, DIR.REMOTE);
+    return fs.existsSync(p) ? p : null;
+}
+
+export function getPluginHandlerPath(basePath: string) {
+    let p = path.join(basePath, DIR.HANDLER);
+    return fs.existsSync(p) ? p : null;
+}
+
+export function getPluginCronPath(basePath: string) {
+    let p = path.join(basePath, DIR.CRON);
+    return fs.existsSync(p) ? p : null;
+}

package/lib/util/remoterHelper.ts

@@ -0,0 +1,68 @@
+/**
+ * 不带路由参数的远程调用代理
+ */
+export interface RemoterProxy<F> {
+    /**
+     * 使用默认路由参数null调用rpc
+     */
+    defaultRoute: F;
+
+    /**
+     * 路由到serverId服务器，并返回rpc函数
+     * notify： 只发送消息，不接收返回，节省一次通信。
+     *  (notify只有tcp的rpc协议支持.其它协议不要使用 notify)
+     */
+    to(serverId: string, notify?: boolean): F;
+
+    /**
+     * 广播到所有定义了这个remoter的服务器
+     */
+    broadcast: F;
+}
+
+/**
+ * 带路由参数的远程调用代理
+ */
+export interface RemoterProxyWithRoute<ROUTE, F> extends RemoterProxy<F> {
+    /**
+     * 路由到routeParam，并返回rpc调用函数
+     * notify： 只发送消息，不接收返回，节省一次通信。
+     * (notify只有tcp的rpc协议支持.其它rpc协议不要使用 notify)
+     */
+    route(routeParam: ROUTE, notify?: boolean): F;
+
+    // 兼容老的写法
+    (routeParam: ROUTE, ...args: any[]): Promise<any>;
+
+    toServer(serverId: string, ...args: any[]): Promise<any>;
+
+    toServer(serverId: '*', ...args: any[]): Promise<any[]>;
+}
+
+export function bindRemoterMethod<ROUTE, T, R, F>(method: F & (() => Promise<R>), thisArg: T, routeParamType: new (...args: any[]) => ROUTE): RemoterProxyWithRoute<ROUTE, F> & ((routeParam: ROUTE) => Promise<R>) & { toServer(serverId: string): Promise<R> };
+export function bindRemoterMethod<ROUTE, T, T1, R, F>(method: F & ((arg1: T1) => Promise<R>), thisArg: T, routeParamType: new (...args: any[]) => ROUTE): RemoterProxyWithRoute<ROUTE, F> & ((routeParam: ROUTE, arg1: T1) => Promise<R>) & { toServer(serverId: string, arg1: T1): Promise<R> };
+export function bindRemoterMethod<ROUTE, T, T1, T2, R, F>(method: F & ((arg1: T1, arg2: T2) => Promise<R>), thisArg: T, routeParamType: new (...args: any[]) => ROUTE): RemoterProxyWithRoute<ROUTE, F> & ((routeParam: ROUTE, arg1: T1, arg2: T2) => Promise<R>) & { toServer(serverId: string, arg1: T1, arg2: T2): Promise<R> };
+export function bindRemoterMethod<ROUTE, T, T1, T2, T3, R, F>(method: F & ((arg1: T1, arg2: T2, arg3: T3) => Promise<R>), thisArg: T, routeParamType: new (...args: any[]) => ROUTE): RemoterProxyWithRoute<ROUTE, F> & ((routeParam: ROUTE, arg1: T1, arg2: T2, arg3: T3) => Promise<R>) & { toServer(serverId: string, arg1: T1, arg2: T2, arg3: T3): Promise<R> };
+export function bindRemoterMethod<ROUTE, T, T1, T2, T3, T4, R, F>(method: F & ((arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<R>), thisArg: T, routeParamType: new (...args: any[]) => ROUTE): RemoterProxyWithRoute<ROUTE, F> & ((routeParam: ROUTE, arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<R>) & { toServer(serverId: string, arg1: T1, arg2: T2, arg3: T3, arg4: T4): Promise<R> };
+export function bindRemoterMethod<ROUTE, T, T1, T2, T3, T4, T5, R, F>(method: F & ((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<R>), thisArg: T, routeParamType: new (...args: any[]) => ROUTE): RemoterProxyWithRoute<ROUTE, F> & ((routeParam: ROUTE, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<R>) & { toServer(serverId: string, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): Promise<R> };
+export function bindRemoterMethod<ROUTE, T, T1, T2, T3, T4, T5, T6, R, F>(method: F & ((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<R>), thisArg: T, routeParamType: new (...args: any[]) => ROUTE): RemoterProxyWithRoute<ROUTE, F> & ((routeParam: ROUTE, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<R>) & { toServer(serverId: string, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6): Promise<R> };
+export function bindRemoterMethod<ROUTE, T, T1, T2, T3, T4, T5, T6, T7, R, F>(method: F & ((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, arg7: T7) => Promise<R>), thisArg: T, routeParamType: new (...args: any[]) => ROUTE): RemoterProxyWithRoute<ROUTE, F> & ((routeParam: ROUTE, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, arg7: T7) => Promise<R>) & { toServer(serverId: string, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, arg7: T): Promise<R> };
+export function bindRemoterMethod<ROUTE, T, T1, T2, T3, T4, T5, T6, T7, T8, R, F>(method: F & ((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, arg7: T7, arg8: T8) => Promise<R>), thisArg: T, routeParamType: new (...args: any[]) => ROUTE): RemoterProxyWithRoute<ROUTE, F> & ((routeParam: ROUTE, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, arg7: T7, arg8: T8) => Promise<R>) & { toServer(serverId: string, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, arg7: T7, arg8: T8): Promise<R> };
+export function bindRemoterMethod<T extends object, F extends Function, ROUTE>(method: F, thisArg: T): RemoterProxy<F>;
+export function bindRemoterMethod<T extends object, F extends Function, ROUTE>(method: F, thisArg: T, routeParamType?: new (...args: any[]) => ROUTE): RemoterProxyWithRoute<ROUTE, F> {
+    return method.bind(thisArg) as any;
+}
+
+export type RemoterClass<ROUTE, T> = {
+    [P in keyof T]?: RemoterProxyWithRoute<ROUTE, T[P]>;
+};
+
+type TestRoutify<ROUTE, T, K extends keyof T> = { [P in K]: RemoterProxyWithRoute<ROUTE, T[K]> };
+
+type FunctionKeys<T> =
+    { [K in keyof T]: T[K] extends Function ? K : never }[keyof T];
+
+
+export type DefineRoutifyMethods<ROUTE, T> = RemoterClass<ROUTE, T>;
+
+

package/lib/util/utils.ts

@@ -0,0 +1,365 @@
+import * as os from 'os';
+import * as util from 'util';
+import {exec} from 'child_process';
+import {getLogger} from '@bigtyphoon/melo-logger';
+import * as Constants from './constants';
+import {ServerInfo} from './constants';
+import {Application} from '../application';
+import * as path from 'path';
+import { melo } from '../melo';
+
+let logger = getLogger('melo', path.basename(__filename));
+
+
+/**
+ * Invoke callback with check
+ */
+export function invokeCallback(cb: Function, ...args: any[]) {
+    if (typeof cb === 'function') {
+        let len = args.length + 1;
+        if (len === 1) {
+            return cb();
+        }
+
+        if (len === 2) {
+            return cb(args[0]);
+        }
+
+        if (len === 3) {
+            return cb(args[0], args[1]);
+        }
+
+        if (len === 4) {
+            return cb(args[0], args[1], args[2]);
+        }
+        cb.apply(null, args);
+        // cb.apply(null, Array.prototype.slice.call(arguments, 1));
+    }
+}
+
+/**
+ * Get the count of elements of object
+ */
+export function size(obj: any) {
+    let count = 0;
+    for (let i in obj) {
+        if (obj.hasOwnProperty(i) && typeof obj[i] !== 'function') {
+            count++;
+        }
+    }
+    return count;
+}
+
+/**
+ * Check a string whether ends with another string
+ */
+export function endsWith(str: string, suffix: string) {
+    if (typeof str !== 'string' || typeof suffix !== 'string' ||
+        suffix.length > str.length) {
+        return false;
+    }
+    return str.indexOf(suffix, str.length - suffix.length) !== -1;
+}
+
+/**
+ * Check a string whether starts with another string
+ */
+export function startsWith(str: string, prefix: string) {
+    if (typeof str !== 'string' || typeof prefix !== 'string' ||
+        prefix.length > str.length) {
+        return false;
+    }
+
+    return str.indexOf(prefix) === 0;
+}
+
+/**
+ * Compare the two arrays and return the difference.
+ */
+export function arrayDiff<T extends string>(array1: Array<T>, array2: Array<T>) {
+    let o: { [key: string]: boolean } = {};
+    for (let i = 0, len = array2.length; i < len; i++) {
+        o[array2[i]] = true;
+    }
+
+    let result = [];
+    for (let i = 0, len = array1.length; i < len; i++) {
+        let v = array1[i];
+        if (o[v]) continue;
+        result.push(v);
+    }
+    return result;
+}
+
+/*
+ * Date format
+ */
+export function format(date: Date, format ?: string) {
+    format = format || 'MMddhhmm';
+    let o = {
+        'M+': date.getMonth() + 1, // month
+        'd+': date.getDate(), // day
+        'h+': date.getHours(), // hour
+        'm+': date.getMinutes(), // minute
+        's+': date.getSeconds(), // second
+        'q+': Math.floor((date.getMonth() + 3) / 3), // quarter
+        'S': date.getMilliseconds() // millisecond
+    };
+
+    if (/(y+)/.test(format)) {
+        format = format.replace(RegExp.$1, (date.getFullYear() + '').substr(4 - RegExp.$1.length));
+    }
+
+    for (let k in o) {
+        if (new RegExp('(' + k + ')').test(format)) {
+            format = format.replace(RegExp.$1, RegExp.$1.length === 1 ? (o as any)[k] :
+                ('00' + (o as any)[k]).substr(('' + (o as any)[k]).length));
+        }
+    }
+    return format;
+}
+
+/**
+ * check if has Chinese characters.
+ */
+export function hasChineseChar(str: string) {
+    if (/.*[\u4e00-\u9fa5]+.*$/.test(str)) {
+        return true;
+    } else {
+        return false;
+    }
+}
+
+/**
+ * transform unicode to utf8
+ */
+export function unicodeToUtf8(str: string) {
+    let i, len, ch;
+    let utf8Str = '';
+    len = str.length;
+    for (i = 0; i < len; i++) {
+        ch = str.charCodeAt(i);
+
+        if ((ch >= 0x0) && (ch <= 0x7F)) {
+            utf8Str += str.charAt(i);
+
+        } else if ((ch >= 0x80) && (ch <= 0x7FF)) {
+            utf8Str += String.fromCharCode(0xc0 | ((ch >> 6) & 0x1F));
+            utf8Str += String.fromCharCode(0x80 | (ch & 0x3F));
+
+        } else if ((ch >= 0x800) && (ch <= 0xFFFF)) {
+            utf8Str += String.fromCharCode(0xe0 | ((ch >> 12) & 0xF));
+            utf8Str += String.fromCharCode(0x80 | ((ch >> 6) & 0x3F));
+            utf8Str += String.fromCharCode(0x80 | (ch & 0x3F));
+
+        } else if ((ch >= 0x10000) && (ch <= 0x1FFFFF)) {
+            utf8Str += String.fromCharCode(0xF0 | ((ch >> 18) & 0x7));
+            utf8Str += String.fromCharCode(0x80 | ((ch >> 12) & 0x3F));
+            utf8Str += String.fromCharCode(0x80 | ((ch >> 6) & 0x3F));
+            utf8Str += String.fromCharCode(0x80 | (ch & 0x3F));
+
+        } else if ((ch >= 0x200000) && (ch <= 0x3FFFFFF)) {
+            utf8Str += String.fromCharCode(0xF8 | ((ch >> 24) & 0x3));
+            utf8Str += String.fromCharCode(0x80 | ((ch >> 18) & 0x3F));
+            utf8Str += String.fromCharCode(0x80 | ((ch >> 12) & 0x3F));
+            utf8Str += String.fromCharCode(0x80 | ((ch >> 6) & 0x3F));
+            utf8Str += String.fromCharCode(0x80 | (ch & 0x3F));
+
+        } else if ((ch >= 0x4000000) && (ch <= 0x7FFFFFFF)) {
+            utf8Str += String.fromCharCode(0xFC | ((ch >> 30) & 0x1));
+            utf8Str += String.fromCharCode(0x80 | ((ch >> 24) & 0x3F));
+            utf8Str += String.fromCharCode(0x80 | ((ch >> 18) & 0x3F));
+            utf8Str += String.fromCharCode(0x80 | ((ch >> 12) & 0x3F));
+            utf8Str += String.fromCharCode(0x80 | ((ch >> 6) & 0x3F));
+            utf8Str += String.fromCharCode(0x80 | (ch & 0x3F));
+
+        }
+
+    }
+    return utf8Str;
+}
+
+/**
+ * Ping server to check if network is available
+ *
+ */
+export function ping(host: string, cb: (ret: boolean) => void) {
+    if (!isLocal(host)) {
+        let cmd = 'ping -w 15 ' + host;
+        exec(cmd, function (err, stdout, stderr) {
+            if (!!err) {
+                cb(false);
+                return;
+            }
+            cb(true);
+        });
+    } else {
+        cb(true);
+    }
+}
+
+/**
+ * Check if server is exsit.
+ *
+ */
+export function checkPort(app: Application, server: ServerInfo, cb: (result: string) => void) {
+    if (!server.port && !server.clientPort) {
+        invokeCallback(cb, 'leisure');
+        return;
+    }
+    let port = server.port || server.clientPort;
+    const host = server.host;
+    const generateCommand = function (host: string, port: number) {
+        let cmd;
+        let ssh_params = app.get(Constants.RESERVED.SSH_CONFIG_PARAMS);
+        if (!!ssh_params && Array.isArray(ssh_params)) {
+            ssh_params = ssh_params.join(' ');
+        }
+        else {
+            ssh_params = '';
+        }
+        if (!isLocal(host)) {
+            cmd = util.format('ssh %s %s "netstat -an|awk \'{print $4}\'|grep %s|wc -l"', host, ssh_params, port);
+        } else {
+            cmd = util.format('netstat -an|awk \'{print $4}\'|grep %s|wc -l', port);
+        }
+        return cmd;
+    };
+    const cmd1 = generateCommand(host, port);
+    exec(cmd1, function (err, stdout, stderr) {
+        if (err) {
+            logger.error('command %s execute with error: %j', cmd1, err.stack);
+            invokeCallback(cb, 'error');
+        } else if (stdout.trim() !== '0') {
+            invokeCallback(cb, 'busy');
+        } else {
+            port = server.clientPort;
+            const cmd2 = generateCommand(host, port);
+            exec(cmd2, function (err, stdout, stderr) {
+                if (err) {
+                    logger.error('command %s execute with error: %j', cmd2, err.stack);
+                    invokeCallback(cb, 'error');
+                } else if (stdout.trim() !== '0') {
+                    invokeCallback(cb, 'busy');
+                } else {
+                    invokeCallback(cb, 'leisure');
+                }
+            });
+        }
+    });
+}
+
+export function isLocal(host: string) {
+    const app = melo.app;
+    if (!app) {
+        return host === '127.0.0.1' || host === 'localhost' || host === '0.0.0.0' || inLocal(host);
+    } else {
+        return host === '127.0.0.1' || host === 'localhost' || host === '0.0.0.0' || inLocal(host) || host === app.master.host;
+    }
+}
+
+/**
+ * Load cluster server.
+ *
+ */
+export function loadCluster(app: Application, server: ServerInfo, serverMap: { [serverId: string]: ServerInfo }) {
+    let increaseFields: { [key: string]: string } = {};
+    let host = server.host;
+    let count = Number(server[Constants.RESERVED.CLUSTER_COUNT]);
+    let seq = app.clusterSeq[server.serverType];
+    if (!seq) {
+        seq = 0;
+        app.clusterSeq[server.serverType] = count;
+    } else {
+        app.clusterSeq[server.serverType] = seq + count;
+    }
+
+    for (let key in server) {
+        let value = (server as any)[key].toString();
+        if (value.indexOf(Constants.RESERVED.CLUSTER_SIGNAL) > 0) {
+            let base = (server as any)[key].slice(0, -2);
+            increaseFields[key] = base;
+        }
+    }
+
+    let clone = function (src: any) {
+        let rs: any = {};
+        for (let key in src) {
+            rs[key] = src[key];
+        }
+        return rs;
+    };
+    for (let i = 0, l = seq; i < count; i++ , l++) {
+        let cserver = clone(server);
+        cserver.id = Constants.RESERVED.CLUSTER_PREFIX + server.serverType + '-' + l;
+        for (let k in increaseFields) {
+            let v = parseInt(increaseFields[k]);
+            cserver[k] = v + i;
+        }
+        serverMap[cserver.id] = cserver;
+    }
+}
+
+// export function extends(origin, add)
+// {
+//    if (!add || !this.isObject(add)) return origin;
+
+//    let keys = Object.keys(add);
+//    let i = keys.length;
+//    while (i--)
+//    {
+//        origin[keys[i]] = add[keys[i]];
+//    }
+//    return origin;
+// };
+
+export function headHandler(headBuffer: Buffer) {
+    let len = 0;
+    for (let i = 1; i < 4; i++) {
+        if (i > 1) {
+            len <<= 8;
+        }
+        len += headBuffer.readUInt8(i);
+    }
+    return len;
+}
+
+let inLocal = function (host: string) {
+    for (let index in localIps) {
+        if (host === localIps[index]) {
+            return true;
+        }
+    }
+    return false;
+};
+
+let localIps = function () {
+    let ifaces = os.networkInterfaces();
+    let ips: string[] = [];
+    let func = function (details: os.NetworkInterfaceInfo) {
+        if (details.family === 'IPv4') {
+            ips.push(details.address);
+        }
+    };
+    for (let dev in ifaces) {
+        ifaces[dev].forEach(func);
+    }
+    return ips;
+}();
+
+export function isObject(arg: any) {
+    return typeof arg === 'object' && arg !== null;
+}
+
+export function extendsObject(origin: any, add: any) {
+    if (!add || !isObject(add)) return origin;
+
+    let keys = Object.keys(add);
+    let i = keys.length;
+    while (i--) {
+        origin[keys[i]] = add[keys[i]];
+    }
+    return origin;
+}
+
+export let promisify = util.promisify;

package/package.json

@@ -0,0 +1,93 @@
+{
+  "name": "@bigtyphoon/melo",
+  "version": "1.7.6",
+  "private": false,
+  "homepage": "https://github.com/node-melo/melo",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:node-melo/melo.git"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "yarn run build && node dist/index",
+    "lint": "node_modules/.bin/tslint --format prose -c ../../tslint.json lib/**/*.ts test/**/*.ts",
+    "fix-lint": "node_modules/.bin/tslint --format prose -c ../../tslint.json lib/**/*.ts test/**/*.ts --fix",
+    "test": "yarn run build",
+    "cov": "nyc mocha",
+    "ci": "yarn run test",
+    "mochatest": "cd dist && mocha --require source-map-support/register --recursive",
+    "gen-api-ref": "node ../../node_modules/typedoc/bin/typedoc --mode file --hideGenerator --excludeExternals --ignoreCompilerErrors --out ../../run/site/public/api-reference/melo lib/"
+  },
+  "engines": {
+    "node": ">=12.9.0"
+  },
+  "bugs": {
+    "url": "https://github.com/node-melo/melo/issues"
+  },
+  "author": "mybios",
+  "licenses": [
+    {
+      "type": "MIT",
+      "url": "https://github.com/node-melo/melo#license"
+    }
+  ],
+  "keywords": [
+    "melo",
+    "framework",
+    "game",
+    "web",
+    "realtime",
+    "server"
+  ],
+  "files": [
+    "bin",
+    "dist",
+    "lib",
+    "template",
+    "test"
+  ],
+  "main": "./dist/lib/index",
+  "types": "./lib/index",
+  "dependencies": {
+    "@bigtyphoon/melo-admin": "^1.7.6",
+    "@bigtyphoon/melo-loader": "^1.7.6",
+    "@bigtyphoon/melo-logger": "^1.7.6",
+    "@bigtyphoon/melo-protobuf": "^1.7.6",
+    "@bigtyphoon/melo-protocol": "^1.7.6",
+    "@bigtyphoon/melo-rpc": "^1.7.6",
+    "@bigtyphoon/melo-scheduler": "^1.7.6",
+    "async": "^3.0.0",
+    "colors": "^1.4.0",
+    "commander": "3.0.2",
+    "crc": "^4.3.2",
+    "eyes": "^0.1.8",
+    "mkdirp": "^3.0.1",
+    "mqtt-connection": "^4.1.0",
+    "node-bignumber": "^1.2.1",
+    "pretty-columns": "^1.2.1",
+    "seq-queue": "^0.0.5",
+    "socket.io": "^4.1.3",
+    "ws": "^8.12.0"
+  },
+  "bin": {
+    "melo": "./dist/bin/melo.js"
+  },
+  "devDependencies": {
+    "@types/async": "3.2.24",
+    "@types/crc": "3.8.3",
+    "@types/eyes": "0.1.35",
+    "@types/mkdirp": "2.0.0",
+    "@types/mocha": "^5.0.0",
+    "@types/node": "^12.20.41",
+    "@types/ws": "8.5.4",
+    "mocha": "10.3.0",
+    "nyc": "15.1.0",
+    "should": "13.2.3",
+    "tslint": "6.1.3",
+    "typescript": "^4.3.5"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "87c4ea8724fa27baf22c0a669a7d89ef6f426af4"
+}

package/template/game-server/.vscode/launch.json

@@ -0,0 +1,27 @@
+{
+    // 使用 IntelliSense 了解相关属性。 
+    // 悬停以查看现有属性的描述。
+    // 欲了解更多信息，请访问: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "type": "node",
+            "request": "launch",
+            "name": "LaunchMaster",
+            "program": "${workspaceFolder}\\dist\\app.js",
+            "outFiles": [
+                "${workspaceFolder}/**/*.js"
+            ]
+        },
+        {
+            "type": "node",
+            "request": "attach",
+            "name": "Attach to Connector",
+            "address": "127.0.0.1",
+            "port": 10001,
+            "localRoot": "${workspaceFolder}",
+            "remoteRoot": "${workspaceFolder}"
+        }
+
+    ]
+}