trm-core 9.10.6 → 10.0.1

package/dist/registry/RegistryDeletionTransportUnavailableError.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The registry can't generate a deletion transport: the user isn't authorized (e.g. registry plan)
+ * or the registry doesn't support it (local .trm files). Cleanups that only tidy up continue without it.
+ */
+export declare class RegistryDeletionTransportUnavailableError extends Error {
+    readonly registryEndpoint: string;
+    readonly originalError: unknown;
+    constructor(registryEndpoint: string, message: string, originalError?: unknown);
+}

package/dist/registry/RegistryDeletionTransportUnavailableError.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegistryDeletionTransportUnavailableError = void 0;
+/**
+ * The registry can't generate a deletion transport: the user isn't authorized (e.g. registry plan)
+ * or the registry doesn't support it (local .trm files). Cleanups that only tidy up continue without it.
+ */
+class RegistryDeletionTransportUnavailableError extends Error {
+    constructor(registryEndpoint, message, originalError) {
+        super(message);
+        this.name = 'RegistryDeletionTransportUnavailableError';
+        this.registryEndpoint = registryEndpoint;
+        this.originalError = originalError;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.RegistryDeletionTransportUnavailableError = RegistryDeletionTransportUnavailableError;

package/dist/registry/RegistryPackageNotFoundError.d.ts

@@ -0,0 +1,7 @@
+export declare class RegistryPackageNotFoundError extends Error {
+    readonly packageName: string;
+    readonly requestedVersion: string;
+    readonly registryEndpoint: string;
+    readonly originalError: unknown;
+    constructor(packageName: string, requestedVersion: string, registryEndpoint: string, originalError: unknown);
+}

package/dist/registry/RegistryPackageNotFoundError.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegistryPackageNotFoundError = void 0;
+class RegistryPackageNotFoundError extends Error {
+    constructor(packageName, requestedVersion, registryEndpoint, originalError) {
+        super(`Package "${packageName}" version "${requestedVersion}" was not found in registry "${registryEndpoint}".`);
+        this.name = 'RegistryPackageNotFoundError';
+        this.packageName = packageName;
+        this.requestedVersion = requestedVersion;
+        this.registryEndpoint = registryEndpoint;
+        this.originalError = originalError;
+    }
+}
+exports.RegistryPackageNotFoundError = RegistryPackageNotFoundError;

package/dist/registry/RegistryV2.d.ts

@@ -1,7 +1,9 @@
 import { RegistryType } from "./RegistryType";
-import { BatchCompareRequest, BatchCompareResponse, Deprecate, DistTagAdd, DistTagRm, Package, PackageContents, Ping, WhoAmI } from "trm-registry-types";
+import { BatchCompareRequest, BatchCompareResponse, Deprecate, DistTagAdd, DistTagRm, Package, Ping, WhoAmI } from "trm-registry-types";
 import { TrmArtifact } from "../trmPackage/TrmArtifact";
-import { AbstractRegistry } from "./AbstractRegistry";
+import { AbstractRegistry, PublishAdditionalData, PublishResult } from "./AbstractRegistry";
+import { TransportEntries } from "../client";
+import { BinaryTransport } from "../transport";
 export declare const PUBLIC_RESERVED_KEYWORD = "public";
 export declare class RegistryV2 implements AbstractRegistry {
     endpoint: string;
@@ -11,8 +13,10 @@ export declare class RegistryV2 implements AbstractRegistry {
     private _registryType;
     private _axiosInstance;
     private _authData;
+    private _externalUserAgent;
     private _userAgent;
     constructor(endpoint: string, name?: string, _coreVersion?: string);
+    setExternalUserAgent(userAgent: string): void;
     private getDefaultAxiosHeaders;
     compare(registry: AbstractRegistry): boolean;
     getRegistryType(): RegistryType;
@@ -21,16 +25,22 @@ export declare class RegistryV2 implements AbstractRegistry {
     private _tokenAuth;
     private _oauth2;
     getAuthData(): any;
+    private assertStatus;
+    private getErrorStatus;
     ping(): Promise<Ping>;
     whoAmI(): Promise<WhoAmI>;
-    getPackage(fullName: string, version?: string): Promise<Package>;
+    getPackage(fullName: string, version?: string, refresh?: boolean): Promise<Package>;
+    private getPackageCacheKey;
+    transportEntries(fullName: string, version: string, trkorr: string): Promise<TransportEntries>;
     downloadArtifact(fullName: string, version?: string): Promise<TrmArtifact>;
     validatePublish(fullName: string, version: string, isPrivate: boolean): Promise<void>;
-    publish(fullName: string, version: string, artifact: TrmArtifact, readme?: string, tags?: string, changelog?: string): Promise<void>;
+    publish(fullName: string, version: string, artifact: TrmArtifact, additionalData?: PublishAdditionalData): Promise<PublishResult | void>;
     unpublish(fullName: string, version: string): Promise<void>;
     deprecate(fullName: string, version: string, deprecate: Deprecate): Promise<void>;
     addDistTag(fullName: string, distTag: DistTagAdd): Promise<void>;
     rmDistTag(fullName: string, distTag: DistTagRm): Promise<void>;
     batchCompare(packages: BatchCompareRequest): Promise<BatchCompareResponse>;
-    contents(fullName: string, version?: string): Promise<PackageContents>;
+    delete(transport: BinaryTransport): Promise<BinaryTransport>;
+    transport(trkorr: string, target?: string): Promise<BinaryTransport>;
+    private downloadTransport;
 }

package/dist/registry/RegistryV2.js

@@ -58,8 +58,15 @@ const protocol_1 = require("../protocol");
 const opener_1 = __importDefault(require("opener"));
 const commons_1 = require("../commons");
 const node_cache_1 = __importDefault(require("node-cache"));
+const AdmZip = __importStar(require("adm-zip"));
+const RegistryPackageNotFoundError_1 = require("./RegistryPackageNotFoundError");
+const RegistryDeletionTransportUnauthorizedError_1 = require("./RegistryDeletionTransportUnauthorizedError");
 const AXIOS_CTX = "RegistryV2";
 exports.PUBLIC_RESERVED_KEYWORD = 'public';
+const PUBLISH_POLL_INTERVAL_MS = 5000;
+const PUBLISH_POLL_TIMEOUT_MS = 30 * 60 * 1000;
+const PUBLISH_POLL_MAX_FAILURES = 3;
+const isPublishStatus = (status) => !!status && Number.isInteger(status.steps) && Number.isInteger(status.current_step);
 class RegistryV2 {
     constructor(endpoint, name = 'Unknown', _coreVersion) {
         this.endpoint = endpoint;
@@ -69,12 +76,15 @@ class RegistryV2 {
         var envEndpoint = process.env.TRM_PUBLIC_REGISTRY_ENDPOINT;
         trm_commons_1.Logger.log(`TRM_PUBLIC_REGISTRY_ENDPOINT Environment variable: ${envEndpoint}`, true);
         if (!envEndpoint || envEndpoint.trim().toLowerCase() === exports.PUBLIC_RESERVED_KEYWORD) {
+            //no env var value or env var value = public
             envEndpoint = 'https://www.trmregistry.com/registry';
         }
         if (endpoint.trim().toLowerCase() === exports.PUBLIC_RESERVED_KEYWORD) {
+            //if input endpoint is public
             this._registryType = RegistryType_1.RegistryType.PUBLIC;
         }
         else {
+            //all other cases
             this._registryType = RegistryType_1.RegistryType.PRIVATE;
         }
         if (this._registryType === RegistryType_1.RegistryType.PUBLIC) {
@@ -99,6 +109,9 @@ class RegistryV2 {
             headers: this.getDefaultAxiosHeaders()
         }, AXIOS_CTX);
     }
+    setExternalUserAgent(userAgent) {
+        this._externalUserAgent = userAgent;
+    }
     getDefaultAxiosHeaders() {
         var axiosHeaders = new axios_1.AxiosHeaders();
         if (!this._userAgent) {
@@ -109,7 +122,7 @@ class RegistryV2 {
                 this._userAgent = `trm-core with unknown version`;
             }
         }
-        axiosHeaders.setUserAgent(this._userAgent);
+        axiosHeaders.setUserAgent(this._externalUserAgent ? `${this._externalUserAgent}, ${this._userAgent}` : this._userAgent);
         return axiosHeaders;
     }
     compare(registry) {
@@ -191,7 +204,7 @@ class RegistryV2 {
             var token = defaultData.token;
             if (!token && this._registryType == RegistryType_1.RegistryType.PUBLIC) {
                 trm_commons_1.Logger.info(`To authenticate, generate a new token.`);
-                trm_commons_1.Logger.info(`Follow the instructions https://docs.trmregistry.com/#/registry/public/authentication.`);
+                trm_commons_1.Logger.info(`Follow the instructions https://docs.trmregistry.com/registry/public/authentication/ .`);
             }
             const inq1 = yield trm_commons_1.Inquirer.prompt([{
                     type: "input",
@@ -232,9 +245,11 @@ class RegistryV2 {
                                 grant_type: "refresh_token",
                                 refresh_token: refreshToken
                             };
-                            oAuth2Response = (yield ((0, commons_1.getAxiosInstance)({
+                            const tokenResponse = yield ((0, commons_1.getAxiosInstance)({
                                 baseURL: this.endpoint
-                            }, AXIOS_CTX)).post('/auth', oAuth2Request)).data;
+                            }, AXIOS_CTX)).post('/auth', oAuth2Request);
+                            this.assertStatus(tokenResponse.status, [200], 'OAuth token refresh');
+                            oAuth2Response = tokenResponse.data;
                             runAuthFlow = false;
                             authData = {
                                 access_token: oAuth2Response.access_token,
@@ -290,9 +305,11 @@ class RegistryV2 {
                         grant_type: "authorization_code",
                         redirect_uri: sRedirectUri
                     };
-                    oAuth2Response = (yield ((0, commons_1.getAxiosInstance)({
+                    const tokenResponse = yield ((0, commons_1.getAxiosInstance)({
                         baseURL: this.endpoint
-                    }, AXIOS_CTX)).post('/auth', oAuth2Request)).data;
+                    }, AXIOS_CTX)).post('/auth', oAuth2Request);
+                    this.assertStatus(tokenResponse.status, [200], 'OAuth token exchange');
+                    oAuth2Response = tokenResponse.data;
                     if (oAuth2Response.token_type !== "Bearer") {
                         throw new Error('Unknown token type.');
                     }
@@ -320,14 +337,26 @@ class RegistryV2 {
     getAuthData() {
         return this._authData;
     }
+    assertStatus(status, expected, operation) {
+        if (!expected.includes(status)) {
+            throw new Error(`${operation} returned unexpected HTTP status ${status}; expected ${expected.join(' or ')}.`);
+        }
+    }
+    getErrorStatus(error) {
+        var _a, _b, _c, _d, _e;
+        const registryError = error;
+        return (_c = (_a = registryError.status) !== null && _a !== void 0 ? _a : (_b = registryError.response) === null || _b === void 0 ? void 0 : _b.status) !== null && _c !== void 0 ? _c : (_e = (_d = registryError.axiosError) === null || _d === void 0 ? void 0 : _d.response) === null || _e === void 0 ? void 0 : _e.status;
+    }
     ping() {
         return __awaiter(this, void 0, void 0, function* () {
             var data = this._cache.get('ping');
             if (!data) {
                 try {
-                    data = (yield this._axiosInstance.get('/', {
+                    const response = yield this._axiosInstance.get('/', {
                         headers: {}
-                    })).data;
+                    });
+                    this.assertStatus(response.status, [200], 'Registry metadata request');
+                    data = response.data;
                 }
                 catch (e) {
                     if (e.errors) {
@@ -350,7 +379,9 @@ class RegistryV2 {
             var data = this._cache.get('whoami');
             if (!data) {
                 try {
-                    data = (yield this._axiosInstance.get('/whoami')).data;
+                    const response = yield this._axiosInstance.get('/whoami');
+                    this.assertStatus(response.status, [200], 'Registry identity request');
+                    data = response.data;
                 }
                 catch (e) {
                     data = e;
@@ -366,16 +397,22 @@ class RegistryV2 {
         });
     }
     getPackage(fullName_1) {
-        return __awaiter(this, arguments, void 0, function* (fullName, version = 'latest') {
-            var data = this._cache.get(`package-${fullName}-${version}`);
+        return __awaiter(this, arguments, void 0, function* (fullName, version = 'latest', refresh = false) {
+            const cacheKey = this.getPackageCacheKey(fullName, version);
+            if (refresh) {
+                this._cache.del(cacheKey);
+            }
+            var data = this._cache.get(cacheKey);
             if (!data) {
                 var ttl;
                 try {
-                    data = (yield this._axiosInstance.get(`/package/${fullName}`, {
+                    const response = yield this._axiosInstance.get(`/package/${fullName}`, {
                         params: {
-                            version: encodeURIComponent(version)
+                            version
                         }
-                    })).data;
+                    });
+                    this.assertStatus(response.status, [200], 'Package metadata request');
+                    data = response.data;
                     if (data.download_link_expiry) {
                         try {
                             ttl = Math.max(0, Math.floor((data.download_link_expiry - Date.now()) / 1000));
@@ -384,9 +421,17 @@ class RegistryV2 {
                     }
                 }
                 catch (e) {
-                    data = e;
+                    data = this.getErrorStatus(e) === 404
+                        ? new RegistryPackageNotFoundError_1.RegistryPackageNotFoundError(fullName, version, this.endpoint, e)
+                        : e;
+                }
+                // A failed refresh must not poison the cache. In particular, a
+                // transient ECONNRESET should allow the caller to retry the GET.
+                if (!(data instanceof Error)) {
+                    if (ttl === undefined || ttl > 0) {
+                        this._cache.set(cacheKey, data, ttl);
+                    }
                 }
-                this._cache.set(`package-${fullName}-${version}`, data, ttl);
             }
             if (data instanceof Error) {
                 throw data;
@@ -396,6 +441,48 @@ class RegistryV2 {
             }
         });
     }
+    getPackageCacheKey(fullName, version) {
+        return `package-${fullName}-${version}`;
+    }
+    transportEntries(fullName, version, trkorr) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const download = (...args_1) => __awaiter(this, [...args_1], void 0, function* (refreshPackage = false) {
+                let packageData;
+                try {
+                    packageData = yield this.getPackage(fullName, version, refreshPackage);
+                }
+                catch (e) {
+                    // Signed links are commonly refreshed after the HTTP connection
+                    // has been idle. Retry this safe metadata GET once if that stale
+                    // connection was reset; Axios retains the instance auth headers.
+                    if (refreshPackage && e.code === 'ECONNRESET') {
+                        packageData = yield this.getPackage(fullName, version, true);
+                    }
+                    else {
+                        throw e;
+                    }
+                }
+                const transport = packageData.transports.find(o => o.trkorr === trkorr);
+                if (!transport) {
+                    throw new Error(`Transport ${trkorr} was not found in package ${fullName} ${version}.`);
+                }
+                if (!refreshPackage && transport.contents.download_link_expiry && transport.contents.download_link_expiry <= Date.now()) {
+                    return download(true);
+                }
+                try {
+                    return (0, commons_1.normalize)((yield this._axiosInstance.get(transport.contents.download_link)).data || {});
+                }
+                catch (e) {
+                    const status = this.getErrorStatus(e);
+                    if (!refreshPackage && (status === 401 || status === 403)) {
+                        return download(true);
+                    }
+                    throw e;
+                }
+            });
+            return download();
+        });
+    }
     downloadArtifact(fullName_1) {
         return __awaiter(this, arguments, void 0, function* (fullName, version = 'latest') {
             var _a;
@@ -438,9 +525,10 @@ class RegistryV2 {
                     logProgress.stop();
                 }
                 catch (_b) {
+                    // ignore stop errors
                 }
                 trm_commons_1.Logger.error(e.toString(), true);
-                trm_commons_1.Logger.error(`Failed to fetch package at ${packageData.download_link}: ${e.message}`);
+                trm_commons_1.Logger.error(`Failed to fetch package ${fullName} ${version}: ${e.message}`, { important: true });
                 throw e;
             }
             return new TrmArtifact_1.TrmArtifact(buffer);
@@ -450,7 +538,7 @@ class RegistryV2 {
         return __awaiter(this, arguments, void 0, function* (fullName, version = 'latest', isPrivate) {
             const status = (yield this._axiosInstance.get(`/publish/check/${fullName}`, {
                 params: {
-                    version: encodeURIComponent(version),
+                    version,
                     private: isPrivate ? 'X' : 'N'
                 }
             })).status;
@@ -459,35 +547,40 @@ class RegistryV2 {
             }
         });
     }
-    publish(fullName, version, artifact, readme, tags, changelog) {
+    publish(fullName, version, artifact, additionalData) {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
             const fileName = `${fullName}_v${version}`.replace('.', '_') + '.trm';
             const formData = new FormData.default();
             formData.append('artifact', artifact.binary, {
                 filename: fileName,
                 contentType: 'application/octet-stream'
             });
-            if (readme) {
-                formData.append('readme', Buffer.from(readme), {
+            if (additionalData && additionalData.readme) {
+                formData.append('readme', Buffer.from(additionalData.readme), {
                     filename: 'readme.md',
                     contentType: 'text/markdown'
                 });
             }
-            if (changelog) {
-                formData.append('changelog', Buffer.from(changelog), {
+            if (additionalData && additionalData.changelog) {
+                formData.append('changelog', Buffer.from(additionalData.changelog), {
                     filename: 'changelog.md',
                     contentType: 'text/markdown'
                 });
             }
-            var params = { version, tags };
-            if (!tags) {
+            if (additionalData && additionalData.retainedCustomizing) {
+                formData.append('retainedCustomizing', JSON.stringify(additionalData.retainedCustomizing));
+            }
+            var params = { version, tags: additionalData && additionalData.tags ? additionalData.tags : undefined };
+            if (!params.tags) {
                 delete params.tags;
             }
             const response = yield this._axiosInstance.post(`/publish/${fullName}`, formData, {
                 params,
                 headers: formData.getHeaders()
             });
-            if (response.status === 202) {
+            this.assertStatus(response.status, [201, 202], 'Publish request');
+            if (response.status === 202) { //publish is async
                 let publishStatus = response.data;
                 const progressPoolUrl = publishStatus.progress_pool_url;
                 const logProgress = trm_commons_1.Logger.progressbar(`↑ ${fullName} ${version} [{bar}] {value}/{total} {message} | Last refresh: {lastRefresh}`, '>');
@@ -495,44 +588,76 @@ class RegistryV2 {
                     message: publishStatus.current_step_message || '',
                     lastRefresh: new Date().toLocaleTimeString()
                 });
+                //the outcome of a publish that can't be followed is unknown: never report it as a success
+                const unknownOutcome = (reason) => new Error(`${reason}; the outcome of publishing ${fullName} ${version} is unknown, check the registry before publishing again.`);
+                const deadline = Date.now() + PUBLISH_POLL_TIMEOUT_MS;
+                let pollFailures = 0;
                 try {
+                    if (!isPublishStatus(publishStatus)) {
+                        throw unknownOutcome(`Registry returned an invalid publish status`);
+                    }
                     while (publishStatus.current_step < publishStatus.steps) {
-                        yield new Promise(resolve => setTimeout(resolve, 5000));
-                        publishStatus = (yield this._axiosInstance.get(progressPoolUrl)).data;
+                        if (Date.now() >= deadline) {
+                            throw unknownOutcome(`Registry publish did not complete within ${PUBLISH_POLL_TIMEOUT_MS / 60000} minutes`);
+                        }
+                        yield new Promise(resolve => setTimeout(resolve, PUBLISH_POLL_INTERVAL_MS));
+                        try {
+                            publishStatus = (yield this._axiosInstance.get(progressPoolUrl)).data;
+                            pollFailures = 0;
+                        }
+                        catch (e) {
+                            //tolerate transient failures
+                            pollFailures++;
+                            trm_commons_1.Logger.error(e.toString(), true);
+                            if (pollFailures >= PUBLISH_POLL_MAX_FAILURES) {
+                                throw unknownOutcome(`Unable to check publish status on registry (${e.message || e})`);
+                            }
+                            continue;
+                        }
+                        if (!isPublishStatus(publishStatus)) {
+                            throw unknownOutcome(`Registry returned an invalid publish status`);
+                        }
                         logProgress.update(publishStatus.current_step, {
                             message: publishStatus.current_step_message || '',
-                            lastCheck: new Date().toLocaleTimeString()
+                            lastRefresh: new Date().toLocaleTimeString()
                         });
                     }
                 }
-                catch (e) {
-                    trm_commons_1.Logger.error(e.toString());
-                    trm_commons_1.Logger.warning(`Unable to check status on registry, check manually`);
-                }
                 finally {
                     logProgress.stop();
                 }
+                //registry may report the outcome: a rejection or the integrity of the stored release (artifact may have been modified)
+                const error = (_a = publishStatus.data) === null || _a === void 0 ? void 0 : _a.error;
+                if (typeof error === 'string' && error.trim()) {
+                    throw new Error(`Registry rejected publish: ${error}`);
+                }
+                const integrity = (_b = publishStatus.data) === null || _b === void 0 ? void 0 : _b.integrity;
+                if (typeof integrity === 'string' && integrity.trim()) {
+                    return { integrity };
+                }
             }
         });
     }
     unpublish(fullName, version) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this._axiosInstance.post(`/unpublish/${fullName}`, null, {
+            const response = yield this._axiosInstance.post(`/unpublish/${fullName}`, null, {
                 params: {
-                    version: encodeURIComponent(version)
+                    version
                 }
             });
+            this.assertStatus(response.status, [204], 'Unpublish request');
         });
     }
     deprecate(fullName, version, deprecate) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this._axiosInstance.post(`/deprecate/${fullName}`, {
+            const response = yield this._axiosInstance.post(`/deprecate/${fullName}`, {
                 deprecate_note: deprecate.deprecate_note
             }, {
                 params: {
-                    version: encodeURIComponent(version)
+                    version
                 }
             });
+            this.assertStatus(response.status, [204], 'Deprecate request');
         });
     }
     addDistTag(fullName, distTag) {
@@ -555,20 +680,132 @@ class RegistryV2 {
     }
     batchCompare(packages) {
         return __awaiter(this, void 0, void 0, function* () {
-            return (yield this._axiosInstance.post('/batchCompare', packages)).data;
+            const response = yield this._axiosInstance.post('/batchCompare', packages);
+            this.assertStatus(response.status, [200], 'Batch comparison request');
+            return response.data;
         });
     }
-    contents(fullName_1) {
-        return __awaiter(this, arguments, void 0, function* (fullName, version = 'latest') {
+    delete(transport) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const formData = new FormData.default();
+            formData.append('header', transport.header, {
+                filename: 'header',
+                contentType: 'application/octet-stream'
+            });
+            formData.append('data', transport.data, {
+                filename: 'data',
+                contentType: 'application/octet-stream'
+            });
+            let deleteResponse;
+            try {
+                deleteResponse = yield this._axiosInstance.post('/delete', formData, {
+                    headers: formData.getHeaders()
+                });
+            }
+            catch (e) {
+                if (this.getErrorStatus(e) === 401) {
+                    throw new RegistryDeletionTransportUnauthorizedError_1.RegistryDeletionTransportUnauthorizedError(this.endpoint, e);
+                }
+                throw e;
+            }
+            this.assertStatus(deleteResponse.status, [200], 'Deletion transport request');
+            const transportDownload = deleteResponse.data;
+            const chunks = [];
+            let buffer;
+            const ping = this._cache.get('ping') && !(this._cache.get('ping') instanceof Error) ? this._cache.get('ping') : undefined;
+            const logProgress = trm_commons_1.Logger.progressbar(`↓ deletion transport [{bar}] {percentage}% | {value}/{total} bytes`, '>');
+            try {
+                const response = yield this._axiosInstance.get(transportDownload.download_link, {
+                    headers: {
+                        Accept: 'application/octet-stream'
+                    },
+                    maxRedirects: 10,
+                    responseType: 'stream',
+                    validateStatus: s => s >= 200 && s < 400
+                });
+                const totalBytes = Number((_a = response.headers['content-length']) !== null && _a !== void 0 ? _a : 0);
+                let downloadedBytes = 0;
+                if (totalBytes > 0) {
+                    logProgress.start(totalBytes, 0);
+                }
+                yield new Promise((resolve, reject) => {
+                    response.data.on('data', (chunk) => {
+                        chunks.push(chunk);
+                        downloadedBytes += chunk.length;
+                        if (totalBytes > 0) {
+                            logProgress.update(downloadedBytes);
+                        }
+                    });
+                    response.data.on('end', resolve);
+                    response.data.on('error', reject);
+                });
+                if (totalBytes > 0) {
+                    logProgress.stop();
+                }
+                buffer = Buffer.concat(chunks);
+            }
+            catch (e) {
+                try {
+                    logProgress.stop();
+                }
+                catch (_b) {
+                    // ignore stop errors
+                }
+                trm_commons_1.Logger.error(e.toString(), true);
+                trm_commons_1.Logger.error(`Failed to download deletion transport: ${e.message}`, { important: true });
+                throw e;
+            }
+            const checksum = (0, crypto_1.createHash)('sha512').update(buffer).digest('base64');
+            if (checksum !== transportDownload.checksum) {
+                trm_commons_1.Logger.error(`SECURITY ISSUE! Deletion transport integrity does NOT match!`, { important: true });
+                trm_commons_1.Logger.error(`SECURITY ISSUE! Expected SHA is ${transportDownload.checksum}, received SHA is ${checksum}`, { important: true });
+                trm_commons_1.Logger.error(`SECURITY ISSUE! Please, report the issue to ${this.ping && ping.alert_email ? ping.alert_email : 'registry support team'}`, { important: true });
+                throw new Error(`Cannot continue due to security issues.`);
+            }
+            const zip = new AdmZip.default(buffer);
+            const kFile = zip.getEntries().find(o => o.name.startsWith('K'));
+            const rFile = zip.getEntries().find(o => o.name.startsWith('R'));
+            if (!kFile) {
+                throw new Error(`Missing header in deletion transport!`);
+            }
+            if (!rFile) {
+                throw new Error(`Missing data in deletion transport!`);
+            }
+            return {
+                header: kFile.getData(),
+                data: rFile.getData()
+            };
+        });
+    }
+    transport(trkorr, target) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this._axiosInstance.get(`/transport/${trkorr}`, {
+                params: {
+                    target: target || undefined
+                }
+            });
+            this.assertStatus(response.status, [200], 'Transport request');
+            const transportDownload = response.data;
+            return this.downloadTransport(transportDownload, trkorr);
+        });
+    }
+    downloadTransport(transportDownload, label) {
+        return __awaiter(this, void 0, void 0, function* () {
             var _a;
             const chunks = [];
-            const logProgress = trm_commons_1.Logger.progressbar(`↓ ${fullName} ${version} contents [{bar}] {percentage}% | {value}/{total} bytes`, '>');
+            let buffer;
+            //from cache if it exists, else ignore
+            const ping = this._cache.get('ping') && !(this._cache.get('ping') instanceof Error) ? this._cache.get('ping') : undefined;
+            const logProgress = trm_commons_1.Logger.progressbar(`↓ ${label} [{bar}] {percentage}% | {value}/{total} bytes`, '>');
             try {
-                const response = yield this._axiosInstance.get(`/package/contents/${fullName}`, {
-                    params: {
-                        version: encodeURIComponent(version),
+                const response = yield this._axiosInstance.get(transportDownload.download_link, {
+                    headers: {
+                        Accept: 'application/octet-stream',
                     },
+                    maxRedirects: 10,
                     responseType: 'stream',
+                    validateStatus: s => s >= 200 && s < 400,
                 });
                 const totalBytes = Number((_a = response.headers['content-length']) !== null && _a !== void 0 ? _a : 0);
                 let downloadedBytes = 0;
@@ -589,18 +826,41 @@ class RegistryV2 {
                 if (totalBytes > 0) {
                     logProgress.stop();
                 }
-                const buffer = Buffer.concat(chunks);
-                return JSON.parse(buffer.toString('utf-8'));
+                buffer = Buffer.concat(chunks);
             }
             catch (e) {
                 try {
                     logProgress.stop();
                 }
-                catch (_b) { }
+                catch (_b) {
+                    // ignore stop errors
+                }
                 trm_commons_1.Logger.error(e.toString(), true);
-                trm_commons_1.Logger.error(`Failed to fetch contents for ${fullName}: ${e.message}`, true);
+                trm_commons_1.Logger.error(`Failed to download transport ${label}: ${e.message}`, { important: true });
                 throw e;
             }
+            const checksum = (0, crypto_1.createHash)("sha512").update(buffer).digest("base64");
+            if (checksum !== transportDownload.checksum) {
+                trm_commons_1.Logger.error(`SECURITY ISSUE! Transport ${label} integrity does NOT match!`, { important: true });
+                trm_commons_1.Logger.error(`SECURITY ISSUE! Expected SHA is ${transportDownload.checksum}, received SHA is ${checksum}`, { important: true });
+                trm_commons_1.Logger.error(`SECURITY ISSUE! Please, report the issue to ${this.ping && ping.alert_email ? ping.alert_email : 'registry support team'}`, { important: true });
+                throw new Error(`Cannot continue due to security issues.`);
+            }
+            const zip = new AdmZip.default(buffer);
+            //we can't assume custom registries will mark K and R file with comment in zip
+            //keeping it simple here with name starts with
+            const kFile = zip.getEntries().find(o => o.name.startsWith('K'));
+            const rFile = zip.getEntries().find(o => o.name.startsWith('R'));
+            if (!kFile) {
+                throw new Error(`Missing header in transport!`);
+            }
+            if (!rFile) {
+                throw new Error(`Missing data in transport!`);
+            }
+            return {
+                header: kFile.getData(),
+                data: rFile.getData()
+            };
         });
     }
 }