@redocly/cli 1.34.3 → 2.0.0-next.0

package/src/__tests__/wrapper.test.ts

@@ -1,91 +0,0 @@
-import { loadConfigAndHandleErrors, sendTelemetry } from '../utils/miscellaneous';
-import * as process from 'process';
-import { commandWrapper } from '../wrapper';
-import { handleLint } from '../commands/lint';
-import { Arguments } from 'yargs';
-import { handlePush, PushOptions } from '../commands/push';
-import { detectSpec } from '@redocly/openapi-core';
-
-const mockFetch = jest.fn();
-const originalFetch = global.fetch;
-
-jest.mock('../utils/miscellaneous', () => ({
-  sendTelemetry: jest.fn(),
-  loadConfigAndHandleErrors: jest.fn(),
-}));
-
-beforeAll(() => {
-  global.fetch = mockFetch;
-});
-
-afterAll(() => {
-  jest.resetAllMocks();
-  global.fetch = originalFetch;
-});
-
-jest.mock('../commands/lint', () => ({
-  handleLint: jest.fn().mockImplementation(({ collectSpecData }) => {
-    collectSpecData({ openapi: '3.1.0' });
-  }),
-  lintConfigCallback: jest.fn(),
-}));
-
-describe('commandWrapper', () => {
-  it('should send telemetry if there is "telemetry: on" in the config', async () => {
-    (loadConfigAndHandleErrors as jest.Mock).mockImplementation(() => {
-      return { telemetry: 'on', styleguide: { recommendedFallback: true } };
-    });
-    (detectSpec as jest.Mock).mockImplementationOnce(() => {
-      return 'oas3_1';
-    });
-    process.env.REDOCLY_TELEMETRY = 'on';
-
-    const wrappedHandler = commandWrapper(handleLint);
-    await wrappedHandler({} as any);
-    expect(handleLint).toHaveBeenCalledTimes(1);
-    expect(sendTelemetry).toHaveBeenCalledTimes(1);
-    expect(sendTelemetry).toHaveBeenCalledWith({}, 0, false, 'oas3_1', 'openapi', '3.1.0');
-  });
-
-  it('should not collect spec version if the file is not parsed to json', async () => {
-    (loadConfigAndHandleErrors as jest.Mock).mockImplementation(() => {
-      return { telemetry: 'on', styleguide: { recommendedFallback: true } };
-    });
-    (handleLint as jest.Mock).mockImplementation(({ collectSpecData }) => {
-      collectSpecData();
-    });
-    process.env.REDOCLY_TELEMETRY = 'on';
-
-    const wrappedHandler = commandWrapper(handleLint);
-    await wrappedHandler({} as any);
-    expect(handleLint).toHaveBeenCalledTimes(1);
-    expect(sendTelemetry).toHaveBeenCalledTimes(1);
-    expect(sendTelemetry).toHaveBeenCalledWith({}, 0, false, undefined, undefined, undefined);
-  });
-
-  it('should NOT send telemetry if there is "telemetry: off" in the config', async () => {
-    (loadConfigAndHandleErrors as jest.Mock).mockImplementation(() => {
-      return { telemetry: 'off', styleguide: { recommendedFallback: true } };
-    });
-    process.env.REDOCLY_TELEMETRY = 'on';
-
-    const wrappedHandler = commandWrapper(handleLint);
-    await wrappedHandler({} as any);
-    expect(handleLint).toHaveBeenCalledTimes(1);
-
-    expect(sendTelemetry).toHaveBeenCalledTimes(0);
-  });
-
-  it('should pass files from arguments to config', async () => {
-    const filesToPush = ['test1.yaml', 'test2.yaml'];
-
-    const loadConfigMock = loadConfigAndHandleErrors as jest.Mock<any, any>;
-
-    const argv = {
-      files: filesToPush,
-    } as Arguments<PushOptions>;
-
-    await commandWrapper(handlePush)(argv);
-    expect(loadConfigMock).toHaveBeenCalledWith(expect.objectContaining({ files: filesToPush }));
-  });
-});

package/src/auth/__tests__/device-flow.test.ts

@@ -1,73 +0,0 @@
-import { RedoclyOAuthDeviceFlow } from '../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: RedoclyOAuthDeviceFlow;
-
-  beforeEach(() => {
-    flow = new 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' } }),
-      } as Response);
-
-      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 }),
-      } as Response);
-
-      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),
-      } as Response);
-
-      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({}),
-      } as Response);
-
-      await expect(flow.refreshToken('invalid-refresh')).rejects.toThrow('Failed to refresh token');
-    });
-  });
-});

package/src/auth/__tests__/oauth-client.test.ts

@@ -1,117 +0,0 @@
-import { RedoclyOAuthClient } from '../oauth-client';
-import { RedoclyOAuthDeviceFlow } from '../device-flow';
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import * as os from '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: RedoclyOAuthClient;
-
-  beforeEach(() => {
-    jest.resetAllMocks();
-    (os.homedir as jest.Mock).mockReturnValue(mockHomeDir);
-    process.env.HOME = mockHomeDir;
-    client = new 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),
-      };
-      (RedoclyOAuthDeviceFlow as jest.Mock).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),
-      };
-      (RedoclyOAuthDeviceFlow as jest.Mock).mockImplementation(() => mockDeviceFlow);
-
-      await expect(client.login(mockBaseUrl)).rejects.toThrow('Failed to login');
-    });
-  });
-
-  describe('logout', () => {
-    it('removes token file if it exists', async () => {
-      (fs.existsSync as jest.Mock).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 as jest.Mock).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),
-      };
-      (RedoclyOAuthDeviceFlow as jest.Mock).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),
-      };
-      (RedoclyOAuthDeviceFlow as jest.Mock).mockImplementation(() => mockDeviceFlow);
-      (fs.readFileSync as jest.Mock).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')),
-      };
-      (RedoclyOAuthDeviceFlow as jest.Mock).mockImplementation(() => mockDeviceFlow);
-      (fs.readFileSync as jest.Mock).mockReturnValue(
-        client['cipher'].update(JSON.stringify(mockToken), 'utf8', 'hex') +
-          client['cipher'].final('hex')
-      );
-
-      const result = await client.isAuthorized(mockBaseUrl);
-
-      expect(result).toBe(false);
-    });
-  });
-});

package/src/auth/device-flow.ts

@@ -1,175 +0,0 @@
-import { blue, green } from 'colorette';
-import * as childProcess from 'child_process';
-import { ReuniteApiClient } from '../reunite/api/api-client';
-
-export type AuthToken = {
-  access_token: string;
-  refresh_token?: string;
-  token_type?: string;
-  expires_in?: number;
-};
-
-export class RedoclyOAuthDeviceFlow {
-  private apiClient: ReuniteApiClient;
-
-  constructor(private baseUrl: string, private clientName: string, private version: string) {
-    this.apiClient = new 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(blue(code.verificationUri));
-    process.stdout.write(`\n\n`);
-    process.stdout.write(`Then enter the code:\n\n`);
-    process.stdout.write(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(green('✅ Logged in\n\n'));
-
-    return accessToken;
-  }
-
-  private openBrowser(url: string) {
-    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: string) {
-    try {
-      const response = await this.sendRequest('/session', 'GET', undefined, {
-        Cookie: `accessToken=${accessToken};`,
-      });
-
-      return !!response.user;
-    } catch {
-      return false;
-    }
-  }
-
-  async verifyApiKey(apiKey: string) {
-    try {
-      const response = await this.sendRequest('/api-keys-verify', 'POST', {
-        apiKey,
-      });
-      return !!response.success;
-    } catch {
-      return false;
-    }
-  }
-
-  async refreshToken(refreshToken: string) {
-    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,
-    };
-  }
-
-  private async pollingAccessToken(
-    deviceCode: string,
-    interval: number,
-    expiresIn: number
-  ): Promise<AuthToken> {
-    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);
-    });
-  }
-
-  private async getAccessToken(deviceCode: string) {
-    return await this.sendRequest('/device-token', 'POST', {
-      client_name: this.clientName,
-      device_code: deviceCode,
-      grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
-    });
-  }
-
-  private 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,
-    };
-  }
-
-  private async sendRequest(
-    url: string,
-    method: string = 'GET',
-    body: Record<string, unknown> | undefined = undefined,
-    headers: Record<string, string> = {}
-  ) {
-    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();
-  }
-}

package/src/auth/oauth-client.ts

@@ -1,111 +0,0 @@
-import { homedir } from 'node:os';
-import * as path from 'node:path';
-import { mkdirSync, existsSync, writeFileSync, readFileSync, rmSync } from 'node:fs';
-import * as crypto from 'node:crypto';
-import { Buffer } from 'node:buffer';
-import { type AuthToken, RedoclyOAuthDeviceFlow } from './device-flow';
-
-const SALT = '4618dbc9-8aed-4e27-aaf0-225f4603e5a4';
-const CRYPTO_ALGORITHM = 'aes-256-cbc';
-
-export class RedoclyOAuthClient {
-  private dir: string;
-  private cipher: crypto.Cipher;
-  private decipher: crypto.Decipher;
-
-  constructor(private clientName: string, private version: string) {
-    this.dir = path.join(homedir(), '.redocly');
-    if (!existsSync(this.dir)) {
-      mkdirSync(this.dir);
-    }
-
-    const homeDirPath = process.env.HOME as string;
-    const hash = crypto.createHash('sha256');
-    hash.update(`${homeDirPath}${SALT}`);
-    const hashHex = hash.digest('hex');
-
-    const key = Buffer.alloc(
-      32,
-      Buffer.from(hashHex).toString('base64')
-    ).toString() as crypto.CipherKey;
-    const iv = Buffer.alloc(
-      16,
-      Buffer.from(process.env.HOME as string).toString('base64')
-    ).toString() as crypto.BinaryLike;
-    this.cipher = crypto.createCipheriv(CRYPTO_ALGORITHM, key, iv);
-    this.decipher = crypto.createDecipheriv(CRYPTO_ALGORITHM, key, iv);
-  }
-
-  async login(baseUrl: string) {
-    const deviceFlow = new 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: string, apiKey?: string) {
-    const deviceFlow = new 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;
-  }
-
-  private async saveToken(token: AuthToken) {
-    try {
-      const encrypted =
-        this.cipher.update(JSON.stringify(token), 'utf8', 'hex') + this.cipher.final('hex');
-      writeFileSync(path.join(this.dir, 'auth.json'), encrypted);
-    } catch (error) {
-      process.stderr.write('Error saving tokens:', error);
-    }
-  }
-
-  private async readToken() {
-    try {
-      const token = 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;
-    }
-  }
-
-  private async removeToken() {
-    const tokenPath = path.join(this.dir, 'auth.json');
-    if (existsSync(tokenPath)) {
-      rmSync(tokenPath);
-    }
-  }
-}

package/src/commands/auth.ts

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

package/src/commands/build-docs/index.ts

@@ -1,55 +0,0 @@
-import { loadAndBundleSpec } from 'redoc';
-import { dirname, resolve } from 'path';
-import { writeFileSync, mkdirSync } from 'fs';
-import { performance } from 'perf_hooks';
-import { getMergedConfig, isAbsoluteUrl } from '@redocly/openapi-core';
-import { getObjectOrJSON, getPageHTML } from './utils';
-import { exitWithError, getExecutionTime, getFallbackApisOrExit } from '../../utils/miscellaneous';
-
-import type { BuildDocsArgv } from './types';
-import type { CommandArgs } from '../../wrapper';
-
-export const handlerBuildCommand = async ({
-  argv,
-  config: configFromFile,
-  collectSpecData,
-}: CommandArgs<BuildDocsArgv>) => {
-  const startedAt = performance.now();
-
-  const config = getMergedConfig(configFromFile, argv.api);
-  const apis = await getFallbackApisOrExit(argv.api ? [argv.api] : [], config);
-  const { path: pathToApi } = apis[0];
-
-  const options = {
-    output: argv.o,
-    title: argv.title,
-    disableGoogleFont: argv.disableGoogleFont,
-    templateFileName: argv.template,
-    templateOptions: argv.templateOptions || {},
-    redocOptions: getObjectOrJSON(argv.theme?.openapi, config),
-  };
-
-  const redocCurrentVersion = require('../../../package.json').dependencies.redoc;
-
-  try {
-    const elapsed = getExecutionTime(startedAt);
-
-    const api = await loadAndBundleSpec(isAbsoluteUrl(pathToApi) ? pathToApi : resolve(pathToApi));
-    collectSpecData?.(api);
-    const pageHTML = await getPageHTML(
-      api,
-      pathToApi,
-      { ...options, redocCurrentVersion },
-      argv.config
-    );
-
-    mkdirSync(dirname(options.output), { recursive: true });
-    writeFileSync(options.output, pageHTML);
-    const sizeInKiB = Math.ceil(Buffer.byteLength(pageHTML) / 1024);
-    process.stdout.write(
-      `\n🎉 bundled successfully in: ${options.output} (${sizeInKiB} KiB) [⏱ ${elapsed}].\n`
-    );
-  } catch (e) {
-    exitWithError(e);
-  }
-};