@adinsure-ops/ops-cli 5.2.2 → 5.3.1

package/lib/commands/npm/publish.js

@@ -18,56 +18,61 @@ class NpmPublish extends CommandBase {
             else {
                 [sh, ...args] = cmd;
             }
+            this.cp = 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 {
-                this.cp = 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 _g = true, _h = __asyncValues(this.cp.stdout), _j; _j = yield _h.next(), _a = _j.done, !_a; _g = true) {
-                        _c = _j.value;
-                        _g = false;
-                        const chunk = _c;
-                        data += chunk;
-                    }
-                }
-                catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                finally {
-                    try {
-                        if (!_g && !_a && (_b = _h.return)) yield _b.call(_h);
-                    }
-                    finally { if (e_1) throw e_1.error; }
+                for (var _g = true, _h = __asyncValues(this.cp.stdout), _j; _j = yield _h.next(), _a = _j.done, !_a; _g = true) {
+                    _c = _j.value;
+                    _g = false;
+                    const chunk = _c;
+                    data += chunk;
                 }
-                let error = '';
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
                 try {
-                    for (var _k = true, _l = __asyncValues(this.cp.stderr), _m; _m = yield _l.next(), _d = _m.done, !_d; _k = true) {
-                        _f = _m.value;
-                        _k = false;
-                        const chunk = _f;
-                        error += chunk;
-                    }
+                    if (!_g && !_a && (_b = _h.return)) yield _b.call(_h);
                 }
-                catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                finally {
-                    try {
-                        if (!_k && !_d && (_e = _l.return)) yield _e.call(_l);
-                    }
-                    finally { if (e_2) throw e_2.error; }
+                finally { if (e_1) throw e_1.error; }
+            }
+            let error = '';
+            try {
+                for (var _k = true, _l = __asyncValues(this.cp.stderr), _m; _m = yield _l.next(), _d = _m.done, !_d; _k = true) {
+                    _f = _m.value;
+                    _k = false;
+                    const chunk = _f;
+                    error += chunk;
                 }
-                const exitCode = yield new Promise((resolve) => {
-                    this.cp.on('close', resolve);
-                });
-                if (exitCode) {
-                    throw new Error(`subprocess error exit ${exitCode}, ${error}`);
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (!_k && !_d && (_e = _l.return)) yield _e.call(_l);
                 }
-                return { data, error };
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                finally { if (e_2) throw e_2.error; }
             }
-            catch (error) {
-                throw new Error(error.message);
+            const exitCode = yield new Promise((resolve) => {
+                this.cp.on('close', resolve);
+            });
+            return { data, error, exitCode };
+        });
+    }
+    wasPublished(data, error, exitCode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (exitCode) {
+                return false;
+            }
+            // Extract the HTTP status code from the error message
+            const statusCodeMatch = /\d{3}/.exec(error);
+            const statusCode = statusCodeMatch ? Number.parseInt(statusCodeMatch[0], 10) : null;
+            if (statusCode && (statusCode >= 400 && statusCode < 600)) {
+                return false;
             }
+            return true;
         });
     }
     checkPackageCanPublish(pkg, allPackages, version, retries) {
@@ -83,22 +88,17 @@ class NpmPublish extends CommandBase {
             if (!matchedPackage) {
                 ux.action.stop(`${chalk.green('new package')}`);
                 ux.action.start(`publish new package ${pkg.name}@${pkg.version} from ${pkg.jsonPath}`, undefined, { stdout: true });
-                try {
-                    yield this.publishPackage(pkg);
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                }
-                catch (error) {
-                    if (error instanceof Error && error.message.includes('subprocess error exit')) {
-                        // Check if the error message contains 'subprocess error exit'
-                        // Extract the HTTP status code from the error message
-                        const statusCodeMatch = /\d{3}/.exec(error.message);
-                        const statusCode = statusCodeMatch ? Number.parseInt(statusCodeMatch[0], 10) : null;
-                        if (statusCode && (statusCode >= 400 && statusCode < 600)) {
-                            for (let i = 0; i < retries - 1; i++) {
-                                yield this.publishPackage(pkg);
-                            }
-                        }
+                let published = false;
+                for (let i = 0; i < retries - 1; i++) {
+                    const { data, error, exitCode } = yield this.publishPackage(pkg);
+                    if (!this.wasPublished(data, error, exitCode)) {
+                        continue;
                     }
+                    published = true;
+                    break;
+                }
+                if (!published) {
+                    throw new Error(`publishing of ${pkg.name}@${pkg.version} failed`);
                 }
                 ux.action.stop(`${chalk.green('done')}`);
                 return true;
@@ -107,7 +107,10 @@ class NpmPublish extends CommandBase {
             if (!matchVersion) {
                 ux.action.stop(`${chalk.yellow('version missing')}`);
                 ux.action.start(`publish new version ${pkg.name}@${pkg.version} from ${pkg.jsonPath}`, undefined, { stdout: true });
-                yield this.publishPackage(pkg);
+                const { data, error, exitCode } = yield this.publishPackage(pkg);
+                if (!this.wasPublished(data, error, exitCode)) {
+                    throw new Error(`publishing of ${pkg.name}@${pkg.version} failed`);
+                }
                 ux.action.stop(`${chalk.green('done')}`);
                 return true;
             }

package/lib/lib/config.d.ts

@@ -0,0 +1,10 @@
+export default class OpsConfig {
+    private filePath;
+    private data;
+    constructor(filePath: string);
+    get(key: string): unknown;
+    set(key: string, value: unknown): void;
+    unset(key: string): void;
+    list(): Record<string, unknown>;
+    save(): void;
+}

package/lib/lib/config.js

@@ -0,0 +1,33 @@
+import fs from 'fs';
+export default class OpsConfig {
+    constructor(filePath) {
+        this.data = {};
+        this.filePath = filePath;
+        // Load existing config or initialize an empty one
+        if (fs.existsSync(this.filePath)) {
+            const fileContent = fs.readFileSync(this.filePath, 'utf8');
+            try {
+                this.data = JSON.parse(fileContent);
+            }
+            catch (_a) {
+                console.log("Could not read data from config.json");
+                this.data = {};
+            }
+        }
+    }
+    get(key) {
+        return this.data[key];
+    }
+    set(key, value) {
+        this.data[key] = value;
+    }
+    unset(key) {
+        delete this.data[key];
+    }
+    list() {
+        return this.data;
+    }
+    save() {
+        fs.writeFileSync(this.filePath, JSON.stringify(this.data, null, 2), 'utf8');
+    }
+}

package/lib/lib/yarnrc.d.ts

@@ -0,0 +1,22 @@
+export default class YarnRc {
+    private readonly filePath;
+    private config;
+    constructor(createIfNotExists?: boolean);
+    /**
+     * Load config file
+     * @returns {void}
+     */
+    load(): void;
+    /**
+     * Add registry to config file
+     * @param key Config key
+     * @param value Config value
+     * @returns {void}
+     */
+    set(key: string, value: string): void;
+    /**
+     * Set token for Registry
+     * @returns {void}
+     */
+    save(): void;
+}

package/lib/lib/yarnrc.js

@@ -0,0 +1,40 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import yaml from "yaml";
+export default class YarnRc {
+    constructor(createIfNotExists = true) {
+        this.config = {};
+        this.filePath = path.resolve(os.homedir(), `.yarnrc.yml`);
+        if (!fs.existsSync(this.filePath) && createIfNotExists) {
+            fs.writeFileSync(this.filePath, JSON.stringify({}));
+        }
+        if (fs.existsSync(this.filePath) &&
+            fs.lstatSync(this.filePath).isFile()) {
+            this.load();
+        }
+    }
+    /**
+     * Load config file
+     * @returns {void}
+     */
+    load() {
+        this.config = yaml.parse(fs.readFileSync(this.filePath, "utf8"));
+    }
+    /**
+     * Add registry to config file
+     * @param key Config key
+     * @param value Config value
+     * @returns {void}
+     */
+    set(key, value) {
+        this.config[key] = value;
+    }
+    /**
+     * Set token for Registry
+     * @returns {void}
+     */
+    save() {
+        fs.writeFileSync(this.filePath, yaml.stringify(this.config));
+    }
+}

package/lib/security/context.d.ts

@@ -7,11 +7,16 @@ import { ParsedUrlQuery } from 'querystring';
 export default class SecurityContext {
     private readonly clientId;
     private readonly devopsResourceId;
+    private readonly managementCoreWindowsNet;
     private readonly tenant;
+    private readonly tenantId;
+    private readonly registry;
     private readonly authorityUrl;
     private readonly redirectUri;
     private readonly resource;
     private readonly _accessTokenPath;
+    private readonly _accessTokenRuPath;
+    private readonly _accessConfigPath;
     private readonly _pca;
     private readonly _cryptoProvider;
     private _verifier;
@@ -26,6 +31,16 @@ export default class SecurityContext {
      * @returns {string} Returns access token path
      */
     getTokenPath(): string;
+    /**
+     * Get the accessTokenRuPath, as it is a private variable
+     * @returns {string} Returns access token Ru path
+     */
+    getTokenRuPath(): string;
+    /**
+     * Get the accessConfigPath, as it is a private variable
+     * @returns {string} Returns config.json path
+     */
+    getConfigPath(): string;
     /**
      * Contacts authority server, fetches and saves the authentication token to be used in subsequent requests.
      *
@@ -58,6 +73,13 @@ export default class SecurityContext {
      * @returns Promise that resolves bearer authentication token
      */
     getToken(): Promise<string>;
+    /**
+     * Fetches the locally stored token for GitlabRu
+     * @returns authentication token for gitlabru.adacta-fintech.ru
+     */
+    getTokenRu(): string;
+    getAADToken(): Promise<string>;
+    getACRToken(): Promise<string>;
     /**
      * Contacts authority server, fetches and saves the authentication token to be used in subsequent requests.
      *

package/lib/security/context.js

@@ -2,7 +2,10 @@ import { __awaiter } from "tslib";
 import { AuthError, ConfidentialClientApplication, CryptoProvider, InteractionRequiredAuthError, PublicClientApplication, } from '@azure/msal-node';
 import { reject } from 'lodash-es';
 import path from 'path';
+import fs from 'fs';
+import querystring from 'querystring';
 import LocalCachePlugin from './cache.js';
+import axios from 'axios';
 /**
  * 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]].
@@ -15,13 +18,18 @@ export default class SecurityContext {
     constructor(configDir) {
         this.clientId = 'bed40d09-53d7-4af8-bf63-3288658b65fb';
         this.devopsResourceId = '499b84ac-1321-427f-aa17-267ca6975798';
+        this.managementCoreWindowsNet = 'https://management.core.windows.net//';
         this.tenant = 'adfintech.onmicrosoft.com';
+        this.tenantId = 'cdeb9156-219a-49e3-b414-f63acd298e9c';
+        this.registry = 'adinsure.azurecr.io';
         this.authorityUrl = `https://login.microsoftonline.com/${this.tenant}/`;
         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._accessTokenRuPath = path.resolve(configDir, 'accessTokenRu.json');
+        this._accessConfigPath = path.resolve(configDir, 'config.json');
         this._cryptoProvider = new CryptoProvider();
         this._pca = new PublicClientApplication({
             auth: {
@@ -40,6 +48,20 @@ export default class SecurityContext {
     getTokenPath() {
         return this._accessTokenPath;
     }
+    /**
+     * Get the accessTokenRuPath, as it is a private variable
+     * @returns {string} Returns access token Ru path
+     */
+    getTokenRuPath() {
+        return this._accessTokenRuPath;
+    }
+    /**
+     * Get the accessConfigPath, as it is a private variable
+     * @returns {string} Returns config.json path
+     */
+    getConfigPath() {
+        return this._accessConfigPath;
+    }
     /**
      * Contacts authority server, fetches and saves the authentication token to be used in subsequent requests.
      *
@@ -202,6 +224,97 @@ export default class SecurityContext {
             }));
         });
     }
+    /**
+     * Fetches the locally stored token for GitlabRu
+     * @returns authentication token for gitlabru.adacta-fintech.ru
+     */
+    getTokenRu() {
+        try {
+            const fileContent = fs.readFileSync(this._accessTokenRuPath, 'utf8').trim();
+            if (!fileContent) {
+                throw new Error('Token file is empty.');
+            }
+            const tokenData = JSON.parse(fileContent);
+            if (!tokenData.accessTokenRu) {
+                throw new Error('GitLabRu token not found in file.');
+            }
+            return tokenData.accessTokenRu;
+            //eslint-disable-next-line @typescript-eslint/no-explicit-any
+        }
+        catch (err) {
+            throw new Error(`Failed to retrieve GitLabRu token: ${err.message}`);
+        }
+    }
+    getAADToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const msalTokenCache = this._pca.getTokenCache();
+            const cachedAccounts = yield msalTokenCache.getAllAccounts();
+            return new Promise((resolve, reject) => {
+                if (cachedAccounts.length > 0) {
+                    this._pca
+                        .acquireTokenSilent({
+                        account: cachedAccounts[0],
+                        scopes: [
+                            this.managementCoreWindowsNet + '.default',
+                            'offline_access',
+                        ],
+                    })
+                        .then((response) => {
+                        if (response) {
+                            resolve(response.accessToken);
+                        }
+                        else {
+                            reject(new Error('Error getting token, please call `ops login`.'));
+                        }
+                    })
+                        .catch((error) => {
+                        reject(new Error(error));
+                    });
+                }
+                else {
+                    reject();
+                }
+            });
+        });
+    }
+    getACRToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // First, retrieve the AAD token using your existing method.
+                const aadAccessToken = yield this.getAADToken();
+                // Build the form data as per the ACR token exchange API:
+                // grant_type=access_token
+                // service=<registry>
+                // tenant=<tenantId>
+                // access_token=<aadAccessToken>
+                const postData = querystring.stringify({
+                    grant_type: 'access_token',
+                    service: this.registry, // e.g., "adinsure.azurecr.io"
+                    tenant: this.tenantId, // e.g., "cdeb9156-219a-49e3-b414-f63acd298e9c"
+                    access_token: aadAccessToken,
+                });
+                // Define the URL for token exchange:
+                const url = `https://${this.registry}/oauth2/exchange`;
+                // Make the POST request with the appropriate headers.
+                const response = yield axios.post(url, postData, {
+                    headers: {
+                        'Content-Type': 'application/x-www-form-urlencoded',
+                    },
+                });
+                // The ACR token should be in the "access_token" field of the response.
+                if (response.data && response.data.refresh_token) {
+                    return response.data.refresh_token;
+                }
+                else {
+                    throw new Error('ACR token not found in the response.');
+                }
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            }
+            catch (error) {
+                throw new Error('Failed to retrieve ACR token: ' + error.message);
+            }
+        });
+    }
     /**
      * Contacts authority server, fetches and saves the authentication token to be used in subsequent requests.
      *