@adinsure-ops/ops-cli 5.4.2 → 5.5.0-rc1

package/lib/lib/command.js

@@ -1,15 +1,15 @@
 import { __asyncValues, __awaiter } from "tslib";
-import { spawn } from 'child_process';
+import { spawn } from 'node:child_process';
 export default class ChildProcessCommand {
     /**
-     * Only Windows supported at this point
-     * @param cmd Command to run
-     * @return {void}
+     * Run a command without a shell and collect its output.
+     * On Windows the command is started through `cmd /c` so that `.cmd` shims such as `yarn` and `code` are found.
+     * @param cmd Command and its arguments
+     * @returns {Promise<{ data: string, error: string }>} stdout and stderr of the command
      */
     runCommand(cmd) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, e_1, _b, _c, _d, e_2, _e, _f;
-            var _g;
+            var _a;
             let sh;
             let args;
             let cp;
@@ -25,47 +25,24 @@ export default class ChildProcessCommand {
                 cp = spawn(sh, args, {
                     // cwd:
                     //     pkg.path,
-                    env: Object.assign(Object.assign({}, process.env), process.stdout.isTTY ? { FORCE_COLOR: (_g = process.env.FORCE_COLOR) !== null && _g !== void 0 ? _g : '1' } : {}),
+                    env: Object.assign(Object.assign({}, process.env), process.stdout.isTTY ? { FORCE_COLOR: (_a = process.env.FORCE_COLOR) !== null && _a !== void 0 ? _a : '1' } : {}),
                     stdio: 'pipe',
-                    shell: true,
                 });
-                let data = '';
-                try {
-                    for (var _h = true, _j = __asyncValues(cp.stdout), _k; _k = yield _j.next(), _a = _k.done, !_a; _h = true) {
-                        _c = _k.value;
-                        _h = false;
-                        const chunk = _c;
-                        data += chunk;
-                    }
-                }
-                catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                finally {
-                    try {
-                        if (!_h && !_a && (_b = _j.return)) yield _b.call(_j);
-                    }
-                    finally { if (e_1) throw e_1.error; }
-                }
-                let error = '';
-                try {
-                    for (var _l = true, _m = __asyncValues(cp.stderr), _o; _o = yield _m.next(), _d = _o.done, !_d; _l = true) {
-                        _f = _o.value;
-                        _l = false;
-                        const chunk = _f;
-                        error += chunk;
-                    }
-                }
-                catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                finally {
-                    try {
-                        if (!_l && !_d && (_e = _m.return)) yield _e.call(_m);
-                    }
-                    finally { if (e_2) throw e_2.error; }
-                }
-                const exitCode = yield new Promise((resolve) => {
-                    cp.on('close', resolve);
+                // Without a shell, a missing executable emits 'error' instead of exiting with a non-zero code
+                const exit = new Promise((resolve, reject) => {
+                    cp.on('error', reject);
+                    cp.on('close', (code, signal) => resolve({ code, signal }));
                 });
-                if (exitCode) {
-                    throw new Error(`subprocess error exit ${exitCode}, ${error}`);
+                // Avoid an unhandled rejection while the output streams are being read
+                exit.catch(() => undefined);
+                // Read both streams at the same time, so a child filling the stderr pipe can't block on it
+                const [data, error] = yield Promise.all([this.readStream(cp.stdout), this.readStream(cp.stderr)]);
+                const { code, signal } = yield exit;
+                if (signal) {
+                    throw new Error(`subprocess killed by ${signal}, ${error}`);
+                }
+                if (code) {
+                    throw new Error(`subprocess error exit ${code}, ${error}`);
                 }
                 return { data, error };
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -75,4 +52,27 @@ export default class ChildProcessCommand {
             }
         });
     }
+    readStream(stream) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, stream_1, stream_1_1;
+            var _b, e_1, _c, _d;
+            let result = '';
+            try {
+                for (_a = true, stream_1 = __asyncValues(stream); stream_1_1 = yield stream_1.next(), _b = stream_1_1.done, !_b; _a = true) {
+                    _d = stream_1_1.value;
+                    _a = false;
+                    const chunk = _d;
+                    result += chunk;
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_a && !_b && (_c = stream_1.return)) yield _c.call(stream_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            return result;
+        });
+    }
 }

package/lib/lib/config.js

@@ -1,4 +1,4 @@
-import fs from 'fs';
+import fs from 'node:fs';
 export default class OpsConfig {
     constructor(filePath) {
         this.data = {};

package/lib/lib/gitlab.d.ts

@@ -1,10 +1,12 @@
 import semver from 'semver';
+import HttpClient from './http.js';
 export default class GitLab {
+    private readonly http;
     private readonly pat;
     private readonly host;
     private readonly project;
     private readonly apiBase;
-    constructor(host: string, project: string, pat: string);
+    constructor(host: string, project: string, pat: string, http?: HttpClient);
     /**
      * Try to figure out latest available version already created
      * @param searchVersion Version to search for

package/lib/lib/gitlab.js

@@ -1,8 +1,9 @@
 import { __awaiter } from "tslib";
-import axios from 'axios';
 import semver from 'semver';
+import HttpClient from './http.js';
 export default class GitLab {
-    constructor(host, project, pat) {
+    constructor(host, project, pat, http = new HttpClient()) {
+        this.http = http;
         this.apiBase = '/api/v4/projects';
         this.pat = pat;
         this.host = host;
@@ -16,22 +17,24 @@ export default class GitLab {
      */
     getLatestVersion(searchVersion_1) {
         return __awaiter(this, arguments, void 0, function* (searchVersion, prefix = '') {
+            var _a;
             const versions = [];
             try {
                 let page = 1;
                 let totalPages = 1;
                 do {
-                    const response = yield axios.get(`${this.host}${this.apiBase}/${this.project}/repository/tags`, {
+                    const response = yield this.http.getJson(`${this.host}${this.apiBase}/${this.project}/repository/tags`, {
                         headers: {
                             Authorization: `Bearer ${this.pat}`,
                         },
                         params: {
                             search: `^${prefix}v${searchVersion}`,
-                            // eslint-disable-next-line camelcase
                             per_page: 100,
                             page,
                         },
                     });
+                    if (!Array.isArray(response.data))
+                        throw new Error('Unexpected GitLab tags response');
                     // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     response.data.forEach((tag) => {
                         const regex = new RegExp(`${prefix}v\\d+\\.\\d+\\.\\d+(-\\d{6}\\.\\d+)?$`);
@@ -52,7 +55,7 @@ export default class GitLab {
                             versions.push(semanticVersion);
                         }
                     });
-                    totalPages = Number.parseInt(response.headers['x-total-pages'], 10);
+                    totalPages = Number.parseInt((_a = response.headers.get('x-total-pages')) !== null && _a !== void 0 ? _a : '1', 10);
                     page++;
                 } while (page <= totalPages);
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -72,7 +75,7 @@ export default class GitLab {
     createNewTag(tag_name, ref) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                yield axios.post(`${this.host}${this.apiBase}/${this.project}/repository/tags`, {
+                yield this.http.postJson(`${this.host}${this.apiBase}/${this.project}/repository/tags`, {
                     tag_name,
                     ref,
                 }, {
@@ -92,7 +95,8 @@ export default class GitLab {
             let pipelines = null;
             tag = tag.replaceAll(/^v/g, ''); // trim if tag starts with v because already include it in search
             try {
-                pipelines = yield axios.get(`${this.host}${this.apiBase}/${this.project}/pipelines?ref=v${tag}`, {
+                pipelines = yield this.http.getJson(`${this.host}${this.apiBase}/${this.project}/pipelines`, {
+                    params: { ref: `v${tag}` },
                     headers: {
                         Authorization: `Bearer ${this.pat}`,
                     },
@@ -102,6 +106,8 @@ export default class GitLab {
             catch (error) {
                 throw new Error(error);
             }
+            if (!Array.isArray(pipelines.data))
+                throw new Error('Unexpected GitLab pipelines response');
             if (pipelines.data.length > 0) {
                 return pipelines.data[0].status;
             }

package/lib/lib/http.d.ts

@@ -0,0 +1,37 @@
+export interface HttpResponse<T> {
+    data: T;
+    status: number;
+    headers: Headers;
+}
+export interface HttpOptions {
+    headers?: HeadersInit;
+    params?: Record<string, string | number | boolean | null | undefined>;
+    signal?: AbortSignal;
+}
+export declare class HttpError extends Error {
+    readonly status: number;
+    readonly data: unknown;
+    constructor(status: number, data: unknown, message?: string);
+}
+export default class HttpClient {
+    private readonly debug;
+    private readonly proxyAgents;
+    private directAgent?;
+    constructor(debug?: (message: string) => void);
+    getJson<T>(url: string, options?: HttpOptions): Promise<HttpResponse<T>>;
+    getBuffer(url: string, options?: HttpOptions): Promise<HttpResponse<Buffer>>;
+    postJson<T>(url: string, data: unknown, options?: HttpOptions): Promise<HttpResponse<T>>;
+    putJson<T>(url: string, data: unknown, options?: HttpOptions): Promise<HttpResponse<T>>;
+    postForm<T>(url: string, data: URLSearchParams, options?: HttpOptions): Promise<HttpResponse<T>>;
+    close(): Promise<void>;
+    private sendJson;
+    private getDispatcher;
+    private forwardProxy;
+    private createHeaders;
+    private readBody;
+    private parseUrl;
+    private networkError;
+    private jsonResponse;
+    private readData;
+    private request;
+}

package/lib/lib/http.js

@@ -0,0 +1,278 @@
+import { __awaiter } from "tslib";
+import { getProxyForUrl } from 'proxy-from-env';
+import { Agent, buildConnector, Pool, ProxyAgent } from 'undici';
+export class HttpError extends Error {
+    constructor(status, data, message = `Request failed with status code ${status}`) {
+        super(message);
+        this.status = status;
+        this.data = data;
+        this.name = 'HttpError';
+    }
+}
+export default class HttpClient {
+    constructor(debug = () => { }) {
+        this.debug = debug;
+        this.proxyAgents = new Map();
+    }
+    getJson(url_1) {
+        return __awaiter(this, arguments, void 0, function* (url, options = {}) {
+            const response = yield this.request(url, 'GET', options);
+            return this.jsonResponse(response, options.signal);
+        });
+    }
+    getBuffer(url_1) {
+        return __awaiter(this, arguments, void 0, function* (url, options = {}) {
+            const response = yield this.request(url, 'GET', options);
+            return { data: Buffer.from(yield this.readBody(() => response.arrayBuffer(), options.signal)), status: response.status, headers: response.headers };
+        });
+    }
+    postJson(url, data, options = {}) {
+        return this.sendJson('POST', url, data, options);
+    }
+    putJson(url, data, options = {}) {
+        return this.sendJson('PUT', url, data, options);
+    }
+    postForm(url_1, data_1) {
+        return __awaiter(this, arguments, void 0, function* (url, data, options = {}) {
+            const headers = this.createHeaders(options.headers);
+            headers.set('Content-Type', 'application/x-www-form-urlencoded');
+            return this.jsonResponse(yield this.request(url, 'POST', Object.assign(Object.assign({}, options), { headers }), data.toString()), options.signal);
+        });
+    }
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                yield Promise.all([(_a = this.directAgent) === null || _a === void 0 ? void 0 : _a.close(), ...[...this.proxyAgents.values()].map(agent => agent.close())]);
+            }
+            finally {
+                this.proxyAgents.clear();
+                this.directAgent = undefined;
+            }
+        });
+    }
+    sendJson(method, url, data, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const headers = this.createHeaders(options.headers);
+            if (!headers.has('Content-Type'))
+                headers.set('Content-Type', 'application/json');
+            return this.jsonResponse(yield this.request(url, method, Object.assign(Object.assign({}, options), { headers }), JSON.stringify(data)), options.signal);
+        });
+    }
+    getDispatcher(url) {
+        var _a;
+        // Keep Axios' protocol selection, NO_PROXY matching and schemeless URL support.
+        // Resolve bypasses before parsing or constructing any proxy agent.
+        const proxy = getProxyForUrl(url.href);
+        if (!proxy)
+            return (_a = this.directAgent) !== null && _a !== void 0 ? _a : (this.directAgent = new Agent());
+        const key = `${url.protocol}:${proxy}`;
+        let agent = this.proxyAgents.get(key);
+        if (!agent) {
+            try {
+                const uri = new URL(proxy);
+                const token = uri.username || uri.password ?
+                    `Basic ${Buffer.from(`${decodeURIComponent(uri.username)}:${decodeURIComponent(uri.password)}`).toString('base64')}` :
+                    undefined;
+                uri.username = '';
+                uri.password = '';
+                // Forward plaintext destinations over either HTTP or TLS to the proxy.
+                // HTTPS destinations retain end-to-end TLS through a CONNECT tunnel.
+                agent = url.protocol === 'http:' ? this.forwardProxy(uri, token) : new ProxyAgent({ uri: uri.href, token });
+                this.proxyAgents.set(key, agent);
+            }
+            catch (_b) {
+                throw new Error('Invalid proxy configuration');
+            }
+        }
+        return agent;
+    }
+    forwardProxy(uri, token) {
+        const connect = buildConnector({});
+        return new Pool(uri, {
+            // The forwarded Host header identifies the destination, but TLS must
+            // authenticate the proxy hostname, never the destination hostname.
+            // Clearing servername makes undici derive SNI from the proxy host it
+            // connects to (and omit it for IP addresses, as RFC 6066 requires).
+            connect: (options, callback) => connect(Object.assign(Object.assign({}, options), { servername: undefined }), callback),
+        }).compose(dispatch => (options, handler) => {
+            // Node's bundled fetch versions use either flat header arrays or HeadersInit.
+            const raw = options.headers;
+            const pairs = Array.isArray(raw) && typeof raw[0] === 'string' ?
+                Array.from({ length: raw.length / 2 }, (_, i) => [raw[i * 2], raw[i * 2 + 1]]) : raw;
+            const headers = this.createHeaders(pairs);
+            if (!headers.has('host'))
+                headers.set('host', new URL(options.origin).host);
+            headers.delete('proxy-authorization');
+            if (token)
+                headers.set('proxy-authorization', token);
+            return dispatch(Object.assign(Object.assign({}, options), { origin: uri.origin, path: `${options.origin}${options.path}`, headers: Object.fromEntries(headers) }), {
+                onRequestStart: (controller, context) => { var _a; return (_a = handler.onRequestStart) === null || _a === void 0 ? void 0 : _a.call(handler, controller, context); },
+                onResponseStart: (controller, status, responseHeaders, statusMessage) => {
+                    var _a;
+                    if (status === 407) {
+                        controller.abort(new HttpError(407, undefined, 'Proxy authentication required (HTTP 407)'));
+                        return;
+                    }
+                    (_a = handler.onResponseStart) === null || _a === void 0 ? void 0 : _a.call(handler, controller, status, responseHeaders, statusMessage);
+                },
+                onResponseData: (controller, chunk) => { var _a; return (_a = handler.onResponseData) === null || _a === void 0 ? void 0 : _a.call(handler, controller, chunk); },
+                onResponseEnd: (controller, trailers) => { var _a; return (_a = handler.onResponseEnd) === null || _a === void 0 ? void 0 : _a.call(handler, controller, trailers); },
+                onResponseError: (controller, error) => { var _a; return (_a = handler.onResponseError) === null || _a === void 0 ? void 0 : _a.call(handler, controller, error); },
+            });
+        });
+    }
+    createHeaders(values) {
+        try {
+            return new Headers(values);
+        }
+        catch (_a) {
+            throw new Error('Invalid HTTP request headers');
+        }
+    }
+    readBody(read, signal) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield read();
+            }
+            catch (error) {
+                if (signal === null || signal === void 0 ? void 0 : signal.aborted)
+                    throw error;
+                throw this.networkError(error);
+            }
+        });
+    }
+    parseUrl(input, base) {
+        let url;
+        try {
+            url = new URL(input, base);
+        }
+        catch (_a) {
+            throw new Error('Invalid HTTP request URL');
+        }
+        if (url.username || url.password)
+            throw new Error('HTTP request URLs must not contain credentials');
+        return url;
+    }
+    networkError(error, url) {
+        // Native fetch hides DNS/TLS/socket errors in cause (sometimes AggregateError).
+        // Report diagnostic codes, never arbitrary messages containing URLs or secrets.
+        const codes = new Set();
+        const visited = new Set();
+        let proxyAuthentication = false;
+        let blockedPort = false;
+        const collect = (value) => {
+            if (!(value instanceof Error) || visited.has(value))
+                return;
+            visited.add(value);
+            // Recognize only fixed transport messages; never include their raw text.
+            proxyAuthentication || (proxyAuthentication = value instanceof HttpError && value.status === 407);
+            // undici words these differently across versions; match the status, not the exact text.
+            proxyAuthentication || (proxyAuthentication = /proxy/i.test(value.message) && /\b407\b|authentication required/i.test(value.message));
+            blockedPort || (blockedPort = value.message === 'bad port');
+            const code = value.code;
+            if (code && /^[A-Z][A-Z0-9_]{1,79}$/.test(code))
+                codes.add(code);
+            collect(value.cause);
+            if (value instanceof AggregateError)
+                value.errors.forEach(collect);
+        };
+        collect(error);
+        if (proxyAuthentication)
+            return new HttpError(407, undefined, 'Proxy authentication required (HTTP 407)');
+        if (blockedPort && url)
+            return new Error(`HTTP request port ${url.port} is blocked by native fetch`);
+        return new Error(`HTTP request failed${codes.size ? ` (${[...codes].join(', ')})` : ''}`);
+    }
+    jsonResponse(response, signal) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return { data: yield this.readData(response, signal), status: response.status, headers: response.headers };
+        });
+    }
+    readData(response, signal) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const text = yield this.readBody(() => response.text(), signal);
+            // Preserve axios' JSON, plain-text and empty-body response handling.
+            try {
+                return JSON.parse(text);
+            }
+            catch (_a) {
+                return text;
+            }
+        });
+    }
+    request(input, method, options, body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d;
+            let url = this.parseUrl(input);
+            for (const [key, value] of Object.entries((_a = options.params) !== null && _a !== void 0 ? _a : {})) {
+                if (value !== undefined && value !== null)
+                    url.searchParams.set(key, String(value));
+            }
+            const headers = this.createHeaders(options.headers);
+            if (!headers.has('Accept'))
+                headers.set('Accept', 'application/json, text/plain, */*');
+            for (let redirects = 0;; redirects++) {
+                if (!['http:', 'https:'].includes(url.protocol))
+                    throw new Error('Only HTTP and HTTPS URLs are supported');
+                // Never log authentication headers, request bodies or signed query strings.
+                this.debug(`HTTP ${method} ${url.origin}${url.pathname}`);
+                const init = {
+                    method, headers, body, signal: options.signal,
+                    redirect: 'manual',
+                    dispatcher: this.getDispatcher(url),
+                };
+                let response;
+                try {
+                    response = yield fetch(url, init);
+                }
+                catch (error) {
+                    if ((_b = options.signal) === null || _b === void 0 ? void 0 : _b.aborted)
+                        throw error;
+                    throw this.networkError(error, url);
+                }
+                const location = response.headers.get('location');
+                if ([301, 302, 303, 307, 308].includes(response.status) && location !== null) {
+                    yield ((_c = response.body) === null || _c === void 0 ? void 0 : _c.cancel());
+                    if (redirects >= 20)
+                        throw new Error('Maximum number of redirects exceeded');
+                    const target = this.parseUrl(location, url);
+                    const switchesToGet = (response.status === 303 && method !== 'HEAD') ||
+                        ([301, 302].includes(response.status) && method === 'POST');
+                    const preservesBody = !switchesToGet && body !== undefined;
+                    if (target.origin !== url.origin) {
+                        // Request bodies may carry credentials (e.g. the ACR access_token form).
+                        if (preservesBody)
+                            throw new Error('Refusing to resend a request body to another origin');
+                        // GitLab package downloads may redirect to object storage on another host; never forward
+                        // PRIVATE-TOKEN/JOB-TOKEN there (LJADIRD-66143). Covered by test/commands/download.redirect.test.ts.
+                        for (const header of ['authorization', 'proxy-authorization', 'cookie', 'private-token', 'job-token']) {
+                            headers.delete(header);
+                        }
+                    }
+                    if (switchesToGet) {
+                        method = 'GET';
+                        body = undefined;
+                        headers.delete('content-type');
+                        headers.delete('content-length');
+                    }
+                    url = target;
+                    continue;
+                }
+                if (!response.ok) {
+                    let data;
+                    try {
+                        data = yield this.readData(response, options.signal);
+                    }
+                    catch (error) {
+                        if ((_d = options.signal) === null || _d === void 0 ? void 0 : _d.aborted)
+                            throw error;
+                        // Keep the status even when the error body cannot be read.
+                    }
+                    throw new HttpError(response.status, data);
+                }
+                return response;
+            }
+        });
+    }
+}

package/lib/lib/npm.d.ts

@@ -1,6 +1,8 @@
-import { AxiosResponse } from 'axios';
-import { NpmPackage } from '../types/npm.types.js';
+import HttpClient, { HttpResponse } from './http.js';
+import { AzurePackageArray, NpmPackage } from '../types/npm.types.js';
 export default class NpmContext {
+    private readonly http;
+    constructor(http?: HttpClient);
     /**
      * Get all workspaces
      * @returns {Promise<string[]>} String array of all workspaces
@@ -8,12 +10,13 @@ export default class NpmContext {
     getWorkspaces(): Promise<string[]>;
     /**
      * Get package names
+     * @param requireVersion Skip packages without a version, e.g. private workspace roots
      */
-    packageList(context: any, packages?: string[], excludes?: string[]): Promise<NpmPackage[]>;
+    packageList(context: any, packages?: string[], excludes?: string[], requireVersion?: boolean): Promise<NpmPackage[]>;
     /**
      * Get package all packages
      * @param patToken Auth token
      * @returns {Promise<string>} Returns all the NPM packages
      */
-    getAllNpmPackages(patToken?: string): Promise<AxiosResponse<any, any>>;
+    getAllNpmPackages(patToken?: string): Promise<HttpResponse<AzurePackageArray>>;
 }

package/lib/lib/npm.js

@@ -1,11 +1,14 @@
 import { __awaiter } from "tslib";
-import axios from 'axios';
 import chalk from 'chalk';
 import fs from 'fs-extra';
 import { globby } from 'globby';
 import { minimatch } from 'minimatch';
-import path from 'path';
+import path from 'node:path';
+import HttpClient from './http.js';
 export default class NpmContext {
+    constructor(http = new HttpClient()) {
+        this.http = http;
+    }
     /**
      * Get all workspaces
      * @returns {Promise<string[]>} String array of all workspaces
@@ -31,10 +34,11 @@ export default class NpmContext {
     }
     /**
      * Get package names
+     * @param requireVersion Skip packages without a version, e.g. private workspace roots
      */
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     packageList(context_1) {
-        return __awaiter(this, arguments, void 0, function* (context, packages = ['**/*'], excludes = ['']) {
+        return __awaiter(this, arguments, void 0, function* (context, packages = ['**/*'], excludes = [''], requireVersion = true) {
             try {
                 const workspaces = yield this.getWorkspaces();
                 let searchPattern = ['package.json', '**/package.json', '.**/package.json', '!**/node_modules'];
@@ -46,7 +50,7 @@ export default class NpmContext {
                 for (const pkgPath of pkgPaths) {
                     try {
                         const data = yield fs.readJSON(pkgPath);
-                        if (!data.version || !data.name || excludes.includes(data.name) || !packages.some(pkg => minimatch(data.name, pkg))) {
+                        if ((requireVersion && !data.version) || !data.name || excludes.includes(data.name) || !packages.some(pkg => minimatch(data.name, pkg))) {
                             continue;
                         }
                         // create object to simply remove duplicates
@@ -76,16 +80,21 @@ export default class NpmContext {
      * @param patToken Auth token
      * @returns {Promise<string>} Returns all the NPM packages
      */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     getAllNpmPackages() {
         return __awaiter(this, arguments, void 0, function* (patToken = '') {
+            var _a;
             const uri = `https://feeds.dev.azure.com/adacta-fintech/adinsure/_apis/packaging/Feeds/feed/packages?api-version=6.0-preview.1&includeAllVersions=true&protocolType=Npm`;
-            return axios.get(uri, {
+            const response = yield this.http.getJson(uri, {
                 headers: {
                     Authorization: 'Basic ' + Buffer.from(`:${patToken}`).toString('base64'),
                     'Content-Type': 'application/octet-strem',
                 },
             });
+            // A missing or invalid PAT is redirected to an HTML sign-in page that returns 200.
+            if (!Array.isArray((_a = response.data) === null || _a === void 0 ? void 0 : _a.value)) {
+                throw new Error('Azure Artifacts did not return package metadata. Check that --pat is a valid Azure DevOps token with Packaging (Read) access.');
+            }
+            return response;
         });
     }
 }

package/lib/lib/npmrc.js

@@ -1,8 +1,8 @@
 import { __awaiter } from "tslib";
-import { execSync } from 'child_process';
-import fs from 'fs';
+import { execSync } from 'node:child_process';
+import fs from 'node:fs';
 import ini from 'ini';
-import os from 'os';
+import os from 'node:os';
 export default class NpmRc {
     constructor(createIfNotExists = true) {
         this.config = {};

package/lib/lib/yarnrc.js

@@ -1,6 +1,6 @@
-import fs from "fs";
-import os from "os";
-import path from "path";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
 import yaml from "yaml";
 export default class YarnRc {
     constructor(createIfNotExists = true) {

package/lib/security/cache.js

@@ -1,6 +1,6 @@
 import { __awaiter } from "tslib";
 import fs from 'fs-extra';
-import path from 'path';
+import path from 'node:path';
 export default class LocalCachePlugin {
     constructor(path) {
         this._accessTokenPath = path;