@asyncapi-actions-test/trusted-publishing-test_asyncapi-cli 4.1.3

package/lib/apps/cli/commands/optimize.d.ts

@@ -0,0 +1,41 @@
+import Command from '../internal/base';
+import { Parser } from '@asyncapi/parser';
+export declare enum Optimizations {
+    REMOVE_COMPONENTS = "remove-components",
+    REUSE_COMPONENTS = "reuse-components",
+    MOVE_DUPLICATES_TO_COMPONENTS = "move-duplicates-to-components",
+    MOVE_ALL_TO_COMPONENTS = "move-all-to-components"
+}
+export declare enum DisableOptimizations {
+    SCHEMA = "schema"
+}
+export declare enum Outputs {
+    TERMINAL = "terminal",
+    NEW_FILE = "new-file",
+    OVERWRITE = "overwrite"
+}
+export default class Optimize extends Command {
+    static description: string;
+    isInteractive: boolean;
+    selectedOptimizations?: Optimizations[];
+    disableOptimizations?: DisableOptimizations[];
+    outputMethod?: Outputs;
+    static examples: string[];
+    static flags: {
+        proxyHost: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        proxyPort: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        help: import("@oclif/core/lib/interfaces").BooleanFlag<void>;
+        optimization: import("@oclif/core/lib/interfaces").OptionFlag<string[], import("@oclif/core/lib/interfaces").CustomOptions>;
+        ignore: import("@oclif/core/lib/interfaces").OptionFlag<string[], import("@oclif/core/lib/interfaces").CustomOptions>;
+        output: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'no-tty': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    static args: {
+        'spec-file': import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    parser: Parser;
+    run(): Promise<void>;
+    private showOptimizations;
+    private interactiveRun;
+    private collectMetricsData;
+}

package/lib/apps/cli/commands/optimize.js

@@ -0,0 +1,289 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Outputs = exports.DisableOptimizations = exports.Optimizations = void 0;
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const optimizer_1 = require("@asyncapi/optimizer");
+const base_1 = tslib_1.__importDefault(require("../internal/base"));
+const validation_error_1 = require("../../../errors/validation-error");
+const SpecificationFile_1 = require("../../../domains/models/SpecificationFile");
+const inquirer = tslib_1.__importStar(require("inquirer"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const fs_1 = require("fs");
+const parser_1 = require("@asyncapi/parser");
+const optimize_flags_1 = require("../internal/flags/optimize.flags");
+const proxy_flags_1 = require("../internal/flags/proxy.flags");
+const { writeFile } = fs_1.promises;
+var Optimizations;
+(function (Optimizations) {
+    Optimizations["REMOVE_COMPONENTS"] = "remove-components";
+    Optimizations["REUSE_COMPONENTS"] = "reuse-components";
+    Optimizations["MOVE_DUPLICATES_TO_COMPONENTS"] = "move-duplicates-to-components";
+    Optimizations["MOVE_ALL_TO_COMPONENTS"] = "move-all-to-components";
+})(Optimizations || (exports.Optimizations = Optimizations = {}));
+var DisableOptimizations;
+(function (DisableOptimizations) {
+    DisableOptimizations["SCHEMA"] = "schema";
+})(DisableOptimizations || (exports.DisableOptimizations = DisableOptimizations = {}));
+var Outputs;
+(function (Outputs) {
+    Outputs["TERMINAL"] = "terminal";
+    Outputs["NEW_FILE"] = "new-file";
+    Outputs["OVERWRITE"] = "overwrite";
+})(Outputs || (exports.Outputs = Outputs = {}));
+class Optimize extends base_1.default {
+    constructor() {
+        super(...arguments);
+        this.isInteractive = false;
+        this.parser = new parser_1.Parser();
+    }
+    run() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d;
+            const { args, flags } = yield this.parse(Optimize); //NOSONAR
+            let filePath = args['spec-file'];
+            const proxyHost = flags['proxyHost'];
+            const proxyPort = flags['proxyPort'];
+            if (proxyHost && proxyPort) {
+                const proxyUrl = `http://${proxyHost}:${proxyPort}`;
+                filePath = `${filePath}+${proxyUrl}`; // Update filePath with proxyUrl
+            }
+            try {
+                this.specFile = yield (0, SpecificationFile_1.load)(filePath);
+            }
+            catch (err) {
+                if (err.message.includes('Failed to download')) {
+                    throw new Error('Proxy Connection Error: Unable to establish a connection to the proxy check hostName or PortNumber.');
+                }
+                else if (filePath) {
+                    this.error(new validation_error_1.ValidationError({
+                        type: 'invalid-file',
+                        filepath: filePath,
+                    }));
+                }
+                else {
+                    this.error(new validation_error_1.ValidationError({
+                        type: 'no-spec-found',
+                    }));
+                }
+            }
+            let optimizer;
+            let report;
+            try {
+                optimizer = new optimizer_1.Optimizer(this.specFile.text());
+                report = yield optimizer.getReport();
+            }
+            catch (err) {
+                this.error(new validation_error_1.ValidationError({
+                    type: 'invalid-syntax-file',
+                    filepath: this.specFile.getFilePath(),
+                }));
+            }
+            this.isInteractive = !flags['no-tty'];
+            this.selectedOptimizations = flags.optimization;
+            this.disableOptimizations = flags.ignore;
+            this.outputMethod = flags.output;
+            this.metricsMetadata.optimized = false;
+            if (!(((_a = report.moveDuplicatesToComponents) === null || _a === void 0 ? void 0 : _a.length) ||
+                ((_b = report.removeComponents) === null || _b === void 0 ? void 0 : _b.length) ||
+                ((_c = report.reuseComponents) === null || _c === void 0 ? void 0 : _c.length))) {
+                this.log(`🎉 Great news! Your file at ${(_d = this.specFile.getFilePath()) !== null && _d !== void 0 ? _d : this.specFile.getFileURL()} is already optimized.`);
+                return;
+            }
+            const isTTY = process.stdout.isTTY;
+            if (this.isInteractive && isTTY) {
+                yield this.interactiveRun(report);
+            }
+            try {
+                const fileFormat = (0, SpecificationFile_1.retrieveFileFormat)(this.specFile.text());
+                let optimizedDocument = optimizer.getOptimizedDocument({
+                    rules: {
+                        moveDuplicatesToComponents: this.selectedOptimizations.includes(Optimizations.MOVE_DUPLICATES_TO_COMPONENTS),
+                        moveAllToComponents: this.selectedOptimizations.includes(Optimizations.MOVE_ALL_TO_COMPONENTS),
+                        removeComponents: this.selectedOptimizations.includes(Optimizations.REMOVE_COMPONENTS),
+                        reuseComponents: this.selectedOptimizations.includes(Optimizations.REUSE_COMPONENTS),
+                    },
+                    disableOptimizationFor: {
+                        schema: this.disableOptimizations.includes(DisableOptimizations.SCHEMA),
+                    },
+                    output: fileFormat === 'json' ? optimizer_1.Output.JSON : optimizer_1.Output.YAML,
+                });
+                if (fileFormat === 'json') {
+                    optimizedDocument = JSON.stringify((JSON.parse(optimizedDocument)), null, 2);
+                }
+                this.collectMetricsData(report);
+                const specPath = this.specFile.getFilePath();
+                let newPath = '';
+                if (specPath) {
+                    const pos = specPath.lastIndexOf('.');
+                    newPath = `${specPath.substring(0, pos)}_optimized.${specPath.substring(pos + 1)}`;
+                }
+                else {
+                    newPath = `optimized-asyncapi.${fileFormat}`;
+                }
+                switch (this.outputMethod) {
+                    case Outputs.TERMINAL:
+                        this.log('📄 Here is your optimized AsyncAPI document:\n');
+                        this.log(optimizedDocument);
+                        break;
+                    case Outputs.NEW_FILE:
+                        yield writeFile(newPath, optimizedDocument, { encoding: 'utf8' });
+                        this.log(`✅ Success! Your optimized file has been created at ${chalk_1.default.blue(newPath)}.`);
+                        break;
+                    case Outputs.OVERWRITE:
+                        yield writeFile(specPath !== null && specPath !== void 0 ? specPath : `asyncapi.${fileFormat}`, optimizedDocument, {
+                            encoding: 'utf8',
+                        });
+                        this.log(`✅ Success! Your original file at ${specPath} has been updated.`);
+                        break;
+                }
+            }
+            catch (error) {
+                throw new validation_error_1.ValidationError({
+                    type: 'parser-error',
+                    err: error,
+                });
+            }
+        });
+    }
+    showOptimizations(elements) {
+        if (!elements) {
+            return;
+        }
+        for (let i = 0; i < elements.length; i++) {
+            const element = elements[+i];
+            if (element.action === 'move') {
+                this.log(`${chalk_1.default.green('move')} ${element.path} to ${element.target} and reference it.`);
+            }
+            else if (element.action === 'reuse') {
+                this.log(`${chalk_1.default.green('reuse')} ${element.target} in ${element.path}.`);
+            }
+            else if (element.action === 'remove') {
+                this.log(`${chalk_1.default.red('remove')} ${element.path}.`);
+            }
+        }
+        this.log('\n');
+    }
+    interactiveRun(report) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+            const canMoveDuplicates = (_a = report.moveDuplicatesToComponents) === null || _a === void 0 ? void 0 : _a.length;
+            const canMoveAll = (_b = report.moveAllToComponents) === null || _b === void 0 ? void 0 : _b.length;
+            const canRemove = (_c = report.removeComponents) === null || _c === void 0 ? void 0 : _c.length;
+            const canReuse = (_d = report.reuseComponents) === null || _d === void 0 ? void 0 : _d.length;
+            const choices = [];
+            if (canMoveAll) {
+                const totalMove = (_e = report.moveAllToComponents) === null || _e === void 0 ? void 0 : _e.filter((e) => e.action === 'move').length;
+                this.log(`${chalk_1.default.green(totalMove)} components can be moved to the components sections.\nthe following changes will be made:`);
+                this.showOptimizations(report.moveAllToComponents);
+                choices.push({
+                    name: 'move all $refs to components section',
+                    value: Optimizations.MOVE_ALL_TO_COMPONENTS,
+                });
+            }
+            if (canMoveDuplicates) {
+                const totalMove = (_f = report.moveDuplicatesToComponents) === null || _f === void 0 ? void 0 : _f.filter((e) => e.action === 'move').length;
+                this.log(`\n${chalk_1.default.green(totalMove)} components can be moved to the components sections.\nthe following changes will be made:`);
+                this.showOptimizations(report.moveDuplicatesToComponents);
+                choices.push({
+                    name: 'move to components section',
+                    value: Optimizations.MOVE_DUPLICATES_TO_COMPONENTS,
+                });
+            }
+            if (canRemove) {
+                const totalMove = (_g = report.removeComponents) === null || _g === void 0 ? void 0 : _g.length;
+                this.log(`${chalk_1.default.green(totalMove)} unused components can be removed.\nthe following changes will be made:`);
+                this.showOptimizations(report.removeComponents);
+                choices.push({
+                    name: 'remove components',
+                    value: Optimizations.REMOVE_COMPONENTS,
+                });
+            }
+            if (canReuse) {
+                const totalMove = (_h = report.reuseComponents) === null || _h === void 0 ? void 0 : _h.length;
+                this.log(`${chalk_1.default.green(totalMove)} components can be reused.\nthe following changes will be made:`);
+                this.showOptimizations(report.reuseComponents);
+                choices.push({
+                    name: 'reuse components',
+                    value: Optimizations.REUSE_COMPONENTS,
+                });
+            }
+            if ((_j = this.disableOptimizations) === null || _j === void 0 ? void 0 : _j.includes(DisableOptimizations.SCHEMA)) {
+                choices.push({
+                    name: 'Do not ignore schema',
+                    value: DisableOptimizations.SCHEMA,
+                });
+            }
+            else {
+                choices.push({
+                    name: 'Ignore schema',
+                    value: DisableOptimizations.SCHEMA,
+                });
+            }
+            const optimizationRes = yield inquirer.prompt([
+                {
+                    name: 'optimization',
+                    message: 'select the type of optimization that you want to apply:',
+                    type: 'checkbox',
+                    default: 'all',
+                    choices,
+                },
+            ]);
+            if (optimizationRes.optimization.includes('schema')) {
+                if ((_k = this.disableOptimizations) === null || _k === void 0 ? void 0 : _k.includes(DisableOptimizations.SCHEMA)) {
+                    this.disableOptimizations = (_l = this.disableOptimizations) === null || _l === void 0 ? void 0 : _l.filter((opt) => opt !== DisableOptimizations.SCHEMA);
+                }
+                else {
+                    this.disableOptimizations = [
+                        ...(this.disableOptimizations || []),
+                        DisableOptimizations.SCHEMA,
+                    ];
+                }
+            }
+            this.selectedOptimizations = optimizationRes.optimization;
+            const outputRes = yield inquirer.prompt([
+                {
+                    name: 'output',
+                    message: 'where do you want to save the result:',
+                    type: 'list',
+                    default: 'log to terminal',
+                    choices: [
+                        { name: 'log to terminal', value: Outputs.TERMINAL },
+                        { name: 'create new file', value: Outputs.NEW_FILE },
+                        { name: 'update original file', value: Outputs.OVERWRITE },
+                    ],
+                },
+            ]);
+            this.outputMethod = outputRes.output;
+        });
+    }
+    collectMetricsData(report) {
+        var _a;
+        for (const availableOptimization in report) {
+            const availableOptimizationKebabCase = availableOptimization
+                .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+                .toLowerCase(); // optimization flags are kebab case
+            if (availableOptimization.length &&
+                ((_a = this.selectedOptimizations) === null || _a === void 0 ? void 0 : _a.includes(availableOptimizationKebabCase))) {
+                this.metricsMetadata[`optimization_${availableOptimization}`] = true;
+                this.metricsMetadata.optimized = true;
+            }
+        }
+    }
+}
+Optimize.description = 'optimize asyncapi specification file';
+Optimize.examples = [
+    'asyncapi optimize ./asyncapi.yaml',
+    'asyncapi optimize ./asyncapi.yaml --no-tty',
+    'asyncapi optimize ./asyncapi.yaml --optimization=remove-components --optimization=reuse-components --optimization=move-all-to-components --no-tty',
+    'asyncapi optimize ./asyncapi.yaml --optimization=remove-components --output=terminal --no-tty',
+    'asyncapi optimize ./asyncapi.yaml --ignore=schema',
+];
+Optimize.flags = Object.assign(Object.assign({}, (0, optimize_flags_1.optimizeFlags)()), (0, proxy_flags_1.proxyFlags)());
+Optimize.args = {
+    'spec-file': core_1.Args.string({
+        description: 'spec path, url, or context-name',
+        required: false,
+    }),
+};
+exports.default = Optimize;

package/lib/apps/cli/commands/pretty.d.ts

@@ -0,0 +1,12 @@
+import Command from '../internal/base';
+export default class Pretty extends Command {
+    static readonly description = "Beautify the AsyncAPI spec file (indentation, styling) in place or output the formatted spec to a new file.";
+    static readonly examples: string[];
+    static readonly flags: {
+        output: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    static readonly args: {
+        'spec-file': import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/lib/apps/cli/commands/pretty.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const fs_1 = require("fs");
+const yaml = tslib_1.__importStar(require("yaml"));
+const base_1 = tslib_1.__importDefault(require("../internal/base"));
+const SpecificationFile_1 = require("../../../domains/models/SpecificationFile");
+const validation_error_1 = require("../../../errors/validation-error");
+const pretty_flags_1 = require("../internal/flags/pretty.flags");
+class Pretty extends base_1.default {
+    run() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const { args, flags } = yield this.parse(Pretty);
+            const filePath = args['spec-file'];
+            const outputPath = flags.output;
+            try {
+                this.specFile = yield (0, SpecificationFile_1.load)(filePath);
+            }
+            catch (err) {
+                this.error(new validation_error_1.ValidationError({
+                    type: 'invalid-file',
+                    filepath: filePath,
+                }));
+            }
+            const content = this.specFile.text();
+            let formatted;
+            try {
+                const fileFormat = (0, SpecificationFile_1.retrieveFileFormat)(this.specFile.text());
+                if (fileFormat === 'yaml' || fileFormat === 'yml') {
+                    const yamlDoc = yaml.parseDocument(content);
+                    formatted = yamlDoc.toString({
+                        lineWidth: 0,
+                    });
+                }
+                else if (fileFormat === 'json') {
+                    const jsonObj = JSON.parse(content);
+                    formatted = JSON.stringify(jsonObj, null, 2);
+                }
+                else {
+                    throw new Error('Unsupported file format');
+                }
+            }
+            catch (err) {
+                this.error(`Error formatting file: ${err}`);
+            }
+            if (outputPath) {
+                yield fs_1.promises.writeFile(outputPath, formatted, 'utf8');
+                this.log(`Asyncapi document has been beautified ${outputPath}`);
+            }
+            else {
+                yield fs_1.promises.writeFile(filePath, formatted, 'utf8');
+                this.log(`Asyncapi document ${filePath} has been beautified in-place.`);
+            }
+        });
+    }
+}
+Pretty.description = 'Beautify the AsyncAPI spec file (indentation, styling) in place or output the formatted spec to a new file.';
+Pretty.examples = [
+    'asyncapi pretty ./asyncapi.yaml',
+    'asyncapi pretty ./asyncapi.yaml --output formatted-asyncapi.yaml',
+];
+Pretty.flags = (0, pretty_flags_1.prettyFlags)();
+Pretty.args = {
+    'spec-file': core_1.Args.string({
+        description: 'spec path, url, or context-name',
+        required: true,
+    }),
+};
+exports.default = Pretty;

package/lib/apps/cli/commands/start/api.d.ts

@@ -0,0 +1,11 @@
+import Command from '../../internal/base';
+export default class Api extends Command {
+    static readonly description = "starts the AsyncAPI server API.";
+    static readonly flags: {
+        help: import("@oclif/core/lib/interfaces").BooleanFlag<void>;
+        mode: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        port: import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    static readonly args: {};
+    run(): Promise<void>;
+}

package/lib/apps/cli/commands/start/api.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+process.env['NODE_CONFIG_DIR'] = `${__dirname}/../../../api/configs`;
+const base_1 = tslib_1.__importDefault(require("../../internal/base"));
+const api_flags_1 = require("../../internal/flags/start/api.flags");
+const app_1 = require("../../../../apps/api/app");
+const api_1 = require("../../../../apps/api");
+class Api extends base_1.default {
+    run() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const { flags } = yield this.parse(Api);
+            const app = new app_1.App(api_1.CONTROLLERS, flags.port || 3000, // Default port if not specified
+            flags.mode);
+            yield app.init();
+            app.listen();
+        });
+    }
+}
+Api.description = 'starts the AsyncAPI server API.';
+Api.flags = (0, api_flags_1.apiFlags)();
+Api.args = {};
+exports.default = Api;

package/lib/apps/cli/commands/start/index.d.ts

@@ -0,0 +1,5 @@
+import Command from '../../internal/base';
+export default class Start extends Command {
+    static description: string;
+    run(): Promise<void>;
+}

package/lib/apps/cli/commands/start/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const base_1 = tslib_1.__importDefault(require("../../internal/base"));
+const core_1 = require("@oclif/core");
+class Start extends base_1.default {
+    run() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const help = new core_1.Help(this.config);
+            help.showHelp(['start', '--help']);
+        });
+    }
+}
+Start.description = 'Starts AsyncAPI-related services. Currently, it supports launching the AsyncAPI Studio';
+exports.default = Start;

package/lib/apps/cli/commands/start/preview.d.ts

@@ -0,0 +1,17 @@
+import Command from '../../internal/base';
+export default class PreviewStudio extends Command {
+    static readonly description = "starts a new local instance of Studio in minimal state bundling all the refs of the schema file and with no editing allowed.";
+    static readonly flags: {
+        help: import("@oclif/core/lib/interfaces").BooleanFlag<void>;
+        port: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        base: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        baseDir: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        xOrigin: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        suppressLogs: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        noBrowser: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    static readonly args: {
+        'spec-file': import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/lib/apps/cli/commands/start/preview.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const base_1 = tslib_1.__importDefault(require("../../internal/base"));
+const preview_flags_1 = require("../../internal/flags/start/preview.flags");
+const SpecificationFile_1 = require("../../../../domains/models/SpecificationFile");
+const Preview_1 = require("../../../../domains/models/Preview");
+class PreviewStudio extends base_1.default {
+    run() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const { args, flags } = yield this.parse(PreviewStudio);
+            let filePath = (_a = args['spec-file']) !== null && _a !== void 0 ? _a : flags.file;
+            const previewPort = parseInt((_b = flags.port) !== null && _b !== void 0 ? _b : '0', 10);
+            if (!filePath) {
+                filePath = (yield (0, SpecificationFile_1.load)()).getFilePath();
+                this.log(`Loaded the specification from: ${filePath}`);
+            }
+            try {
+                this.specFile = yield (0, SpecificationFile_1.load)(filePath);
+            }
+            catch (error) {
+                if (filePath) {
+                    this.error(error);
+                }
+            }
+            this.metricsMetadata.port = previewPort;
+            yield (0, Preview_1.startPreview)(filePath, flags.base, flags.baseDir, flags.xOrigin, flags.suppressLogs, previewPort, flags.noBrowser);
+        });
+    }
+}
+PreviewStudio.description = 'starts a new local instance of Studio in minimal state bundling all the refs of the schema file and with no editing allowed.';
+PreviewStudio.flags = (0, preview_flags_1.previewFlags)();
+PreviewStudio.args = {
+    'spec-file': core_1.Args.string({
+        description: 'the path to the file to be opened with studio or context name',
+        required: true,
+    }),
+};
+exports.default = PreviewStudio;

package/lib/apps/cli/commands/start/studio.d.ts

@@ -0,0 +1,16 @@
+import Command from '../../internal/base';
+export default class StartStudio extends Command {
+    static description: string;
+    static flags: {
+        help: import("@oclif/core/lib/interfaces").BooleanFlag<void>;
+        file: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        port: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'no-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        noBrowser: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    static readonly args: {
+        'spec-file': import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+    private parseArgs;
+}

package/lib/apps/cli/commands/start/studio.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const base_1 = tslib_1.__importDefault(require("../../internal/base"));
+const Studio_1 = require("../../../../domains/models/Studio");
+const SpecificationFile_1 = require("../../../../domains/models/SpecificationFile");
+const studio_flags_1 = require("../../internal/flags/start/studio.flags");
+const core_1 = require("@oclif/core");
+const prompts_1 = require("@clack/prompts");
+class StartStudio extends base_1.default {
+    run() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const { args, flags } = yield this.parse(StartStudio);
+            let filePath = (_a = args['spec-file']) !== null && _a !== void 0 ? _a : flags.file;
+            let port = parseInt((_b = flags.port) !== null && _b !== void 0 ? _b : '0', 10);
+            if (flags.file) {
+                this.warn('The file flag has been removed and is being replaced by the argument spec-file. Please pass the filename directly like `asyncapi start studio asyncapi.yml`');
+            }
+            const isInteractive = !flags['no-interactive'];
+            if (isInteractive && !filePath) {
+                const parsedArgs = yield this.parseArgs({ filePath }, port === null || port === void 0 ? void 0 : port.toString());
+                filePath = parsedArgs.filePath;
+                port = parseInt(parsedArgs.port, 10);
+            }
+            if (!filePath) {
+                try {
+                    filePath = (yield (0, SpecificationFile_1.load)()).getFilePath();
+                    this.log(`Loaded specification from: ${filePath}`);
+                }
+                catch (error) {
+                    filePath = '';
+                    this.error('No file specified.');
+                }
+            }
+            try {
+                this.specFile = yield (0, SpecificationFile_1.load)(filePath);
+            }
+            catch (error) {
+                if (filePath) {
+                    this.error(error);
+                }
+            }
+            this.metricsMetadata.port = port;
+            (0, Studio_1.start)(filePath, port, flags.noBrowser);
+        });
+    }
+    parseArgs(args, port) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const operationCancelled = 'Operation cancelled by the user.';
+            let askForPort = false;
+            let { filePath } = args;
+            if (!filePath) {
+                filePath = yield (0, prompts_1.text)({
+                    message: 'Enter the path to the AsyncAPI document',
+                    defaultValue: 'asyncapi.yaml',
+                    placeholder: 'asyncapi.yaml',
+                    validate: (value) => {
+                        if (!value) {
+                            return 'The path to the AsyncAPI document is required';
+                        }
+                    },
+                });
+                askForPort = true;
+            }
+            if ((0, prompts_1.isCancel)(filePath)) {
+                (0, prompts_1.cancel)(operationCancelled);
+                this.exit();
+            }
+            if (!port && askForPort) {
+                port = (yield (0, prompts_1.text)({
+                    message: 'Enter the port in which to start Studio',
+                    defaultValue: '3210',
+                    placeholder: '3210',
+                    validate: (value) => !value ? 'The port number is required' : undefined,
+                }));
+            }
+            if ((0, prompts_1.isCancel)(port)) {
+                (0, prompts_1.cancel)(operationCancelled);
+                this.exit();
+            }
+            return { filePath, port: port !== null && port !== void 0 ? port : '3210' };
+        });
+    }
+}
+StartStudio.description = 'starts a new local instance of Studio';
+StartStudio.flags = (0, studio_flags_1.studioFlags)();
+StartStudio.args = {
+    'spec-file': core_1.Args.string({
+        description: 'spec path, url, or context-name',
+        required: false,
+    }),
+};
+exports.default = StartStudio;