@cyklang/cli 0.3.1 → 0.5.0

package/build/AssetCommand.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[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];
@@ -36,21 +40,125 @@ const core_1 = require("@cyklang/core");
 const form_data_1 = __importDefault(require("form-data"));
 const logger = (0, loglevel_1.getLogger)('AssetCommand.ts');
 logger.setLevel('debug');
+//----------------------------------------------------------------------------------------------
+// scanAssets
+//----------------------------------------------------------------------------------------------
+const scanAssets = async (dbManager, dest) => {
+    const result = [];
+    if (dbManager === undefined)
+        throw 'dbManager undefined';
+    const dbReq = new core_1.DBExecuteRequest();
+    dbReq.selectFromTable = 'cyk_asset';
+    const pFields = dbReq.parameters.addVariable('fields', dbManager.scope.structure.stringDataType);
+    pFields.data = new core_1.PrimitiveData(dbManager.scope.structure.stringDataType, "asset_id,asset_route,asset_last_update,asset_mimetype");
+    const xmlResult = await dbManager.dbExecute(dbReq);
+    if (xmlResult === undefined || xmlResult === null)
+        throw 'xmlResult null or undefined';
+    const tag = (0, core_1.parseXML)('scanAssets', xmlResult);
+    const objResult = await dbManager.scope.structure.objectDataType.parseData(tag, dbManager.scope);
+    const rows = objResult.variables.getData('cyk_asset').variables;
+    for (let ind = 0; ind < rows.list.length; ind++) {
+        const { variable: row } = rows.list[ind];
+        const record = row.data;
+        const asset_id = record.variables.getData('asset_id').value;
+        const asset_route = record.variables.getData('asset_route').value;
+        const asset_last_update = record.variables.getData('asset_last_update')?.value;
+        // logger.debug('asset_route ' + asset_route,'asset_last_update ' + asset_last_update)
+        if (!dest || asset_route.startsWith(dest))
+            result.push({ path: asset_route, mtime: asset_last_update, id: asset_id });
+    }
+    return result;
+};
 class AssetCommand extends commander_1.Command {
     constructor(name, description) {
         super(name);
         this.description(description);
         this.addCommand(new AssetList('list', 'list assets'));
         this.addCommand(new AssetList('l', '(l)ist assets'));
-        this.addCommand(new AssetUpload('upload', 'upload assets from sources'));
-        this.addCommand(new AssetUpload('u', '(u)pload assets'));
+        this.addCommand(new AssetU('upload', 'upload asset content from source files to a <destination> path'));
+        this.addCommand(new AssetU('update', 'update properties of asset identified by its <id>'));
+        this.addCommand(new AssetU('u', '(u)pload assets content from sources or (u)pdate asset properties'));
+        this.addCommand(new AssetDelete('delete', 'delete an asset'));
     }
 }
 exports.AssetCommand = AssetCommand;
+/**
+ * class AssetDelete
+ */
+class AssetDelete extends Cmd_1.Cmd {
+    constructor(name, description) {
+        super(name);
+        this.description(description)
+            .option('-i --id <id_pathname>', 'asset id or pathname to delete')
+            .option('-d --dest <destination>', 'delete all assets whose pathname begins with dest')
+            .action(async (options) => {
+            if (options.id)
+                await this.commandDeleteOne(options);
+            else if (options.dest) {
+                await this.commandDeletePathname(options);
+            }
+            else {
+                logger.error('one of --id or --dest options is required');
+            }
+        });
+    }
+    /**
+     *
+     * @param options
+     */
+    async commandDeleteOne(options) {
+        try {
+            await this.prologue(options);
+            if (this.dbManager === undefined)
+                throw 'dbManager undefined';
+            if (options.id === undefined)
+                throw '<id_or_pathname> of asset to delete is missing';
+            if (!options.id.startsWith('/'))
+                throw '-i --id only pathname is supported at the moment';
+            const dbAsset = await this.dbManager.dbAssetExist(options.id);
+            if (dbAsset === undefined)
+                throw 'Asset ' + options.id + ' not found';
+            await this.dbManager.dbAssetDelete(dbAsset);
+            logger.info('asset ' + dbAsset.id + ' ' + dbAsset.route + ' deleted');
+        }
+        catch (err) {
+            logger.error(err);
+        }
+    }
+    /**
+     *
+     * @param options
+     */
+    async commandDeletePathname(options) {
+        try {
+            await this.prologue(options);
+            if (!this.dbManager)
+                throw 'dbManager undefined';
+            const dbClient = new DBClient_1.DBClient(this.dbManager);
+            const list = await dbClient.selectFromTable('Assets to delete', 'cyk_asset', {
+                fields: 'asset_id,asset_route,asset_auth,asset_access,asset_mimetype,asset_last_update', sort: options.sort || '1',
+                where: (options.dest ? "asset_route like '" + options.dest + "%'" : undefined)
+            });
+            const reply = await inquirer_1.default.prompt({ type: 'confirm', name: 'confirm', message: 'Do you want to delete these ' + list.length + ' file(s)' });
+            if (reply.confirm) {
+                for (let ind = 0; ind < list.length; ind++) {
+                    const asset = list[ind];
+                    logger.info('delete ' + asset.asset_route);
+                    const url = '/api/admin/assets/' + asset.asset_id;
+                    await this.dbRemote?.apiServer.delete(url);
+                }
+            }
+        }
+        catch (err) {
+            logger.error(err);
+        }
+    }
+}
 class AssetList extends Cmd_1.Cmd {
     constructor(name, description) {
         super(name);
         this.description(description)
+            .option('-d --dest <destination>', 'filter assets whose pathname begins with destination')
             .option('-s --sort <columns>', 'sort list by column numbers (begins by 0) separated by comma')
             .action(async (options) => { await this.commandList(options); });
     }
@@ -60,14 +168,20 @@ class AssetList extends Cmd_1.Cmd {
             if (this.dbManager === undefined)
                 throw 'dbManager undefined';
             const dbClient = new DBClient_1.DBClient(this.dbManager);
-            dbClient.selectFromTable('List of Assets', 'cyk_asset', { fields: 'asset_id,asset_route,asset_auth,asset_access,asset_mimetype,asset_last_update', sort: options.sort || '1' });
+            dbClient.selectFromTable('List of Assets', 'cyk_asset', {
+                fields: 'asset_id,asset_route,asset_auth,asset_access,asset_mimetype,asset_last_update', sort: options.sort || '1',
+                where: (options.dest ? "asset_route like '" + options.dest + "%'" : undefined)
+            });
         }
         catch (err) {
             logger.error(err);
         }
     }
 }
-class AssetUpload extends Cmd_1.Cmd {
+/**
+ * class AssetU
+ */
+class AssetU extends Cmd_1.Cmd {
     constructor(name, description) {
         super(name);
         //----------------------------------------------------------------------------------------------
@@ -75,13 +189,15 @@ class AssetUpload extends Cmd_1.Cmd {
         //----------------------------------------------------------------------------------------------
         this.ignorePatterns = ['.git', 'node_modules'];
         this.description(description)
-            .option('-a --auth <auth_schema>', 'authentication schema : basic | token | any, default is no authentication')
+            .option('-i --id <id>', 'asset id or pathname whose properties are updated')
+            .option('--auth <auth_schema>', 'authentication schema : basic | token | cookie | any | none, default is none')
+            .option('--access <access>', 'access rights required')
             .option('-d --dest <destination>', 'destination path, directory name')
             .option('-c --clean', 'clean destination path before uploading')
             .option('-y --yes', 'upload list is automatically confirmed')
             .argument('[sources...]', 'local files or directories to upload as assets to the server')
             .action(async (sources, options) => {
-            await this.commandUpload(sources, options);
+            await this.commandU(sources, options);
         });
     }
     mimetypeLookup(filename) {
@@ -94,6 +210,50 @@ class AssetUpload extends Cmd_1.Cmd {
         }
         return result;
     }
+    /**
+     * method commandU
+     * @param sources
+     * @param options
+     */
+    async commandU(sources, options) {
+        if (sources.length > 0) {
+            // upload
+            // logger.debug('upload sources :', sources)
+            await this.commandUpload(sources, options);
+        }
+        else {
+            // update
+            // logger.debug('update', options)
+            await this.commandUpdate(options);
+        }
+    }
+    /**
+     * method commandUpdate
+     * @param options
+     */
+    async commandUpdate(options) {
+        try {
+            await this.prologue(options);
+            if (this.dbManager === undefined)
+                throw 'dbManager undefined';
+            if (options.id === undefined)
+                throw '<id_or_pathname> of asset to update is missing';
+            if (!options.id.startsWith('/'))
+                throw '-i --id only pathname is supported at the moment';
+            const dbAsset = await this.dbManager.dbAssetExist(options.id);
+            if (dbAsset === undefined)
+                throw 'Asset ' + options.id + ' not found';
+            await this.updateAuthAccess('cyk_asset', 'asset', dbAsset.id || '', options);
+        }
+        catch (err) {
+            logger.error(err);
+        }
+    }
+    /**
+     * method commandUpload
+     * @param sources
+     * @param options
+     */
     async commandUpload(sources, options) {
         try {
             await this.prologue(options);
@@ -101,11 +261,11 @@ class AssetUpload extends Cmd_1.Cmd {
                 throw 'dbManager undefined';
             if (sources.length === 0)
                 throw 'no source to upload';
-            if (options.auth && ' basic | token | any '.indexOf(options.auth) === -1) {
-                throw 'valid authentication schemas are : basic | token | any';
+            if (options.auth && ' basic | token | cookie | any | none'.indexOf(options.auth) === -1) {
+                throw 'valid authentication schemas are : basic | token | cookie | any | none';
             }
-            logger.debug('options : ', options);
-            logger.debug('auth : ' + options.auth);
+            // logger.debug('options : ', options)
+            // logger.debug('auth : ' + options.auth)
             let dest = "/";
             if (options.dest !== undefined)
                 dest = options.dest;
@@ -139,7 +299,7 @@ class AssetUpload extends Cmd_1.Cmd {
     // cleanDestination
     //----------------------------------------------------------------------------------------------
     async cleanDestination(dest) {
-        const remoteList = await this.scanAssets();
+        const remoteList = await scanAssets(this.dbManager);
         for (let ind = 0; ind < remoteList.length; ind++) {
             const fd = remoteList[ind];
             if (fd.path.startsWith(dest)) {
@@ -161,9 +321,9 @@ class AssetUpload extends Cmd_1.Cmd {
         else {
             dirName = source + '/';
         }
-        logger.debug('options', options);
+        // logger.debug('options', options)
         this.scanDir(dirName, localList);
-        const remoteList = await this.scanAssets();
+        const remoteList = await scanAssets(this.dbManager);
         const uploadList = this.buildUploadList(dirName, dest, localList, remoteList);
         // logger.info(fileNames.join('\n'))
         if (uploadList.length === 0)
@@ -213,34 +373,6 @@ class AssetUpload extends Cmd_1.Cmd {
         return result;
     }
     //----------------------------------------------------------------------------------------------
-    // scanAssets
-    //----------------------------------------------------------------------------------------------
-    async scanAssets() {
-        const result = [];
-        if (this.dbManager === undefined)
-            throw 'dbManager undefined';
-        const dbReq = new core_1.DBExecuteRequest();
-        dbReq.selectFromTable = 'cyk_asset';
-        const pFields = dbReq.parameters.addVariable('fields', this.dbManager.scope.structure.stringDataType);
-        pFields.data = new core_1.PrimitiveData(this.dbManager.scope.structure.stringDataType, "asset_id,asset_route,asset_last_update,asset_mimetype");
-        const xmlResult = await this.dbManager.dbExecute(dbReq);
-        if (xmlResult === undefined || xmlResult === null)
-            throw 'xmlResult null or undefined';
-        const tag = (0, core_1.parseXML)('scanAssets', xmlResult);
-        const objResult = await this.dbManager.scope.structure.objectDataType.parseData(tag, this.dbManager.scope);
-        const rows = objResult.variables.getData('cyk_asset').variables;
-        for (let ind = 0; ind < rows.list.length; ind++) {
-            const { variable: row } = rows.list[ind];
-            const record = row.data;
-            const asset_id = record.variables.getData('asset_id').value;
-            const asset_route = record.variables.getData('asset_route').value;
-            const asset_last_update = record.variables.getData('asset_last_update')?.value;
-            // logger.debug('asset_route ' + asset_route,'asset_last_update ' + asset_last_update)
-            result.push({ path: asset_route, mtime: asset_last_update, id: asset_id });
-        }
-        return result;
-    }
-    //----------------------------------------------------------------------------------------------
     // scanDir
     //----------------------------------------------------------------------------------------------
     scanDir(dirName, result) {
@@ -287,7 +419,7 @@ class AssetUpload extends Cmd_1.Cmd {
     // uploadAsset
     //----------------------------------------------------------------------------------------------
     async uploadAsset(upload, route, auth) {
-        logger.debug('uploadAsset ' + upload.path + ' to route ' + route + ' with mimetype ' + this.mimetypeLookup(upload.path) + ', auth : ' + auth);
+        // logger.debug('uploadAsset ' + upload.path + ' to route ' + route + ' with mimetype ' + this.mimetypeLookup(upload.path) + ', auth : ' + auth)
         try {
             let dbAsset = await this.dbManager?.dbAssetExist(route);
             if (dbAsset === undefined) {
@@ -299,6 +431,8 @@ class AssetUpload extends Cmd_1.Cmd {
             dbAsset.mimetype = mimetype;
             dbAsset.route = route;
             dbAsset.auth = auth;
+            if (dbAsset.auth === 'none')
+                dbAsset.auth = undefined;
             // const fstat = fs.statSync(fileName)
             dbAsset.last_update = upload.mtime;
             // const contentBuffer = fs.readFileSync(fileName)

package/build/Cmd.d.ts

@@ -5,4 +5,12 @@ export declare class Cmd extends Command {
     dbRemote: DBRemote | undefined;
     constructor(name: string);
     prologue(options: any): Promise<SigninResponse>;
+    /**
+     * method updateAuthAccess
+     * @param tableName
+     * @param prefix
+     * @param id
+     * @param options
+     */
+    updateAuthAccess(tableName: string, prefix: string, id: string, options: any): Promise<void>;
 }

package/build/Cmd.js

@@ -9,6 +9,7 @@ const commander_1 = require("commander");
 const dotenv_1 = __importDefault(require("dotenv"));
 const loglevel_1 = __importDefault(require("loglevel"));
 const NodeCrypto_1 = require("./NodeCrypto");
+const DBClient_1 = require("./DBClient");
 const logger = loglevel_1.default.getLogger('Cmd.ts');
 logger.setLevel('debug');
 class Cmd extends commander_1.Command {
@@ -32,5 +33,54 @@ class Cmd extends commander_1.Command {
         await this.dbManager.initialize();
         return login;
     }
+    /**
+     * method updateAuthAccess
+     * @param tableName
+     * @param prefix
+     * @param id
+     * @param options
+     */
+    async updateAuthAccess(tableName, prefix, id, options) {
+        try {
+            let dclAuth;
+            if (options.auth) {
+                if (' basic | token | cookie | any | none | null '.indexOf(' ' + options.auth + ' ') === -1) {
+                    throw 'valid authentication schemas are : basic | token | cookie | any | null';
+                }
+                dclAuth = `<string name='${prefix}_auth'>`;
+                if (' none | null '.indexOf(' ' + options.auth + ' ') === -1)
+                    dclAuth += ` "${options.auth}" `;
+                else
+                    dclAuth += ' null ';
+                dclAuth += "</string>";
+            }
+            let dclAccess;
+            if (options.access) {
+                dclAccess = `<string name='${prefix}_access'> `;
+                if (' null | none '.indexOf(' ' + options.access + ' ') === -1)
+                    dclAccess += `"${options.access}"`;
+                else
+                    dclAccess += ' null ';
+                dclAccess += "</string>";
+            }
+            const inst = `
+            <db.update table='${tableName}'>
+                <object>
+                    <number name='${prefix}_id'>${id}</number>
+                    ${dclAuth}
+                    ${dclAccess ? dclAccess : ''}
+                </object>
+            </db.update>
+            `;
+            if (!this.dbManager)
+                throw 'prologue() has not been called before';
+            const dbClient = new DBClient_1.DBClient(this.dbManager);
+            dbClient.execInstructions(inst);
+        }
+        catch (err) {
+            logger.error(err);
+            throw err;
+        }
+    }
 }
 exports.Cmd = Cmd;

package/build/DBClient.d.ts

@@ -2,12 +2,22 @@ import { DBManager } from "@cyklang/core";
 export declare class DBClient {
     dbManager: DBManager;
     constructor(dbManager: DBManager);
+    /**
+     * method execInstructions
+     * @param source
+     */
+    execInstructions(source: string): Promise<void>;
+    /**
+     * method execScript
+     * @param source
+     */
+    execScript(source: string): Promise<void>;
     runQuery(): Promise<void>;
     selectFromTable(title: string, tableName: string, options: {
         fields: string;
         sort?: string | undefined;
         where?: string | undefined;
         width?: string | undefined;
-    }): Promise<void>;
+    }): Promise<any[]>;
     deleteModule(dbname: string): Promise<void>;
 }

package/build/DBClient.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DBClient = void 0;
 const core_1 = require("@cyklang/core");
 const loglevel_1 = __importDefault(require("loglevel"));
+const console_1 = require("./console");
 const logger = loglevel_1.default.getLogger('DBClient.ts');
 logger.setLevel('debug');
 // DBManager wrapper class
@@ -13,9 +14,41 @@ class DBClient {
     constructor(dbManager) {
         this.dbManager = dbManager;
     }
+    /**
+     * method execInstructions
+     * @param source
+     */
+    async execInstructions(source) {
+        const script = `<?xml-model href="https://www.cyklang.net/schema/cyklang.xsd" type="application/xml" schematypens="http://www.w3.org/2001/XMLSchema"?>
+        <module>
+        ` + source + `
+        </module>`;
+        await this.execScript(script);
+    }
+    /**
+     * method execScript
+     * @param source
+     */
+    async execScript(source) {
+        try {
+            const script = new core_1.Script(this.dbManager.scope, '', source);
+            await script.parseInstructions();
+            await script.execute();
+        }
+        catch (err) {
+            console.log(source);
+            console.log();
+            if (err instanceof core_1.XmlError) {
+                let xmlError = err;
+                (0, console_1.errorconsole)(xmlError);
+            }
+            console.log(err);
+        }
+    }
     async runQuery() {
     }
     async selectFromTable(title, tableName, options) {
+        let result = [];
         try {
             const objectDataType = this.dbManager.scope.structure.objectDataType;
             const stringDataType = this.dbManager.scope.structure.stringDataType;
@@ -69,14 +102,19 @@ class DBClient {
             }
             const objDataset = objXmlResult.variables.getData(tableName);
             for (let ind = 0; ind < objDataset.variables.length(); ind++) {
-                const record = objDataset.variables.at(ind)?.data;
-                list.addObjectData(record);
+                const variable = objDataset.variables.at(ind);
+                if (variable) {
+                    const record = variable?.data;
+                    list.addObjectData(record);
+                    result.push((0, core_1.variable2json)(variable));
+                }
             }
             logger.info(list.renderList(title));
         }
         catch (err) {
             logger.error(err);
         }
+        return result;
     }
     async deleteModule(dbname) {
         try {

package/build/InitCommand.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[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];

package/build/ModuleCommand.js

@@ -2,7 +2,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[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];
@@ -38,10 +42,10 @@ class ModuleCommand extends commander_1.Command {
         super(name);
         this.description('manage modules');
         // upload
-        this.addCommand(new ModuleUpload('upload', `Upload local module file(s) to the database.
+        this.addCommand(new ModuleU('upload', `Upload local module file(s) to the database.
 Module name is the base name of the file. If a module with the same name already exists, it will be updated.
 Otherwise, a new module is inserted in the database. To rename a module, use option --id to indicate the module you want to rename`));
-        this.addCommand(new ModuleUpload('u', 'shortcut for (u)pload'));
+        this.addCommand(new ModuleU('u', 'shortcut for (u)pload'));
         // download
         this.addCommand(new ModuleDownload('download', 'download module files to the current directory'));
         this.addCommand(new ModuleDownload('d', 'shortcut for (d)ownload'));
@@ -64,16 +68,52 @@ function getModuleDBName(filePath) {
         throw 'filename ' + result + ' does not match identifier syntax';
     return result;
 }
-class ModuleUpload extends Cmd_1.Cmd {
+/**
+ * class ModuleU
+ */
+class ModuleU extends Cmd_1.Cmd {
     constructor(name, description) {
         super(name);
         this.description(description)
-            .option('-i --id <id>', 'module ID to upload')
+            .option('--auth <auth_schema>', 'authentication schema : basic | token | cookie | any | none, default is none')
+            .option('--access <access_right>', 'access rights required')
+            .option('-i --id <id>', 'module ID to upload or update')
             .argument('[files...]', 'local module file(s) to upload to the server')
             .action(async (files, options) => {
-            await this.commandUpload(files, options);
+            await this.commandU(files, options);
         });
     }
+    async commandU(files, options) {
+        if (files.length > 0) {
+            await this.commandUpload(files, options);
+        }
+        else {
+            await this.commandUpdate(options);
+        }
+    }
+    /**
+     * method commandUpdate
+     * @param options
+     */
+    async commandUpdate(options) {
+        try {
+            await this.prologue(options);
+            if (this.dbManager === undefined)
+                throw 'dbManager undefined';
+            if (options.id === undefined)
+                throw '<id_or_route> of module to update is missing';
+            const dbModule = await this.dbManager.getModule(options.id);
+            await this.updateAuthAccess('cyk_module', 'module', dbModule.id || '', options);
+        }
+        catch (err) {
+            logger.error(err);
+        }
+    }
+    /**
+     * method commandUpload
+     * @param files
+     * @param options
+     */
     async commandUpload(files, options) {
         try {
             await this.prologue(options);

package/build/OpenCommand.d.ts

@@ -0,0 +1,5 @@
+import { Cmd } from "./Cmd";
+export declare class OpenCommand extends Cmd {
+    constructor();
+    openBrowser(module: string, options: any): Promise<void>;
+}

package/build/OpenCommand.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenCommand = void 0;
+const Cmd_1 = require("./Cmd");
+const loglevel_1 = __importDefault(require("loglevel"));
+const logger = loglevel_1.default.getLogger('OpenCommand.ts');
+logger.setLevel('debug');
+class OpenCommand extends Cmd_1.Cmd {
+    constructor() {
+        super('open');
+        this.description('open browser').version('0.1')
+            .argument('<module>', 'module to execute')
+            .action(async (module, options) => {
+            await this.openBrowser(module, options);
+        });
+    }
+    async openBrowser(module, options) {
+        try {
+            await this.prologue(options);
+            if (process.env.DBREMOTE_URL === undefined)
+                throw 'DBREMOTE_URL undefined';
+            const url = process.env.DBREMOTE_URL + '/cyk/#/run/' + module;
+            const open = await import('open');
+            open.default(url);
+        }
+        catch (err) {
+            logger.error(err);
+        }
+    }
+}
+exports.OpenCommand = OpenCommand;

package/build/RunCommand.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[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];