@cyklang/cli 0.1.0

package/build/NodeCrypto.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeCrypto = void 0;
+const crypto_1 = require("crypto");
+const loglevel_1 = require("loglevel");
+const core_1 = require("@cyklang/core");
+const pako_1 = __importDefault(require("pako"));
+const util_1 = require("util");
+const logger = (0, loglevel_1.getLogger)('NodeCrypto.ts');
+logger.setLevel('debug');
+const algorithm = 'aes-128-cbc';
+const iv_length = 16;
+class NodeCrypto {
+    // last_iv: Buffer | undefined
+    async encrypt(plain) {
+        const deflatedData = pako_1.default.deflate(plain);
+        // logger.debug('deflatedData : ', deflatedData[0], deflatedData[1])
+        const iv = (0, crypto_1.randomBytes)(iv_length);
+        // this.last_iv = iv
+        // logger.debug("encrypt iv " + iv.toString('hex'))
+        const cipher = (0, crypto_1.createCipheriv)(algorithm, core_1.cipherKey, iv);
+        let result = cipher.update(deflatedData, undefined, "hex");
+        result += cipher.final("hex");
+        result += iv.toString('hex');
+        return result;
+    }
+    async decrypt(encoded) {
+        const iv_hex = encoded.substring(encoded.length - 2 * iv_length);
+        const encryptedData = encoded.substring(0, encoded.length - 2 * iv_length);
+        // logger.debug("decrypt iv " + iv_hex)
+        const iv = Buffer.from(iv_hex, 'hex');
+        // if (this.last_iv === undefined) throw 'last_iv undefined'
+        // if (Buffer.compare(iv, this.last_iv) !== 0) throw 'iv and last_iv are different'
+        const decipher = (0, crypto_1.createDecipheriv)(algorithm, core_1.cipherKey, iv);
+        let deflatedData1 = decipher.update(encryptedData, 'hex');
+        const deflatedData2 = decipher.final();
+        const deflatedData = Buffer.concat([deflatedData1, deflatedData2]);
+        let inflatedData = deflatedData;
+        if (deflatedData[0] === 0x78 && deflatedData[1] === 0x9c) {
+            inflatedData = Buffer.from(pako_1.default.inflate(deflatedData));
+        }
+        const result = (new util_1.TextDecoder()).decode(inflatedData);
+        return result;
+    }
+}
+exports.NodeCrypto = NodeCrypto;

package/build/QueryCommand.d.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env ts-node
+import { Command } from 'commander';
+export declare class QueryCommand extends Command {
+    constructor(name: string);
+}

package/build/QueryCommand.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env ts-node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryCommand = void 0;
+const core_1 = require("@cyklang/core");
+const loglevel_1 = __importDefault(require("loglevel"));
+const commander_1 = require("commander");
+const logger = loglevel_1.default.getLogger("QueryCommand.ts");
+logger.setLevel("debug");
+class QueryCommand extends commander_1.Command {
+    constructor(name) {
+        super(name);
+    }
+}
+exports.QueryCommand = QueryCommand;
+function parseXmlFile(filepath, basename, xmlSource) {
+    const tag = (0, core_1.parseXML)(filepath, xmlSource);
+    if (tag.name !== 'DB.QUERY') {
+        throw Error('tag ' + tag.name + ', should be <db.query>');
+    }
+    const name = tag.attributes.NAME;
+    if (name === undefined) {
+        throw Error('name attribute is missing');
+    }
+    if (basename !== name + '.xml') {
+        throw Error('filename ' + filepath + ' and name ' + name + ' do not correspond');
+    }
+    return tag;
+}
+async function executeXml(structure, tag, xmlSource) {
+    try {
+        logger.debug('executeXml ' + tag.attributes.NAME);
+        // structure.setInstructionType("print", new PrintInstructionType(logfilename))
+        const dbQueryInstructionType = structure.scope.getInstructionType('db.query');
+        if (dbQueryInstructionType === undefined) {
+            throw Error('dbQueryInstructionType not found');
+        }
+        const scopeParse = new core_1.Scope(structure, structure.scope, undefined);
+        const dbQueryInst = await dbQueryInstructionType.parseInstruction(tag, scopeParse);
+        dbQueryInst.source = xmlSource;
+        const scopeExecute = new core_1.Scope(structure, structure.scope, undefined);
+        await dbQueryInst.execute(scopeExecute);
+    }
+    catch (err) {
+        logger.error(err);
+    }
+}
+async function testQuery(structure, queryName) {
+    const xmlScript = `
+    <block>
+    <object name='result'/>
+    <db.execute query='${queryName}' result='result' />
+    <print>string(result)</print>
+    </block>
+    `;
+    const script = new core_1.Script(structure.scope, 'test', xmlScript);
+    await script.parseInstructions();
+    await script.execute();
+}

package/build/RunCommand.d.ts

@@ -0,0 +1,5 @@
+import { Cmd } from "./Cmd";
+export declare class RunCommand extends Cmd {
+    constructor();
+    runFiles(files: string[], options: any): Promise<void>;
+}

package/build/RunCommand.js

@@ -0,0 +1,112 @@
+"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]; } });
+}) : (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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunCommand = void 0;
+const core_1 = require("@cyklang/core");
+const fs = __importStar(require("fs"));
+const console_1 = require("./console");
+const loglevel_1 = __importDefault(require("loglevel"));
+const NodeCrypto_1 = require("./NodeCrypto");
+const Cmd_1 = require("./Cmd");
+loglevel_1.default.setLevel('debug');
+const logger = loglevel_1.default.getLogger('RunCommand.ts');
+class RunCommand extends Cmd_1.Cmd {
+    constructor() {
+        super('run');
+        this.description('run module').version('0.2')
+            .argument('<files...>', 'local module file(s) to run')
+            .action(async (files, options) => {
+            await this.runFiles(files, options);
+        });
+    }
+    async runFiles(files, options) {
+        try {
+            await this.prologue(options);
+            for (let ind = 0; ind < files.length; ind++) {
+                const result = await runFile(files[ind]);
+                // if (result === false) {
+                //     logger.debug('*********** FAILURE ' + process.argv[ind] + ' ***************')
+                // }
+            }
+        }
+        catch (err) {
+            logger.error(err);
+        }
+    }
+}
+exports.RunCommand = RunCommand;
+async function runFile(filename) {
+    let result;
+    if (filename.indexOf(".") !== -1) {
+        filename = filename.substring(0, filename.indexOf("."));
+    }
+    let xmlfilename = filename + ".xml";
+    // let logfilename = filename + ".log"
+    // let outfilename = filename + ".output"
+    let xml = fs.readFileSync(xmlfilename);
+    // fs.writeFileSync(logfilename, "")
+    try {
+        if (process.env.DBREMOTE_URL === undefined)
+            throw 'DBREMOTE_URL undefined';
+        logger.trace('DBREMOTE_URL ' + process.env.DBREMOTE_URL);
+        const structure = new core_1.Structure();
+        const nodeCrypto = new NodeCrypto_1.NodeCrypto();
+        const dbRemote = new core_1.DBRemote(structure.scope, process.env.DBREMOTE_URL, nodeCrypto);
+        const login = await dbRemote.signin(process.env.USER_NAME, undefined, process.env.USER_PASSWORD);
+        const dbManager = new core_1.DBManager(structure.scope, dbRemote);
+        await dbManager.initialize();
+        const tag = (0, core_1.parseXML)(xmlfilename, xml.toString());
+        const moduleInstruction = new core_1.ModuleInstruction(tag, dbManager);
+        await moduleInstruction.parse(structure.scope);
+        await moduleInstruction.execute(structure.scope);
+        // structure.scope.addInstructionType(new PrintInstructionType(logfilename))
+        // let script = new Script(structure.scope, xmlfilename, xml.toString())
+        // await script.parseInstructions()
+        // await script.execute()
+    }
+    catch (err) {
+        if (err instanceof core_1.XmlError) {
+            let xmlError = err;
+            (0, console_1.errorconsole)(xmlError);
+        }
+        console.log(err);
+    }
+    // let log = fs.readFileSync(logfilename)
+    // if (fs.existsSync(outfilename) === true ) {
+    //     let out = fs.readFileSync(outfilename)
+    //     if (log.toString() === out.toString()) {
+    //         console.log("test " + xmlfilename + " SUCCESS")
+    //         result = true
+    //     }
+    //     else {
+    //         console.log("test " + xmlfilename + " FAILURE")
+    //         result = false
+    //     }
+    // }
+    // else {
+    //     console.log("test " + xmlfilename + " output file not found ")
+    //     result = false
+    // }
+    // return result
+}

package/build/TableCommand.d.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env ts-node
+import { Command } from "commander";
+export declare class TableCommand extends Command {
+    constructor(name: string);
+}

package/build/TableCommand.js

@@ -0,0 +1,140 @@
+#!/usr/bin/env ts-node
+"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]; } });
+}) : (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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableCommand = void 0;
+const fs = __importStar(require("fs"));
+const loglevel_1 = __importDefault(require("loglevel"));
+const commander_1 = require("commander");
+const child_process_1 = require("child_process");
+const Cmd_1 = require("./Cmd");
+const logger = loglevel_1.default.getLogger("TableCommand.ts");
+logger.setLevel("debug");
+class TableCommand extends commander_1.Command {
+    constructor(name) {
+        super(name);
+        this.description('import/export table rows').version('0.1');
+        this.addCommand(new TableExportCmd());
+    }
+}
+exports.TableCommand = TableCommand;
+class TableExportCmd extends Cmd_1.Cmd {
+    constructor() {
+        super('export');
+        this.description('export to CSV file(s)')
+            .argument('<tables...>', 'table(s) to export')
+            .option('-f --file <file>', 'name of the file to create, defaults to <table_name>.csv')
+            .option('-d --dir <directory>', 'name of the directory where to create exported files')
+            .action(async (tables, options) => this.commandExport(tables, options));
+    }
+    async commandExport(tables, options) {
+        await this.prologue(options);
+        if (this.dbManager === undefined)
+            throw 'dbManager undefined';
+        await commandImportExport(this.dbManager, 'to', tables, options);
+    }
+}
+class TableImportCmd extends Cmd_1.Cmd {
+    constructor() {
+        super('import');
+        this.description('import from CSV file(s)')
+            .option('-f --file <file>', 'name of the file to import, defaults to <table_name>.csv')
+            .option('-d --dir <directory>', 'name of the directory where to find files to import')
+            .action(async (tables, options) => this.commandImport(tables, options));
+    }
+    async commandImport(tables, options) {
+        await this.prologue(options);
+        if (this.dbManager === undefined)
+            throw 'dbManager undefined';
+        await commandImportExport(this.dbManager, 'from', tables, options);
+    }
+}
+const commandImportExport = async (dbManager, direction, tables, options) => {
+    logger.debug('tables : ', tables, 'options : ', options);
+    try {
+        if (options.file === undefined && options.dir === undefined)
+            throw '--file or --dir mandatory';
+        if (options.file !== undefined && options.dir !== undefined)
+            throw '--file and --dir are mutually exclusive';
+        if (tables.length === 0)
+            throw 'at least one table name is mandatory';
+        if (tables.length > 1 && options.dir === undefined)
+            throw 'for multiple tables, --dir is mandatory';
+        for (let indi = 0; indi < tables.length; indi++) {
+            const tableName = tables[indi];
+            const dbTable = await dbManager.dbTableExist(tableName);
+            if (dbTable === undefined) {
+                logger.info('table ' + tableName + ' not found');
+                continue;
+            }
+            let lcols;
+            for (let indj = 0; indj < dbTable.columns.length; indj++) {
+                const dbColumn = dbTable.columns[indj];
+                if (lcols === undefined) {
+                    lcols = "(";
+                }
+                else {
+                    lcols += ",";
+                }
+                lcols += dbColumn.name;
+            }
+            lcols += ")";
+            let psql_cmd = "psql -c";
+            if (process.env.HEROKU_CLI !== undefined) {
+                psql_cmd = process.env.HEROKU_CLI + ' -c ';
+            }
+            let filename;
+            if (options.file !== undefined) {
+                if (fs.existsSync(options.file) && fs.lstatSync(options.file).isDirectory())
+                    throw '--file ' + options.file + ' is a directory';
+                filename = options.file;
+            }
+            else if (options.dir === undefined)
+                throw '--file and --dir unspecified';
+            else if (fs.existsSync(options.dir) === false)
+                throw 'directory ' + options.dir + ' does not exist';
+            else if (fs.lstatSync(options.dir).isFile()) {
+                logger.debug("--dir " + options.dir + " is a file ");
+            }
+            else {
+                let directory = options.dir.trim();
+                if (directory[directory.length - 1] !== '/') {
+                    directory += '/';
+                }
+                filename = directory + tableName + '.csv';
+            }
+            let copy_cmd = "\\copy " + tableName + lcols + direction + " '" + filename + "' csv header";
+            const shell_cmd = psql_cmd + '"' + copy_cmd + '"';
+            logger.debug(shell_cmd);
+            const child = (0, child_process_1.spawn)(shell_cmd.trim(), { stdio: 'inherit', shell: true });
+            // exec(shell_cmd.trim(), (error, stdout, stderr) => {
+            //     if (error) throw error
+            //     logger.debug(stdout, stderr)
+            // })
+        }
+    }
+    catch (err) {
+        logger.error(err);
+    }
+};

package/build/TestCommand copy.d.ts

@@ -0,0 +1,5 @@
+import { Cmd } from "./Cmd";
+export declare class TestCommand extends Cmd {
+    constructor();
+    testRun(files: string[], options: any): Promise<void>;
+}

package/build/TestCommand copy.js

@@ -0,0 +1,111 @@
+"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]; } });
+}) : (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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestCommand = void 0;
+const core_1 = require("@cyklang/core");
+const fs = __importStar(require("fs"));
+const console_1 = require("./console");
+const loglevel_1 = __importDefault(require("loglevel"));
+const NodeCrypto_1 = require("./NodeCrypto");
+const Cmd_1 = require("./Cmd");
+loglevel_1.default.setLevel('debug');
+const logger = loglevel_1.default.getLogger('TestCommand.ts');
+class TestCommand extends Cmd_1.Cmd {
+    constructor() {
+        super('test');
+        this.description('test script').version('0.1')
+            .argument('<files...>', 'local module file(s) to test run')
+            .action(async (files, options) => {
+            await this.testRun(files, options);
+        });
+    }
+    async testRun(files, options) {
+        try {
+            await this.prologue(options);
+            for (let ind = 0; ind < files.length; ind++) {
+                const result = await testfile(files[ind]);
+                if (result === false) {
+                    logger.debug('*********** FAILURE ' + process.argv[ind] + ' ***************');
+                }
+            }
+        }
+        catch (err) {
+            logger.error(err);
+        }
+    }
+}
+exports.TestCommand = TestCommand;
+async function testfile(filename) {
+    let result;
+    if (filename.indexOf(".") !== -1) {
+        filename = filename.substring(0, filename.indexOf("."));
+    }
+    let xmlfilename = filename + ".xml";
+    let logfilename = filename + ".log";
+    let outfilename = filename + ".output";
+    let xml = fs.readFileSync(xmlfilename);
+    fs.writeFileSync(logfilename, "");
+    //console.log(xml.toString())
+    try {
+        if (process.env.DBREMOTE_URL === undefined)
+            throw 'DBREMOTE_URL undefined';
+        logger.trace('DBREMOTE_URL ' + process.env.DBREMOTE_URL);
+        const structure = new core_1.Structure();
+        const nodeCrypto = new NodeCrypto_1.NodeCrypto();
+        const dbRemote = new core_1.DBRemote(structure.scope, process.env.DBREMOTE_URL, nodeCrypto);
+        const login = await dbRemote.signin(process.env.USER_NAME, undefined, process.env.USER_PASSWORD);
+        //const dbRemote = new DBRemote(structure, 'https://cyk-postgres.herokuapp.com')
+        const dbManager = new core_1.DBManager(structure.scope, dbRemote);
+        await dbManager.initialize();
+        structure.scope.addInstructionType(new console_1.PrintInstructionType(logfilename));
+        let script = new core_1.Script(structure.scope, xmlfilename, xml.toString());
+        await script.parseInstructions();
+        await script.execute();
+        // console.log(JSON.stringify(script.block.toString()))
+    }
+    catch (err) {
+        if (err instanceof core_1.XmlError) {
+            let xmlError = err;
+            (0, console_1.errorconsole)(xmlError);
+        }
+        console.log(err);
+    }
+    let log = fs.readFileSync(logfilename);
+    if (fs.existsSync(outfilename) === true) {
+        let out = fs.readFileSync(outfilename);
+        if (log.toString() === out.toString()) {
+            console.log("test " + xmlfilename + " SUCCESS");
+            result = true;
+        }
+        else {
+            console.log("test " + xmlfilename + " FAILURE");
+            result = false;
+        }
+    }
+    else {
+        console.log("test " + xmlfilename + " output file not found ");
+        result = false;
+    }
+    return result;
+}

package/build/TestCommand.d.ts

@@ -0,0 +1,5 @@
+import { Cmd } from "./Cmd";
+export declare class TestCommand extends Cmd {
+    constructor();
+    testRun(files: string[], options: any): Promise<void>;
+}

package/build/TestCommand.js

@@ -0,0 +1,111 @@
+"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]; } });
+}) : (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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestCommand = void 0;
+const core_1 = require("@cyklang/core");
+const fs = __importStar(require("fs"));
+const console_1 = require("./console");
+const loglevel_1 = __importDefault(require("loglevel"));
+const NodeCrypto_1 = require("./NodeCrypto");
+const Cmd_1 = require("./Cmd");
+loglevel_1.default.setLevel('debug');
+const logger = loglevel_1.default.getLogger('TestCommand.ts');
+class TestCommand extends Cmd_1.Cmd {
+    constructor() {
+        super('test');
+        this.description('test script').version('0.1')
+            .argument('<files...>', 'local module file(s) to test run')
+            .action(async (files, options) => {
+            await this.testRun(files, options);
+        });
+    }
+    async testRun(files, options) {
+        try {
+            await this.prologue(options);
+            for (let ind = 0; ind < files.length; ind++) {
+                const result = await testfile(files[ind]);
+                if (result === false) {
+                    logger.debug('*********** FAILURE ' + process.argv[ind] + ' ***************');
+                }
+            }
+        }
+        catch (err) {
+            logger.error(err);
+        }
+    }
+}
+exports.TestCommand = TestCommand;
+async function testfile(filename) {
+    let result;
+    if (filename.indexOf(".") !== -1) {
+        filename = filename.substring(0, filename.indexOf("."));
+    }
+    let xmlfilename = filename + ".xml";
+    let logfilename = filename + ".log";
+    let outfilename = filename + ".output";
+    let xml = fs.readFileSync(xmlfilename);
+    fs.writeFileSync(logfilename, "");
+    //console.log(xml.toString())
+    try {
+        if (process.env.DBREMOTE_URL === undefined)
+            throw 'DBREMOTE_URL undefined';
+        logger.trace('DBREMOTE_URL ' + process.env.DBREMOTE_URL);
+        const structure = new core_1.Structure();
+        const nodeCrypto = new NodeCrypto_1.NodeCrypto();
+        const dbRemote = new core_1.DBRemote(structure.scope, process.env.DBREMOTE_URL, nodeCrypto);
+        const login = await dbRemote.signin(process.env.USER_NAME, undefined, process.env.USER_PASSWORD);
+        //const dbRemote = new DBRemote(structure, 'https://cyk-postgres.herokuapp.com')
+        const dbManager = new core_1.DBManager(structure.scope, dbRemote);
+        await dbManager.initialize();
+        structure.scope.addInstructionType(new console_1.PrintInstructionType(logfilename));
+        let script = new core_1.Script(structure.scope, xmlfilename, xml.toString());
+        await script.parseInstructions();
+        await script.execute();
+        // console.log(JSON.stringify(script.block.toString()))
+    }
+    catch (err) {
+        if (err instanceof core_1.XmlError) {
+            let xmlError = err;
+            (0, console_1.errorconsole)(xmlError);
+        }
+        console.log(err);
+    }
+    let log = fs.readFileSync(logfilename);
+    if (fs.existsSync(outfilename) === true) {
+        let out = fs.readFileSync(outfilename);
+        if (log.toString() === out.toString()) {
+            console.log("test " + xmlfilename + " SUCCESS");
+            result = true;
+        }
+        else {
+            console.log("test " + xmlfilename + " FAILURE");
+            result = false;
+        }
+    }
+    else {
+        console.log("test " + xmlfilename + " output file not found ");
+        result = false;
+    }
+    return result;
+}

package/build/UserCommand.d.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env ts-node
+import { Command } from 'commander';
+export declare class UserCommand extends Command {
+    constructor(name: string);
+}