@redocly/cli 0.0.0-snapshot.1737554067

package/lib/commands/login.d.ts

@@ -0,0 +1,9 @@
+import type { CommandArgs } from '../wrapper';
+import type { Region } from '@redocly/openapi-core';
+export declare function promptClientToken(domain: string): Promise<string>;
+export type LoginOptions = {
+    verbose?: boolean;
+    region?: Region;
+    config?: string;
+};
+export declare function handleLogin({ argv, config }: CommandArgs<LoginOptions>): Promise<void>;

package/lib/commands/login.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptClientToken = promptClientToken;
+exports.handleLogin = handleLogin;
+const colorette_1 = require("colorette");
+const openapi_core_1 = require("@redocly/openapi-core");
+const miscellaneous_1 = require("../utils/miscellaneous");
+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`), true);
+}
+async function handleLogin({ argv, config }) {
+    try {
+        const region = argv.region || 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);
+    }
+}

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

@@ -0,0 +1,12 @@
+import type { Skips, VerifyConfigOptions } from '../../types';
+import type { CommandArgs } from '../../wrapper';
+export type PreviewDocsOptions = {
+    port: number;
+    host: string;
+    'use-community-edition'?: boolean;
+    config?: string;
+    api?: string;
+    force?: boolean;
+} & Omit<Skips, 'skip-rule'> & VerifyConfigOptions;
+export declare function previewDocs({ argv, config: configFromFile, }: CommandArgs<PreviewDocsOptions>): Promise<void>;
+export declare function debounce(func: Function, wait: number, immediate?: boolean): (...args: any[]) => void;

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

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.previewDocs = previewDocs;
+exports.debounce = debounce;
+const colorette = require("colorette");
+const chockidar = require("chokidar");
+const openapi_core_1 = require("@redocly/openapi-core");
+const miscellaneous_1 = require("../../utils/miscellaneous");
+const preview_server_1 = require("./preview-server/preview-server");
+async function previewDocs({ argv, config: configFromFile, }) {
+    let isAuthorizedWithRedocly = false;
+    let redocOptions = {};
+    let config = await reloadConfig(configFromFile);
+    const apis = await (0, miscellaneous_1.getFallbackApisOrExit)(argv.api ? [argv.api] : [], config);
+    const api = apis[0];
+    let cachedBundle;
+    const deps = new Set();
+    async function getBundle() {
+        return cachedBundle;
+    }
+    async function updateBundle() {
+        process.stdout.write('\nBundling...\n\n');
+        try {
+            const { bundle: openapiBundle, problems, fileDependencies, } = await (0, openapi_core_1.bundle)({
+                ref: api.path,
+                config,
+            });
+            const removed = [...deps].filter((x) => !fileDependencies.has(x));
+            watcher.unwatch(removed);
+            watcher.add([...fileDependencies]);
+            deps.clear();
+            fileDependencies.forEach(deps.add, deps);
+            const fileTotals = (0, openapi_core_1.getTotals)(problems);
+            if (fileTotals.errors === 0) {
+                process.stdout.write(fileTotals.errors === 0
+                    ? `Created a bundle for ${api.alias || api.path} ${fileTotals.warnings > 0 ? 'with warnings' : 'successfully'}\n`
+                    : colorette.yellow(`Created a bundle for ${api.alias || api.path} with errors. Docs may be broken or not accurate\n`));
+            }
+            return openapiBundle.parsed;
+        }
+        catch (e) {
+            (0, miscellaneous_1.handleError)(e, api.path);
+        }
+    }
+    setImmediate(() => {
+        cachedBundle = updateBundle();
+    }); // initial cache
+    const isAuthorized = isAuthorizedWithRedocly || redocOptions.licenseKey;
+    if (!isAuthorized) {
+        process.stderr.write(`Using Redoc community edition.\nLogin with redocly ${colorette.blue('login')} or use an enterprise license key to preview with the premium docs.\n\n`);
+    }
+    const hotClients = await (0, preview_server_1.default)(argv.port, argv.host, {
+        getBundle,
+        getOptions: () => redocOptions,
+        useRedocPro: isAuthorized && !redocOptions.useCommunityEdition,
+    });
+    const watchPaths = [api.path, config.configFile].filter((e) => !!e);
+    const watcher = chockidar.watch(watchPaths, {
+        disableGlobbing: true,
+        ignoreInitial: true,
+    });
+    const debouncedUpdatedBundle = debounce(async () => {
+        cachedBundle = updateBundle();
+        await cachedBundle;
+        hotClients.broadcast('{"type": "reload", "bundle": true}');
+    }, 2000);
+    const changeHandler = async (type, file) => {
+        process.stdout.write(`${colorette.green('watch')} ${type} ${colorette.blue(file)}\n`);
+        if (file === config.configFile) {
+            config = await reloadConfig();
+            hotClients.broadcast(JSON.stringify({ type: 'reload' }));
+            return;
+        }
+        debouncedUpdatedBundle();
+    };
+    watcher.on('change', changeHandler.bind(undefined, 'changed'));
+    watcher.on('add', changeHandler.bind(undefined, 'added'));
+    watcher.on('unlink', changeHandler.bind(undefined, 'removed'));
+    watcher.on('ready', () => {
+        process.stdout.write(`\n  👀  Watching ${colorette.blue(api.path)} and all related resources for changes\n\n`);
+    });
+    async function reloadConfig(config) {
+        if (!config) {
+            try {
+                config = (await (0, miscellaneous_1.loadConfigAndHandleErrors)({ configPath: argv.config }));
+            }
+            catch (err) {
+                config = new openapi_core_1.Config({ apis: {}, styleguide: {} });
+            }
+        }
+        const redoclyClient = new openapi_core_1.RedoclyClient();
+        isAuthorizedWithRedocly = await redoclyClient.isAuthorizedWithRedocly();
+        const resolvedConfig = (0, openapi_core_1.getMergedConfig)(config, argv.api);
+        const { styleguide } = resolvedConfig;
+        styleguide.skipPreprocessors(argv['skip-preprocessor']);
+        styleguide.skipDecorators(argv['skip-decorator']);
+        const referenceDocs = resolvedConfig.theme?.openapi;
+        redocOptions = {
+            ...referenceDocs,
+            useCommunityEdition: argv['use-community-edition'] || referenceDocs?.useCommunityEdition,
+            licenseKey: process.env.REDOCLY_LICENSE_KEY || referenceDocs?.licenseKey,
+            whiteLabel: true,
+        };
+        return resolvedConfig;
+    }
+}
+// eslint-disable-next-line @typescript-eslint/ban-types
+function debounce(func, wait, immediate) {
+    let timeout;
+    return function executedFunction(...args) {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const context = this;
+        const later = () => {
+            timeout = null;
+            if (!immediate)
+                func.apply(context, args);
+        };
+        const callNow = immediate && !timeout;
+        if (timeout)
+            clearTimeout(timeout);
+        timeout = setTimeout(later, wait);
+        if (callNow)
+            func.apply(context, args);
+    };
+}

package/lib/commands/preview-docs/preview-server/default.hbs

@@ -0,0 +1,24 @@
+
+<!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}}}
+  <link href="https://fonts.googleapis.com/css?family=Montserrat:300,400,700|Roboto:300,400,700" rel="stylesheet">
+</head>
+
+<body>
+  {{{redocHTML}}}
+</body>
+
+</html>

package/lib/commands/preview-docs/preview-server/hot.js

@@ -0,0 +1,59 @@
+(function run() {
+  const Socket = window.SimpleWebsocket;
+  const port = window.__OPENAPI_CLI_WS_PORT;
+  const host = window.__OPENAPI_CLI_WS_HOST;
+
+  let socket;
+
+  reconnect();
+
+  function getFormattedHost() {
+    // Use localhost when bound to all interfaces
+    if (host === '::' || host === '0.0.0.0') {
+      return 'localhost';
+    }
+
+    // Other IPv6 addresses must be wrapped in brackets
+    if (host.includes('::')) {
+      return `[${host}]`;
+    }
+
+    // Otherwise return as-is
+    return host;
+  }
+
+  function reconnect() {
+    socket = new Socket(`ws://${getFormattedHost()}:${port}`);
+    socket.on('connect', () => {
+      socket.send('{"type": "ping"}');
+    });
+
+    socket.on('data', (data) => {
+      const message = JSON.parse(data);
+      switch (message.type) {
+        case 'pong':
+          console.log('[hot] hot reloading connected');
+          break;
+        case 'reload':
+          console.log('[hot] full page reload');
+          window.location.reload();
+          break;
+        default:
+          console.log(`[hot] ${message.type} received`);
+      }
+    });
+
+    socket.on('close', () => {
+      socket.destroy();
+      console.log('[hot] Connection lost, trying to reconnect in 4s');
+      setTimeout(() => {
+        reconnect();
+      }, 4000);
+    });
+
+    socket.on('error', () => {
+      console.log('[hot] Error connecting to hot reloading server');
+      socket.destroy();
+    });
+  }
+})();

package/lib/commands/preview-docs/preview-server/oauth2-redirect.html

@@ -0,0 +1,21 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width,initial-scale=1,shrink-to-fit=no" />
+    <title>Redocly Reference Docs: OAuth2 Redirect</title>
+    <style>
+      .user-info {
+        margin: 150px auto auto;
+        width: 50%;
+        background-color: whitesmoke;
+        padding: 20px;
+        text-align: center;
+      }
+    </style>
+  </head>
+  <body>
+    <script src="https://cdn.redocly.com/reference-docs/latest/oauth2-redirect.js"></script>
+    <noscript>You need to enable JavaScript to run this app.</noscript>
+  </body>
+</html>

package/lib/commands/preview-docs/preview-server/preview-server.d.ts

@@ -0,0 +1,5 @@
+export default function startPreviewServer(port: number, host: string, { getBundle, getOptions, useRedocPro, }: {
+    getBundle: Function;
+    getOptions: Function;
+    useRedocPro: boolean;
+}): Promise<any>;

package/lib/commands/preview-docs/preview-server/preview-server.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = startPreviewServer;
+const handlebars_1 = require("handlebars");
+const colorette = require("colorette");
+const get_port_please_1 = require("get-port-please");
+const fs_1 = require("fs");
+const path = require("path");
+const server_1 = require("./server");
+const miscellaneous_1 = require("../../../utils/miscellaneous");
+function getPageHTML(htmlTemplate, redocOptions = {}, useRedocPro, wsPort, host) {
+    let templateSrc = (0, fs_1.readFileSync)(htmlTemplate, 'utf-8');
+    // fix template for backward compatibility
+    templateSrc = templateSrc
+        .replace(/{?{{redocHead}}}?/, '{{{redocHead}}}')
+        .replace('{{redocBody}}', '{{{redocHTML}}}');
+    const template = (0, handlebars_1.compile)(templateSrc);
+    return template({
+        redocHead: `
+  <script>
+    window.__REDOC_EXPORT = '${useRedocPro ? 'RedoclyReferenceDocs' : 'Redoc'}';
+    window.__OPENAPI_CLI_WS_PORT = ${wsPort};
+    window.__OPENAPI_CLI_WS_HOST = "${host}";
+  </script>
+  <script src="/simplewebsocket.min.js"></script>
+  <script src="/hot.js"></script>
+  <script src="${useRedocPro
+            ? 'https://cdn.redocly.com/reference-docs/latest/redocly-reference-docs.min.js'
+            : 'https://cdn.redocly.com/redoc/latest/bundles/redoc.standalone.js'}"></script>
+`,
+        redocHTML: `
+  <div id="redoc"></div>
+  <script>
+    var container = document.getElementById('redoc');
+    ${useRedocPro
+            ? "window[window.__REDOC_EXPORT].setPublicPath('https://cdn.redocly.com/reference-docs/latest/');"
+            : ''}
+    window[window.__REDOC_EXPORT].init("/openapi.json", ${JSON.stringify(redocOptions)}, container)
+  </script>`,
+    });
+}
+async function startPreviewServer(port, host, { getBundle, getOptions, useRedocPro, }) {
+    const defaultTemplate = path.join(__dirname, 'default.hbs');
+    const handler = async (request, response) => {
+        console.time(colorette.dim(`GET ${request.url}`));
+        const { htmlTemplate } = getOptions() || {};
+        if (request.url?.endsWith('/') || path.extname(request.url) === '') {
+            (0, server_1.respondWithGzip)(getPageHTML(htmlTemplate || defaultTemplate, getOptions(), useRedocPro, wsPort, host), request, response, {
+                'Content-Type': 'text/html',
+            });
+        }
+        else if (request.url === '/openapi.json') {
+            const bundle = await getBundle();
+            if (bundle === undefined) {
+                (0, server_1.respondWithGzip)(JSON.stringify({
+                    openapi: '3.0.0',
+                    info: {
+                        description: '<code> Failed to generate bundle: check out console output for more details </code>',
+                    },
+                    paths: {},
+                }), request, response, {
+                    'Content-Type': 'application/json',
+                });
+            }
+            else {
+                (0, server_1.respondWithGzip)(JSON.stringify(bundle), request, response, {
+                    'Content-Type': 'application/json',
+                });
+            }
+        }
+        else {
+            let filePath = 
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            {
+                '/hot.js': path.join(__dirname, 'hot.js'),
+                '/oauth2-redirect.html': path.join(__dirname, 'oauth2-redirect.html'),
+                '/simplewebsocket.min.js': require.resolve('simple-websocket/simplewebsocket.min.js'),
+            }[request.url || ''];
+            if (!filePath) {
+                const basePath = htmlTemplate ? path.dirname(htmlTemplate) : process.cwd();
+                filePath = path.resolve(basePath, `.${request.url}`);
+                if (!(0, miscellaneous_1.isSubdir)(basePath, filePath)) {
+                    (0, server_1.respondWithGzip)('404 Not Found', request, response, { 'Content-Type': 'text/html' }, 404);
+                    console.timeEnd(colorette.dim(`GET ${request.url}`));
+                    return;
+                }
+            }
+            const extname = String(path.extname(filePath)).toLowerCase();
+            const contentType = server_1.mimeTypes[extname] || 'application/octet-stream';
+            try {
+                (0, server_1.respondWithGzip)(await fs_1.promises.readFile(filePath), request, response, {
+                    'Content-Type': contentType,
+                });
+            }
+            catch (e) {
+                if (e.code === 'ENOENT') {
+                    (0, server_1.respondWithGzip)('404 Not Found', request, response, { 'Content-Type': 'text/html' }, 404);
+                }
+                else {
+                    (0, server_1.respondWithGzip)(`Something went wrong: ${e.code || e.message}...\n`, request, response, {}, 500);
+                }
+            }
+        }
+        console.timeEnd(colorette.dim(`GET ${request.url}`));
+    };
+    const wsPort = await (0, get_port_please_1.getPort)({ port: 32201, portRange: [32201, 32301], host });
+    const server = (0, server_1.startHttpServer)(port, host, handler);
+    server.on('listening', () => {
+        process.stdout.write(`\n  🔎  Preview server running at ${colorette.blue(`http://${host}:${port}\n`)}`);
+    });
+    return (0, server_1.startWsServer)(wsPort, host);
+}

package/lib/commands/preview-docs/preview-server/server.d.ts

@@ -0,0 +1,22 @@
+import * as http from 'http';
+import type { ReadStream } from 'fs';
+export declare const mimeTypes: {
+    '.html': string;
+    '.js': string;
+    '.css': string;
+    '.json': string;
+    '.png': string;
+    '.jpg': string;
+    '.gif': string;
+    '.svg': string;
+    '.wav': string;
+    '.mp4': string;
+    '.woff': string;
+    '.ttf': string;
+    '.eot': string;
+    '.otf': string;
+    '.wasm': string;
+};
+export declare function respondWithGzip(contents: string | Buffer | ReadStream, request: http.IncomingMessage, response: http.ServerResponse, headers?: {}, code?: number): void;
+export declare function startHttpServer(port: number, host: string, handler: http.RequestListener): http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
+export declare function startWsServer(port: number, host: string): any;

package/lib/commands/preview-docs/preview-server/server.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mimeTypes = void 0;
+exports.respondWithGzip = respondWithGzip;
+exports.startHttpServer = startHttpServer;
+exports.startWsServer = startWsServer;
+const http = require("http");
+const zlib = require("zlib");
+const SocketServer = require('simple-websocket/server.js');
+exports.mimeTypes = {
+    '.html': 'text/html',
+    '.js': 'text/javascript',
+    '.css': 'text/css',
+    '.json': 'application/json',
+    '.png': 'image/png',
+    '.jpg': 'image/jpg',
+    '.gif': 'image/gif',
+    '.svg': 'image/svg+xml',
+    '.wav': 'audio/wav',
+    '.mp4': 'video/mp4',
+    '.woff': 'application/font-woff',
+    '.ttf': 'application/font-ttf',
+    '.eot': 'application/vnd.ms-fontobject',
+    '.otf': 'application/font-otf',
+    '.wasm': 'application/wasm',
+};
+// credits: https://stackoverflow.com/a/9238214/1749888
+function respondWithGzip(contents, request, response, headers = {}, code = 200) {
+    let compressedStream;
+    const acceptEncoding = request.headers['accept-encoding'] || '';
+    if (acceptEncoding.match(/\bdeflate\b/)) {
+        response.writeHead(code, { ...headers, 'content-encoding': 'deflate' });
+        compressedStream = zlib.createDeflate();
+    }
+    else if (acceptEncoding.match(/\bgzip\b/)) {
+        response.writeHead(code, { ...headers, 'content-encoding': 'gzip' });
+        compressedStream = zlib.createGzip();
+    }
+    else {
+        response.writeHead(code, headers);
+        if (typeof contents === 'string' || Buffer.isBuffer(contents)) {
+            response.write(contents);
+            response.end();
+        }
+        else if (response !== undefined) {
+            contents.pipe(response);
+        }
+        return;
+    }
+    if (typeof contents === 'string' || Buffer.isBuffer(contents)) {
+        compressedStream.write(contents);
+        compressedStream.pipe(response);
+        compressedStream.end();
+    }
+    else {
+        contents.pipe(compressedStream).pipe(response);
+    }
+}
+function startHttpServer(port, host, handler) {
+    return http.createServer(handler).listen(port, host);
+}
+function startWsServer(port, host) {
+    const socketServer = new SocketServer({ port, host, clientTracking: true });
+    socketServer.on('connection', (socket) => {
+        socket.on('data', (data) => {
+            const message = JSON.parse(data);
+            switch (message.type) {
+                case 'ping':
+                    socket.send('{"type": "pong"}');
+                    break;
+                default:
+                // nope
+            }
+        });
+    });
+    socketServer.broadcast = (message) => {
+        socketServer._server.clients.forEach((client) => {
+            if (client.readyState === 1) {
+                // OPEN
+                client.send(message);
+            }
+        });
+    };
+    return socketServer;
+}

package/lib/commands/preview-project/constants.d.ts

@@ -0,0 +1,14 @@
+import type { Product } from './types';
+export declare const PRODUCT_PACKAGES: {
+    realm: string;
+    'redoc-revel': string;
+    'revel-reef': string;
+    'redoc-reef': string;
+    redoc: string;
+    revel: string;
+    reef: string;
+};
+export declare const PRODUCT_NAMES: {
+    [key in Product]: string;
+};
+export declare const PRODUCT_PLANS: readonly ["pro", "enterprise"];

package/lib/commands/preview-project/constants.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PRODUCT_PLANS = exports.PRODUCT_NAMES = exports.PRODUCT_PACKAGES = void 0;
+exports.PRODUCT_PACKAGES = {
+    realm: '@redocly/realm',
+    'redoc-revel': '@redocly/redoc-revel',
+    'revel-reef': '@redocly/revel-reef',
+    'redoc-reef': '@redocly/redoc-reef',
+    redoc: '@redocly/redoc',
+    revel: '@redocly/revel',
+    reef: '@redocly/reef',
+};
+exports.PRODUCT_NAMES = {
+    redoc: 'Redoc',
+    revel: 'Revel',
+    reef: 'Reef',
+    realm: 'Realm',
+    'redoc-revel': 'Redoc + Revel',
+    'redoc-reef': 'Redoc + Reef',
+    'revel-reef': 'Revel + Reef',
+};
+exports.PRODUCT_PLANS = ['pro', 'enterprise'];

package/lib/commands/preview-project/index.d.ts

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

package/lib/commands/preview-project/index.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.previewProject = void 0;
+const path = require("path");
+const fs_1 = require("fs");
+const child_process_1 = require("child_process");
+const constants_1 = require("./constants");
+const platform_1 = require("../../utils/platform");
+const previewProject = async ({ argv }) => {
+    const { plan, port } = argv;
+    const projectDir = argv['project-dir'];
+    const product = argv.product || tryGetProductFromPackageJson(projectDir);
+    if (!isValidProduct(product)) {
+        process.stderr.write(`Invalid product ${product}.`);
+        throw new Error(`Project preview launch failed.`);
+    }
+    const productName = constants_1.PRODUCT_NAMES[product];
+    const packageName = constants_1.PRODUCT_PACKAGES[product];
+    process.stdout.write(`\nLaunching preview of ${productName} ${plan} using NPX.\n\n`);
+    const { npxExecutableName, shell } = (0, platform_1.getPlatformSpawnArgs)();
+    const child = (0, child_process_1.spawn)(npxExecutableName, ['-y', packageName, 'preview', `--plan=${plan}`, `--port=${port || 4000}`], {
+        stdio: 'inherit',
+        cwd: projectDir,
+        shell,
+    });
+    child.on('error', (error) => {
+        process.stderr.write(`Project preview launch failed: ${error.message}`);
+        throw new Error(`Project preview launch failed.`);
+    });
+};
+exports.previewProject = previewProject;
+const isValidProduct = (product) => {
+    if (!product) {
+        return false;
+    }
+    return !!constants_1.PRODUCT_NAMES[product];
+};
+const tryGetProductFromPackageJson = (projectDir) => {
+    const packageJsonPath = path.join(process.cwd(), projectDir, 'package.json');
+    if ((0, fs_1.existsSync)(packageJsonPath)) {
+        try {
+            const packageJson = JSON.parse((0, fs_1.readFileSync)(packageJsonPath, 'utf-8'));
+            const packageJsonDeps = packageJson.dependencies || {};
+            for (const [product, packageName] of Object.entries(constants_1.PRODUCT_PACKAGES)) {
+                if (packageJsonDeps[packageName]) {
+                    process.stdout.write(`\n${packageName} detected in project's 'package.json'`);
+                    return product;
+                }
+            }
+        }
+        catch (error) {
+            process.stdout.write(`Invalid 'package.json': ${packageJsonPath}. Using Realm.`);
+        }
+    }
+    return 'realm';
+};

package/lib/commands/preview-project/types.d.ts

@@ -0,0 +1,10 @@
+import type { VerifyConfigOptions } from '../../types';
+import type { PRODUCT_PACKAGES, PRODUCT_PLANS } from './constants';
+export type Product = keyof typeof PRODUCT_PACKAGES;
+export type ProductPlan = typeof PRODUCT_PLANS[number];
+export type PreviewProjectOptions = {
+    product?: Product | string;
+    plan: ProductPlan | string;
+    port?: number;
+    'project-dir': string;
+} & VerifyConfigOptions;

package/lib/commands/preview-project/types.js

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