@redocly/cli 0.0.0-snapshot.1737554067

package/lib/cms/api/__tests__/api-keys.test.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const api_keys_1 = require("../api-keys");
+const fs = require("fs");
+describe('getApiKeys()', () => {
+    afterEach(() => {
+        jest.resetAllMocks();
+    });
+    it('should return api key from environment variable', () => {
+        process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
+        expect((0, api_keys_1.getApiKeys)('test-domain')).toEqual('test-api-key');
+    });
+    it('should return api key from credentials file', () => {
+        process.env.REDOCLY_AUTHORIZATION = '';
+        jest.spyOn(fs, 'existsSync').mockReturnValue(true);
+        jest.spyOn(fs, 'readFileSync').mockReturnValue(JSON.stringify({
+            ['test-domain']: 'test-api-key-from-credentials-file',
+        }));
+        expect((0, api_keys_1.getApiKeys)('test-domain')).toEqual('test-api-key-from-credentials-file');
+    });
+    it('should throw an error if no api key provided', () => {
+        process.env.REDOCLY_AUTHORIZATION = '';
+        jest.spyOn(fs, 'existsSync').mockReturnValue(false);
+        expect(() => (0, api_keys_1.getApiKeys)('test-domain')).toThrowError('No api key provided, please use environment variable REDOCLY_AUTHORIZATION.');
+    });
+});

package/lib/cms/api/__tests__/api.client.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/cms/api/__tests__/api.client.test.js

@@ -0,0 +1,333 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fetch_1 = require("node-fetch");
+const FormData = require("form-data");
+const colorette_1 = require("colorette");
+const api_client_1 = require("../api-client");
+jest.mock('node-fetch', () => ({
+    default: jest.fn(),
+}));
+function mockFetchResponse(response) {
+    node_fetch_1.default.mockResolvedValue(response);
+}
+describe('ApiClient', () => {
+    const testToken = 'test-token';
+    const testDomain = 'test-domain.com';
+    const testOrg = 'test-org';
+    const testProject = 'test-project';
+    const version = '1.0.0';
+    const command = 'push';
+    const expectedUserAgent = `redocly-cli/${version} ${command}`;
+    describe('getDefaultBranch()', () => {
+        let apiClient;
+        beforeEach(() => {
+            apiClient = new api_client_1.ReuniteApi({ domain: testDomain, apiKey: testToken, version, command });
+        });
+        it('should get default project branch', async () => {
+            mockFetchResponse({
+                ok: true,
+                json: jest.fn().mockResolvedValue({
+                    branchName: 'test-branch',
+                }),
+            });
+            const result = await apiClient.remotes.getDefaultBranch(testOrg, testProject);
+            expect(node_fetch_1.default).toHaveBeenCalledWith(`${testDomain}/api/orgs/${testOrg}/projects/${testProject}/source`, {
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${testToken}`,
+                    'user-agent': expectedUserAgent,
+                },
+                signal: expect.any(Object),
+            });
+            expect(result).toEqual('test-branch');
+        });
+        it('should throw parsed error if response is not ok', async () => {
+            mockFetchResponse({
+                ok: false,
+                json: jest.fn().mockResolvedValue({
+                    type: 'about:blank',
+                    title: 'Project source not found',
+                    status: 404,
+                    detail: 'Not Found',
+                    object: 'problem',
+                }),
+            });
+            await expect(apiClient.remotes.getDefaultBranch(testOrg, testProject)).rejects.toThrow(new api_client_1.ReuniteApiError('Failed to fetch default branch. Project source not found.', 404));
+        });
+        it('should throw statusText error if response is not ok', async () => {
+            mockFetchResponse({
+                ok: false,
+                statusText: 'Not found',
+                json: jest.fn().mockResolvedValue({
+                    unknownField: 'unknown-error',
+                }),
+            });
+            await expect(apiClient.remotes.getDefaultBranch(testOrg, testProject)).rejects.toThrow(new api_client_1.ReuniteApiError('Failed to fetch default branch. Not found.', 404));
+        });
+    });
+    describe('upsert()', () => {
+        const remotePayload = {
+            mountBranchName: 'remote-mount-branch-name',
+            mountPath: 'remote-mount-path',
+        };
+        const responseMock = {
+            id: 'remote-id',
+            type: 'CICD',
+            mountPath: 'remote-mount-path',
+            mountBranchName: 'remote-mount-branch-name',
+            organizationId: testOrg,
+            projectId: testProject,
+        };
+        let apiClient;
+        beforeEach(() => {
+            apiClient = new api_client_1.ReuniteApi({ domain: testDomain, apiKey: testToken, version, command });
+        });
+        it('should upsert remote', async () => {
+            mockFetchResponse({
+                ok: true,
+                json: jest.fn().mockResolvedValue(responseMock),
+            });
+            const result = await apiClient.remotes.upsert(testOrg, testProject, remotePayload);
+            expect(node_fetch_1.default).toHaveBeenCalledWith(`${testDomain}/api/orgs/${testOrg}/projects/${testProject}/remotes`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${testToken}`,
+                    'user-agent': expectedUserAgent,
+                },
+                body: JSON.stringify({
+                    mountPath: remotePayload.mountPath,
+                    mountBranchName: remotePayload.mountBranchName,
+                    type: 'CICD',
+                    autoMerge: true,
+                }),
+                signal: expect.any(Object),
+                agent: undefined,
+            });
+            expect(result).toEqual(responseMock);
+        });
+        it('should throw parsed error if response is not ok', async () => {
+            mockFetchResponse({
+                ok: false,
+                json: jest.fn().mockResolvedValue({
+                    type: 'about:blank',
+                    title: 'Not allowed to mount remote outside of project content path: /docs',
+                    status: 403,
+                    detail: 'Forbidden',
+                    object: 'problem',
+                }),
+            });
+            await expect(apiClient.remotes.upsert(testOrg, testProject, remotePayload)).rejects.toThrow(new api_client_1.ReuniteApiError('Failed to upsert remote. Not allowed to mount remote outside of project content path: /docs.', 403));
+        });
+        it('should throw statusText error if response is not ok', async () => {
+            mockFetchResponse({
+                ok: false,
+                status: 404,
+                statusText: 'Not found',
+                json: jest.fn().mockResolvedValue({
+                    unknownField: 'unknown-error',
+                }),
+            });
+            await expect(apiClient.remotes.upsert(testOrg, testProject, remotePayload)).rejects.toThrow(new api_client_1.ReuniteApiError('Failed to upsert remote. Not found.', 404));
+        });
+    });
+    describe('push()', () => {
+        const testRemoteId = 'test-remote-id';
+        const pushPayload = {
+            remoteId: testRemoteId,
+            commit: {
+                message: 'test-message',
+                author: {
+                    name: 'test-name',
+                    email: 'test-email',
+                },
+                branchName: 'test-branch-name',
+            },
+        };
+        const filesMock = [{ path: 'some-file.yaml', stream: Buffer.from('fefef') }];
+        const responseMock = {
+            branchName: 'rem/cicd/rem_01he7sr6ys2agb7w0g9t7978fn-main',
+            hasChanges: true,
+            files: [
+                {
+                    type: 'file',
+                    name: 'some-file.yaml',
+                    path: 'docs/remotes/some-file.yaml',
+                    lastModified: 1698925132394.2993,
+                    mimeType: 'text/yaml',
+                },
+            ],
+            commitSha: 'bb23a2f8e012ac0b7b9961b57fb40d8686b21b43',
+            outdated: false,
+        };
+        let apiClient;
+        beforeEach(() => {
+            apiClient = new api_client_1.ReuniteApi({ domain: testDomain, apiKey: testToken, version, command });
+        });
+        it('should push to remote', async () => {
+            let passedFormData = new FormData();
+            node_fetch_1.default.mockImplementationOnce(async (_, options) => {
+                passedFormData = options.body;
+                return {
+                    ok: true,
+                    json: jest.fn().mockResolvedValue(responseMock),
+                };
+            });
+            const formData = new FormData();
+            formData.append('remoteId', testRemoteId);
+            formData.append('commit[message]', pushPayload.commit.message);
+            formData.append('commit[author][name]', pushPayload.commit.author.name);
+            formData.append('commit[author][email]', pushPayload.commit.author.email);
+            formData.append('commit[branchName]', pushPayload.commit.branchName);
+            formData.append('files[some-file.yaml]', filesMock[0].stream);
+            const result = await apiClient.remotes.push(testOrg, testProject, pushPayload, filesMock);
+            expect(node_fetch_1.default).toHaveBeenCalledWith(`${testDomain}/api/orgs/${testOrg}/projects/${testProject}/pushes`, expect.objectContaining({
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${testToken}`,
+                    'user-agent': expectedUserAgent,
+                },
+            }));
+            expect(JSON.stringify(passedFormData).replace(new RegExp(passedFormData.getBoundary(), 'g'), '')).toEqual(JSON.stringify(formData).replace(new RegExp(formData.getBoundary(), 'g'), ''));
+            expect(result).toEqual(responseMock);
+        });
+        it('should throw parsed error if response is not ok', async () => {
+            mockFetchResponse({
+                ok: false,
+                json: jest.fn().mockResolvedValue({
+                    type: 'about:blank',
+                    title: 'Cannot push to remote',
+                    status: 403,
+                    detail: 'Forbidden',
+                    object: 'problem',
+                }),
+            });
+            await expect(apiClient.remotes.push(testOrg, testProject, pushPayload, filesMock)).rejects.toThrow(new api_client_1.ReuniteApiError('Failed to push. Cannot push to remote.', 403));
+        });
+        it('should throw statusText error if response is not ok', async () => {
+            mockFetchResponse({
+                ok: false,
+                status: 404,
+                statusText: 'Not found',
+                json: jest.fn().mockResolvedValue({
+                    unknownField: 'unknown-error',
+                }),
+            });
+            await expect(apiClient.remotes.push(testOrg, testProject, pushPayload, filesMock)).rejects.toThrow(new api_client_1.ReuniteApiError('Failed to push. Not found.', 404));
+        });
+    });
+    describe('Sunset header', () => {
+        const upsertRemoteMock = {
+            requestFn: () => apiClient.remotes.upsert(testOrg, testProject, {
+                mountBranchName: 'remote-mount-branch-name',
+                mountPath: 'remote-mount-path',
+            }),
+            responseBody: {
+                id: 'remote-id',
+                type: 'CICD',
+                mountPath: 'remote-mount-path',
+                mountBranchName: 'remote-mount-branch-name',
+                organizationId: testOrg,
+                projectId: testProject,
+            },
+        };
+        const getDefaultBranchMock = {
+            requestFn: () => apiClient.remotes.getDefaultBranch(testOrg, testProject),
+            responseBody: {
+                branchName: 'test-branch',
+            },
+        };
+        const pushMock = {
+            requestFn: () => apiClient.remotes.push(testOrg, testProject, {
+                remoteId: 'test-remote-id',
+                commit: {
+                    message: 'test-message',
+                    author: {
+                        name: 'test-name',
+                        email: 'test-email',
+                    },
+                    branchName: 'test-branch-name',
+                },
+            }, [{ path: 'some-file.yaml', stream: Buffer.from('text content') }]),
+            responseBody: {
+                branchName: 'rem/cicd/rem_01he7sr6ys2agb7w0g9t7978fn-main',
+                hasChanges: true,
+                files: [
+                    {
+                        type: 'file',
+                        name: 'some-file.yaml',
+                        path: 'docs/remotes/some-file.yaml',
+                        lastModified: 1698925132394.2993,
+                        mimeType: 'text/yaml',
+                    },
+                ],
+                commitSha: 'bb23a2f8e012ac0b7b9961b57fb40d8686b21b43',
+                outdated: false,
+            },
+        };
+        const endpointMocks = [upsertRemoteMock, getDefaultBranchMock, pushMock];
+        let apiClient;
+        beforeEach(() => {
+            apiClient = new api_client_1.ReuniteApi({ domain: testDomain, apiKey: testToken, version, command });
+        });
+        it.each(endpointMocks)('should report endpoint sunset in the past', async ({ responseBody, requestFn }) => {
+            jest.spyOn(process.stdout, 'write').mockImplementationOnce(() => true);
+            const sunsetDate = new Date('2024-09-06T12:30:32.456Z');
+            mockFetchResponse({
+                ok: true,
+                json: jest.fn().mockResolvedValue(responseBody),
+                headers: new Headers({
+                    Sunset: sunsetDate.toISOString(),
+                }),
+            });
+            await requestFn();
+            apiClient.reportSunsetWarnings();
+            expect(process.stdout.write).toHaveBeenCalledWith((0, colorette_1.red)(`The "push" command is not compatible with your version of Redocly CLI. Update to the latest version by running "npm install @redocly/cli@latest".\n\n`));
+        });
+        it.each(endpointMocks)('should report endpoint sunset in the future', async ({ responseBody, requestFn }) => {
+            jest.spyOn(process.stdout, 'write').mockImplementationOnce(() => true);
+            const sunsetDate = new Date(Date.now() + 1000 * 60 * 60 * 24);
+            mockFetchResponse({
+                ok: true,
+                json: jest.fn().mockResolvedValue(responseBody),
+                headers: new Headers({
+                    Sunset: sunsetDate.toISOString(),
+                }),
+            });
+            await requestFn();
+            apiClient.reportSunsetWarnings();
+            expect(process.stdout.write).toHaveBeenCalledWith((0, colorette_1.yellow)(`The "push" command will be incompatible with your version of Redocly CLI after ${sunsetDate.toLocaleString()}. Update to the latest version by running "npm install @redocly/cli@latest".\n\n`));
+        });
+        it('should report only expired resource', async () => {
+            jest.spyOn(process.stdout, 'write').mockImplementationOnce(() => true);
+            mockFetchResponse({
+                ok: true,
+                json: jest.fn().mockResolvedValue(upsertRemoteMock.responseBody),
+                headers: new Headers({
+                    Sunset: new Date('2024-08-06T12:30:32.456Z').toISOString(),
+                }),
+            });
+            await upsertRemoteMock.requestFn();
+            mockFetchResponse({
+                ok: true,
+                json: jest.fn().mockResolvedValue(getDefaultBranchMock.responseBody),
+                headers: new Headers({
+                    Sunset: new Date(Date.now() + 1000 * 60 * 60 * 24).toISOString(),
+                }),
+            });
+            await getDefaultBranchMock.requestFn();
+            mockFetchResponse({
+                ok: true,
+                json: jest.fn().mockResolvedValue(pushMock.responseBody),
+                headers: new Headers({
+                    Sunset: new Date('2024-08-06T12:30:32.456Z').toISOString(),
+                }),
+            });
+            await pushMock.requestFn();
+            apiClient.reportSunsetWarnings();
+            expect(process.stdout.write).toHaveBeenCalledTimes(1);
+            expect(process.stdout.write).toHaveBeenCalledWith((0, colorette_1.red)(`The "push" command is not compatible with your version of Redocly CLI. Update to the latest version by running "npm install @redocly/cli@latest".\n\n`));
+        });
+    });
+});

package/lib/cms/api/__tests__/domains.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/cms/api/__tests__/domains.test.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const domains_1 = require("../domains");
+describe('getDomain()', () => {
+    it('should return the domain from environment variable', () => {
+        process.env.REDOCLY_DOMAIN = 'test-domain';
+        expect((0, domains_1.getDomain)()).toBe('test-domain');
+    });
+    it('should return the default domain if no domain provided', () => {
+        process.env.REDOCLY_DOMAIN = '';
+        expect((0, domains_1.getDomain)()).toBe('https://app.cloud.redocly.com');
+    });
+});

package/lib/cms/api/api-client.d.ts

@@ -0,0 +1,75 @@
+import { type FetchWithTimeoutOptions } from '../../utils/fetch-with-timeout';
+import type { Response } from 'node-fetch';
+import type { ReadStream } from 'fs';
+import type { ListRemotesResponse, PushResponse, UpsertRemoteResponse } from './types';
+interface BaseApiClient {
+    request(url: string, options: FetchWithTimeoutOptions): Promise<Response>;
+}
+type CommandOption = 'push' | 'push-status';
+export type SunsetWarning = {
+    sunsetDate: Date;
+    isSunsetExpired: boolean;
+};
+export type SunsetWarningsBuffer = SunsetWarning[];
+export declare class ReuniteApiError extends Error {
+    status: number;
+    constructor(message: string, status: number);
+}
+declare class RemotesApi {
+    private client;
+    private readonly domain;
+    private readonly apiKey;
+    constructor(client: BaseApiClient, domain: string, apiKey: string);
+    protected getParsedResponse<T>(response: Response): Promise<T>;
+    getDefaultBranch(organizationId: string, projectId: string): Promise<string>;
+    upsert(organizationId: string, projectId: string, remote: {
+        mountPath: string;
+        mountBranchName: string;
+    }): Promise<UpsertRemoteResponse>;
+    push(organizationId: string, projectId: string, payload: PushPayload, files: {
+        path: string;
+        stream: ReadStream | Buffer;
+    }[]): Promise<PushResponse>;
+    getRemotesList({ organizationId, projectId, mountPath, }: {
+        organizationId: string;
+        projectId: string;
+        mountPath: string;
+    }): Promise<ListRemotesResponse>;
+    getPush({ organizationId, projectId, pushId, }: {
+        organizationId: string;
+        projectId: string;
+        pushId: string;
+    }): Promise<PushResponse>;
+}
+export declare class ReuniteApi {
+    private apiClient;
+    private version;
+    private command;
+    remotes: RemotesApi;
+    constructor({ domain, apiKey, version, command, }: {
+        domain: string;
+        apiKey: string;
+        version: string;
+        command: CommandOption;
+    });
+    reportSunsetWarnings(): void;
+}
+export type PushPayload = {
+    remoteId: string;
+    commit: {
+        message: string;
+        branchName: string;
+        sha?: string;
+        url?: string;
+        createdAt?: string;
+        namespace?: string;
+        repository?: string;
+        author: {
+            name: string;
+            email: string;
+            image?: string;
+        };
+    };
+    isMainBranch?: boolean;
+};
+export {};

package/lib/cms/api/api-client.js

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReuniteApi = exports.ReuniteApiError = void 0;
+const colorette_1 = require("colorette");
+const FormData = require("form-data");
+const fetch_with_timeout_1 = require("../../utils/fetch-with-timeout");
+class ReuniteApiError extends Error {
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+    }
+}
+exports.ReuniteApiError = ReuniteApiError;
+class ReuniteApiClient {
+    constructor(version, command) {
+        this.version = version;
+        this.command = command;
+        this.sunsetWarnings = [];
+    }
+    async request(url, options) {
+        const headers = {
+            ...options.headers,
+            'user-agent': `redocly-cli/${this.version.trim()} ${this.command}`,
+        };
+        const response = await (0, fetch_with_timeout_1.default)(url, {
+            ...options,
+            headers,
+        });
+        this.collectSunsetWarning(response);
+        return response;
+    }
+    collectSunsetWarning(response) {
+        const sunsetTime = this.getSunsetDate(response);
+        if (!sunsetTime)
+            return;
+        const sunsetDate = new Date(sunsetTime);
+        if (sunsetTime > Date.now()) {
+            this.sunsetWarnings.push({
+                sunsetDate,
+                isSunsetExpired: false,
+            });
+        }
+        else {
+            this.sunsetWarnings.push({
+                sunsetDate,
+                isSunsetExpired: true,
+            });
+        }
+    }
+    getSunsetDate(response) {
+        const { headers } = response;
+        if (!headers) {
+            return;
+        }
+        const sunsetDate = headers.get('sunset') || headers.get('Sunset');
+        if (!sunsetDate) {
+            return;
+        }
+        return Date.parse(sunsetDate);
+    }
+}
+class RemotesApi {
+    constructor(client, domain, apiKey) {
+        this.client = client;
+        this.domain = domain;
+        this.apiKey = apiKey;
+    }
+    async getParsedResponse(response) {
+        const responseBody = await response.json();
+        if (response.ok) {
+            return responseBody;
+        }
+        throw new ReuniteApiError(`${responseBody.title || response.statusText || 'Unknown error'}.`, response.status);
+    }
+    async getDefaultBranch(organizationId, projectId) {
+        try {
+            const response = await this.client.request(`${this.domain}/api/orgs/${organizationId}/projects/${projectId}/source`, {
+                timeout: fetch_with_timeout_1.DEFAULT_FETCH_TIMEOUT,
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${this.apiKey}`,
+                },
+            });
+            const source = await this.getParsedResponse(response);
+            return source.branchName;
+        }
+        catch (err) {
+            const message = `Failed to fetch default branch. ${err.message}`;
+            if (err instanceof ReuniteApiError) {
+                throw new ReuniteApiError(message, err.status);
+            }
+            throw new Error(message);
+        }
+    }
+    async upsert(organizationId, projectId, remote) {
+        try {
+            const response = await this.client.request(`${this.domain}/api/orgs/${organizationId}/projects/${projectId}/remotes`, {
+                timeout: fetch_with_timeout_1.DEFAULT_FETCH_TIMEOUT,
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${this.apiKey}`,
+                },
+                body: JSON.stringify({
+                    mountPath: remote.mountPath,
+                    mountBranchName: remote.mountBranchName,
+                    type: 'CICD',
+                    autoMerge: true,
+                }),
+            });
+            return await this.getParsedResponse(response);
+        }
+        catch (err) {
+            const message = `Failed to upsert remote. ${err.message}`;
+            if (err instanceof ReuniteApiError) {
+                throw new ReuniteApiError(message, err.status);
+            }
+            throw new Error(message);
+        }
+    }
+    async push(organizationId, projectId, payload, files) {
+        const formData = new FormData();
+        formData.append('remoteId', payload.remoteId);
+        formData.append('commit[message]', payload.commit.message);
+        formData.append('commit[author][name]', payload.commit.author.name);
+        formData.append('commit[author][email]', payload.commit.author.email);
+        formData.append('commit[branchName]', payload.commit.branchName);
+        payload.commit.url && formData.append('commit[url]', payload.commit.url);
+        payload.commit.namespace && formData.append('commit[namespaceId]', payload.commit.namespace);
+        payload.commit.sha && formData.append('commit[sha]', payload.commit.sha);
+        payload.commit.repository && formData.append('commit[repositoryId]', payload.commit.repository);
+        payload.commit.createdAt && formData.append('commit[createdAt]', payload.commit.createdAt);
+        for (const file of files) {
+            formData.append(`files[${file.path}]`, file.stream);
+        }
+        payload.isMainBranch && formData.append('isMainBranch', 'true');
+        try {
+            const response = await this.client.request(`${this.domain}/api/orgs/${organizationId}/projects/${projectId}/pushes`, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${this.apiKey}`,
+                },
+                body: formData,
+            });
+            return await this.getParsedResponse(response);
+        }
+        catch (err) {
+            const message = `Failed to push. ${err.message}`;
+            if (err instanceof ReuniteApiError) {
+                throw new ReuniteApiError(message, err.status);
+            }
+            throw new Error(message);
+        }
+    }
+    async getRemotesList({ organizationId, projectId, mountPath, }) {
+        try {
+            const response = await this.client.request(`${this.domain}/api/orgs/${organizationId}/projects/${projectId}/remotes?filter=mountPath:/${mountPath}/`, {
+                timeout: fetch_with_timeout_1.DEFAULT_FETCH_TIMEOUT,
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${this.apiKey}`,
+                },
+            });
+            return await this.getParsedResponse(response);
+        }
+        catch (err) {
+            const message = `Failed to get remote list. ${err.message}`;
+            if (err instanceof ReuniteApiError) {
+                throw new ReuniteApiError(message, err.status);
+            }
+            throw new Error(message);
+        }
+    }
+    async getPush({ organizationId, projectId, pushId, }) {
+        try {
+            const response = await this.client.request(`${this.domain}/api/orgs/${organizationId}/projects/${projectId}/pushes/${pushId}`, {
+                timeout: fetch_with_timeout_1.DEFAULT_FETCH_TIMEOUT,
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${this.apiKey}`,
+                },
+            });
+            return await this.getParsedResponse(response);
+        }
+        catch (err) {
+            const message = `Failed to get push status. ${err.message}`;
+            if (err instanceof ReuniteApiError) {
+                throw new ReuniteApiError(message, err.status);
+            }
+            throw new Error(message);
+        }
+    }
+}
+class ReuniteApi {
+    constructor({ domain, apiKey, version, command, }) {
+        this.command = command;
+        this.version = version;
+        this.apiClient = new ReuniteApiClient(this.version, this.command);
+        this.remotes = new RemotesApi(this.apiClient, domain, apiKey);
+    }
+    reportSunsetWarnings() {
+        const sunsetWarnings = this.apiClient.sunsetWarnings;
+        if (sunsetWarnings.length) {
+            const [{ isSunsetExpired, sunsetDate }] = sunsetWarnings.sort((a, b) => {
+                // First, prioritize by expiration status
+                if (a.isSunsetExpired !== b.isSunsetExpired) {
+                    return a.isSunsetExpired ? -1 : 1;
+                }
+                // If both are either expired or not, sort by sunset date
+                return a.sunsetDate > b.sunsetDate ? 1 : -1;
+            });
+            const updateVersionMessage = `Update to the latest version by running "npm install @redocly/cli@latest".`;
+            if (isSunsetExpired) {
+                process.stdout.write((0, colorette_1.red)(`The "${this.command}" command is not compatible with your version of Redocly CLI. ${updateVersionMessage}\n\n`));
+            }
+            else {
+                process.stdout.write((0, colorette_1.yellow)(`The "${this.command}" command will be incompatible with your version of Redocly CLI after ${sunsetDate.toLocaleString()}. ${updateVersionMessage}\n\n`));
+            }
+        }
+    }
+}
+exports.ReuniteApi = ReuniteApi;

package/lib/cms/api/api-keys.d.ts

@@ -0,0 +1 @@
+export declare function getApiKeys(domain: string): any;