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

package/package.json

@@ -0,0 +1,203 @@
+{
+  "name": "@asyncapi-actions-test/trusted-publishing-test_asyncapi-cli",
+  "description": "All in one CLI for all AsyncAPI tools",
+  "version": "4.1.3",
+  "author": "@asyncapi-actions-test",
+  "bin": {
+    "asyncapi": "./bin/run_bin"
+  },
+  "repository": {
+    "url": "git+https://github.com/asyncapi-actions-test/cli.git",
+    "type": "git"
+  },
+  "bugs": "https://github.com/asyncapi/cli/issues",
+  "dependencies": {
+    "@asyncapi/avro-schema-parser": "^3.0.23",
+    "@asyncapi/bundler": "^0.6.4",
+    "@asyncapi/converter": "^1.6.2",
+    "@asyncapi/diff": "^0.5.0",
+    "@asyncapi/generator": "^3.0.1",
+    "@asyncapi/modelina-cli": "^5.3.5",
+    "@asyncapi/openapi-schema-parser": "^3.0.24",
+    "@asyncapi/optimizer": "^1.0.4",
+    "@asyncapi/parser": "^3.3.0",
+    "@asyncapi/problem": "^1.0.0",
+    "@asyncapi/protobuf-schema-parser": "^3.6.0",
+    "@asyncapi/raml-dt-schema-parser": "^4.0.24",
+    "@asyncapi/studio": "^1.1.0",
+    "@clack/prompts": "^0.7.0",
+    "@oclif/core": "^4.2.9",
+    "@oclif/plugin-autocomplete": "^3.2.26",
+    "@smoya/asyncapi-adoption-metrics": "^2.4.9",
+    "@stoplight/spectral-cli": "6.9.0",
+    "archiver": "^7.0.1",
+    "body-parser": "^2.2.0",
+    "chalk": "^4.1.0",
+    "chokidar": "^3.5.2",
+    "compression": "^1.8.0",
+    "config": "^4.0.0",
+    "cors": "^2.8.5",
+    "express": "^4.17.1",
+    "fast-levenshtein": "^3.0.0",
+    "fs-extra": "^11.1.0",
+    "helmet": "^8.1.0",
+    "https-proxy-agent": "^7.0.6",
+    "inquirer": "^8.2.0",
+    "js-yaml": "^4.1.0",
+    "oclif": "^4.17.34",
+    "open": "^8.4.0",
+    "picocolors": "^1.1.0",
+    "redoc-express": "^2.1.0",
+    "unzipper": "^0.10.11",
+    "uuid": "^11.1.0",
+    "winston": "^3.17.0",
+    "ws": "^8.2.3",
+    "yaml": "^2.6.1"
+  },
+  "devDependencies": {
+    "@asyncapi/minimaltemplate": "./test/fixtures/minimaltemplate",
+    "@asyncapi/newtemplate": "./test/fixtures/newtemplate",
+    "@commitlint/cli": "^19.8.1",
+    "@commitlint/config-conventional": "^19.8.1",
+    "@oclif/test": "^2",
+    "@types/archiver": "^6.0.3",
+    "@types/body-parser": "^1.19.6",
+    "@types/chai": "^4.3.6",
+    "@types/compression": "^1.8.1",
+    "@types/config": "^3.3.5",
+    "@types/cors": "^2.8.19",
+    "@types/express": "^5.0.3",
+    "@types/fast-levenshtein": "^0.0.2",
+    "@types/fs-extra": "^11.0.1",
+    "@types/inquirer": "^8.1.3",
+    "@types/js-yaml": "^4.0.5",
+    "@types/mocha": "^10.0.2",
+    "@types/node": "^22.13.10",
+    "@types/rimraf": "^3.0.2",
+    "@types/supertest": "^6.0.3",
+    "@types/uuid": "^10.0.0",
+    "@types/ws": "^8.2.0",
+    "@typescript-eslint/eslint-plugin": "^5.38.1",
+    "@typescript-eslint/parser": "^5.38.1",
+    "chai": "^4.3.6",
+    "cross-env": "^7.0.3",
+    "eslint": "^8.24.0",
+    "eslint-config-oclif": "^4",
+    "eslint-config-oclif-typescript": "^1.0.3",
+    "eslint-plugin-github": "^4.3.7",
+    "eslint-plugin-security": "^1.4.0",
+    "eslint-plugin-sonarjs": "^0.15.0",
+    "markdown-toc": "^1.2.0",
+    "mocha": "^10.2.0",
+    "nodemon": "^3.1.10",
+    "nyc": "^15.1.0",
+    "puppeteer": "^24.17.0",
+    "rimraf": "^3.0.2",
+    "simple-git": "^3.16.0",
+    "supertest": "^7.1.4",
+    "ts-node": "^10.9.1",
+    "tsc-alias": "^1.8.16",
+    "tsconfig-paths": "^4.2.0",
+    "typescript": "^5.8.2"
+  },
+  "engines": {
+    "node": ">=24.0"
+  },
+  "files": [
+    "/bin",
+    "/lib",
+    "/assets",
+    "/scripts",
+    "/npm-shrinkwrap.json",
+    "/openapi.yaml",
+    "/oclif.manifest.json"
+  ],
+  "homepage": "https://github.com/asyncapi/cli",
+  "keywords": [
+    "oclif"
+  ],
+  "license": "Apache-2.0",
+  "main": "lib/index.js",
+  "oclif": {
+    "commands": "./lib/apps/cli/commands",
+    "bin": "asyncapi",
+    "additionalVersionFlags": [
+      "--v"
+    ],
+    "hooks": {
+      "command_not_found": [
+        "./lib/apps/cli/internal/hooks/command_not_found/myhook"
+      ]
+    },
+    "macos": {
+      "identifier": "com.asyncapi.cli"
+    },
+    "topicSeparator": " ",
+    "topics": {
+      "config:context": {},
+      "config": {
+        "description": "CLI config settings"
+      },
+      "generate": {
+        "description": "Generate models and template"
+      }
+    },
+    "plugins": [
+      "@oclif/plugin-warn-if-update-available",
+      "@oclif/plugin-autocomplete"
+    ],
+    "warn-if-update-available": {
+      "frequency": 24,
+      "message": "\n<%= chalk.yellow('╭────────────────────────────────────────────────────────────────╮') %>\n<%= chalk.yellow('│                                                                │') %>\n<%= chalk.yellow('│') %>               Update available! <%= chalk.red(config.version) %> → <%= chalk.greenBright(latest) %>.                 <%= chalk.yellow('│') %>\n<%= chalk.yellow('│') %> <%= chalk.magentaBright('Changelog:') %> https://github.com/asyncapi/cli/releases/tag/v<%= latest %> <%= chalk.yellow('│') %>\n<%= chalk.yellow('│') %>      Run \"<%= chalk.magentaBright('npm install -g @asyncapi/cli@latest') %>\" to update.      <%= chalk.yellow('│') %>\n<%= chalk.yellow('│') %>                                                                <%= chalk.yellow('│') %>\n<%= chalk.yellow('╰────────────────────────────────────────────────────────────────╯') %>",
+      "frequencyUnit": "hours"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "optionalDependencies": {
+    "fsevents": "^2.3.2"
+  },
+  "scripts": {
+    "build": "rimraf lib && node scripts/fetch-asyncapi-example.js && npm run generate:languages && tsc && tsc-alias --project tsconfig.json && oclif manifest && echo \"Build Completed\"",
+    "bump:github-action": "cd github-action/lib/ && node bump-action-version.js",
+    "bump:version": "npx -p @changesets/cli@2.27.7 changeset version && npm run bump:github-action",
+    "dev": "tsc --watch",
+    "docker:build": "docker build -t asyncapi/cli:latest .",
+    "generate:readme:create": "node -e \"const fs = require('fs'); fs.writeFileSync('scripts/README.md', '# Usage\\n\\n<!-- usage -->\\n\\n# Commands\\n\\n<!-- commands -->\\n');\"",
+    "generate:readme:commands": "npm run build && cd scripts && cross-env DEBUG=* oclif readme",
+    "generate:assets": "npm run generate:readme:toc && npm run generate:commands",
+    "generate:commands": "npm run generate:readme:create && npm run generate:readme:commands && node ./scripts/updateUsageDocs.js && rimraf ./scripts/README.md",
+    "generate:readme:toc": "markdown-toc -i README.md",
+    "generate:languages": "node scripts/generateTypesForGenerateCommand.js",
+    "lint": "eslint --max-warnings 5 --config .eslintrc .",
+    "lint:fix": "eslint --max-warnings 5 --config .eslintrc . --fix",
+    "pack:macos": "oclif pack macos && npm run pack:rename",
+    "pack:linux": "oclif pack deb && npm run pack:rename",
+    "pack:tarballs": "oclif pack tarballs -t linux-x64 && npm run pack:rename",
+    "pack:tarballs:alpine": "oclif pack tarballs -t linux-x64 && npm run pack:rename alpine",
+    "pack:windows": "oclif pack win && npm run pack:rename",
+    "pack:rename": "node scripts/releasePackagesRename.js",
+    "prepublishOnly": "npm run build",
+    "pretest": "npm run build",
+    "pretest:coverage": "npm run build",
+    "posttest": "rimraf ./test.asyncapi-cli",
+    "postinstall": "node ./scripts/enableAutoComplete.js",
+    "test": "npm run cli:test && npm run action:test",
+    "cli:test": "cross-env NODE_ENV=development TEST=1 CUSTOM_CONTEXT_FILENAME=\"test.asyncapi-cli\" CUSTOM_CONTEXT_FILE_LOCATION=\"\" NODE_CONFIG_DIR=\"./src/apps/api/configs\" nyc --extension .ts mocha --require ts-node/register --require tsconfig-paths/register --require test/helpers/init.js --reporter spec --timeout 100000 \"test/**/*.test.ts\"",
+    "unit:test": "cross-env NODE_ENV=development TEST=1 CUSTOM_CONTEXT_FILENAME=\"test.asyncapi-cli\" CUSTOM_CONTEXT_FILE_LOCATION=\"\" NODE_CONFIG_DIR=\"./src/apps/api/configs\" nyc --extension .ts mocha --require ts-node/register --require tsconfig-paths/register --require test/helpers/init.js --reporter spec --timeout 100000 \"test/unit/**/*.test.ts\"",
+    "test:one": "cross-env NODE_ENV=development TEST=1 CUSTOM_CONTEXT_FILENAME=\"test.asyncapi-cli\" CUSTOM_CONTEXT_FILE_LOCATION=\"\"  NODE_CONFIG_DIR=\"./src/apps/api/configs\" nyc --extension .ts mocha --require ts-node/register --require tsconfig-paths/register --require test/helpers/init.js --reporter spec --timeout 100000",
+    "get-version": "echo $npm_package_version",
+    "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": "npm run build && cd github-action && make test",
+    "api:dev": "cross-env NODE_ENV=development PORT=3000 nodemon",
+    "api:prod": "npm run api:build && cross-env NODE_ENV=production PORT=80 node lib/apps/api/server.js",
+    "api:docker": "docker run -it -p 80:80 asyncapi/server-api",
+    "api:build:docker": "docker build -t asyncapi/server-api -f ./src/apps/api/Dockerfile .",
+    "api:build": "rimraf lib && npm run generate:languages && tsc && tsc-alias --project tsconfig.json",
+    "api: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/generateTypesForGenerateCommand.js

@@ -0,0 +1,40 @@
+const { writeFile } = require('fs/promises');
+const path = require('path');
+const { listBakedInTemplates } = require('@asyncapi/generator');
+
+async function generateClientLanguages() {
+  const bakedInClients = listBakedInTemplates({ type: 'client' });
+
+  const targets = Array.from(new Set(bakedInClients.map(t => t.target))).sort();
+
+  const enumEntries = targets
+    .map(t => `  ${capitalize(t)} = '${t}',`)
+    .join('\n');
+
+  const fileContent = `// Auto-generated. Do not edit manually.
+export enum AvailableLanguage {
+${enumEntries}
+}
+
+export const availableLanguages = [${targets.map(t => `'${t}'`).join(', ')}] as const;
+export type AvailableLanguageType = typeof availableLanguages[number];
+
+/**
+ * Returns the first available language as the default option.
+ */
+export const getDefaultLanguage = (): AvailableLanguageType => availableLanguages[0];
+`;
+
+  const outputPath = path.join(__dirname, '../src/domains/models/generate/ClientLanguages.ts');
+  await writeFile(outputPath, fileContent);
+
+  console.log('✅ ClientLanguages.ts generated');
+}
+
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+generateClientLanguages().catch(err => {
+  throw new Error(`Failed to generate ClientLanguages.ts: ${err.message}`);
+});

package/scripts/releasePackagesRename.js

@@ -0,0 +1,88 @@
+/* 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, isAlpine}) {
+  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 fileName = isAlpine ? 'asyncapi-alpine.tar.gz' : 'asyncapi.tar.gz';
+  const newPath = path.resolve(tarDirectory, fileName);
+  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']);
+  const isAlpine = process.argv.includes('alpine');
+
+  if (isAlpine) {
+    await renameTar({version, name, sha, isAlpine: true});
+  } else {
+    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, isAlpine: false});
+  }
+}
+
+renamePackages();