@redocly/cli 1.18.0 → 1.19.0

package/lib/cms/commands/__tests__/push.test.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 const fs = require("fs");
 const path = require("path");
@@ -21,9 +12,12 @@ const remotes = {
 jest.mock('@redocly/openapi-core', () => ({
     slash: jest.fn().mockImplementation((p) => p),
 }));
-jest.mock('../../api', () => (Object.assign(Object.assign({}, jest.requireActual('../../api')), { ReuniteApiClient: jest.fn().mockImplementation(function (...args) {
+jest.mock('../../api', () => ({
+    ...jest.requireActual('../../api'),
+    ReuniteApiClient: jest.fn().mockImplementation(function (...args) {
         this.remotes = remotes;
-    }) })));
+    }),
+}));
 describe('handlePush()', () => {
     let pathResolveSpy;
     let pathRelativeSpy;
@@ -48,7 +42,7 @@ describe('handlePush()', () => {
         fsStatSyncSpy.mockRestore();
         fsReaddirSyncSpy.mockRestore();
     });
-    it('should upload files', () => __awaiter(void 0, void 0, void 0, function* () {
+    it('should upload files', async () => {
         const mockConfig = { apis: {} };
         process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
         fsStatSyncSpy.mockReturnValueOnce({
@@ -59,23 +53,27 @@ describe('handlePush()', () => {
         pathResolveSpy.mockImplementationOnce((p) => p);
         pathRelativeSpy.mockImplementationOnce((_, p) => p);
         pathDirnameSpy.mockImplementation((_) => '.');
-        yield (0, push_1.handlePush)({
-            domain: 'test-domain',
-            'mount-path': 'test-mount-path',
-            organization: 'test-org',
-            project: 'test-project',
-            branch: 'test-branch',
-            namespace: 'test-namespace',
-            repository: 'test-repository',
-            'commit-sha': 'test-commit-sha',
-            'commit-url': 'test-commit-url',
-            'default-branch': 'test-branch',
-            'created-at': 'test-created-at',
-            author: 'TestAuthor <test-author@mail.com>',
-            message: 'Test message',
-            files: ['test-file'],
-            'max-execution-time': 10,
-        }, mockConfig);
+        await (0, push_1.handlePush)({
+            argv: {
+                domain: 'test-domain',
+                'mount-path': 'test-mount-path',
+                organization: 'test-org',
+                project: 'test-project',
+                branch: 'test-branch',
+                namespace: 'test-namespace',
+                repository: 'test-repository',
+                'commit-sha': 'test-commit-sha',
+                'commit-url': 'test-commit-url',
+                'default-branch': 'test-branch',
+                'created-at': 'test-created-at',
+                author: 'TestAuthor <test-author@mail.com>',
+                message: 'Test message',
+                files: ['test-file'],
+                'max-execution-time': 10,
+            },
+            config: mockConfig,
+            version: 'cli-version',
+        });
         expect(remotes.getDefaultBranch).toHaveBeenCalledWith('test-org', 'test-project');
         expect(remotes.upsert).toHaveBeenCalledWith('test-org', 'test-project', {
             mountBranchName: 'test-default-branch',
@@ -103,8 +101,8 @@ describe('handlePush()', () => {
                 stream: 'stream',
             },
         ]);
-    }));
-    it('should return push id', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it('should return push id', async () => {
         const mockConfig = { apis: {} };
         process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
         fsStatSyncSpy.mockReturnValueOnce({
@@ -115,26 +113,30 @@ describe('handlePush()', () => {
         pathResolveSpy.mockImplementationOnce((p) => p);
         pathRelativeSpy.mockImplementationOnce((_, p) => p);
         pathDirnameSpy.mockImplementation((_) => '.');
-        const result = yield (0, push_1.handlePush)({
-            domain: 'test-domain',
-            'mount-path': 'test-mount-path',
-            organization: 'test-org',
-            project: 'test-project',
-            branch: 'test-branch',
-            namespace: 'test-namespace',
-            repository: 'test-repository',
-            'commit-sha': 'test-commit-sha',
-            'commit-url': 'test-commit-url',
-            'default-branch': 'test-branch',
-            'created-at': 'test-created-at',
-            author: 'TestAuthor <test-author@mail.com>',
-            message: 'Test message',
-            files: ['test-file'],
-            'max-execution-time': 10,
-        }, mockConfig);
+        const result = await (0, push_1.handlePush)({
+            argv: {
+                domain: 'test-domain',
+                'mount-path': 'test-mount-path',
+                organization: 'test-org',
+                project: 'test-project',
+                branch: 'test-branch',
+                namespace: 'test-namespace',
+                repository: 'test-repository',
+                'commit-sha': 'test-commit-sha',
+                'commit-url': 'test-commit-url',
+                'default-branch': 'test-branch',
+                'created-at': 'test-created-at',
+                author: 'TestAuthor <test-author@mail.com>',
+                message: 'Test message',
+                files: ['test-file'],
+                'max-execution-time': 10,
+            },
+            config: mockConfig,
+            version: 'cli-version',
+        });
         expect(result).toEqual({ pushId: 'test-id' });
-    }));
-    it('should collect files from directory and preserve file structure', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it('should collect files from directory and preserve file structure', async () => {
         const mockConfig = { apis: {} };
         process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
         /*
@@ -157,18 +159,22 @@ describe('handlePush()', () => {
             }
             throw new Error('Not a directory');
         });
-        yield (0, push_1.handlePush)({
-            domain: 'test-domain',
-            'mount-path': 'test-mount-path',
-            organization: 'test-org',
-            project: 'test-project',
-            branch: 'test-branch',
-            author: 'TestAuthor <test-author@mail.com>',
-            message: 'Test message',
-            'default-branch': 'main',
-            files: ['test-folder'],
-            'max-execution-time': 10,
-        }, mockConfig);
+        await (0, push_1.handlePush)({
+            argv: {
+                domain: 'test-domain',
+                'mount-path': 'test-mount-path',
+                organization: 'test-org',
+                project: 'test-project',
+                branch: 'test-branch',
+                author: 'TestAuthor <test-author@mail.com>',
+                message: 'Test message',
+                'default-branch': 'main',
+                files: ['test-folder'],
+                'max-execution-time': 10,
+            },
+            config: mockConfig,
+            version: 'cli-version',
+        });
         expect(remotes.push).toHaveBeenCalledWith(expect.anything(), expect.anything(), expect.anything(), [
             {
                 path: 'app/index.html',
@@ -183,27 +189,31 @@ describe('handlePush()', () => {
                 stream: 'stream',
             },
         ]);
-    }));
-    it('should not upload files if no files passed', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it('should not upload files if no files passed', async () => {
         const mockConfig = { apis: {} };
         process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
-        yield (0, push_1.handlePush)({
-            domain: 'test-domain',
-            'mount-path': 'test-mount-path',
-            organization: 'test-org',
-            project: 'test-project',
-            branch: 'test-branch',
-            author: 'TestAuthor <test-author@mail.com>',
-            message: 'Test message',
-            'default-branch': 'main',
-            files: [],
-            'max-execution-time': 10,
-        }, mockConfig);
+        await (0, push_1.handlePush)({
+            argv: {
+                domain: 'test-domain',
+                'mount-path': 'test-mount-path',
+                organization: 'test-org',
+                project: 'test-project',
+                branch: 'test-branch',
+                author: 'TestAuthor <test-author@mail.com>',
+                message: 'Test message',
+                'default-branch': 'main',
+                files: [],
+                'max-execution-time': 10,
+            },
+            config: mockConfig,
+            version: 'cli-version',
+        });
         expect(remotes.getDefaultBranch).not.toHaveBeenCalled();
         expect(remotes.upsert).not.toHaveBeenCalled();
         expect(remotes.push).not.toHaveBeenCalled();
-    }));
-    it('should get organization from config if not passed', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it('should get organization from config if not passed', async () => {
         const mockConfig = { organization: 'test-org-from-config', apis: {} };
         process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
         fsStatSyncSpy.mockReturnValueOnce({
@@ -214,22 +224,26 @@ describe('handlePush()', () => {
         pathResolveSpy.mockImplementationOnce((p) => p);
         pathRelativeSpy.mockImplementationOnce((_, p) => p);
         pathDirnameSpy.mockImplementation((_) => '.');
-        yield (0, push_1.handlePush)({
-            domain: 'test-domain',
-            'mount-path': 'test-mount-path',
-            project: 'test-project',
-            branch: 'test-branch',
-            author: 'TestAuthor <test-author@mail.com>',
-            message: 'Test message',
-            files: ['test-file'],
-            'default-branch': 'main',
-            'max-execution-time': 10,
-        }, mockConfig);
+        await (0, push_1.handlePush)({
+            argv: {
+                domain: 'test-domain',
+                'mount-path': 'test-mount-path',
+                project: 'test-project',
+                branch: 'test-branch',
+                author: 'TestAuthor <test-author@mail.com>',
+                message: 'Test message',
+                files: ['test-file'],
+                'default-branch': 'main',
+                'max-execution-time': 10,
+            },
+            config: mockConfig,
+            version: 'cli-version',
+        });
         expect(remotes.getDefaultBranch).toHaveBeenCalledWith('test-org-from-config', expect.anything());
         expect(remotes.upsert).toHaveBeenCalledWith('test-org-from-config', expect.anything(), expect.anything());
         expect(remotes.push).toHaveBeenCalledWith('test-org-from-config', expect.anything(), expect.anything(), expect.anything());
-    }));
-    it('should get domain from env if not passed', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it('should get domain from env if not passed', async () => {
         const mockConfig = { organization: 'test-org-from-config', apis: {} };
         process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
         process.env.REDOCLY_DOMAIN = 'test-domain-from-env';
@@ -241,16 +255,20 @@ describe('handlePush()', () => {
         pathResolveSpy.mockImplementationOnce((p) => p);
         pathRelativeSpy.mockImplementationOnce((_, p) => p);
         pathDirnameSpy.mockImplementation((_) => '.');
-        yield (0, push_1.handlePush)({
-            'mount-path': 'test-mount-path',
-            project: 'test-project',
-            branch: 'test-branch',
-            'default-branch': 'main',
-            author: 'TestAuthor <test-author@mail.com>',
-            message: 'Test message',
-            files: ['test-file'],
-            'max-execution-time': 10,
-        }, mockConfig);
+        await (0, push_1.handlePush)({
+            argv: {
+                'mount-path': 'test-mount-path',
+                project: 'test-project',
+                branch: 'test-branch',
+                'default-branch': 'main',
+                author: 'TestAuthor <test-author@mail.com>',
+                message: 'Test message',
+                files: ['test-file'],
+                'max-execution-time': 10,
+            },
+            config: mockConfig,
+            version: 'cli-version',
+        });
         expect(api_1.ReuniteApiClient).toBeCalledWith('test-domain-from-env', 'test-api-key');
-    }));
+    });
 });

package/lib/cms/commands/__tests__/utils.test.js

@@ -1,43 +1,34 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("../utils");
 jest.mock('@redocly/openapi-core', () => ({
     pause: jest.requireActual('@redocly/openapi-core').pause,
 }));
 describe('retryUntilConditionMet()', () => {
-    it('should retry until condition meet and return result', () => __awaiter(void 0, void 0, void 0, function* () {
+    it('should retry until condition meet and return result', async () => {
         const operation = jest
             .fn()
             .mockResolvedValueOnce({ status: 'pending' })
             .mockResolvedValueOnce({ status: 'pending' })
             .mockResolvedValueOnce({ status: 'done' });
-        const data = yield (0, utils_1.retryUntilConditionMet)({
+        const data = await (0, utils_1.retryUntilConditionMet)({
             operation,
-            condition: (result) => (result === null || result === void 0 ? void 0 : result.status) === 'done',
+            condition: (result) => result?.status === 'done',
             retryIntervalMs: 100,
             retryTimeoutMs: 1000,
         });
         expect(data).toEqual({ status: 'done' });
-    }));
-    it('should throw error if condition not meet for desired timeout', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it('should throw error if condition not meet for desired timeout', async () => {
         const operation = jest.fn().mockResolvedValue({ status: 'pending' });
-        yield expect((0, utils_1.retryUntilConditionMet)({
+        await expect((0, utils_1.retryUntilConditionMet)({
             operation,
-            condition: (result) => (result === null || result === void 0 ? void 0 : result.status) === 'done',
+            condition: (result) => result?.status === 'done',
             retryIntervalMs: 100,
             retryTimeoutMs: 1000,
         })).rejects.toThrow('Timeout exceeded');
-    }));
-    it('should call "onConditionNotMet" and "onRetry" callbacks', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    it('should call "onConditionNotMet" and "onRetry" callbacks', async () => {
         const operation = jest
             .fn()
             .mockResolvedValueOnce({ status: 'pending' })
@@ -45,9 +36,9 @@ describe('retryUntilConditionMet()', () => {
             .mockResolvedValueOnce({ status: 'done' });
         const onConditionNotMet = jest.fn();
         const onRetry = jest.fn();
-        const data = yield (0, utils_1.retryUntilConditionMet)({
+        const data = await (0, utils_1.retryUntilConditionMet)({
             operation,
-            condition: (result) => (result === null || result === void 0 ? void 0 : result.status) === 'done',
+            condition: (result) => result?.status === 'done',
             retryIntervalMs: 100,
             retryTimeoutMs: 1000,
             onConditionNotMet,
@@ -56,5 +47,5 @@ describe('retryUntilConditionMet()', () => {
         expect(data).toEqual({ status: 'done' });
         expect(onConditionNotMet).toHaveBeenCalledTimes(2);
         expect(onRetry).toHaveBeenCalledTimes(2);
-    }));
+    });
 });

package/lib/cms/commands/push-status.d.ts

@@ -1,4 +1,5 @@
-import type { Config, OutputFormat } from '@redocly/openapi-core';
+import type { OutputFormat } from '@redocly/openapi-core';
+import type { CommandArgs } from '../../wrapper';
 import type { DeploymentStatusResponse, PushResponse } from '../api/types';
 export type PushStatusOptions = {
     organization: string;
@@ -19,4 +20,4 @@ export interface PushStatusSummary {
     production: DeploymentStatusResponse | null;
     commit: PushResponse['commit'];
 }
-export declare function handlePushStatus(argv: PushStatusOptions, config: Config): Promise<PushStatusSummary | undefined>;
+export declare function handlePushStatus({ argv, config, }: CommandArgs<PushStatusOptions>): Promise<PushStatusSummary | undefined>;

package/lib/cms/commands/push-status.js

@@ -1,15 +1,6 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.handlePushStatus = void 0;
+exports.handlePushStatus = handlePushStatus;
 const colors = require("colorette");
 const miscellaneous_1 = require("../../utils/miscellaneous");
 const spinner_1 = require("../../utils/spinner");
@@ -18,29 +9,72 @@ const api_1 = require("../api");
 const js_utils_1 = require("../../utils/js-utils");
 const utils_2 = require("./utils");
 const RETRY_INTERVAL_MS = 5000; // 5 sec
-function handlePushStatus(argv, config) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const startedAt = performance.now();
-        const spinner = new spinner_1.Spinner();
-        const { organization, project: projectId, pushId, wait } = argv;
-        const orgId = organization || config.organization;
-        if (!orgId) {
-            (0, miscellaneous_1.exitWithError)(`No organization provided, please use --organization option or specify the 'organization' field in the config file.`);
-            return;
-        }
-        const domain = argv.domain || (0, api_1.getDomain)();
-        const maxExecutionTime = argv['max-execution-time'] || 1200; // 20 min
-        const retryIntervalMs = argv['retry-interval']
-            ? argv['retry-interval'] * 1000
-            : RETRY_INTERVAL_MS;
-        const startTime = argv['start-time'] || Date.now();
-        const retryTimeoutMs = maxExecutionTime * 1000;
-        const continueOnDeployFailures = argv['continue-on-deploy-failures'] || false;
-        try {
-            const apiKey = (0, api_1.getApiKeys)(domain);
-            const client = new api_1.ReuniteApiClient(domain, apiKey);
-            let pushResponse;
-            pushResponse = yield (0, utils_2.retryUntilConditionMet)({
+async function handlePushStatus({ argv, config, }) {
+    const startedAt = performance.now();
+    const spinner = new spinner_1.Spinner();
+    const { organization, project: projectId, pushId, wait } = argv;
+    const orgId = organization || config.organization;
+    if (!orgId) {
+        (0, miscellaneous_1.exitWithError)(`No organization provided, please use --organization option or specify the 'organization' field in the config file.`);
+        return;
+    }
+    const domain = argv.domain || (0, api_1.getDomain)();
+    const maxExecutionTime = argv['max-execution-time'] || 1200; // 20 min
+    const retryIntervalMs = argv['retry-interval']
+        ? argv['retry-interval'] * 1000
+        : RETRY_INTERVAL_MS;
+    const startTime = argv['start-time'] || Date.now();
+    const retryTimeoutMs = maxExecutionTime * 1000;
+    const continueOnDeployFailures = argv['continue-on-deploy-failures'] || false;
+    try {
+        const apiKey = (0, api_1.getApiKeys)(domain);
+        const client = new api_1.ReuniteApiClient(domain, apiKey);
+        let pushResponse;
+        pushResponse = await (0, utils_2.retryUntilConditionMet)({
+            operation: () => client.remotes.getPush({
+                organizationId: orgId,
+                projectId,
+                pushId,
+            }),
+            condition: wait
+                ? // Keep retrying if status is "pending" or "running" (returning false, so the operation will be retried)
+                    (result) => !['pending', 'running'].includes(result.status['preview'].deploy.status)
+                : null,
+            onConditionNotMet: (lastResult) => {
+                displayDeploymentAndBuildStatus({
+                    status: lastResult.status['preview'].deploy.status,
+                    url: lastResult.status['preview'].deploy.url,
+                    spinner,
+                    buildType: 'preview',
+                    continueOnDeployFailures,
+                    wait,
+                });
+            },
+            onRetry: (lastResult) => {
+                if (argv.onRetry) {
+                    argv.onRetry({
+                        preview: lastResult.status.preview,
+                        production: lastResult.isMainBranch ? lastResult.status.production : null,
+                        commit: lastResult.commit,
+                    });
+                }
+            },
+            startTime,
+            retryTimeoutMs,
+            retryIntervalMs,
+        });
+        printPushStatus({
+            buildType: 'preview',
+            spinner,
+            wait,
+            push: pushResponse,
+            continueOnDeployFailures,
+        });
+        printScorecard(pushResponse.status.preview.scorecard);
+        const shouldWaitForProdDeployment = pushResponse.isMainBranch &&
+            (wait ? pushResponse.status.preview.deploy.status === 'success' : true);
+        if (shouldWaitForProdDeployment) {
+            pushResponse = await (0, utils_2.retryUntilConditionMet)({
                 operation: () => client.remotes.getPush({
                     organizationId: orgId,
                     projectId,
@@ -48,14 +82,14 @@ function handlePushStatus(argv, config) {
                 }),
                 condition: wait
                     ? // Keep retrying if status is "pending" or "running" (returning false, so the operation will be retried)
-                        (result) => !['pending', 'running'].includes(result.status['preview'].deploy.status)
+                        (result) => !['pending', 'running'].includes(result.status['production'].deploy.status)
                     : null,
                 onConditionNotMet: (lastResult) => {
                     displayDeploymentAndBuildStatus({
-                        status: lastResult.status['preview'].deploy.status,
-                        url: lastResult.status['preview'].deploy.url,
+                        status: lastResult.status['production'].deploy.status,
+                        url: lastResult.status['production'].deploy.url,
                         spinner,
-                        buildType: 'preview',
+                        buildType: 'production',
                         continueOnDeployFailures,
                         wait,
                     });
@@ -73,83 +107,37 @@ function handlePushStatus(argv, config) {
                 retryTimeoutMs,
                 retryIntervalMs,
             });
+        }
+        if (pushResponse.isMainBranch) {
             printPushStatus({
-                buildType: 'preview',
+                buildType: 'production',
                 spinner,
                 wait,
                 push: pushResponse,
                 continueOnDeployFailures,
             });
-            printScorecard(pushResponse.status.preview.scorecard);
-            const shouldWaitForProdDeployment = pushResponse.isMainBranch &&
-                (wait ? pushResponse.status.preview.deploy.status === 'success' : true);
-            if (shouldWaitForProdDeployment) {
-                pushResponse = yield (0, utils_2.retryUntilConditionMet)({
-                    operation: () => client.remotes.getPush({
-                        organizationId: orgId,
-                        projectId,
-                        pushId,
-                    }),
-                    condition: wait
-                        ? // Keep retrying if status is "pending" or "running" (returning false, so the operation will be retried)
-                            (result) => !['pending', 'running'].includes(result.status['production'].deploy.status)
-                        : null,
-                    onConditionNotMet: (lastResult) => {
-                        displayDeploymentAndBuildStatus({
-                            status: lastResult.status['production'].deploy.status,
-                            url: lastResult.status['production'].deploy.url,
-                            spinner,
-                            buildType: 'production',
-                            continueOnDeployFailures,
-                            wait,
-                        });
-                    },
-                    onRetry: (lastResult) => {
-                        if (argv.onRetry) {
-                            argv.onRetry({
-                                preview: lastResult.status.preview,
-                                production: lastResult.isMainBranch ? lastResult.status.production : null,
-                                commit: lastResult.commit,
-                            });
-                        }
-                    },
-                    startTime,
-                    retryTimeoutMs,
-                    retryIntervalMs,
-                });
-            }
-            if (pushResponse.isMainBranch) {
-                printPushStatus({
-                    buildType: 'production',
-                    spinner,
-                    wait,
-                    push: pushResponse,
-                    continueOnDeployFailures,
-                });
-                printScorecard(pushResponse.status.production.scorecard);
-            }
-            printPushStatusInfo({ orgId, projectId, pushId, startedAt });
-            const summary = {
-                preview: pushResponse.status.preview,
-                production: pushResponse.isMainBranch ? pushResponse.status.production : null,
-                commit: pushResponse.commit,
-            };
-            return summary;
-        }
-        catch (err) {
-            spinner.stop(); // Spinner can block process exit, so we need to stop it explicitly.
-            const message = err instanceof utils_1.DeploymentError
-                ? err.message
-                : `✗ Failed to get push status. Reason: ${err.message}\n`;
-            (0, miscellaneous_1.exitWithError)(message);
-            return;
+            printScorecard(pushResponse.status.production.scorecard);
         }
-        finally {
-            spinner.stop(); // Spinner can block process exit, so we need to stop it explicitly.
-        }
-    });
+        printPushStatusInfo({ orgId, projectId, pushId, startedAt });
+        const summary = {
+            preview: pushResponse.status.preview,
+            production: pushResponse.isMainBranch ? pushResponse.status.production : null,
+            commit: pushResponse.commit,
+        };
+        return summary;
+    }
+    catch (err) {
+        spinner.stop(); // Spinner can block process exit, so we need to stop it explicitly.
+        const message = err instanceof utils_1.DeploymentError
+            ? err.message
+            : `✗ Failed to get push status. Reason: ${err.message}\n`;
+        (0, miscellaneous_1.exitWithError)(message);
+        return;
+    }
+    finally {
+        spinner.stop(); // Spinner can block process exit, so we need to stop it explicitly.
+    }
 }
-exports.handlePushStatus = handlePushStatus;
 function printPushStatusInfo({ orgId, projectId, pushId, startedAt, }) {
     process.stderr.write(`\nProcessed push-status for ${colors.yellow(orgId)}, ${colors.yellow(projectId)} and pushID ${colors.yellow(pushId)}.\n`);
     (0, miscellaneous_1.printExecutionTime)('push-status', startedAt, 'Finished');

package/lib/cms/commands/push.d.ts

@@ -1,4 +1,5 @@
-import type { OutputFormat, Config } from '@redocly/openapi-core';
+import type { OutputFormat } from '@redocly/openapi-core';
+import type { CommandArgs } from '../../wrapper';
 export type PushOptions = {
     apis?: string[];
     organization?: string;
@@ -22,6 +23,6 @@ export type PushOptions = {
     verbose?: boolean;
     format?: Extract<OutputFormat, 'stylish'>;
 };
-export declare function handlePush(argv: PushOptions, config: Config): Promise<{
+export declare function handlePush({ argv, config, version, }: CommandArgs<PushOptions>): Promise<{
     pushId: string;
 } | void>;