@adinsure-ops/ops-cli 4.0.0-rc6

package/lib/commands/npm/check.publish.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@oclif/command");
+const chalk_1 = require("chalk");
+const cli_ux_1 = require("cli-ux");
+const command_base_1 = require("../../command.base");
+const npm_1 = require("../../lib/npm");
+class NpmCheckPublish extends command_base_1.default {
+    async checkPackagesExists(packages, allPackages, version) {
+        let errorCount = 0;
+        for (const pkg of packages) {
+            cli_ux_1.default.action.start(`${pkg.name}@${version}`, undefined, { stdout: true });
+            let matchedPackage = allPackages.value.find(azurePackage => azurePackage.name === pkg.name);
+            if (!matchedPackage) {
+                cli_ux_1.default.action.stop(`${chalk_1.default.red('package missing')}`);
+                errorCount++;
+                continue;
+            }
+            let matchVersion = matchedPackage.versions.find(azurePackageVersion => azurePackageVersion.version === version);
+            if (!matchVersion) {
+                cli_ux_1.default.action.stop(`${chalk_1.default.red('version missing')}`);
+                errorCount++;
+                continue;
+            }
+            cli_ux_1.default.action.stop(`${chalk_1.default.green('exists')}`);
+        }
+        if (errorCount > 0) {
+            throw new Error(`${errorCount} packages or versions missing!`);
+        }
+    }
+    async run() {
+        try {
+            const { flags } = this.parse(NpmCheckPublish);
+            let npmContext = new npm_1.default();
+            cli_ux_1.default.action.start('Parsing packages to check', undefined, { stdout: true });
+            const packages = await npmContext.packageList(flags.package, flags.exclude, this);
+            cli_ux_1.default.action.stop(`${chalk_1.default.green('done')}`);
+            cli_ux_1.default.action.start('Getting list of available packages', undefined, { stdout: true });
+            const allPackages = JSON.parse(await npmContext.getAllNpmPackages(flags.pat));
+            cli_ux_1.default.action.stop(`${chalk_1.default.green('done')}`);
+            await this.checkPackagesExists(packages, allPackages, flags.version);
+            cli_ux_1.default.action.stop('success');
+        }
+        catch (err) {
+            cli_ux_1.default.action.stop('error');
+            this.error(`${err.message}`);
+        }
+    }
+}
+exports.default = NpmCheckPublish;
+NpmCheckPublish.aliases = ['npm:check-publish'];
+NpmCheckPublish.description = 'check if npm packages was published';
+NpmCheckPublish.usage = 'npm:check-publish [options]';
+NpmCheckPublish.examples = [
+    '$ ops npm:check-publish -v 6.0.1',
+    '$ ops npm:check-publish -p @adinsure/* -v 6.0.0',
+    '$ ops npm:check-publish -p @adinsure/* -x @adisure/demo -v 6.0.0'
+];
+NpmCheckPublish.flags = {
+    package: command_1.flags.string({
+        char: 'p',
+        description: 'package name filter you want to check',
+        multiple: true
+    }),
+    exclude: command_1.flags.string({
+        char: 'x',
+        description: 'exclude packages from filter',
+        multiple: true
+    }),
+    version: command_1.flags.string({
+        char: 'v',
+        description: 'version we want to check if published',
+        required: true
+    }),
+    pat: command_1.flags.string({
+        description: 'PAT token or AZURE_DEVOPS_EXT_PAT environment variable'
+    }),
+};

package/lib/commands/npm/publish.d.ts

@@ -0,0 +1,23 @@
+import { flags } from '@oclif/command';
+import CommandBase from '../../command.base';
+import { AzurePackageArray, NpmPackage } from '../../types/npm.types';
+export default class NpmPublish extends CommandBase {
+    static aliases: string[];
+    static description: string;
+    static usage: string;
+    static examples: string[];
+    static flags: {
+        package: flags.IOptionFlag<string[]>;
+        exclude: flags.IOptionFlag<string[]>;
+        version: flags.IOptionFlag<string>;
+        pat: flags.IOptionFlag<string | undefined>;
+    };
+    private cp;
+    publishPackage(pkg: NpmPackage, cmd?: string[]): Promise<{
+        data: string;
+        error: string;
+    }>;
+    checkPackageCanPublish(pkg: NpmPackage, allPackages: AzurePackageArray, version: string): Promise<boolean>;
+    publishPackages(packages: NpmPackage[], allPackages: AzurePackageArray, version: string): Promise<void>;
+    run(): Promise<void>;
+}

package/lib/commands/npm/publish.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const command_1 = require("@oclif/command");
+const chalk_1 = require("chalk");
+const child_process_1 = require("child_process");
+const cli_ux_1 = require("cli-ux");
+const command_base_1 = require("../../command.base");
+const npm_1 = require("../../lib/npm");
+class NpmPublish extends command_base_1.default {
+    async publishPackage(pkg, cmd = ['yarn', 'publish']) {
+        var e_1, _a, e_2, _b;
+        let sh;
+        let args;
+        // cross platform compatibility
+        if (process.platform === 'win32') {
+            sh = 'cmd';
+            args = ['/c'].concat(cmd);
+        }
+        else {
+            [sh, ...args] = cmd;
+        }
+        try {
+            this.cp = child_process_1.spawn(sh, args, {
+                cwd: pkg.path,
+                env: Object.assign(Object.assign({}, process.env), process.stdout.isTTY ? { FORCE_COLOR: process.env.FORCE_COLOR || '1' } : {}),
+                stdio: 'pipe'
+            });
+            let data = '';
+            try {
+                for (var _c = tslib_1.__asyncValues(this.cp.stdout), _d; _d = await _c.next(), !_d.done;) {
+                    const chunk = _d.value;
+                    data += chunk;
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_a = _c.return)) await _a.call(_c);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            let error = '';
+            try {
+                for (var _e = tslib_1.__asyncValues(this.cp.stderr), _f; _f = await _e.next(), !_f.done;) {
+                    const chunk = _f.value;
+                    error += chunk;
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_f && !_f.done && (_b = _e.return)) await _b.call(_e);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            const exitCode = await new Promise((resolve, _reject) => {
+                this.cp.on('close', resolve);
+            });
+            if (exitCode) {
+                throw new Error(`subprocess error exit ${exitCode}, ${error}`);
+            }
+            return { data, error };
+        }
+        catch (err) {
+            throw new Error(err.message);
+        }
+    }
+    async checkPackageCanPublish(pkg, allPackages, version) {
+        this.log('');
+        cli_ux_1.default.action.start(`${pkg.name}@${pkg.version}`, undefined, { stdout: true });
+        let matchedPackage = allPackages.value.find(azurePackage => azurePackage.name === pkg.name);
+        if (pkg.version !== version) {
+            this.warn(`${pkg.name}@${pkg.version} doesn't match desired publish version!`);
+            cli_ux_1.default.action.stop(chalk_1.default.red(`version doesn't match version ${version}`));
+            throw new Error(`Version in package.json doesn't match desired published version`);
+        }
+        if (!matchedPackage) {
+            cli_ux_1.default.action.stop(`${chalk_1.default.green('new package')}`);
+            cli_ux_1.default.action.start(`publish new package ${pkg.name}@${pkg.version} from ${pkg.jsonPath}`, undefined, { stdout: true });
+            await this.publishPackage(pkg);
+            cli_ux_1.default.action.stop(`${chalk_1.default.green('done')}`);
+            return true;
+        }
+        let matchVersion = matchedPackage.versions.find(azurePackageVersion => azurePackageVersion.version === pkg.version);
+        if (!matchVersion) {
+            cli_ux_1.default.action.stop(`${chalk_1.default.yellow('version missing')}`);
+            cli_ux_1.default.action.start(`publish new version ${pkg.name}@${pkg.version} from ${pkg.jsonPath}`, undefined, { stdout: true });
+            await this.publishPackage(pkg);
+            cli_ux_1.default.action.stop(`${chalk_1.default.green('done')}`);
+            return true;
+        }
+        this.warn(`${pkg.name}@${pkg.version} already exists`);
+        cli_ux_1.default.action.stop(`${chalk_1.default.blue('skipping')}`);
+        return false;
+    }
+    async publishPackages(packages, allPackages, version) {
+        let errorCount = 0;
+        this.log(`publishing ${packages.length} packages:`);
+        this.log(packages.map(pkg => pkg.name).toString());
+        for (const pkg of packages) {
+            try {
+                await this.checkPackageCanPublish(pkg, allPackages, version);
+            }
+            catch (_a) {
+                errorCount++;
+                continue;
+            }
+        }
+        if (errorCount > 0) {
+            throw new Error(`${errorCount} with Errors!`);
+        }
+    }
+    async run() {
+        try {
+            const { flags } = this.parse(NpmPublish);
+            let npmContext = new npm_1.default();
+            cli_ux_1.default.action.start('Parsing packages to check', undefined, { stdout: true });
+            const packages = await npmContext.packageList(flags.package, flags.exclude, this);
+            cli_ux_1.default.action.stop(`${chalk_1.default.green('done')}`);
+            cli_ux_1.default.action.start('Getting list of published packages', undefined, { stdout: true });
+            const allPackages = JSON.parse(await npmContext.getAllNpmPackages(flags.pat));
+            cli_ux_1.default.action.stop(`${chalk_1.default.green('done')}`);
+            await this.publishPackages(packages, allPackages, flags.version);
+            cli_ux_1.default.action.stop('success');
+        }
+        catch (err) {
+            cli_ux_1.default.action.stop('error');
+            this.error(`${err.message}`);
+        }
+    }
+}
+exports.default = NpmPublish;
+NpmPublish.aliases = ['npm:publish'];
+NpmPublish.description = 'Publish npm packages';
+NpmPublish.usage = 'npm:publish [options]';
+NpmPublish.examples = [
+    '$ ops npm:publish -v 15.0.0',
+    '$ ops npm:publish -v 15.0.0',
+    '$ ops npm:publish -p @adinsure-tooling/* -v 15.0.0',
+    '$ ops npm:publish -p @adinsure-tooling/* -x @adisure-tooling/studio-services -v 6.0.0'
+];
+NpmPublish.flags = {
+    package: command_1.flags.string({
+        char: 'p',
+        description: 'package name filter you want to check',
+        multiple: true
+    }),
+    exclude: command_1.flags.string({
+        char: 'x',
+        description: 'exclude packages from filter',
+        multiple: true
+    }),
+    version: command_1.flags.string({
+        char: 'v',
+        description: 'version we want to check if published',
+        required: true
+    }),
+    pat: command_1.flags.string({
+        description: 'PAT token or AZURE_DEVOPS_EXT_PAT environment variable',
+        env: 'AZURE_DEVOPS_EXT_PAT'
+    }),
+};

package/lib/commands/prepare-content.d.ts

@@ -0,0 +1,29 @@
+import { flags } from '@oclif/command';
+import CommandBase from '../command.base';
+interface Transformation {
+    name: string;
+    srcPath: string;
+    transform(): void;
+}
+interface DotfileLine {
+    prefix: string;
+    source: string;
+    transformData: string;
+}
+export default class PrepareContent extends CommandBase {
+    static readonly dotfile = ".opsprepare";
+    static description: string;
+    static usage: string;
+    static examples: string[];
+    static flags: {
+        destination: flags.IOptionFlag<string>;
+        source: flags.IOptionFlag<string>;
+    };
+    parseDotfileLine(line: string, sourceDirectory: string): Promise<DotfileLine>;
+    readDotfile(sourceDirectory: string): Promise<DotfileLine[]>;
+    getTransformation(lineData: DotfileLine, baseSourcedir: string, baseDestinationDir: string): Promise<Transformation>;
+    prepareTransformations(linesData: DotfileLine[], baseSourceDir: string, baseDestinationDir: string): Promise<Transformation[]>;
+    runTransformations(transformations: Transformation[]): Promise<void>;
+    run(): Promise<void>;
+}
+export {};

package/lib/commands/prepare-content.js

@@ -0,0 +1,386 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@oclif/command");
+const chalk_1 = require("chalk");
+const cli_ux_1 = require("cli-ux");
+const fs = require("fs-extra");
+const path = require("path");
+const command_base_1 = require("../command.base");
+class CopyTransformation {
+    constructor(srcPath, dstPath) {
+        this.name = this.constructor.name;
+        this.srcPath = srcPath;
+        this.dstPath = dstPath;
+    }
+    transform() {
+        try {
+            fs.accessSync(this.srcPath, fs.constants.R_OK);
+        }
+        catch (err) {
+            if (err.code === 'ENOENT') {
+                throw new Error(`${this.name}: source file does not exist <${this.srcPath}>`);
+            }
+            else {
+                throw new Error(`${this.name}: ${err} <${this.srcPath}>`);
+            }
+        }
+        cli_ux_1.default.log(`Copying from ${this.srcPath} to ${this.dstPath}`);
+        try {
+            fs.copySync(this.srcPath, this.dstPath, { overwrite: true });
+        }
+        catch (err) {
+            throw new Error(`${this.name}: ${err} <${this.srcPath}>`);
+        }
+    }
+}
+class JavascriptTransformation {
+    constructor(srcPath, dstPath, javascriptFile, functionName) {
+        this.name = this.constructor.name;
+        this.srcPath = srcPath;
+        this.dstPath = dstPath;
+        this.jsFile = path.resolve(javascriptFile);
+        this.functionName = functionName;
+    }
+    importTransformationModule() {
+        try {
+            return require(this.jsFile);
+        }
+        catch (err) {
+            if (err.code === 'MODULE_NOT_FOUND') {
+                throw new Error(`${this.name}: module file ${this.jsFile} not found <${this.srcPath}>`);
+            }
+            else if (err instanceof SyntaxError) {
+                throw new Error(`${this.name}: ${err} in \'${this.jsFile}\' <${this.srcPath}>`);
+            }
+            throw new Error(`${this.name}: ${err} <${this.srcPath}>`);
+        }
+    }
+    executeTransformationFunction(transformationModule) {
+        try {
+            let result = transformationModule[this.functionName](this.srcPath);
+            if (typeof (result) !== 'string') {
+                throw new Error(`${this.name}: transformation functions must return string, ${this.functionName} returned ${typeof (result)} <${this.srcPath}>`);
+            }
+            return result;
+        }
+        catch (err) {
+            if (err instanceof TypeError) {
+                throw new Error(`${this.name}: invalid function \'${this.functionName}\' in ${this.jsFile} <${this.srcPath}>`);
+            }
+            /*
+            Rethrow anything errors that were thrown in the above try block
+            */
+            if (err.message && err.message.search(`${this.name}`.length > 0)) {
+                throw err;
+            }
+            throw new Error(`${this.name}: ${err} <${this.srcPath}>`);
+        }
+    }
+    transform() {
+        // Check if source exists, if not, issue a warning
+        try {
+            fs.accessSync(this.srcPath);
+        }
+        catch (err) {
+            if (err.code === 'ENOENT') {
+                let errMsg = `${this.name}: source does not exist, relying on transformation to find proper source file <${this.srcPath}>`;
+                cli_ux_1.default.log(`${chalk_1.default.yellow(errMsg)}`);
+            }
+            else {
+                throw new Error(`${this.name}: ${err} <${this.srcPath}>`);
+            }
+        }
+        cli_ux_1.default.log(`Transforming from ${this.srcPath} to ${this.dstPath} using ${this.jsFile} function ${this.functionName}`);
+        // Import transformation module
+        let transModule = this.importTransformationModule();
+        // Execute transformation function
+        let transResult = this.executeTransformationFunction(transModule);
+        // Write output to destination file
+        try {
+            fs.outputFileSync(this.dstPath, transResult, { encoding: 'utf-8', mode: 0o644, flag: 'w' });
+        }
+        catch (err) {
+            throw new Error(`${this.name}: ${err} <${this.srcPath}>`);
+        }
+    }
+}
+class RemovalTransformation {
+    constructor(srcPath) {
+        this.name = this.constructor.name;
+        this.srcPath = srcPath;
+    }
+    transform() {
+        try {
+            fs.accessSync(this.srcPath, fs.constants.W_OK);
+            cli_ux_1.default.log(`Removing ${this.srcPath}.`);
+            fs.removeSync(this.srcPath);
+        }
+        catch (err) {
+            if (err.code === 'ENOENT') {
+                let errMsg = `${this.name}: target does not exist, skipping removal <${this.srcPath}>`;
+                cli_ux_1.default.log(`${chalk_1.default.yellow(errMsg)}`);
+            }
+            else {
+                throw new Error(`${this.name}: ${err} <${this.srcPath}>`);
+            }
+        }
+    }
+}
+class PrepareContent extends command_base_1.default {
+    async parseDotfileLine(line, sourceDirectory) {
+        const re = RegExp('^([!#]{1})?(.+?)({.*?})?$');
+        let m = line.match(re);
+        let dotfileLine = {
+            prefix: m[1],
+            source: path.join(sourceDirectory, path.normalize(m[2].trim())),
+            transformData: m[3]
+        };
+        /*
+        Sanity check on source file name. Should not contain "{", ":", or "}" characters
+        */
+        const valRe = RegExp('[{:}]+');
+        let vm = dotfileLine.source.match(valRe);
+        if (vm !== null) {
+            throw new SyntaxError(`<${PrepareContent.dotfile}> source file name '${dotfileLine.source}' contains invalid character '${vm[0]}'`);
+        }
+        return dotfileLine;
+    }
+    async readDotfile(sourceDirectory) {
+        let file_content;
+        try {
+            file_content = fs.readFileSync(path.join(sourceDirectory, PrepareContent.dotfile), 'utf-8');
+        }
+        catch (err) {
+            if (err.code === 'ENOENT') {
+                let errMsg = `.opsprepare file not found in ${path.resolve(sourceDirectory)}`;
+                throw new Error(errMsg);
+            }
+            throw new Error(err.message);
+        }
+        let lines = file_content.split(/\r?\n/).filter(line => line.length !== 0);
+        const lineParse = lines.map(line => {
+            return this.parseDotfileLine(line.trim(), sourceDirectory);
+        });
+        const parsedLines = Promise.all(lineParse).then(lines => lines.filter(line => line.prefix !== '#'));
+        return parsedLines;
+    }
+    async getTransformation(lineData, baseSourcedir, baseDestinationDir) {
+        const targetPath = path.join(baseDestinationDir, lineData.source);
+        /*
+        Anything prefixed with ! is a removal
+        */
+        if (lineData.prefix === '!') {
+            return new RemovalTransformation(targetPath);
+        }
+        /*
+        In case transformation data is present, prepare transformations based on requested plugin.
+        */
+        if (lineData.transformData) {
+            const re = RegExp('^{(.+?):.*}$');
+            const transformType = lineData.transformData.match(re)[1];
+            switch (transformType) {
+                case 'cp': {
+                    const rePath = RegExp('^{cp:([^:]+)}$');
+                    const mPath = lineData.transformData.match(rePath);
+                    if (!mPath) {
+                        throw new SyntaxError(`<${PrepareContent.dotfile}> syntax '${lineData.transformData}' is invalid for 'cp' transformation type`);
+                    }
+                    const tPath = path.join(baseDestinationDir, path.dirname(lineData.source), mPath[1]);
+                    return new CopyTransformation(lineData.source, tPath);
+                }
+                case 'js': {
+                    /* TODO: Some sanity checking will be required after regex matching
+                             to make sure everything was matched and is defined
+                    */
+                    // Parse transformation data
+                    const reData = RegExp('^{js:(.+?):(.+)}$');
+                    const mData = lineData.transformData.match(reData);
+                    if (!mData) {
+                        throw new SyntaxError(`<${PrepareContent.dotfile}> syntax '${lineData.transformData}' is invalid for 'js' transformation type`);
+                    }
+                    const jsFile = path.join(baseSourcedir, mData[1]);
+                    const jsFunc = mData[2];
+                    // File path absolute. Should it be relative to the transformation function?
+                    const filePath = path.resolve(lineData.source);
+                    return new JavascriptTransformation(filePath, targetPath, jsFile, jsFunc);
+                }
+                default: {
+                    const p = lineData.prefix ? lineData.prefix : '';
+                    const s = lineData.source;
+                    const t = lineData.transformData ? lineData.transformData : '';
+                    this.error(`No valid transformation can be extrapolated from ${p}${s}${t}`);
+                }
+            }
+        }
+        /*
+        Return default transformation
+        */
+        return new CopyTransformation(lineData.source, targetPath);
+    }
+    async prepareTransformations(linesData, baseSourceDir, baseDestinationDir) {
+        const transformations = linesData.map(line => {
+            return this.getTransformation(line, baseSourceDir, baseDestinationDir);
+        });
+        return Promise.all(transformations);
+    }
+    /*
+    This function divides transformations into execution groups based on their class
+    and runs transformations for each group
+    */
+    async runTransformations(transformations) {
+        let copyTransformList = [];
+        let modlueTransformList = [];
+        let excludeList = [];
+        // Sort transformation into two lists
+        transformations.forEach(t => {
+            if (t instanceof CopyTransformation) {
+                copyTransformList.push(t);
+            }
+            else if (t instanceof RemovalTransformation) {
+                excludeList.push(t);
+            }
+            else {
+                modlueTransformList.push(t);
+            }
+        });
+        const t = async (transformation) => {
+            try {
+                transformation.transform();
+            }
+            catch (err) {
+                return Promise.reject(err.message);
+            }
+        };
+        const doCopyTransform = copyTransformList.map(t);
+        const doModuleTransform = modlueTransformList.map(t);
+        const doExclude = excludeList.map(t);
+        /* Copy first, then transform and finally remove files. This should
+           ensure that transformations can overwrite previous copies. Removals
+           can still erase transformations though. If needed, we can remove
+           before transforming.
+        */
+        await Promise.all(doCopyTransform);
+        await Promise.all(doModuleTransform);
+        await Promise.all(doExclude);
+    }
+    /*
+    Validates file system on source repository by checking if files or directories exist
+    */
+    /*
+    async validate(arr: string[][], source: string): Promise<boolean> {
+        //this.log(`${chalk.blue('Validating if files and directories exist.')}`);
+        cli.action.start(`${chalk.blue('Validating if files and directories exist')}`, '', {stdout: true});
+        for (let a of arr[0]) {
+            let element_path = path.join(source, a);
+            if(!(fs.existsSync(path.join(element_path)))) {
+                this.log(`${chalk.red('File or directory: ' + path.join(element_path) + ' could not be found')}`);
+                return false;
+            }
+        }
+        for (let a of arr[1]) {
+            let element_path = path.join(source, a);
+            if(!(fs.existsSync(element_path))) {
+                this.log(`${chalk.red('File or directory: ' + element_path + ' could not be found')}`);
+                return false;
+            }
+        }
+
+        //this.log(`${chalk.green('Validation done.')}`);
+        cli.action.stop(`${chalk.green('done')}`);
+        return true;
+    }
+    */
+    /*
+    This function copies elements and removes excluded ones.
+    */
+    /*
+    async copyWorkspace(arr: string[][], dest: string, source: string): Promise<any> {
+        if (await this.validate(arr, source)) {
+            cli.action.start(`${chalk.blue('Preparing content')}`, '', {stdout: true});
+            arr[0].forEach(a => {
+                this.log('Copying: ', path.join(source, a));
+                fs.copySync(path.join(source, a), path.join(dest, a), {overwrite: true});
+            });
+            this.log(`${chalk.green('Copying done.')}`);
+            this.log(`${chalk.blue('Removing excluded elements.')}`);
+            arr[1].forEach(a => {
+                let curPath = path.join(dest, a);
+                if (fs.pathExistsSync(curPath)) {
+                    if (fs.lstatSync(curPath).isFile()) {
+                        try {
+                            fs.removeSync(curPath);
+                            this.log('Removing file: ', curPath);
+                        } catch (error) {
+                            cli.action.stop(`${chalk.red('failed')}`);
+                            this.error(error.message);
+                        }
+                    } else if (fs.lstatSync(curPath).isDirectory()) {
+                        try {
+                            fs.removeSync(curPath);
+                            this.log('Removing dir: ', curPath);
+                        } catch (error) {
+                            cli.action.stop(`${chalk.red('failed')}`);
+                            this.error(error.message);
+                        }
+                    } else {
+                        cli.action.stop(`${chalk.red('error')}`);
+                        this.error('Type not file or directory');
+                    }
+                }
+            });
+            this.log(`${chalk.green('Removing done.')}`);
+            cli.action.stop(`${chalk.green('done')}`);
+        } else {
+            cli.action.stop(`${chalk.red('error')}`);
+            this.error('Content validation failed.');
+        }
+    }
+    */
+    async run() {
+        const { flags } = this.parse(PrepareContent);
+        // read the flags and set paths relative to execution directory
+        let source = path.relative(process.cwd(), flags.source);
+        source = source ? source : '.';
+        let dest = flags.destination;
+        try {
+            let dotfileLines = await this.readDotfile(source);
+            this.log(`${chalk_1.default.blue('Content transformation started.')}`);
+            let transformations = await this.prepareTransformations(dotfileLines, source, dest);
+            await this.runTransformations(transformations);
+            this.log(`${chalk_1.default.green('Content prepared at: ', dest)}`);
+        }
+        catch (err) {
+            this.log(`${chalk_1.default.red(err)}`);
+            /*
+            In test mode, exit with status 0
+            */
+            if (process.env.OPS_TEST_MODE === 'true') {
+                this.exit(0);
+            }
+            this.exit(1);
+        }
+    }
+}
+exports.default = PrepareContent;
+PrepareContent.dotfile = '.opsprepare';
+PrepareContent.description = `copies files as described in ${PrepareContent.dotfile} which is at root of source directory`;
+PrepareContent.usage = 'prepare-content -d <destination> [-s <source>]';
+PrepareContent.examples = [
+    `$ ops prepare-content -d .\\my_workspace`,
+    `$ ops prepare-content -d .\\my_workspace -s .\\my_repository`,
+    `$ ops prepare-content -d C:\\git\\my_workspace`,
+    `$ ops prepare-content -d C:\\git\\my_workspace -s C:\\git\\my_repository\\my_repository`
+];
+PrepareContent.flags = {
+    destination: command_1.flags.string({
+        char: 'd',
+        description: 'where to copy the workspace files',
+        required: true
+    }),
+    source: command_1.flags.string({
+        char: 's',
+        description: '[optional] source directory, default: current dir',
+        required: false,
+        default: '.'
+    })
+};