@asyncapi/cli 3.0.0 → 3.1.0

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

@@ -0,0 +1,16 @@
+import Command from '../../core/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<number | 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>;
+    };
+    static readonly args: {
+        'spec-file': import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/start/preview.js

@@ -0,0 +1,38 @@
+"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("../../core/base"));
+const preview_flags_1 = require("../../core/flags/start/preview.flags");
+const SpecificationFile_1 = require("../../core/models/SpecificationFile");
+const Preview_1 = require("../../core/models/Preview");
+class PreviewStudio extends base_1.default {
+    run() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const { args, flags } = yield this.parse(PreviewStudio);
+            let filePath = (_a = args['spec-file']) !== null && _a !== void 0 ? _a : flags.file;
+            const previewPort = flags.port;
+            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;
+            (0, Preview_1.startPreview)(filePath, flags.base, flags.baseDir, flags.xOrigin, flags.suppressLogs, previewPort);
+        });
+    }
+}
+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/core/flags/start/preview.flags.d.ts

@@ -0,0 +1,8 @@
+export declare const previewFlags: () => {
+    help: import("@oclif/core/lib/interfaces").BooleanFlag<void>;
+    port: import("@oclif/core/lib/interfaces").OptionFlag<number | 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>;
+};

package/lib/core/flags/start/preview.flags.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.previewFlags = void 0;
+const core_1 = require("@oclif/core");
+const previewFlags = () => {
+    return {
+        help: core_1.Flags.help({ char: 'h' }),
+        port: core_1.Flags.integer({ char: 'p', description: 'port in which to start Studio in the preview mode' }),
+        base: core_1.Flags.string({ char: 'b', description: 'Path to the file which will act as a base. This is required when some properties need to be overwritten while bundling with the file.' }),
+        baseDir: core_1.Flags.string({ char: 'd', description: 'One relative/absolute path to directory relative to which paths to AsyncAPI Documents that should be bundled will be resolved.' }),
+        xOrigin: core_1.Flags.boolean({ char: 'x', description: 'Pass this switch to generate properties "x-origin" that will contain historical values of dereferenced "$ref"s.' }),
+        suppressLogs: core_1.Flags.boolean({ char: 'l', description: 'Pass this to suppress the detiled error logs.', default: false })
+    };
+};
+exports.previewFlags = previewFlags;

package/lib/core/models/Preview.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_PORT = 3210;
+export declare function startPreview(filePath: string, base: string | undefined, baseDirectory: string | undefined, xOrigin: boolean | undefined, suppressLogs: boolean | undefined, port?: number): void;

package/lib/core/models/Preview.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PORT = void 0;
+exports.startPreview = startPreview;
+const tslib_1 = require("tslib");
+const specification_file_1 = require("../errors/specification-file");
+const fs_1 = require("fs");
+const bundler_1 = tslib_1.__importDefault(require("@asyncapi/bundler"));
+const http_1 = require("http");
+const ws_1 = require("ws");
+const chokidar_1 = tslib_1.__importDefault(require("chokidar"));
+const open_1 = tslib_1.__importDefault(require("open"));
+const next_1 = tslib_1.__importDefault(require("next"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const js_yaml_1 = tslib_1.__importDefault(require("js-yaml"));
+const picocolors_1 = require("picocolors");
+const package_json_1 = require("@asyncapi/studio/package.json");
+const sockets = [];
+const messageQueue = [];
+const filePathsToWatch = new Set();
+const defaultErrorMessage = 'error occured while bundling files. use --detailedLog or -l flag to get more details.';
+let bundleError = true;
+exports.DEFAULT_PORT = 3210;
+function isValidFilePath(filePath) {
+    return (0, fs_1.existsSync)(filePath);
+}
+// eslint-disable-next-line sonarjs/cognitive-complexity
+function startPreview(filePath, base, baseDirectory, xOrigin, suppressLogs, port = exports.DEFAULT_PORT) {
+    if (filePath && !isValidFilePath(filePath)) {
+        throw new specification_file_1.SpecificationFileNotFound(filePath);
+    }
+    const baseDir = path_1.default.dirname(path_1.default.resolve(filePath));
+    (0, bundler_1.default)(filePath).then((doc) => {
+        if (doc) {
+            bundleError = false;
+        }
+    }).catch((err) => {
+        if (suppressLogs) {
+            console.log(defaultErrorMessage);
+        }
+        else {
+            console.log(err);
+        }
+    });
+    const studioPath = path_1.default.dirname(require.resolve('@asyncapi/studio/package.json'));
+    const app = (0, next_1.default)({
+        dev: false,
+        dir: studioPath,
+        conf: {
+            distDir: 'build',
+        },
+    });
+    const handle = app.getRequestHandler();
+    const wsServer = new ws_1.WebSocketServer({ noServer: true });
+    wsServer.on('connection', (socket) => {
+        sockets.push(socket);
+        sendQueuedMessages();
+    });
+    wsServer.on('close', (socket) => {
+        sockets.splice(sockets.findIndex(s => s === socket));
+    });
+    app.prepare().then(() => {
+        if (filePath && !bundleError) {
+            messageQueue.push(JSON.stringify({
+                type: 'preview:connected',
+                code: 'Preview server connected'
+            }));
+            sendQueuedMessages();
+            findPathsToWatchFromSchemaRef(filePath, baseDir);
+            filePathsToWatch.add(path_1.default.resolve(baseDir, filePath));
+            chokidar_1.default.watch([...filePathsToWatch]).on('all', (event) => {
+                switch (event) {
+                    case 'add':
+                        (0, bundler_1.default)([filePath], {
+                            base,
+                            baseDir: baseDirectory,
+                            xOrigin,
+                        }).then((intitalDocument) => {
+                            messageQueue.push(JSON.stringify({
+                                type: 'preview:file:added',
+                                code: (path_1.default.extname(filePath) === '.yaml' || path_1.default.extname(filePath) === '.yml') ?
+                                    intitalDocument.yml() : intitalDocument.string()
+                            }));
+                            sendQueuedMessages();
+                        }).catch((e) => {
+                            if (suppressLogs) {
+                                console.log(defaultErrorMessage);
+                            }
+                            else {
+                                console.log(e);
+                            }
+                        });
+                        break;
+                    case 'change':
+                        (0, bundler_1.default)([filePath], {
+                            base,
+                            baseDir: baseDirectory,
+                            xOrigin,
+                        }).then((modifiedDocument) => {
+                            messageQueue.push(JSON.stringify({
+                                type: 'preview:file:changed',
+                                code: (path_1.default.extname(filePath) === '.yaml' || path_1.default.extname(filePath) === '.yml') ?
+                                    modifiedDocument.yml() : modifiedDocument.string()
+                            }));
+                            sendQueuedMessages();
+                        }).catch((error) => {
+                            if (suppressLogs) {
+                                console.log(defaultErrorMessage);
+                            }
+                            else {
+                                console.log(error);
+                            }
+                        });
+                        break;
+                    case 'unlink':
+                        messageQueue.push(JSON.stringify({
+                            type: 'preview:file:deleted',
+                            filePath,
+                        }));
+                        sendQueuedMessages();
+                        break;
+                }
+            });
+        }
+        const server = (0, http_1.createServer)((req, res) => handle(req, res));
+        server.on('upgrade', (request, socket, head) => {
+            if (request.url === '/preview-server' && request.headers['origin'] === `http://localhost:${port}`) {
+                console.log('🔗 WebSocket connection established for the preview.');
+                wsServer.handleUpgrade(request, socket, head, (sock) => {
+                    wsServer.emit('connection', sock, request);
+                });
+            }
+            else {
+                console.log('🔗 WebSocket connection not established.');
+                socket.destroy();
+            }
+        });
+        if (!bundleError) {
+            server.listen(port, () => {
+                const url = `http://localhost:${port}?previewServer=${port}&studio-version=${package_json_1.version}`;
+                console.log(`🎉 Connected to Preview Server running at ${(0, picocolors_1.blueBright)(url)}.`);
+                console.log(`🌐 Open this URL in your web browser: ${(0, picocolors_1.blueBright)(url)}`);
+                console.log(`🛑 If needed, press ${(0, picocolors_1.redBright)('Ctrl + C')} to stop the server.`);
+                if (filePath) {
+                    for (const entry of filePathsToWatch) {
+                        console.log(`👁️ Watching changes on file ${(0, picocolors_1.blueBright)(entry)}`);
+                    }
+                }
+                else {
+                    console.warn('Warning: No file was provided, and we couldn\'t find a default file (like "asyncapi.yaml" or "asyncapi.json") in the current folder. Starting Studio with a blank workspace.');
+                }
+                if (!bundleError) {
+                    (0, open_1.default)(url);
+                }
+            }).on('error', (error) => {
+                console.error(`Failed to start server on port ${port}:`, error.message);
+            });
+        }
+    });
+}
+function sendQueuedMessages() {
+    while (messageQueue.length && sockets.length) {
+        const nextMessage = messageQueue.shift();
+        for (const socket of sockets) {
+            socket.send(nextMessage);
+        }
+    }
+}
+function isLocalRefAPath(key, value) {
+    return (typeof value === 'string' && key === '$ref' &&
+        (value.startsWith('.') || value.startsWith('./') ||
+            value.startsWith('../') || !value.startsWith('#')));
+}
+function findPathsToWatchFromSchemaRef(filePath, baseDir) {
+    if (filePath && !isValidFilePath(filePath)) {
+        throw new specification_file_1.SpecificationFileNotFound(filePath);
+    }
+    const document = js_yaml_1.default.load((0, fs_1.readFileSync)(filePath, 'utf-8'));
+    const stack = [document];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (current === null || typeof current !== 'object') {
+            continue;
+        }
+        for (const [key, value] of Object.entries(current)) {
+            if (isLocalRefAPath(key, value)) {
+                const absolutePath = path_1.default.resolve(baseDir, value);
+                filePathsToWatch.add(absolutePath);
+            }
+            if (value !== null && typeof value === 'object') {
+                stack.push(value);
+            }
+        }
+    }
+}

package/oclif.manifest.json

@@ -1451,6 +1451,78 @@
         "index.js"
       ]
     },
+    "start:preview": {
+      "aliases": [],
+      "args": {
+        "spec-file": {
+          "description": "the path to the file to be opened with studio or context name",
+          "name": "spec-file",
+          "required": true
+        }
+      },
+      "description": "starts a new local instance of Studio in minimal state bundling all the refs of the schema file and with no editing allowed.",
+      "flags": {
+        "help": {
+          "char": "h",
+          "description": "Show CLI help.",
+          "name": "help",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "port": {
+          "char": "p",
+          "description": "port in which to start Studio in the preview mode",
+          "name": "port",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "base": {
+          "char": "b",
+          "description": "Path to the file which will act as a base. This is required when some properties need to be overwritten while bundling with the file.",
+          "name": "base",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "baseDir": {
+          "char": "d",
+          "description": "One relative/absolute path to directory relative to which paths to AsyncAPI Documents that should be bundled will be resolved.",
+          "name": "baseDir",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "xOrigin": {
+          "char": "x",
+          "description": "Pass this switch to generate properties \"x-origin\" that will contain historical values of dereferenced \"$ref\"s.",
+          "name": "xOrigin",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "suppressLogs": {
+          "char": "l",
+          "description": "Pass this to suppress the detiled error logs.",
+          "name": "suppressLogs",
+          "allowNo": false,
+          "type": "boolean"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "start:preview",
+      "pluginAlias": "@asyncapi/cli",
+      "pluginName": "@asyncapi/cli",
+      "pluginType": "core",
+      "strict": true,
+      "isESM": false,
+      "relativePath": [
+        "lib",
+        "commands",
+        "start",
+        "preview.js"
+      ]
+    },
     "start:studio": {
       "aliases": [],
       "args": {
@@ -1776,5 +1848,5 @@
       ]
     }
   },
-  "version": "3.0.0"
+  "version": "3.1.0"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@asyncapi/cli",
   "description": "All in one CLI for all AsyncAPI tools",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "author": "@asyncapi",
   "bin": {
     "asyncapi": "./bin/run_bin"
@@ -19,7 +19,7 @@
     "@asyncapi/parser": "^3.3.0",
     "@asyncapi/protobuf-schema-parser": "^3.5.1",
     "@asyncapi/raml-dt-schema-parser": "^4.0.24",
-    "@asyncapi/studio": "^0.23.1",
+    "@asyncapi/studio": "^0.24.2",
     "@changesets/changelog-git": "^0.2.0",
     "@clack/prompts": "^0.7.0",
     "@oclif/core": "^4.2.9",
@@ -94,6 +94,7 @@
     "/bin",
     "/lib",
     "/assets",
+    "/scripts",
     "/npm-shrinkwrap.json",
     "/oclif.manifest.json"
   ],
@@ -174,7 +175,7 @@
     "createhook": "oclif generate hook myhook --event=command_not_found",
     "createhookinit": "oclif generate hook inithook --event=init",
     "action:docker:build": "docker build -f github-action/Dockerfile -t asyncapi/github-action-for-cli:latest .",
-    "action:test": "cd github-action && make test"
+    "action:test": "npm run build && cd github-action && make test"
   },
   "types": "lib/index.d.ts"
 }

package/scripts/enableAutoComplete.js

@@ -0,0 +1,160 @@
+/* eslint-disable @typescript-eslint/no-var-requires */
+const { spawnSync } = require('child_process');
+const os = require('os');
+const fs = require('fs');
+const path = require('path');
+
+const allowedShells = ['zsh', 'bash'];
+
+// Helper function to find the first existing file among a list of paths
+function findExistingFile(possibleFiles) {
+  for (const file of possibleFiles) {
+    const fullPath = path.join(os.homedir(), file);
+    if (fs.existsSync(fullPath)) {
+      return fullPath;
+    }
+  }
+  return null;
+}
+
+const shellConfigs = {
+  zsh: {
+    rcFile: path.join(os.homedir(), '.zshrc'),
+    detectFile: path.join(os.homedir(), '.zshrc'),
+    postMessage: 'Run: source ~/.zshrc',
+    action: (output, rcFile) => {
+      const configContent = fs.existsSync(rcFile) ? fs.readFileSync(rcFile, 'utf-8') : '';
+
+      if (configContent.includes(output.trim())) {
+        console.log(`✅ Autocomplete is already configured in ${rcFile}. Skipping addition.`);
+      } else {
+        fs.appendFileSync(rcFile, `\n# AsyncAPI CLI Autocomplete\n${output}\n`);
+        console.log(`✅ Autocomplete configuration added to ${rcFile}.`);
+      }
+    },
+  },
+  bash: {
+    rcFile: findExistingFile(['.bashrc', '.bash_profile', '.profile']) || path.join(os.homedir(), '.bashrc'),
+    detectFile: findExistingFile(['.bashrc', '.bash_profile', '.profile']),
+    postMessage: '', // This will be set dynamically later
+    action: (output, rcFile) => {
+      const configContent = fs.existsSync(rcFile) ? fs.readFileSync(rcFile, 'utf-8') : '';
+
+      if (configContent.includes(output.trim())) {
+        console.log(`✅ Autocomplete is already configured in ${rcFile}. Skipping addition.`);
+      } else {
+        fs.appendFileSync(rcFile, `\n# AsyncAPI CLI Autocomplete\n${output}\n`);
+        console.log(`✅ Autocomplete configuration added to ${rcFile}.`);
+      }
+    },
+  },
+};
+
+// Set correct postMessage dynamically
+if (shellConfigs.bash.detectFile) {
+  shellConfigs.bash.postMessage = `Run: source ${shellConfigs.bash.detectFile}`;
+} else {
+  shellConfigs.bash.postMessage = 'Run: source ~/.bashrc';
+}
+
+function getShellConfig(shell) {
+  if (!allowedShells.includes(shell)) {
+    throw new Error(`Unsupported shell: ${shell}. Autocomplete only supports zsh and bash.`);
+  }
+  return shellConfigs[shell];
+}
+
+function detectShell() {
+  const detectedShells = [];
+  for (const [shell, config] of Object.entries(shellConfigs)) {
+    if (config.detectFile && fs.existsSync(config.detectFile)) {
+      detectedShells.push(shell);
+    }
+  }
+  return detectedShells;
+}
+
+function checkPotentialPath(potentialPath) {
+  if (potentialPath.includes(path.sep)) {
+    if (fs.existsSync(potentialPath)) {
+      return potentialPath;
+    }
+  } else {
+    const result = spawnSync('/bin/sh', ['-c', `command -v ${potentialPath}`], {
+      encoding: 'utf-8',
+      stdio: 'pipe',
+    });
+    if (result.status === 0 && result.stdout) {
+      return result.stdout.trim().split('\n')[0];
+    }
+  }
+  return null;
+}
+
+function findCliExecutable() {
+  const possiblePaths = [
+    path.resolve('./bin/run'),
+    path.resolve('../bin/run'),
+    path.resolve('./node_modules/.bin/asyncapi'),
+    'asyncapi',
+  ];
+
+  for (const potentialPath of possiblePaths) {
+    try {
+      const foundPath = checkPotentialPath(potentialPath);
+      if (foundPath) {
+        console.log(`Found CLI executable at: ${foundPath}`);
+        return foundPath;
+      }
+    } catch (error) {
+      console.warn(`⚠️ Ignored error while checking path ${potentialPath}: ${error.message}`);
+    }
+  }
+
+  throw new Error('CLI executable not found. Ensure AsyncAPI CLI is installed.');
+}
+
+function generateAutocompleteScript(shell) {
+  const executablePath = findCliExecutable();
+  const result = spawnSync(executablePath, ['autocomplete', 'script', shell], {
+    encoding: 'utf-8',
+    stdio: 'pipe',
+  });
+  if (result.status !== 0 || result.error) {
+    throw new Error(
+      `Autocomplete setup for ${shell} failed: ${result.stderr || result.error?.message || 'Unknown error'}`
+    );
+  }
+  const output = result.stdout;
+  if (!output || output.trim() === '') {
+    throw new Error(`No autocomplete script generated for ${shell}.`);
+  }
+  return output;
+}
+
+function setupAutocomplete(shell) {
+  if (!allowedShells.includes(shell)) {
+    console.error(`❌ Autocomplete only supports zsh and bash. Skipping setup for ${shell}.`);
+    return;
+  }
+
+  try {
+    const config = getShellConfig(shell);
+    console.log(`🔧 Generating autocomplete script for ${shell}...`);
+    const output = generateAutocompleteScript(shell);
+    config.action(output, config.rcFile);
+    console.log(`✅ Autocomplete configured for ${shell}. ${config.postMessage}`);
+  } catch (error) {
+    console.error(`❌ Failed to setup autocomplete for ${shell}: ${error.message}`);
+  }
+}
+
+// Start
+const shells = detectShell();
+if (shells.length) {
+  for (const shell of shells) {
+    setupAutocomplete(shell);
+  }
+} else {
+  console.log('⚠️ Shell not detected or unsupported. Autocomplete setup skipped.');
+}

package/scripts/fetch-asyncapi-example.js

@@ -0,0 +1,126 @@
+/* eslint-disable @typescript-eslint/no-var-requires */
+
+const fs = require('fs');
+const unzipper = require('unzipper');
+const path = require('path');
+
+const { Parser } = require('@asyncapi/parser/cjs');
+const { AvroSchemaParser } = require('@asyncapi/avro-schema-parser');
+const { OpenAPISchemaParser } = require('@asyncapi/openapi-schema-parser');
+const { RamlDTSchemaParser } = require('@asyncapi/raml-dt-schema-parser');
+const { pipeline } = require('stream');
+const { promisify } = require('util');
+
+const streamPipeline = promisify(pipeline);
+
+const parser = new Parser({
+  schemaParsers: [
+    AvroSchemaParser(),
+    OpenAPISchemaParser(),
+    RamlDTSchemaParser(),
+  ]
+});
+
+const SPEC_EXAMPLES_ZIP_URL = 'https://github.com/asyncapi/spec/archive/refs/heads/master.zip';
+const EXAMPLE_DIRECTORY = path.join(__dirname, '../assets/examples');
+const TEMP_ZIP_NAME = 'spec-examples.zip';
+
+const fetchAsyncAPIExamplesFromExternalURL = () => {
+  try {
+    return new Promise((resolve, reject) => {
+      fetch(SPEC_EXAMPLES_ZIP_URL)
+        .then(async (res) => {
+          if (res.status !== 200) {
+            return reject(new Error(`Failed to fetch examples from ${SPEC_EXAMPLES_ZIP_URL}`));
+          }
+
+          const file = fs.createWriteStream(TEMP_ZIP_NAME);
+          await streamPipeline(res.body, file);
+
+          console.log('Fetched ZIP file');
+          resolve();
+        })
+        .catch(reject);
+    });
+  } catch (error) {
+    console.error(error);
+  }
+};
+
+const unzipAsyncAPIExamples = async () => {
+  return new Promise((resolve, reject) => {
+    if (!fs.existsSync(EXAMPLE_DIRECTORY)) {
+      fs.mkdirSync(EXAMPLE_DIRECTORY);
+    }
+
+    fs.createReadStream(TEMP_ZIP_NAME)
+      .pipe(unzipper.Parse())
+      .on('entry', async (entry) => {
+        const fileName = entry.path;
+        if (fileName.includes('examples/') && fileName.includes('.yml') && entry.type === 'File') {
+          const fileContent = await entry.buffer();
+          const fileNameWithExtension = fileName.split('examples/')[1];
+          fs.writeFileSync(path.join(EXAMPLE_DIRECTORY, fileNameWithExtension), fileContent.toString());
+        } else {
+          entry.autodrain();
+        }
+      }).on('close', () => {
+        console.log('Unzipped all examples from ZIP');
+        resolve();
+      }).on('error', (error) => {
+        reject(new Error(`Error in unzipping from ZIP: ${error.message}`));
+      });
+  });
+};
+
+const buildCLIListFromExamples = async () => {
+  const files = fs.readdirSync(EXAMPLE_DIRECTORY);
+  const examples = files.filter(file => file.includes('.yml')).sort();
+
+  const buildExampleList = examples.map(async example => {
+    const examplePath = path.join(EXAMPLE_DIRECTORY, example);
+    const exampleContent = fs.readFileSync(examplePath, { encoding: 'utf-8' });
+
+    try {
+      const { document } = await parser.parse(exampleContent);
+      // Failed for some reason to parse this spec file (document is undefined), ignore for now
+      if (!document) {
+        return;
+      }
+
+      const title = document.info().title();
+      const protocols = listAllProtocolsForFile(document);
+      return {
+        name: protocols ? `${title} - (protocols: ${protocols})` : title,
+        value: example
+      };
+    } catch (error) {
+      console.error(error);
+    }
+  });
+
+  const exampleList = (await Promise.all(buildExampleList)).filter(item => !!item);
+  const orderedExampleList = exampleList.sort((a, b) => a.name.localeCompare(b.name));
+
+  fs.writeFileSync(path.join(EXAMPLE_DIRECTORY, 'examples.json'), JSON.stringify(orderedExampleList, null, 4));
+};
+
+const listAllProtocolsForFile = (document) => {
+  const servers = document.servers();
+  if (servers.length === 0) {
+    return '';
+  }
+
+  return servers.all().map(server => server.protocol()).join(',');
+};
+
+const tidyUp = async () => {
+  fs.unlinkSync(TEMP_ZIP_NAME);
+};
+
+(async () => {
+  await fetchAsyncAPIExamplesFromExternalURL();
+  await unzipAsyncAPIExamples();
+  await buildCLIListFromExamples();
+  await tidyUp();
+})();

package/scripts/releasePackagesRename.js

@@ -0,0 +1,80 @@
+/* eslint-disable @typescript-eslint/no-var-requires */
+
+const { rename, access, mkdir } = require('fs').promises;
+const packageJson = require('../package.json');
+const path = require('path');
+const simpleGit = require('simple-git');
+const git = simpleGit({baseDir: process.cwd()});
+
+async function fileExists(checkPath) {
+  try {
+    await access(checkPath);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+async function checkAndRenameFile(generatedPath, newPath) {
+  if (await fileExists(generatedPath)) {
+    await rename(generatedPath, newPath);
+  }
+}
+
+async function createDirectory(directoryPath) {
+  const exists = await fileExists(directoryPath);
+  if (!exists) {
+    await mkdir(directoryPath);
+  }
+}
+
+async function renameDeb({version, name, sha}) {
+  const dist = 'dist/deb';
+
+  // deb package naming convention: https://github.com/oclif/oclif/blob/fb5da961f925fa0eba5c5b05c8cee0c9bd156c00/src/upload-util.ts#L51
+  const generatedPath = path.resolve(dist, `${name}_${version}.${sha}-1_amd64.deb`);
+  const newPath = path.resolve(dist, 'asyncapi.deb');
+  await checkAndRenameFile(generatedPath, newPath);
+}
+
+async function renameTar({version, name, sha}) {
+  const dist = 'dist';
+
+  const generatedPath = path.resolve(dist, `${name}-v${version}-${sha}-linux-x64.tar.gz`);
+  // for tarballs, the files are generated in `dist/` directory.
+  // Creates a new `tar` directory(`dist/tar`), and moves the generated tarball inside that directory.
+  const tarDirectory = path.resolve(dist, 'tar');
+  await createDirectory(tarDirectory);
+  const newPath = path.resolve(tarDirectory, 'asyncapi.tar.gz');
+  await checkAndRenameFile(generatedPath, newPath);
+}
+
+async function renameWindows({version, name, sha, arch}) {
+  const dist = 'dist/win32';
+
+  const generatedPath = path.resolve(dist, `${name}-v${version}-${sha}-${arch}.exe`);
+  const newPath = path.resolve(dist, `asyncapi.${arch}.exe`);
+  await checkAndRenameFile(generatedPath, newPath);
+}
+
+async function renamePkg({version, name, sha, arch}) {
+  const dist = 'dist/macos';
+
+  const generatedPath = path.resolve(dist, `${name}-v${version}-${sha}-${arch}.pkg`);
+  const newPath = path.resolve(dist, `asyncapi.${arch}.pkg`);
+  await checkAndRenameFile(generatedPath, newPath);
+}
+
+async function renamePackages() {
+  const version = packageJson.version;
+  const name = 'asyncapi';
+  const sha = await git.revparse(['--short', 'HEAD']);
+  await renameDeb({version: version.split('-')[0], name, sha});
+  await renamePkg({version, name, sha, arch: 'x64'});
+  await renamePkg({version, name, sha, arch: 'arm64'});
+  await renameWindows({version, name, sha, arch: 'x64'});
+  await renameWindows({version, name, sha, arch: 'x86'});
+  await renameTar({version, name, sha});
+}
+
+renamePackages();

package/scripts/updateUsageDocs.js

@@ -0,0 +1,73 @@
+/* eslint-disable @typescript-eslint/no-var-requires */
+const {writeFile, readFile} = require('fs').promises;
+
+// Define the paths to the README and usage files
+const README_PATH = './scripts/README.md'; // File path for the generated README file
+const USAGE_PATH = './docs/usage.md'; // File path for the usage documentation file
+
+const header = `---
+title: 'Usage'
+weight: 40
+---
+
+<!-- 
+
+This file is automatically generated from updateUsageDocs.js script. In package.json in line 158-161 lines the following steps has been executed in order to run this script successfully - 
+
+* generate:readme:create: It creates the initial content for the README file by printing the usage and commands tags using printf and redirects the output to scripts/README.md file.
+* generate:readme:commands: It changes the directory to the scripts folder and executes the oclif readme command. This command generates the usage and commands sections based on the CLI commands and updates the content in the scripts/README.md file.
+* generate:assets: This script combines the two previously mentioned scripts (generate:readme:toc and generate:commands) to generate the necessary assets, such as the README file and usage documentation.
+* generate:commands: This script executes the following steps:
+ - Runs the generate:readme:create script to create the initial content for the README file.
+ - Executes the generate:readme:commands script to generate the usage and commands sections based on the CLI commands.
+ - Runs the updateUsageDocs.js script using Node.js to update the usage documentation file with the contents of the generated README file.
+ - Deletes the scripts/README.md file using the rimraf command.
+
+-->
+
+The AsyncAPI CLI makes it easier to work with AsyncAPI documents.
+`;
+
+// Define an async function to write the header and the README contents to the usage documentation file
+async function run() {
+  try {
+    await writeFile(USAGE_PATH, header);
+    const readmeContents = await readContents();
+    // Append the contents of the README file to the usage documentation file
+    await writeFile(USAGE_PATH, readmeContents, { flag: 'a' });
+  } catch (e) {
+    console.error(e);
+  }
+}
+
+run();
+
+async function readContents() {
+  let readmeContents;
+  let commandsContent = '';
+
+  while (commandsContent.length === 0) {
+    readmeContents = await readFile(README_PATH, 'utf8');
+    
+    // Check if the content between <!-- commands --> and <!-- commandsstop --> is empty
+    const commandsStartText = '<!-- commands -->';
+    const commandStartIndex = readmeContents.indexOf(commandsStartText);
+    const commandStopIndex = readmeContents.indexOf('<!-- commandsstop -->');
+    //cutting the content between the above mentioned tags, removing white spaces and checking if there is some text as it will mean text was added by oclif
+    commandsContent = readmeContents.slice(commandStartIndex + commandsStartText.length, commandStopIndex).trim();
+
+    if (commandsContent.length === 0) {
+      console.log('No content between <!-- commands --> and <!-- commandsstop -->. Trying again...');
+    } else {
+      console.log('Content found!');
+    }
+
+    await delay(3000); // 3-second delay
+  }
+
+  return readmeContents;
+}
+
+function delay(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}