@redocly/cli 0.0.0-snapshot.1737554067

package/lib/cms/commands/push.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handlePush = handlePush;
+const fs = require("fs");
+const path = require("path");
+const openapi_core_1 = require("@redocly/openapi-core");
+const utils_1 = require("@redocly/openapi-core/lib/utils");
+const colorette_1 = require("colorette");
+const miscellaneous_1 = require("../../utils/miscellaneous");
+const push_status_1 = require("./push-status");
+const api_1 = require("../api");
+const utils_2 = require("./utils");
+async function handlePush({ argv, config, version, }) {
+    const startedAt = performance.now(); // for printing execution time
+    const startTime = Date.now(); // for push-status command
+    const { organization, project: projectId, 'mount-path': mountPath, verbose } = argv;
+    const orgId = organization || config.organization;
+    if (!argv.message || !argv.author || !argv.branch) {
+        (0, miscellaneous_1.exitWithError)('Error: message, author and branch are required for push to the Reunite.');
+    }
+    if (!orgId) {
+        return (0, miscellaneous_1.exitWithError)(`No organization provided, please use --organization option or specify the 'organization' field in the config file.`);
+    }
+    const domain = argv.domain || (0, api_1.getDomain)();
+    if (!domain) {
+        return (0, miscellaneous_1.exitWithError)(`No domain provided, please use --domain option or environment variable REDOCLY_AUTHORIZATION.`);
+    }
+    try {
+        const { 'commit-sha': commitSha, 'commit-url': commitUrl, 'default-branch': defaultBranch, 'wait-for-deployment': waitForDeployment, 'max-execution-time': maxExecutionTime, } = argv;
+        const author = parseCommitAuthor(argv.author);
+        const apiKey = (0, api_1.getApiKeys)(domain);
+        const filesToUpload = collectFilesToPush(argv.files || argv.apis);
+        const commandName = 'push';
+        if (!filesToUpload.length) {
+            return (0, miscellaneous_1.printExecutionTime)(commandName, startedAt, `No files to upload`);
+        }
+        const client = new api_1.ReuniteApi({ domain, apiKey, version, command: commandName });
+        const projectDefaultBranch = await client.remotes.getDefaultBranch(orgId, projectId);
+        const remote = await client.remotes.upsert(orgId, projectId, {
+            mountBranchName: projectDefaultBranch,
+            mountPath,
+        });
+        process.stderr.write(`Uploading to ${remote.mountPath} ${filesToUpload.length} ${(0, utils_1.pluralize)('file', filesToUpload.length)}:\n`);
+        const { id } = await client.remotes.push(orgId, projectId, {
+            remoteId: remote.id,
+            commit: {
+                message: argv.message,
+                branchName: argv.branch,
+                sha: commitSha,
+                url: commitUrl,
+                createdAt: argv['created-at'],
+                namespace: argv.namespace,
+                repository: argv.repository,
+                author,
+            },
+            isMainBranch: defaultBranch === argv.branch,
+        }, filesToUpload.map((f) => ({ path: (0, openapi_core_1.slash)(f.name), stream: fs.createReadStream(f.path) })));
+        filesToUpload.forEach((f) => {
+            process.stderr.write((0, colorette_1.green)(`✓ ${f.name}\n`));
+        });
+        process.stdout.write('\n');
+        process.stdout.write(`Push ID: ${id}\n`);
+        if (waitForDeployment) {
+            process.stdout.write('\n');
+            await (0, push_status_1.handlePushStatus)({
+                argv: {
+                    organization: orgId,
+                    project: projectId,
+                    pushId: id,
+                    wait: true,
+                    domain,
+                    'max-execution-time': maxExecutionTime,
+                    'start-time': startTime,
+                    'continue-on-deploy-failures': argv['continue-on-deploy-failures'],
+                },
+                config,
+                version,
+            });
+        }
+        verbose &&
+            (0, miscellaneous_1.printExecutionTime)(commandName, startedAt, `${(0, utils_1.pluralize)('file', filesToUpload.length)} uploaded to organization ${orgId}, project ${projectId}. Push ID: ${id}.`);
+        client.reportSunsetWarnings();
+        return {
+            pushId: id,
+        };
+    }
+    catch (err) {
+        (0, utils_2.handleReuniteError)('✗ File upload failed.', err);
+    }
+}
+function parseCommitAuthor(author) {
+    // Author Name <author@email.com>
+    const reg = /^.+\s<[^<>]+>$/;
+    if (!reg.test(author)) {
+        throw new Error('Invalid author format. Use "Author Name <author@email.com>"');
+    }
+    const [name, email] = author.split('<');
+    return {
+        name: name.trim(),
+        email: email.replace('>', '').trim(),
+    };
+}
+function collectFilesToPush(files) {
+    const collectedFiles = {};
+    for (const file of files) {
+        if (fs.statSync(file).isDirectory()) {
+            const dir = file;
+            const fileList = getFilesList(dir, []);
+            fileList.forEach((f) => addFile(f, dir));
+        }
+        else {
+            addFile(file, path.dirname(file));
+        }
+    }
+    function addFile(filePath, fileDir) {
+        const fileName = path.relative(fileDir, filePath);
+        if (collectedFiles[fileName]) {
+            process.stdout.write((0, colorette_1.yellow)(`File ${collectedFiles[fileName]} is overwritten by ${filePath}\n`));
+        }
+        collectedFiles[fileName] = filePath;
+    }
+    return Object.entries(collectedFiles).map(([name, filePath]) => getFileEntry(name, filePath));
+}
+function getFileEntry(name, filePath) {
+    return {
+        name,
+        path: path.resolve(filePath),
+    };
+}
+function getFilesList(dir, files) {
+    const filesAndDirs = fs.readdirSync(dir);
+    for (const name of filesAndDirs) {
+        const currentPath = path.join(dir, name);
+        if (fs.statSync(currentPath).isDirectory()) {
+            files = getFilesList(currentPath, files);
+        }
+        else {
+            files.push(currentPath);
+        }
+    }
+    return files;
+}

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

@@ -0,0 +1,25 @@
+import { DeploymentError } from '../utils';
+import type { ReuniteApiError } from '../api';
+/**
+ * This function retries an operation until a condition is met or a timeout is exceeded.
+ * If the condition is not met within the timeout, an error is thrown.
+ * @operation The operation to retry.
+ * @condition The condition to check after each operation result. Return false to continue retrying. Return true to stop retrying.
+ *            If not provided, the first result will be returned.
+ * @param onConditionNotMet Will be called with the last result right after checking condition and before timeout and retrying.
+ * @param onRetry Will be called right before retrying operation with the last result before retrying.
+ * @param startTime The start time of the operation. Default is the current time.
+ * @param retryTimeoutMs The maximum time to retry the operation. Default is 10 minutes.
+ * @param retryIntervalMs The interval between retries. Default is 5 seconds.
+ */
+export declare function retryUntilConditionMet<T>({ operation, condition, onConditionNotMet, onRetry, startTime, retryTimeoutMs, // 10 min
+retryIntervalMs, }: {
+    operation: () => Promise<T>;
+    condition?: ((result: T) => boolean) | null;
+    onConditionNotMet?: (lastResult: T) => void;
+    onRetry?: (lastResult: T) => void | Promise<void>;
+    startTime?: number;
+    retryTimeoutMs?: number;
+    retryIntervalMs?: number;
+}): Promise<T>;
+export declare function handleReuniteError(message: string, error: ReuniteApiError | DeploymentError | Error): void;

package/lib/cms/commands/utils.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retryUntilConditionMet = retryUntilConditionMet;
+exports.handleReuniteError = handleReuniteError;
+const openapi_core_1 = require("@redocly/openapi-core");
+const utils_1 = require("../utils");
+const miscellaneous_1 = require("../../utils/miscellaneous");
+/**
+ * This function retries an operation until a condition is met or a timeout is exceeded.
+ * If the condition is not met within the timeout, an error is thrown.
+ * @operation The operation to retry.
+ * @condition The condition to check after each operation result. Return false to continue retrying. Return true to stop retrying.
+ *            If not provided, the first result will be returned.
+ * @param onConditionNotMet Will be called with the last result right after checking condition and before timeout and retrying.
+ * @param onRetry Will be called right before retrying operation with the last result before retrying.
+ * @param startTime The start time of the operation. Default is the current time.
+ * @param retryTimeoutMs The maximum time to retry the operation. Default is 10 minutes.
+ * @param retryIntervalMs The interval between retries. Default is 5 seconds.
+ */
+async function retryUntilConditionMet({ operation, condition, onConditionNotMet, onRetry, startTime = Date.now(), retryTimeoutMs = 600000, // 10 min
+retryIntervalMs = 5000, // 5 sec
+ }) {
+    async function attempt() {
+        const result = await operation();
+        if (!condition) {
+            return result;
+        }
+        if (condition(result)) {
+            return result;
+        }
+        else if (Date.now() - startTime > retryTimeoutMs) {
+            throw new Error('Timeout exceeded.');
+        }
+        else {
+            onConditionNotMet?.(result);
+            await (0, openapi_core_1.pause)(retryIntervalMs);
+            await onRetry?.(result);
+            return attempt();
+        }
+    }
+    return attempt();
+}
+function handleReuniteError(message, error) {
+    const errorMessage = error instanceof utils_1.DeploymentError ? error.message : `${message} Reason: ${error.message}\n`;
+    return (0, miscellaneous_1.exitWithError)(errorMessage);
+}

package/lib/cms/utils.d.ts

@@ -0,0 +1,2 @@
+export declare class DeploymentError extends Error {
+}

package/lib/cms/utils.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeploymentError = void 0;
+class DeploymentError extends Error {
+}
+exports.DeploymentError = DeploymentError;

package/lib/commands/build-docs/index.d.ts

@@ -0,0 +1,3 @@
+import type { BuildDocsArgv } from './types';
+import type { CommandArgs } from '../../wrapper';
+export declare const handlerBuildCommand: ({ argv, config: configFromFile, collectSpecData, }: CommandArgs<BuildDocsArgv>) => Promise<void>;

package/lib/commands/build-docs/index.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handlerBuildCommand = void 0;
+const redoc_1 = require("redoc");
+const path_1 = require("path");
+const fs_1 = require("fs");
+const perf_hooks_1 = require("perf_hooks");
+const openapi_core_1 = require("@redocly/openapi-core");
+const utils_1 = require("./utils");
+const miscellaneous_1 = require("../../utils/miscellaneous");
+const handlerBuildCommand = async ({ argv, config: configFromFile, collectSpecData, }) => {
+    const startedAt = perf_hooks_1.performance.now();
+    const config = (0, openapi_core_1.getMergedConfig)(configFromFile, argv.api);
+    const apis = await (0, miscellaneous_1.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: (0, utils_1.getObjectOrJSON)(argv.theme?.openapi, config),
+    };
+    const redocCurrentVersion = require('../../../package.json').dependencies.redoc.substring(1); // remove ~
+    try {
+        const elapsed = (0, miscellaneous_1.getExecutionTime)(startedAt);
+        const api = await (0, redoc_1.loadAndBundleSpec)((0, openapi_core_1.isAbsoluteUrl)(pathToApi) ? pathToApi : (0, path_1.resolve)(pathToApi));
+        collectSpecData?.(api);
+        const pageHTML = await (0, utils_1.getPageHTML)(api, pathToApi, { ...options, redocCurrentVersion }, argv.config);
+        (0, fs_1.mkdirSync)((0, path_1.dirname)(options.output), { recursive: true });
+        (0, fs_1.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) {
+        (0, miscellaneous_1.exitWithError)(e);
+    }
+};
+exports.handlerBuildCommand = handlerBuildCommand;

package/lib/commands/build-docs/template.hbs

@@ -0,0 +1,23 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+  <meta charset="utf8" />
+  <title>{{title}}</title>
+  <!-- needed for adaptive design -->
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <style>
+    body {
+      padding: 0;
+      margin: 0;
+    }
+  </style>
+  {{{redocHead}}}
+  {{#unless disableGoogleFont}}<link href="https://fonts.googleapis.com/css?family=Montserrat:300,400,700|Roboto:300,400,700" rel="stylesheet">{{/unless}}
+</head>
+
+<body>
+  {{{redocHTML}}}
+</body>
+
+</html>

package/lib/commands/build-docs/types.d.ts

@@ -0,0 +1,23 @@
+import type { VerifyConfigOptions } from '../../types';
+export type BuildDocsOptions = {
+    watch?: boolean;
+    output?: string;
+    title?: string;
+    disableGoogleFont?: boolean;
+    port?: number;
+    templateFileName?: string;
+    templateOptions?: any;
+    redocOptions?: any;
+    redocCurrentVersion: string;
+};
+export type BuildDocsArgv = {
+    api: string;
+    o: string;
+    title?: string;
+    disableGoogleFont?: boolean;
+    template?: string;
+    templateOptions: Record<string, any>;
+    theme: {
+        openapi: string | Record<string, unknown>;
+    };
+} & VerifyConfigOptions;

package/lib/commands/build-docs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/commands/build-docs/utils.d.ts

@@ -0,0 +1,7 @@
+import type { Config } from '@redocly/openapi-core';
+import type { BuildDocsOptions } from './types';
+export declare function getObjectOrJSON(openapiOptions: string | Record<string, unknown>, config: Config): JSON | Record<string, unknown> | Config;
+export declare function getPageHTML(api: any, pathToApi: string, { title, disableGoogleFont, templateFileName, templateOptions, redocOptions, redocCurrentVersion, }: BuildDocsOptions, configPath?: string): Promise<string>;
+export declare function sanitizeJSONString(str: string): string;
+export declare function escapeClosingScriptTag(str: string): string;
+export declare function escapeUnicode(str: string): string;

package/lib/commands/build-docs/utils.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getObjectOrJSON = getObjectOrJSON;
+exports.getPageHTML = getPageHTML;
+exports.sanitizeJSONString = sanitizeJSONString;
+exports.escapeClosingScriptTag = escapeClosingScriptTag;
+exports.escapeUnicode = escapeUnicode;
+const react_1 = require("react");
+const redoc_1 = require("redoc");
+const server_1 = require("react-dom/server");
+const styled_components_1 = require("styled-components");
+const handlebars_1 = require("handlebars");
+const path_1 = require("path");
+const fs_1 = require("fs");
+const colorette_1 = require("colorette");
+const openapi_core_1 = require("@redocly/openapi-core");
+const miscellaneous_1 = require("../../utils/miscellaneous");
+function getObjectOrJSON(openapiOptions, config) {
+    switch (typeof openapiOptions) {
+        case 'object':
+            return openapiOptions;
+        case 'string':
+            try {
+                if ((0, fs_1.existsSync)(openapiOptions) && (0, fs_1.lstatSync)(openapiOptions).isFile()) {
+                    return JSON.parse((0, fs_1.readFileSync)(openapiOptions, 'utf-8'));
+                }
+                else {
+                    return JSON.parse(openapiOptions);
+                }
+            }
+            catch (e) {
+                process.stderr.write((0, colorette_1.red)(`Encountered error:\n\n${openapiOptions}\n\nis neither a file with a valid JSON object neither a stringified JSON object.`));
+                (0, miscellaneous_1.exitWithError)(e);
+            }
+            break;
+        default: {
+            if (config) {
+                process.stdout.write(`Found ${config.configFile} and using theme.openapi options\n`);
+                return config.theme.openapi ? config.theme.openapi : {};
+            }
+            return {};
+        }
+    }
+    return {};
+}
+async function getPageHTML(api, pathToApi, { title, disableGoogleFont, templateFileName, templateOptions, redocOptions = {}, redocCurrentVersion, }, configPath) {
+    process.stdout.write('Prerendering docs\n');
+    const apiUrl = redocOptions.specUrl || ((0, openapi_core_1.isAbsoluteUrl)(pathToApi) ? pathToApi : undefined);
+    const store = await (0, redoc_1.createStore)(api, apiUrl, redocOptions);
+    const sheet = new styled_components_1.ServerStyleSheet();
+    const html = (0, server_1.renderToString)(sheet.collectStyles((0, react_1.createElement)(redoc_1.Redoc, { store })));
+    const state = await store.toJS();
+    const css = sheet.getStyleTags();
+    templateFileName = templateFileName
+        ? templateFileName
+        : redocOptions?.htmlTemplate
+            ? (0, path_1.resolve)(configPath ? (0, path_1.dirname)(configPath) : '', redocOptions.htmlTemplate)
+            : (0, path_1.join)(__dirname, './template.hbs');
+    const template = (0, handlebars_1.compile)((0, fs_1.readFileSync)(templateFileName).toString());
+    return template({
+        redocHTML: `
+      <div id="redoc">${html || ''}</div>
+      <script>
+      ${`const __redoc_state = ${sanitizeJSONString(JSON.stringify(state))};` || ''}
+
+      var container = document.getElementById('redoc');
+      Redoc.${'hydrate(__redoc_state, container)'};
+
+      </script>`,
+        redocHead: `<script src="https://cdn.redocly.com/redoc/v${redocCurrentVersion}/bundles/redoc.standalone.js"></script>` +
+            css,
+        title: title || api.info.title || 'ReDoc documentation',
+        disableGoogleFont,
+        templateOptions,
+    });
+}
+function sanitizeJSONString(str) {
+    return escapeClosingScriptTag(escapeUnicode(str));
+}
+// see http://www.thespanner.co.uk/2011/07/25/the-json-specification-is-now-wrong/
+function escapeClosingScriptTag(str) {
+    return str.replace(/<\/script>/g, '<\\/script>');
+}
+// see http://www.thespanner.co.uk/2011/07/25/the-json-specification-is-now-wrong/
+function escapeUnicode(str) {
+    return str.replace(/\u2028|\u2029/g, (m) => '\\u202' + (m === '\u2028' ? '8' : '9'));
+}

package/lib/commands/bundle.d.ts

@@ -0,0 +1,14 @@
+import type { OutputExtensions, Skips, VerifyConfigOptions } from '../types';
+import type { CommandArgs } from '../wrapper';
+export type BundleOptions = {
+    apis?: string[];
+    extends?: string[];
+    output?: string;
+    ext?: OutputExtensions;
+    dereferenced?: boolean;
+    force?: boolean;
+    metafile?: string;
+    'remove-unused-components'?: boolean;
+    'keep-url-references'?: boolean;
+} & Skips & VerifyConfigOptions;
+export declare function handleBundle({ argv, config, version, collectSpecData, }: CommandArgs<BundleOptions>): Promise<void>;

package/lib/commands/bundle.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleBundle = handleBundle;
+const perf_hooks_1 = require("perf_hooks");
+const colorette_1 = require("colorette");
+const fs_1 = require("fs");
+const openapi_core_1 = require("@redocly/openapi-core");
+const miscellaneous_1 = require("../utils/miscellaneous");
+async function handleBundle({ argv, config, version, collectSpecData, }) {
+    const removeUnusedComponents = argv['remove-unused-components'] ||
+        config.rawConfig?.styleguide?.decorators?.hasOwnProperty('remove-unused-components');
+    const apis = await (0, miscellaneous_1.getFallbackApisOrExit)(argv.apis, config);
+    const totals = { errors: 0, warnings: 0, ignored: 0 };
+    const deprecatedOptions = [];
+    (0, miscellaneous_1.checkForDeprecatedOptions)(argv, deprecatedOptions);
+    for (const { path, alias, output } of apis) {
+        try {
+            const startedAt = perf_hooks_1.performance.now();
+            const resolvedConfig = (0, openapi_core_1.getMergedConfig)(config, alias);
+            const { styleguide } = resolvedConfig;
+            styleguide.skipPreprocessors(argv['skip-preprocessor']);
+            styleguide.skipDecorators(argv['skip-decorator']);
+            process.stderr.write((0, colorette_1.gray)(`bundling ${(0, miscellaneous_1.formatPath)(path)}...\n`));
+            const { bundle: result, problems, ...meta } = await (0, openapi_core_1.bundle)({
+                config: resolvedConfig,
+                ref: path,
+                dereference: argv.dereferenced,
+                removeUnusedComponents,
+                keepUrlRefs: argv['keep-url-references'],
+                collectSpecData,
+            });
+            const fileTotals = (0, openapi_core_1.getTotals)(problems);
+            const { outputFile, ext } = (0, miscellaneous_1.getOutputFileName)({
+                entrypoint: path,
+                output,
+                argvOutput: argv.output,
+                ext: argv.ext,
+                entries: argv?.apis?.length || 0,
+            });
+            if (fileTotals.errors === 0 || argv.force) {
+                if (!outputFile) {
+                    const bundled = (0, miscellaneous_1.dumpBundle)((0, miscellaneous_1.sortTopLevelKeysForOas)(result.parsed), argv.ext || 'yaml', argv.dereferenced);
+                    process.stdout.write(bundled);
+                }
+                else {
+                    const bundled = (0, miscellaneous_1.dumpBundle)((0, miscellaneous_1.sortTopLevelKeysForOas)(result.parsed), ext, argv.dereferenced);
+                    (0, miscellaneous_1.saveBundle)(outputFile, bundled);
+                }
+            }
+            totals.errors += fileTotals.errors;
+            totals.warnings += fileTotals.warnings;
+            totals.ignored += fileTotals.ignored;
+            (0, openapi_core_1.formatProblems)(problems, {
+                format: 'codeframe',
+                totals: fileTotals,
+                version,
+            });
+            if (argv.metafile) {
+                if (apis.length > 1) {
+                    process.stderr.write((0, colorette_1.yellow)(`[WARNING] "--metafile" cannot be used with multiple apis. Skipping...`));
+                }
+                {
+                    (0, fs_1.writeFileSync)(argv.metafile, JSON.stringify(meta), 'utf-8');
+                }
+            }
+            const elapsed = (0, miscellaneous_1.getExecutionTime)(startedAt);
+            if (fileTotals.errors > 0) {
+                if (argv.force) {
+                    process.stderr.write(`❓ Created a bundle for ${(0, colorette_1.blue)((0, miscellaneous_1.formatPath)(path))} at ${(0, colorette_1.blue)(outputFile || 'stdout')} with errors ${(0, colorette_1.green)(elapsed)}.\n${(0, colorette_1.yellow)('Errors ignored because of --force')}.\n`);
+                }
+                else {
+                    process.stderr.write(`❌ Errors encountered while bundling ${(0, colorette_1.blue)((0, miscellaneous_1.formatPath)(path))}: bundle not created (use --force to ignore errors).\n`);
+                }
+            }
+            else {
+                process.stderr.write(`📦 Created a bundle for ${(0, colorette_1.blue)((0, miscellaneous_1.formatPath)(path))} at ${(0, colorette_1.blue)(outputFile || 'stdout')} ${(0, colorette_1.green)(elapsed)}.\n`);
+            }
+            const removedCount = meta.visitorsData?.['remove-unused-components']?.removedCount;
+            if (removedCount) {
+                process.stderr.write((0, colorette_1.gray)(`🧹 Removed ${removedCount} unused components.\n`));
+            }
+        }
+        catch (e) {
+            (0, miscellaneous_1.handleError)(e, path);
+        }
+    }
+    (0, miscellaneous_1.printUnusedWarnings)(config.styleguide);
+    if (!(totals.errors === 0 || argv.force)) {
+        throw new Error('Bundle failed.');
+    }
+}

package/lib/commands/eject.d.ts

@@ -0,0 +1,9 @@
+import type { CommandArgs } from '../wrapper';
+import type { VerifyConfigOptions } from '../types';
+export type EjectOptions = {
+    type: 'component';
+    path?: string;
+    'project-dir'?: string;
+    force: boolean;
+} & VerifyConfigOptions;
+export declare const handleEject: ({ argv }: CommandArgs<EjectOptions>) => Promise<void>;

package/lib/commands/eject.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleEject = void 0;
+const child_process_1 = require("child_process");
+const platform_1 = require("../utils/platform");
+const handleEject = async ({ argv }) => {
+    process.stdout.write(`\nLaunching eject using NPX.\n\n`);
+    const { npxExecutableName, sanitize, shell } = (0, platform_1.getPlatformSpawnArgs)();
+    const path = sanitize(argv.path, platform_1.sanitizePath);
+    const projectDir = sanitize(argv['project-dir'], platform_1.sanitizePath);
+    const child = (0, child_process_1.spawn)(npxExecutableName, [
+        '-y',
+        '@redocly/realm',
+        'eject',
+        `${argv.type}`,
+        path,
+        `-d=${projectDir}`,
+        argv.force ? `--force=${argv.force}` : '',
+    ], {
+        stdio: 'inherit',
+        shell,
+    });
+    child.on('error', (error) => {
+        process.stderr.write(`Eject launch failed: ${error.message}`);
+        throw new Error('Eject launch failed.');
+    });
+};
+exports.handleEject = handleEject;

package/lib/commands/join.d.ts

@@ -0,0 +1,11 @@
+import type { CommandArgs } from '../wrapper';
+import type { VerifyConfigOptions } from '../types';
+export type JoinOptions = {
+    apis: string[];
+    'prefix-tags-with-info-prop'?: string;
+    'prefix-tags-with-filename'?: boolean;
+    'prefix-components-with-info-prop'?: string;
+    'without-x-tag-groups'?: boolean;
+    output?: string;
+} & VerifyConfigOptions;
+export declare function handleJoin({ argv, config, version: packageVersion, }: CommandArgs<JoinOptions>): Promise<void>;