@redocly/cli 1.28.5 → 1.30.0

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # @redocly/cli
 
+## 1.30.0
+
+### Minor Changes
+
+- Added [OAuth 2.0 Device authorization flow](https://datatracker.ietf.org/doc/html/rfc8628) that enables users to authenticate through Reunite API.
+
+### Patch Changes
+
+- Updated `operation-tag-defined` built-in rule to verify tags are defined on the operation prior to matching them to a global tag.
+- Updated @redocly/openapi-core to v1.30.0.
+
+## 1.29.0
+
+### Minor Changes
+
+- Added typings and interfaces for Overlay Specification v1.0.0.
+
+### Patch Changes
+
+- Fixed a problem where the `split` command produced backslashes instead of forward slashes in `$ref`s on Windows.
+- Fixed an issue where the `no-invalid-media-type-examples` rule crashed instead of reporting an error when it failed to resolve an example from a $ref.
+- Updated @redocly/openapi-core to v1.29.0.
+
 ## 1.28.5
 
 ### Patch Changes

package/lib/__tests__/commands/push-region.test.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const openapi_core_1 = require("@redocly/openapi-core");
 const push_1 = require("../../commands/push");
-const login_1 = require("../../commands/login");
+const auth_1 = require("../../commands/auth");
 const config_1 = require("../fixtures/config");
 const node_stream_1 = require("node:stream");
 // Mock fs operations
@@ -22,9 +22,9 @@ jest.mock('fs', () => ({
 openapi_core_1.getMergedConfig.mockImplementation((config) => config);
 // Mock OpenAPI core
 jest.mock('@redocly/openapi-core');
-jest.mock('../../commands/login');
+jest.mock('../../commands/auth');
 jest.mock('../../utils/miscellaneous');
-const mockPromptClientToken = login_1.promptClientToken;
+const mockPromptClientToken = auth_1.promptClientToken;
 describe('push-with-region', () => {
     const redoclyClient = require('@redocly/openapi-core').__redoclyClient;
     redoclyClient.isAuthorizedWithRedoclyByRegion = jest.fn().mockResolvedValue(false);

package/lib/__tests__/utils.test.js

@@ -409,6 +409,7 @@ describe('checkIfRulesetExist', () => {
             async2: {},
             async3: {},
             arazzo1: {},
+            overlay1: {},
         };
         expect(() => (0, miscellaneous_1.checkIfRulesetExist)(rules)).toThrowError('⚠️ No rules were configured. Learn how to configure rules: https://redocly.com/docs/cli/rules/');
     });

package/lib/auth/__tests__/device-flow.test.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const device_flow_1 = require("../device-flow");
+jest.mock('child_process');
+describe('RedoclyOAuthDeviceFlow', () => {
+    const mockBaseUrl = 'https://test.redocly.com';
+    const mockClientName = 'test-client';
+    const mockVersion = '1.0.0';
+    let flow;
+    beforeEach(() => {
+        flow = new device_flow_1.RedoclyOAuthDeviceFlow(mockBaseUrl, mockClientName, mockVersion);
+        jest.resetAllMocks();
+    });
+    describe('verifyToken', () => {
+        it('returns true for valid token', async () => {
+            jest.spyOn(flow['apiClient'], 'request').mockResolvedValue({
+                json: () => Promise.resolve({ user: { id: '123' } }),
+            });
+            const result = await flow.verifyToken('valid-token');
+            expect(result).toBe(true);
+        });
+        it('returns false for invalid token', async () => {
+            jest.spyOn(flow['apiClient'], 'request').mockRejectedValue(new Error('Invalid token'));
+            const result = await flow.verifyToken('invalid-token');
+            expect(result).toBe(false);
+        });
+    });
+    describe('verifyApiKey', () => {
+        it('returns true for valid API key', async () => {
+            jest.spyOn(flow['apiClient'], 'request').mockResolvedValue({
+                json: () => Promise.resolve({ success: true }),
+            });
+            const result = await flow.verifyApiKey('valid-key');
+            expect(result).toBe(true);
+        });
+        it('returns false for invalid API key', async () => {
+            jest.spyOn(flow['apiClient'], 'request').mockRejectedValue(new Error('Invalid API key'));
+            const result = await flow.verifyApiKey('invalid-key');
+            expect(result).toBe(false);
+        });
+    });
+    describe('refreshToken', () => {
+        it('successfully refreshes token', async () => {
+            const mockResponse = {
+                access_token: 'new-token',
+                refresh_token: 'new-refresh',
+                expires_in: 3600,
+            };
+            jest.spyOn(flow['apiClient'], 'request').mockResolvedValue({
+                json: () => Promise.resolve(mockResponse),
+            });
+            const result = await flow.refreshToken('old-refresh-token');
+            expect(result).toEqual(mockResponse);
+        });
+        it('throws error when refresh fails', async () => {
+            jest.spyOn(flow['apiClient'], 'request').mockResolvedValue({
+                json: () => Promise.resolve({}),
+            });
+            await expect(flow.refreshToken('invalid-refresh')).rejects.toThrow('Failed to refresh token');
+        });
+    });
+});

package/lib/auth/__tests__/oauth-client.test.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const oauth_client_1 = require("../oauth-client");
+const device_flow_1 = require("../device-flow");
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+jest.mock('node:fs');
+jest.mock('node:os');
+jest.mock('../device-flow');
+describe('RedoclyOAuthClient', () => {
+    const mockClientName = 'test-client';
+    const mockVersion = '1.0.0';
+    const mockBaseUrl = 'https://test.redocly.com';
+    const mockHomeDir = '/mock/home/dir';
+    const mockRedoclyDir = path.join(mockHomeDir, '.redocly');
+    let client;
+    beforeEach(() => {
+        jest.resetAllMocks();
+        os.homedir.mockReturnValue(mockHomeDir);
+        process.env.HOME = mockHomeDir;
+        client = new oauth_client_1.RedoclyOAuthClient(mockClientName, mockVersion);
+    });
+    describe('login', () => {
+        it('successfully logs in and saves token', async () => {
+            const mockToken = { access_token: 'test-token' };
+            const mockDeviceFlow = {
+                run: jest.fn().mockResolvedValue(mockToken),
+            };
+            device_flow_1.RedoclyOAuthDeviceFlow.mockImplementation(() => mockDeviceFlow);
+            await client.login(mockBaseUrl);
+            expect(mockDeviceFlow.run).toHaveBeenCalled();
+            expect(fs.writeFileSync).toHaveBeenCalled();
+        });
+        it('throws error when login fails', async () => {
+            const mockDeviceFlow = {
+                run: jest.fn().mockResolvedValue(null),
+            };
+            device_flow_1.RedoclyOAuthDeviceFlow.mockImplementation(() => mockDeviceFlow);
+            await expect(client.login(mockBaseUrl)).rejects.toThrow('Failed to login');
+        });
+    });
+    describe('logout', () => {
+        it('removes token file if it exists', async () => {
+            fs.existsSync.mockReturnValue(true);
+            await client.logout();
+            expect(fs.rmSync).toHaveBeenCalledWith(path.join(mockRedoclyDir, 'auth.json'));
+        });
+        it('silently fails if token file does not exist', async () => {
+            fs.existsSync.mockReturnValue(false);
+            await expect(client.logout()).resolves.not.toThrow();
+            expect(fs.rmSync).not.toHaveBeenCalled();
+        });
+    });
+    describe('isAuthorized', () => {
+        it('verifies API key if provided', async () => {
+            const mockDeviceFlow = {
+                verifyApiKey: jest.fn().mockResolvedValue(true),
+            };
+            device_flow_1.RedoclyOAuthDeviceFlow.mockImplementation(() => mockDeviceFlow);
+            const result = await client.isAuthorized(mockBaseUrl, 'test-api-key');
+            expect(result).toBe(true);
+            expect(mockDeviceFlow.verifyApiKey).toHaveBeenCalledWith('test-api-key');
+        });
+        it('verifies access token if no API key provided', async () => {
+            const mockToken = { access_token: 'test-token' };
+            const mockDeviceFlow = {
+                verifyToken: jest.fn().mockResolvedValue(true),
+            };
+            device_flow_1.RedoclyOAuthDeviceFlow.mockImplementation(() => mockDeviceFlow);
+            fs.readFileSync.mockReturnValue(client['cipher'].update(JSON.stringify(mockToken), 'utf8', 'hex') +
+                client['cipher'].final('hex'));
+            const result = await client.isAuthorized(mockBaseUrl);
+            expect(result).toBe(true);
+            expect(mockDeviceFlow.verifyToken).toHaveBeenCalledWith('test-token');
+        });
+        it('returns false if token refresh fails', async () => {
+            const mockToken = {
+                access_token: 'old-token',
+                refresh_token: 'refresh-token',
+            };
+            const mockDeviceFlow = {
+                verifyToken: jest.fn().mockResolvedValue(false),
+                refreshToken: jest.fn().mockRejectedValue(new Error('Refresh failed')),
+            };
+            device_flow_1.RedoclyOAuthDeviceFlow.mockImplementation(() => mockDeviceFlow);
+            fs.readFileSync.mockReturnValue(client['cipher'].update(JSON.stringify(mockToken), 'utf8', 'hex') +
+                client['cipher'].final('hex'));
+            const result = await client.isAuthorized(mockBaseUrl);
+            expect(result).toBe(false);
+        });
+    });
+});

package/lib/auth/device-flow.d.ts

@@ -0,0 +1,26 @@
+export type AuthToken = {
+    access_token: string;
+    refresh_token?: string;
+    token_type?: string;
+    expires_in?: number;
+};
+export declare class RedoclyOAuthDeviceFlow {
+    private baseUrl;
+    private clientName;
+    private version;
+    private apiClient;
+    constructor(baseUrl: string, clientName: string, version: string);
+    run(): Promise<AuthToken>;
+    private openBrowser;
+    verifyToken(accessToken: string): Promise<boolean>;
+    verifyApiKey(apiKey: string): Promise<boolean>;
+    refreshToken(refreshToken: string): Promise<{
+        access_token: any;
+        refresh_token: any;
+        expires_in: any;
+    }>;
+    private pollingAccessToken;
+    private getAccessToken;
+    private getDeviceCode;
+    private sendRequest;
+}

package/lib/auth/device-flow.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedoclyOAuthDeviceFlow = void 0;
+const colorette_1 = require("colorette");
+const childProcess = require("child_process");
+const api_client_1 = require("../reunite/api/api-client");
+class RedoclyOAuthDeviceFlow {
+    constructor(baseUrl, clientName, version) {
+        this.baseUrl = baseUrl;
+        this.clientName = clientName;
+        this.version = version;
+        this.apiClient = new api_client_1.ReuniteApiClient(this.version, 'login');
+    }
+    async run() {
+        const code = await this.getDeviceCode();
+        process.stdout.write('Attempting to automatically open the SSO authorization page in your default browser.\n');
+        process.stdout.write('If the browser does not open or you wish to use a different device to authorize this request, open the following URL:\n\n');
+        process.stdout.write((0, colorette_1.blue)(code.verificationUri));
+        process.stdout.write(`\n\n`);
+        process.stdout.write(`Then enter the code:\n\n`);
+        process.stdout.write((0, colorette_1.blue)(code.userCode));
+        process.stdout.write(`\n\n`);
+        this.openBrowser(code.verificationUriComplete);
+        const accessToken = await this.pollingAccessToken(code.deviceCode, code.interval, code.expiresIn);
+        process.stdout.write((0, colorette_1.green)('✅ Logged in\n\n'));
+        return accessToken;
+    }
+    openBrowser(url) {
+        try {
+            const cmd = process.platform === 'win32'
+                ? `start ${url}`
+                : process.platform === 'darwin'
+                    ? `open ${url}`
+                    : `xdg-open ${url}`;
+            childProcess.execSync(cmd);
+        }
+        catch {
+            // silently fail if browser cannot be opened
+        }
+    }
+    async verifyToken(accessToken) {
+        try {
+            const response = await this.sendRequest('/session', 'GET', undefined, {
+                Cookie: `accessToken=${accessToken};`,
+            });
+            return !!response.user;
+        }
+        catch {
+            return false;
+        }
+    }
+    async verifyApiKey(apiKey) {
+        try {
+            const response = await this.sendRequest('/api-keys-verify', 'POST', {
+                apiKey,
+            });
+            return !!response.success;
+        }
+        catch {
+            return false;
+        }
+    }
+    async refreshToken(refreshToken) {
+        const response = await this.sendRequest(`/device-rotate-token`, 'POST', {
+            grant_type: 'refresh_token',
+            client_name: this.clientName,
+            refresh_token: refreshToken,
+        });
+        if (!response.access_token) {
+            throw new Error('Failed to refresh token');
+        }
+        return {
+            access_token: response.access_token,
+            refresh_token: response.refresh_token,
+            expires_in: response.expires_in,
+        };
+    }
+    async pollingAccessToken(deviceCode, interval, expiresIn) {
+        return new Promise((resolve, reject) => {
+            const intervalId = setInterval(async () => {
+                const response = await this.getAccessToken(deviceCode);
+                if (response.access_token) {
+                    clearInterval(intervalId);
+                    clearTimeout(timeoutId);
+                    resolve(response);
+                }
+                if (response.error && response.error !== 'authorization_pending') {
+                    clearInterval(intervalId);
+                    clearTimeout(timeoutId);
+                    reject(response.error_description);
+                }
+            }, interval * 1000);
+            const timeoutId = setTimeout(async () => {
+                clearInterval(intervalId);
+                clearTimeout(timeoutId);
+                reject('Authorization has expired. Please try again.');
+            }, expiresIn * 1000);
+        });
+    }
+    async getAccessToken(deviceCode) {
+        return await this.sendRequest('/device-token', 'POST', {
+            client_name: this.clientName,
+            device_code: deviceCode,
+            grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
+        });
+    }
+    async getDeviceCode() {
+        const { device_code: deviceCode, user_code: userCode, verification_uri: verificationUri, verification_uri_complete: verificationUriComplete, interval = 10, expires_in: expiresIn = 300, } = await this.sendRequest('/device-authorize', 'POST', {
+            client_name: this.clientName,
+        });
+        return {
+            deviceCode,
+            userCode,
+            verificationUri,
+            verificationUriComplete,
+            interval,
+            expiresIn,
+        };
+    }
+    async sendRequest(url, method = 'GET', body = undefined, headers = {}) {
+        url = `${this.baseUrl}${url}`;
+        const response = await this.apiClient.request(url, {
+            body: body ? JSON.stringify(body) : body,
+            method,
+            headers: { 'Content-Type': 'application/json', ...headers },
+        });
+        if (response.status === 204) {
+            return { success: true };
+        }
+        return await response.json();
+    }
+}
+exports.RedoclyOAuthDeviceFlow = RedoclyOAuthDeviceFlow;

package/lib/auth/oauth-client.d.ts

@@ -0,0 +1,14 @@
+export declare class RedoclyOAuthClient {
+    private clientName;
+    private version;
+    private dir;
+    private cipher;
+    private decipher;
+    constructor(clientName: string, version: string);
+    login(baseUrl: string): Promise<void>;
+    logout(): Promise<void>;
+    isAuthorized(baseUrl: string, apiKey?: string): Promise<boolean>;
+    private saveToken;
+    private readToken;
+    private removeToken;
+}

package/lib/auth/oauth-client.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedoclyOAuthClient = void 0;
+const node_os_1 = require("node:os");
+const path = require("node:path");
+const node_fs_1 = require("node:fs");
+const crypto = require("node:crypto");
+const node_buffer_1 = require("node:buffer");
+const device_flow_1 = require("./device-flow");
+const SALT = '4618dbc9-8aed-4e27-aaf0-225f4603e5a4';
+const CRYPTO_ALGORITHM = 'aes-256-cbc';
+class RedoclyOAuthClient {
+    constructor(clientName, version) {
+        this.clientName = clientName;
+        this.version = version;
+        this.dir = path.join((0, node_os_1.homedir)(), '.redocly');
+        if (!(0, node_fs_1.existsSync)(this.dir)) {
+            (0, node_fs_1.mkdirSync)(this.dir);
+        }
+        const homeDirPath = process.env.HOME;
+        const hash = crypto.createHash('sha256');
+        hash.update(`${homeDirPath}${SALT}`);
+        const hashHex = hash.digest('hex');
+        const key = node_buffer_1.Buffer.alloc(32, node_buffer_1.Buffer.from(hashHex).toString('base64')).toString();
+        const iv = node_buffer_1.Buffer.alloc(16, node_buffer_1.Buffer.from(process.env.HOME).toString('base64')).toString();
+        this.cipher = crypto.createCipheriv(CRYPTO_ALGORITHM, key, iv);
+        this.decipher = crypto.createDecipheriv(CRYPTO_ALGORITHM, key, iv);
+    }
+    async login(baseUrl) {
+        const deviceFlow = new device_flow_1.RedoclyOAuthDeviceFlow(baseUrl, this.clientName, this.version);
+        const token = await deviceFlow.run();
+        if (!token) {
+            throw new Error('Failed to login');
+        }
+        this.saveToken(token);
+    }
+    async logout() {
+        try {
+            this.removeToken();
+        }
+        catch (err) {
+            // do nothing
+        }
+    }
+    async isAuthorized(baseUrl, apiKey) {
+        const deviceFlow = new device_flow_1.RedoclyOAuthDeviceFlow(baseUrl, this.clientName, this.version);
+        if (apiKey) {
+            return await deviceFlow.verifyApiKey(apiKey);
+        }
+        const token = await this.readToken();
+        if (!token) {
+            return false;
+        }
+        const isValidAccessToken = await deviceFlow.verifyToken(token.access_token);
+        if (isValidAccessToken) {
+            return true;
+        }
+        try {
+            const newToken = await deviceFlow.refreshToken(token.refresh_token);
+            await this.saveToken(newToken);
+        }
+        catch {
+            return false;
+        }
+        return true;
+    }
+    async saveToken(token) {
+        try {
+            const encrypted = this.cipher.update(JSON.stringify(token), 'utf8', 'hex') + this.cipher.final('hex');
+            (0, node_fs_1.writeFileSync)(path.join(this.dir, 'auth.json'), encrypted);
+        }
+        catch (error) {
+            process.stderr.write('Error saving tokens:', error);
+        }
+    }
+    async readToken() {
+        try {
+            const token = (0, node_fs_1.readFileSync)(path.join(this.dir, 'auth.json'), 'utf8');
+            const decrypted = this.decipher.update(token, 'hex', 'utf8') + this.decipher.final('utf8');
+            return decrypted ? JSON.parse(decrypted) : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async removeToken() {
+        const tokenPath = path.join(this.dir, 'auth.json');
+        if ((0, node_fs_1.existsSync)(tokenPath)) {
+            (0, node_fs_1.rmSync)(tokenPath);
+        }
+    }
+}
+exports.RedoclyOAuthClient = RedoclyOAuthClient;

package/lib/commands/auth.d.ts

@@ -0,0 +1,13 @@
+import type { CommandArgs } from '../wrapper';
+export declare function promptClientToken(domain: string): Promise<string>;
+export type LoginOptions = {
+    verbose?: boolean;
+    residency?: string;
+    config?: string;
+    next?: boolean;
+};
+export declare function handleLogin({ argv, config, version }: CommandArgs<LoginOptions>): Promise<void>;
+export type LogoutOptions = {
+    config?: string;
+};
+export declare function handleLogout({ version }: CommandArgs<LogoutOptions>): Promise<void>;

package/lib/commands/auth.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptClientToken = promptClientToken;
+exports.handleLogin = handleLogin;
+exports.handleLogout = handleLogout;
+const colorette_1 = require("colorette");
+const openapi_core_1 = require("@redocly/openapi-core");
+const miscellaneous_1 = require("../utils/miscellaneous");
+const oauth_client_1 = require("../auth/oauth-client");
+const api_1 = require("../reunite/api");
+function promptClientToken(domain) {
+    return (0, miscellaneous_1.promptUser)((0, colorette_1.green)(`\n  🔑 Copy your API key from ${(0, colorette_1.blue)(`https://app.${domain}/profile`)} and paste it below`) + (0, colorette_1.yellow)(' (if you want to log in with Reunite, please run `redocly login --next` instead)'), true);
+}
+async function handleLogin({ argv, config, version }) {
+    if (argv.next) {
+        try {
+            const reuniteUrl = (0, api_1.getReuniteUrl)(argv.residency);
+            const oauthClient = new oauth_client_1.RedoclyOAuthClient('redocly-cli', version);
+            await oauthClient.login(reuniteUrl);
+        }
+        catch {
+            if (argv.residency) {
+                const reuniteUrl = (0, api_1.getReuniteUrl)(argv.residency);
+                (0, miscellaneous_1.exitWithError)(`❌ Connection to ${reuniteUrl} failed.`);
+            }
+            else {
+                (0, miscellaneous_1.exitWithError)(`❌ Login failed. Please check your credentials and try again.`);
+            }
+        }
+    }
+    else {
+        try {
+            const region = argv.residency || config.region;
+            const client = new openapi_core_1.RedoclyClient(region);
+            const clientToken = await promptClientToken(client.domain);
+            process.stdout.write((0, colorette_1.gray)('\n  Logging in...\n'));
+            await client.login(clientToken, argv.verbose);
+            process.stdout.write((0, colorette_1.green)('  Authorization confirmed. ✅\n\n'));
+        }
+        catch (err) {
+            (0, miscellaneous_1.exitWithError)('  ' + err?.message);
+        }
+    }
+}
+async function handleLogout({ version }) {
+    const client = new openapi_core_1.RedoclyClient();
+    client.logout();
+    const oauthClient = new oauth_client_1.RedoclyOAuthClient('redocly-cli', version);
+    oauthClient.logout();
+    process.stdout.write('Logged out from the Redocly account. ✋ \n');
+}

package/lib/commands/push.d.ts

@@ -1,4 +1,4 @@
-import { handlePush as handleCMSPush } from '../cms/commands/push';
+import { handlePush as handleCMSPush } from '../reunite/commands/push';
 import type { Config, Region } from '@redocly/openapi-core';
 import type { CommandArgs } from '../wrapper';
 import type { VerifyConfigOptions } from '../types';

package/lib/commands/push.js

@@ -13,9 +13,9 @@ const crypto_1 = require("crypto");
 const openapi_core_1 = require("@redocly/openapi-core");
 const utils_1 = require("@redocly/openapi-core/lib/utils");
 const miscellaneous_1 = require("../utils/miscellaneous");
-const login_1 = require("./login");
-const push_1 = require("../cms/commands/push");
-const api_client_1 = require("../cms/api/api-client");
+const auth_1 = require("./auth");
+const push_1 = require("../reunite/commands/push");
+const api_client_1 = require("../reunite/api/api-client");
 const DEFAULT_VERSION = 'latest';
 exports.DESTINATION_REGEX = 
 // eslint-disable-next-line no-useless-escape
@@ -31,7 +31,7 @@ async function handlePush({ argv, config }) {
     const isAuthorized = await client.isAuthorizedWithRedoclyByRegion();
     if (!isAuthorized) {
         try {
-            const clientToken = await (0, login_1.promptClientToken)(client.domain);
+            const clientToken = await (0, auth_1.promptClientToken)(client.domain);
             await client.login(clientToken);
         }
         catch (e) {

package/lib/commands/split/index.js

@@ -111,9 +111,9 @@ function replace$Refs(obj, relativeFrom, componentFiles = {}) {
         const filesGroupName = componentFiles[groupName];
         if (!filesGroupName || !filesGroupName[name])
             return;
-        let filename = path.relative(relativeFrom, filesGroupName[name].filename);
+        let filename = (0, openapi_core_1.slash)(path.relative(relativeFrom, filesGroupName[name].filename));
         if (!filename.startsWith('.')) {
-            filename = '.' + path.sep + filename;
+            filename = './' + filename;
         }
         node[key] = filename;
     }
@@ -125,8 +125,8 @@ function implicitlyReferenceDiscriminator(obj, defName, filename, schemaFiles) {
     const implicitMapping = {};
     for (const [name, { inherits, filename: parentFilename }] of Object.entries(schemaFiles)) {
         if (inherits.indexOf(defPtr) > -1) {
-            const res = path.relative(path.dirname(filename), parentFilename);
-            implicitMapping[name] = res.startsWith('.') ? res : '.' + path.sep + res;
+            const res = (0, openapi_core_1.slash)(path.relative(path.dirname(filename), parentFilename));
+            implicitMapping[name] = res.startsWith('.') ? res : './' + res;
         }
     }
     if ((0, js_utils_1.isEmptyObject)(implicitMapping))

package/lib/index.js

@@ -4,16 +4,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 require("./utils/assert-node-version");
 const yargs = require("yargs");
 const colors = require("colorette");
-const openapi_core_1 = require("@redocly/openapi-core");
 const types_1 = require("./types");
 const preview_docs_1 = require("./commands/preview-docs");
 const stats_1 = require("./commands/stats");
 const split_1 = require("./commands/split");
 const join_1 = require("./commands/join");
-const push_status_1 = require("./cms/commands/push-status");
+const push_status_1 = require("./reunite/commands/push-status");
 const lint_1 = require("./commands/lint");
 const bundle_1 = require("./commands/bundle");
-const login_1 = require("./commands/login");
+const auth_1 = require("./commands/auth");
 const build_docs_1 = require("./commands/build-docs");
 const update_version_notifier_1 = require("./utils/update-version-notifier");
 const wrapper_1 = require("./wrapper");
@@ -521,32 +520,32 @@ yargs
     process.env.REDOCLY_CLI_COMMAND = 'check-config';
     (0, wrapper_1.commandWrapper)()(argv);
 })
-    .command('login', 'Login to the Redocly API registry with an access token.', async (yargs) => yargs.options({
+    .command('login', 'Log in to Redocly.', async (yargs) => yargs.options({
     verbose: {
         description: 'Include additional output.',
         type: 'boolean',
     },
-    region: {
-        description: 'Specify a region.',
-        alias: 'r',
-        choices: types_1.regionChoices,
+    residency: {
+        description: 'Residency of the application. Defaults to `us`.',
+        alias: ['r', 'region'],
+        type: 'string',
     },
     config: {
         description: 'Path to the config file.',
         requiresArg: true,
         type: 'string',
     },
+    next: {
+        description: 'Use Reunite application to login.',
+        type: 'boolean',
+    },
 }), (argv) => {
     process.env.REDOCLY_CLI_COMMAND = 'login';
-    (0, wrapper_1.commandWrapper)(login_1.handleLogin)(argv);
+    (0, wrapper_1.commandWrapper)(auth_1.handleLogin)(argv);
 })
-    .command('logout', 'Clear your stored credentials for the Redocly API registry.', (yargs) => yargs, async (argv) => {
+    .command('logout', 'Clear your stored credentials for the Redocly API registry.', (yargs) => yargs, (argv) => {
     process.env.REDOCLY_CLI_COMMAND = 'logout';
-    await (0, wrapper_1.commandWrapper)(async () => {
-        const client = new openapi_core_1.RedoclyClient();
-        client.logout();
-        process.stdout.write('Logged out from the Redocly account. ✋\n');
-    })(argv);
+    (0, wrapper_1.commandWrapper)(auth_1.handleLogout)(argv);
 })
     .command('preview', 'Preview Redocly project using one of the product NPM packages.', (yargs) => yargs.options({
     product: {