@adinsure-ops/ops-cli 4.0.0-rc6

package/lib/config.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultConfig = void 0;
+exports.DefaultConfig = {
+    changelogs: {
+        file: 'CHANGELOG.md',
+        unreleasedFolder: 'changelogs/unreleased'
+    }
+};

package/lib/hooks/init/version-override.d.ts

@@ -0,0 +1,2 @@
+import { Hook } from '@oclif/config';
+export declare const versionOverride: Hook.Init;

package/lib/hooks/init/version-override.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.versionOverride = void 0;
+const version_1 = require("../../commands/version");
+exports.versionOverride = async function () {
+    if (process.argv[2] === 'version') {
+        try {
+            await version_1.default.run(process.argv.splice(3));
+        }
+        catch (err) {
+            this.error(err);
+        }
+        return process.exit(0);
+    }
+};

package/lib/index.d.ts

@@ -0,0 +1 @@
+export { run } from '@oclif/command';

package/lib/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var command_1 = require("@oclif/command");
+Object.defineProperty(exports, "run", { enumerable: true, get: function () { return command_1.run; } });

package/lib/lib/command.d.ts

@@ -0,0 +1,9 @@
+export default class ChildProcessCommand {
+    /**
+     * Only Windows supported at this point
+     */
+    runCommand(cmd: string[]): Promise<{
+        data: string;
+        error: string;
+    }>;
+}

package/lib/lib/command.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const child_process_1 = require("child_process");
+class ChildProcessCommand {
+    /**
+     * Only Windows supported at this point
+     */
+    async runCommand(cmd) {
+        var e_1, _a, e_2, _b;
+        let sh;
+        let args;
+        let cp;
+        // cross platform compatibility
+        if (process.platform === 'win32') {
+            sh = 'cmd';
+            args = ['/c'].concat(cmd);
+        }
+        else {
+            [sh, ...args] = cmd;
+        }
+        try {
+            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',
+                shell: true
+            });
+            let data = '';
+            try {
+                for (var _c = tslib_1.__asyncValues(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(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) => {
+                cp.on('close', resolve);
+            });
+            if (exitCode) {
+                throw new Error(`subprocess error exit ${exitCode}, ${error}`);
+            }
+            return { data, error };
+        }
+        catch (err) {
+            throw new Error(err.message);
+        }
+    }
+}
+exports.default = ChildProcessCommand;

package/lib/lib/npm.d.ts

@@ -0,0 +1,15 @@
+import { NpmPackage } from '../types/npm.types';
+export default class NpmContext {
+    /**
+     * Get all workspaces
+     */
+    getWorkspaces(): Promise<string[]>;
+    /**
+     * Get package names
+     */
+    packageList(packages: string[] | undefined, excludes: string[] | undefined, context: any): Promise<NpmPackage[]>;
+    /**
+     * Get package all packages
+     */
+    getAllNpmPackages(patToken?: string): Promise<string>;
+}

package/lib/lib/npm.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chalk_1 = require("chalk");
+const fs = require("fs-extra");
+const globby = require("globby");
+const minimatch = require("minimatch");
+const path = require("path");
+const request = require("request-promise");
+class NpmContext {
+    /**
+     * Get all workspaces
+     */
+    async getWorkspaces() {
+        let workspaces = [];
+        try {
+            let data = await fs.readJSON('./package.json');
+            if (!data.workspaces) {
+                return [];
+            }
+            for (const workspace of data.workspaces.packages) {
+                workspaces.push(`${workspace}/+(package.json|yarn.json)`);
+            }
+            return workspaces;
+        }
+        catch (err) {
+            throw new Error(err.message);
+        }
+    }
+    /**
+     * Get package names
+     */
+    async packageList(packages = ['**/*'], excludes = [''], context) {
+        try {
+            let workspaces = await this.getWorkspaces();
+            let searchPattern = ['**/package.json', '!**/node_modules'];
+            let pkgs = [];
+            if (workspaces.length > 0) {
+                searchPattern = workspaces.concat(['!**/node_modules']);
+            }
+            const pkgPaths = await globby(searchPattern);
+            for (const pkgPath of pkgPaths) {
+                try {
+                    let data = await fs.readJSON(pkgPath);
+                    if (!data.version || !data.name || excludes.indexOf(data.name) >= 0 || !packages.some(pkg => minimatch(data.name, pkg))) {
+                        continue;
+                    }
+                    // create object to simply remove duplicates
+                    pkgs[data.name] = {
+                        name: data.name,
+                        path: path.dirname(pkgPath),
+                        jsonPath: pkgPath,
+                        version: data.version
+                    };
+                }
+                catch (err) {
+                    context.warn(`Error reading package.json: ${chalk_1.default.yellow(err.message)}.`);
+                    continue;
+                }
+            }
+            return Object.values(pkgs); // return array of values
+        }
+        catch (err) {
+            throw new Error(`Unknown error: ${chalk_1.default.red(err)}`);
+        }
+    }
+    /**
+     * Get package all packages
+     */
+    async getAllNpmPackages(patToken = '') {
+        let options = {
+            uri: `https://feeds.dev.azure.com/adacta-fintech/adinsure/_apis/packaging/Feeds/feed/packages?api-version=6.0-preview.1&includeAllVersions=true&protocolType=Npm`,
+            headers: {
+                Authorization: 'Basic ' + Buffer.from(`:${patToken}`).toString('base64')
+            }
+        };
+        return request.get(options);
+    }
+}
+exports.default = NpmContext;

package/lib/lib/npmrc.d.ts

@@ -0,0 +1,17 @@
+export default class NpmRc {
+    private filePath;
+    private config;
+    constructor(createIfNotExists?: boolean);
+    /**
+     * Load config file
+     */
+    load(): Promise<void>;
+    /**
+     * Add registry to config file
+     */
+    set(key: string, value: string): Promise<void>;
+    /**
+     * Set token for Registry
+     */
+    save(): Promise<void>;
+}

package/lib/lib/npmrc.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require("fs");
+const child_process_1 = require("child_process");
+const os = require("os");
+const ini = require("ini");
+class NpmRc {
+    constructor(createIfNotExists = true) {
+        this.config = {};
+        try {
+            this.filePath = child_process_1.execSync("npm config get userconfig", { stdio: ["pipe", "pipe", "ignore"] })
+                .toString()
+                .trim();
+        }
+        catch (_a) {
+            this.filePath = os.homedir();
+        }
+        if (!fs.existsSync(this.filePath) && createIfNotExists) {
+            fs.writeFileSync(this.filePath, JSON.stringify({}));
+        }
+        if (fs.existsSync(this.filePath)) {
+            this.load();
+        }
+    }
+    /**
+     * Load config file
+     */
+    async load() {
+        this.config = ini.parse(fs.readFileSync(this.filePath, "utf8"));
+    }
+    /**
+     * Add registry to config file
+     */
+    async set(key, value) {
+        this.config[key] = value;
+    }
+    /**
+     * Set token for Registry
+     */
+    async save() {
+        fs.writeFileSync(this.filePath, ini.encode(this.config));
+    }
+}
+exports.default = NpmRc;

package/lib/security/cache.d.ts

@@ -0,0 +1,7 @@
+import { ICachePlugin } from '@azure/msal-node';
+export default class LocalCachePlugin implements ICachePlugin {
+    private readonly _accessTokenPath;
+    constructor(path: string);
+    beforeCacheAccess(cacheContext: any): Promise<void>;
+    afterCacheAccess(cacheContext: any): Promise<void>;
+}

package/lib/security/cache.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const fs = require("fs-extra");
+class LocalCachePlugin {
+    constructor(path) {
+        this._accessTokenPath = path;
+    }
+    async beforeCacheAccess(cacheContext) {
+        // Create folder if doesn't exists
+        if (!fs.pathExistsSync(path.dirname(this._accessTokenPath))) {
+            fs.mkdirSync(path.dirname(this._accessTokenPath), {
+                recursive: true
+            });
+        }
+        // Load file only if exists
+        if (fs.existsSync(this._accessTokenPath)) {
+            cacheContext.tokenCache.deserialize(await fs.readFile(this._accessTokenPath, "utf-8"));
+        }
+    }
+    async afterCacheAccess(cacheContext) {
+        // Create folder if doesn't exists
+        if (!fs.pathExistsSync(path.dirname(this._accessTokenPath))) {
+            fs.mkdirSync(path.dirname(this._accessTokenPath), {
+                recursive: true
+            });
+        }
+        if (cacheContext.cacheHasChanged) {
+            await fs.writeFile(this._accessTokenPath, cacheContext.tokenCache.serialize());
+        }
+    }
+}
+exports.default = LocalCachePlugin;

package/lib/security/context.d.ts

@@ -0,0 +1,58 @@
+/// <reference types="node" />
+import { ParsedUrlQuery } from 'querystring';
+/**
+ * Security context that keeps track of current authentication token.
+ * It's not recommended you instantiate this class on your own but rather inherit your commands from [[CommandBase]].
+ */
+export default class SecurityContext {
+    private readonly clientId;
+    private readonly devopsResourceId;
+    private readonly tenant;
+    private readonly authorityUrl;
+    private readonly redirectUri;
+    private readonly resource;
+    private readonly _accessTokenPath;
+    private _pca;
+    private _cryptoProvider;
+    private _verifier;
+    private _challenge;
+    /**
+     * Initializes [[SecurityContext]] with config directory where access token JSON will be stored.
+     * @param configDir Directory where CLI configuration is stored
+     */
+    constructor(configDir: string);
+    /**
+     * Contacts authority server, fetches and saves the authentication token to be used in subsequent requests.
+     *
+     * @param code Authorization code used to fetch the token.
+     * @returns [[Promise<TokenResponse>]]
+     */
+    getLoginUrl(): Promise<string>;
+    /**
+     * Gets the current authentication token.
+     * This function will also automatically try to refresh token if expired.
+     *
+     * @throws Error when authentication failed and/or call to login is needed
+     * @returns Promise that resolves bearer authentication token
+     */
+    getToken(): Promise<string>;
+    /**
+     * Contacts authority server, fetches and saves the authentication token to be used in subsequent requests.
+     *
+     * @param code Authorization code used to fetch the token.
+     * @returns [[Promise<TokenResponse>]]
+     */
+    acquireToken(query: ParsedUrlQuery): Promise<string>;
+    /**
+     * Acquires token using device flow.
+     *
+     * @returns [[Promise<TokenResponse>]]
+     */
+    acquireTokenDeviceFlow(): Promise<void>;
+    /**
+     * Get NPM token for adinsure npm repositories
+     *
+     * @returns [[Promise<string>]]
+     */
+    getNPMToken(): Promise<string>;
+}

package/lib/security/context.js

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const msal_node_1 = require("@azure/msal-node");
+const path = require("path");
+const cache_1 = require("./cache");
+/**
+ * Security context that keeps track of current authentication token.
+ * It's not recommended you instantiate this class on your own but rather inherit your commands from [[CommandBase]].
+ */
+class SecurityContext {
+    /**
+     * Initializes [[SecurityContext]] with config directory where access token JSON will be stored.
+     * @param configDir Directory where CLI configuration is stored
+     */
+    constructor(configDir) {
+        this.clientId = 'bed40d09-53d7-4af8-bf63-3288658b65fb';
+        this.devopsResourceId = '499b84ac-1321-427f-aa17-267ca6975798';
+        this.tenant = 'adfintech.onmicrosoft.com';
+        this.authorityUrl = `https://login.microsoftonline.com/${this.tenant}/`;
+        // tslint:disable-next-line: no-http-string
+        this.redirectUri = 'http://localhost:3044';
+        this.resource = 'https://ops.adinsure.com';
+        this._verifier = null;
+        this._challenge = null;
+        this._accessTokenPath = path.resolve(configDir, 'accessToken.json');
+        this._cryptoProvider = new msal_node_1.CryptoProvider();
+        this._pca = new msal_node_1.PublicClientApplication({
+            auth: {
+                clientId: this.clientId,
+                authority: this.authorityUrl
+            },
+            cache: {
+                cachePlugin: new cache_1.default(this._accessTokenPath),
+            }
+        });
+    }
+    /**
+     * Contacts authority server, fetches and saves the authentication token to be used in subsequent requests.
+     *
+     * @param code Authorization code used to fetch the token.
+     * @returns [[Promise<TokenResponse>]]
+     */
+    getLoginUrl() {
+        return new Promise((resolve, reject) => {
+            // Generate PKCE Codes before starting the authorization flow
+            this._cryptoProvider.generatePkceCodes().then(({ verifier, challenge }) => {
+                this._verifier = verifier;
+                this._challenge = challenge;
+                const authCodeUrlParameters = {
+                    scopes: [this.resource + "/.default"],
+                    redirectUri: this.redirectUri,
+                    codeChallenge: this._challenge,
+                    codeChallengeMethod: 'S256'
+                };
+                // Get url to sign user in and consent to scopes needed for applicatio
+                this._pca.getAuthCodeUrl(authCodeUrlParameters).then((url) => {
+                    resolve(url);
+                }).catch((error) => {
+                    console.log(JSON.stringify(error));
+                });
+            });
+        });
+    }
+    /**
+     * Gets the current authentication token.
+     * This function will also automatically try to refresh token if expired.
+     *
+     * @throws Error when authentication failed and/or call to login is needed
+     * @returns Promise that resolves bearer authentication token
+     */
+    async getToken() {
+        const msalTokenCache = this._pca.getTokenCache();
+        const cachedAccounts = await msalTokenCache.getAllAccounts();
+        return new Promise(async (resolve, reject) => {
+            if (cachedAccounts.length > 0) {
+                this._pca.acquireTokenSilent({
+                    account: cachedAccounts[0],
+                    scopes: [this.resource + "/.default", "offline_access"]
+                }).then(response => {
+                    if (response) {
+                        let accessToken = response.accessToken;
+                        resolve(accessToken);
+                    }
+                    else {
+                        reject(new Error('Error getting token, please call `ops login`.'));
+                    }
+                }).catch(err => {
+                    reject(new Error(err));
+                });
+            }
+            else if (process.env.AZURE_CLIENT_ID && process.env.AZURE_CLIENT_SECRET) {
+                const cca = new msal_node_1.ConfidentialClientApplication({
+                    auth: {
+                        clientId: process.env.AZURE_CLIENT_ID,
+                        clientSecret: process.env.AZURE_CLIENT_SECRET,
+                        authority: this.authorityUrl,
+                    },
+                    cache: {
+                        cachePlugin: new cache_1.default(this._accessTokenPath),
+                    }
+                });
+                const msalCcaTokenCache = cca.getTokenCache();
+                const ccaCachedAccounts = await msalCcaTokenCache.getAllAccounts();
+                if (ccaCachedAccounts.length > 0) {
+                    cca.acquireTokenSilent({
+                        account: ccaCachedAccounts[0],
+                        scopes: [this.resource + "/.default"]
+                    }).then(response => {
+                        if (response) {
+                            let accessToken = response.accessToken;
+                            resolve(accessToken);
+                        }
+                        else {
+                            reject(new Error('Error getting token, please call `ops login`.'));
+                        }
+                    }).catch(err => {
+                        reject(new Error(err));
+                    });
+                }
+                else {
+                    cca.acquireTokenByClientCredential({
+                        scopes: [this.resource + "/.default", "offline_access"]
+                    }).then(response => {
+                        if (response) {
+                            let accessToken = response.accessToken;
+                            resolve(accessToken);
+                        }
+                        else {
+                            reject(new Error('Error getting token, please call `ops login`.'));
+                        }
+                    }).catch(err => {
+                        reject(new Error(err));
+                    });
+                }
+            }
+            else {
+                throw new Error('You are not authenticated, please call `ops login`.');
+            }
+        });
+    }
+    /**
+     * Contacts authority server, fetches and saves the authentication token to be used in subsequent requests.
+     *
+     * @param code Authorization code used to fetch the token.
+     * @returns [[Promise<TokenResponse>]]
+     */
+    acquireToken(query) {
+        return new Promise((resolve, _reject) => {
+            if (this._verifier === null) {
+                throw new Error(`PKCE verifier missing.`);
+            }
+            // Add PKCE code verifier to token request object
+            const tokenRequest = {
+                code: query.code,
+                scopes: [this.resource + "/.default", "offline_access"],
+                redirectUri: this.redirectUri,
+                codeVerifier: this._verifier,
+                clientInfo: query.client_info
+            };
+            this._pca.acquireTokenByCode(tokenRequest).then((token) => {
+                var _a;
+                if (token === null) {
+                    throw new Error(`PKCE getting token.`);
+                }
+                if ((_a = token.account) === null || _a === void 0 ? void 0 : _a.name) {
+                    resolve(token.account.name);
+                }
+            }).catch((err) => {
+                throw new Error(err);
+            });
+        });
+    }
+    /**
+     * Acquires token using device flow.
+     *
+     * @returns [[Promise<TokenResponse>]]
+     */
+    acquireTokenDeviceFlow() {
+        return new Promise((resolve, reject) => {
+            this._pca.acquireTokenByDeviceCode({
+                deviceCodeCallback: (response) => {
+                    if (response.message) {
+                        console.log(response.message);
+                    }
+                },
+                scopes: [this.resource + "/.default", "offline_access"]
+            }).then(response => {
+                resolve();
+            }).catch((err) => {
+                reject(err);
+            });
+        });
+    }
+    /**
+     * Get NPM token for adinsure npm repositories
+     *
+     * @returns [[Promise<string>]]
+     */
+    async getNPMToken() {
+        const msalTokenCache = this._pca.getTokenCache();
+        const cachedAccounts = await msalTokenCache.getAllAccounts();
+        return new Promise((resolve, reject) => {
+            if (cachedAccounts.length > 0) {
+                this._pca.acquireTokenSilent({
+                    account: cachedAccounts[0],
+                    scopes: [this.devopsResourceId + "/.default", "offline_access"]
+                }).then(response => {
+                    if (response) {
+                        resolve(response.accessToken);
+                    }
+                    else {
+                        reject(new Error('Error getting token, please call `ops login`.'));
+                    }
+                }).catch(err => {
+                    reject(new Error(err));
+                });
+            }
+            else {
+                reject();
+            }
+        });
+    }
+}
+exports.default = SecurityContext;

package/lib/types/changelog.types.d.ts

@@ -0,0 +1,6 @@
+export interface ChangelogEntry {
+    type: string;
+    issue: string;
+    component: string;
+    content: string;
+}

package/lib/types/changelog.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/npm.types.d.ts

@@ -0,0 +1,34 @@
+export declare type AzurePackageArray = {
+    count: number;
+    value: AzurePackage[];
+};
+export declare type AzurePackage = {
+    id: string;
+    normalizedName: string;
+    name: string;
+    protocolType: string;
+    url: string;
+    versions: AzurePackageVersion[];
+};
+export declare type AzurePackageVersion = {
+    id: string;
+    normalizedVersion: string;
+    version: string;
+    isLatest: boolean;
+    isListed: boolean;
+    storageId: string;
+    views: AzurePackageView[];
+    publishDate: string;
+};
+export declare type AzurePackageView = {
+    id: string;
+    name: string;
+    url: string;
+    type: boolean;
+};
+export declare type NpmPackage = {
+    name: string;
+    version: string;
+    path: string;
+    jsonPath: string;
+};

package/lib/types/npm.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });