@blastlauncher/cli 1.0.1

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @blastlauncher/cli
+
+## 1.0.1
+
+### Patch Changes
+
+- Initial npm publish

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2023 Yukai Huang
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,19 @@
+# `blast-cli`
+
+## Development
+
+```bash
+# Output single cjs file with esbuild
+pnpm build
+
+# Run the cli
+node ./dist/index.cjs --help
+
+# Package to cli executable with pkg
+pnpm package
+
+# Run the cli executable
+./dist/cli-macos --help
+
+
+```

package/build.js

@@ -0,0 +1,15 @@
+/* eslint-disable @typescript-eslint/no-var-requires */
+const esbuild = require("esbuild");
+const { nodeExternalsPlugin } = require("esbuild-node-externals");
+
+esbuild.build({
+  entryPoints: ["index.js"],
+  bundle: true,
+  platform: "node",
+  outfile: "dist/index.cjs",
+  plugins: [
+    nodeExternalsPlugin({
+      allowList: ["tempy"],
+    }),
+  ],
+});

package/dist/index.cjs

@@ -0,0 +1,359 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/.pnpm/temp-dir@2.0.0/node_modules/temp-dir/index.js
+var require_temp_dir = __commonJS({
+  "../../node_modules/.pnpm/temp-dir@2.0.0/node_modules/temp-dir/index.js"(exports, module2) {
+    "use strict";
+    var fs3 = require("fs");
+    var os = require("os");
+    var tempDirectorySymbol = Symbol.for("__RESOLVED_TEMP_DIRECTORY__");
+    if (!global[tempDirectorySymbol]) {
+      Object.defineProperty(global, tempDirectorySymbol, {
+        value: fs3.realpathSync(os.tmpdir())
+      });
+    }
+    module2.exports = global[tempDirectorySymbol];
+  }
+});
+
+// index.js
+var import_child_process = require("child_process");
+var import_https = __toESM(require("https"));
+var import_path = __toESM(require("path"));
+var import_commander = require("commander");
+var import_esbuild = __toESM(require("esbuild"));
+var import_fs_extra = __toESM(require("fs-extra"));
+var import_semver = __toESM(require("semver"));
+
+// ../../node_modules/.pnpm/tempy@3.0.0/node_modules/tempy/index.js
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_node_stream = __toESM(require("node:stream"), 1);
+var import_node_util = require("node:util");
+
+// ../../node_modules/.pnpm/crypto-random-string@4.0.0/node_modules/crypto-random-string/index.js
+var import_util = require("util");
+var import_crypto = __toESM(require("crypto"), 1);
+var randomBytesAsync = (0, import_util.promisify)(import_crypto.default.randomBytes);
+var urlSafeCharacters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._~".split("");
+var numericCharacters = "0123456789".split("");
+var distinguishableCharacters = "CDEHKMPRTUWXY012458".split("");
+var asciiPrintableCharacters = "!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~".split("");
+var alphanumericCharacters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789".split("");
+var generateForCustomCharacters = (length, characters) => {
+  const characterCount = characters.length;
+  const maxValidSelector = Math.floor(65536 / characterCount) * characterCount - 1;
+  const entropyLength = 2 * Math.ceil(1.1 * length);
+  let string = "";
+  let stringLength = 0;
+  while (stringLength < length) {
+    const entropy = import_crypto.default.randomBytes(entropyLength);
+    let entropyPosition = 0;
+    while (entropyPosition < entropyLength && stringLength < length) {
+      const entropyValue = entropy.readUInt16LE(entropyPosition);
+      entropyPosition += 2;
+      if (entropyValue > maxValidSelector) {
+        continue;
+      }
+      string += characters[entropyValue % characterCount];
+      stringLength++;
+    }
+  }
+  return string;
+};
+var generateForCustomCharactersAsync = async (length, characters) => {
+  const characterCount = characters.length;
+  const maxValidSelector = Math.floor(65536 / characterCount) * characterCount - 1;
+  const entropyLength = 2 * Math.ceil(1.1 * length);
+  let string = "";
+  let stringLength = 0;
+  while (stringLength < length) {
+    const entropy = await randomBytesAsync(entropyLength);
+    let entropyPosition = 0;
+    while (entropyPosition < entropyLength && stringLength < length) {
+      const entropyValue = entropy.readUInt16LE(entropyPosition);
+      entropyPosition += 2;
+      if (entropyValue > maxValidSelector) {
+        continue;
+      }
+      string += characters[entropyValue % characterCount];
+      stringLength++;
+    }
+  }
+  return string;
+};
+var generateRandomBytes = (byteLength, type, length) => import_crypto.default.randomBytes(byteLength).toString(type).slice(0, length);
+var generateRandomBytesAsync = async (byteLength, type, length) => {
+  const buffer = await randomBytesAsync(byteLength);
+  return buffer.toString(type).slice(0, length);
+};
+var allowedTypes = /* @__PURE__ */ new Set([
+  void 0,
+  "hex",
+  "base64",
+  "url-safe",
+  "numeric",
+  "distinguishable",
+  "ascii-printable",
+  "alphanumeric"
+]);
+var createGenerator = (generateForCustomCharacters2, generateRandomBytes2) => ({ length, type, characters }) => {
+  if (!(length >= 0 && Number.isFinite(length))) {
+    throw new TypeError("Expected a `length` to be a non-negative finite number");
+  }
+  if (type !== void 0 && characters !== void 0) {
+    throw new TypeError("Expected either `type` or `characters`");
+  }
+  if (characters !== void 0 && typeof characters !== "string") {
+    throw new TypeError("Expected `characters` to be string");
+  }
+  if (!allowedTypes.has(type)) {
+    throw new TypeError(`Unknown type: ${type}`);
+  }
+  if (type === void 0 && characters === void 0) {
+    type = "hex";
+  }
+  if (type === "hex" || type === void 0 && characters === void 0) {
+    return generateRandomBytes2(Math.ceil(length * 0.5), "hex", length);
+  }
+  if (type === "base64") {
+    return generateRandomBytes2(Math.ceil(length * 0.75), "base64", length);
+  }
+  if (type === "url-safe") {
+    return generateForCustomCharacters2(length, urlSafeCharacters);
+  }
+  if (type === "numeric") {
+    return generateForCustomCharacters2(length, numericCharacters);
+  }
+  if (type === "distinguishable") {
+    return generateForCustomCharacters2(length, distinguishableCharacters);
+  }
+  if (type === "ascii-printable") {
+    return generateForCustomCharacters2(length, asciiPrintableCharacters);
+  }
+  if (type === "alphanumeric") {
+    return generateForCustomCharacters2(length, alphanumericCharacters);
+  }
+  if (characters.length === 0) {
+    throw new TypeError("Expected `characters` string length to be greater than or equal to 1");
+  }
+  if (characters.length > 65536) {
+    throw new TypeError("Expected `characters` string length to be less or equal to 65536");
+  }
+  return generateForCustomCharacters2(length, characters.split(""));
+};
+var cryptoRandomString = createGenerator(generateForCustomCharacters, generateRandomBytes);
+cryptoRandomString.async = createGenerator(generateForCustomCharactersAsync, generateRandomBytesAsync);
+var crypto_random_string_default = cryptoRandomString;
+
+// ../../node_modules/.pnpm/unique-string@3.0.0/node_modules/unique-string/index.js
+function uniqueString() {
+  return crypto_random_string_default({ length: 32 });
+}
+
+// ../../node_modules/.pnpm/tempy@3.0.0/node_modules/tempy/index.js
+var import_temp_dir = __toESM(require_temp_dir(), 1);
+var import_temp_dir2 = __toESM(require_temp_dir(), 1);
+var pipeline = (0, import_node_util.promisify)(import_node_stream.default.pipeline);
+var getPath = (prefix = "") => import_node_path.default.join(import_temp_dir.default, prefix + uniqueString());
+function temporaryFile({ name, extension } = {}) {
+  if (name) {
+    if (extension !== void 0 && extension !== null) {
+      throw new Error("The `name` and `extension` options are mutually exclusive");
+    }
+    return import_node_path.default.join(temporaryDirectory(), name);
+  }
+  return getPath() + (extension === void 0 || extension === null ? "" : "." + extension.replace(/^\./, ""));
+}
+function temporaryDirectory({ prefix = "" } = {}) {
+  const directory = getPath(prefix);
+  import_node_fs.default.mkdirSync(directory);
+  return directory;
+}
+
+// index.js
+function getJSON(url) {
+  return new Promise((resolve, reject) => {
+    import_https.default.get(url, (res) => {
+      let body = "";
+      res.on("data", (chunk) => {
+        body += chunk;
+      });
+      res.on("end", () => {
+        try {
+          resolve(JSON.parse(body));
+        } catch (e) {
+          reject(e);
+        }
+      });
+    }).on("error", (e) => {
+      reject(e);
+    });
+  });
+}
+var PackageVersionHelper = class {
+  constructor(npmOrg, registryUrl = "https://registry.npmjs.org") {
+    this.npmOrg = npmOrg;
+    this.registryUrl = registryUrl;
+  }
+  async fetchPackageVersions(packageName) {
+    let res;
+    try {
+      console.log(`fetching ${this.registryUrl}/@${this.npmOrg}/${packageName}`);
+      res = await getJSON(`${this.registryUrl}/@${this.npmOrg}/${packageName}`);
+      if (res.error) {
+        return null;
+      }
+      return Object.keys(res.versions);
+    } catch (e) {
+      return null;
+    }
+  }
+  async getLatestVersion(versions) {
+    const sortedVersions = versions.sort((a, b) => import_semver.default.compare(a, b));
+    return sortedVersions[sortedVersions.length - 1];
+  }
+  async getPackageVersion(packageName) {
+    const versions = await this.fetchPackageVersions(packageName);
+    if (!versions) {
+      return null;
+    }
+    return this.getLatestVersion(versions);
+  }
+  getPackageName(extensionFolder) {
+    const packageJson = JSON.parse(import_fs_extra.default.readFileSync(import_path.default.resolve(extensionFolder, "package.json"), "utf8"));
+    let packageName = packageJson.name;
+    if (packageName.startsWith("@")) {
+      packageName = packageName.split("/")[1];
+    }
+    packageName = packageName.toLowerCase();
+    console.debug(`package name is ${packageName}`);
+    return packageName;
+  }
+};
+async function publishExtensions(extensionFolder, npmOrganization, npmRegistry) {
+  const versionHelper = new PackageVersionHelper(npmOrganization, npmRegistry);
+  console.log(`
+Entering ${extensionFolder}
+`);
+  (0, import_child_process.execSync)(`cd "${extensionFolder}"`);
+  const distDir = import_path.default.resolve(extensionFolder, "dist");
+  if (!import_fs_extra.default.existsSync(distDir)) {
+    console.error(`dist directory does not exist at ${distDir}`);
+    process.exit(1);
+  }
+  const packageName = versionHelper.getPackageName(extensionFolder);
+  let version = await versionHelper.getPackageVersion(packageName);
+  if (version) {
+    console.info(`current version is ${version}`);
+    version = import_semver.default.inc(version, "major");
+  } else {
+    console.info(`no version found, using 1.0.0`);
+    version = "1.0.0";
+  }
+  updatePackageInfo(distDir, version, npmOrganization);
+  console.info(`publishing version ${version}`);
+  (0, import_child_process.execSync)(`npm publish --access public`, {
+    cwd: distDir
+  });
+}
+function getTSConfigPath(extensionDir) {
+  const originalTSconfigPath = import_path.default.resolve(extensionDir, "tsconfig.json");
+  const tsconfigJson = JSON.parse(import_fs_extra.default.readFileSync(originalTSconfigPath, "utf8"));
+  tsconfigJson.compilerOptions.jsx = "react";
+  tsconfigJson.compilerOptions.strict = false;
+  const tempTSconfigPath = temporaryFile({ extension: "json" });
+  import_fs_extra.default.writeFileSync(tempTSconfigPath, JSON.stringify(tsconfigJson, null, 2));
+  return tempTSconfigPath;
+}
+async function buildExtension(extensionDir, outputFolder) {
+  const packageJson = JSON.parse(import_fs_extra.default.readFileSync(import_path.default.resolve(extensionDir, "package.json"), "utf8"));
+  const commandNames = packageJson.commands.map((command) => command.name);
+  const supportedExts = [".js", ".ts", ".tsx", ".jsx"];
+  const tsconfigPath = getTSConfigPath(extensionDir);
+  const esbuildConfigs = commandNames.map((commandName) => {
+    const files = import_fs_extra.default.readdirSync(import_path.default.join(extensionDir, "src"));
+    const entry = files.find((file) => {
+      return supportedExts.some((ext) => file === `${commandName}${ext}`);
+    });
+    if (!entry) {
+      throw new Error(`No entry point found for ${commandName}`);
+    }
+    const entryPath = import_path.default.join(extensionDir, "src", entry);
+    const outputPath = import_path.default.join(outputFolder, `${commandName}.js`);
+    console.debug(`entry point for ${commandName} is ${entryPath}`);
+    return {
+      input: entryPath,
+      output: outputPath
+    };
+  });
+  console.info(`entry points [${esbuildConfigs.map((config) => config.input).join(", ")}]`);
+  for (const config of esbuildConfigs) {
+    await import_esbuild.default.build({
+      entryPoints: [config.input],
+      bundle: true,
+      platform: "node",
+      outfile: config.output,
+      external: ["@raycast/api", "react"],
+      jsx: "transform",
+      jsxFactory: "_jsx",
+      jsxFragment: "_jsxFragment",
+      tsconfig: tsconfigPath,
+      minify: true
+    });
+  }
+  import_fs_extra.default.copyFileSync(import_path.default.join(extensionDir, "package.json"), import_path.default.join(outputFolder, "package.json"));
+  const assetsDir = import_path.default.join(extensionDir, "assets");
+  if (import_fs_extra.default.existsSync(assetsDir)) {
+    import_fs_extra.default.copySync(assetsDir, import_path.default.join(outputFolder, "assets"));
+  }
+}
+function updatePackageInfo(targetDir, version, npmOrganization) {
+  const packagePath = import_path.default.join(targetDir, "package.json");
+  const packageJson = JSON.parse(import_fs_extra.default.readFileSync(packagePath, "utf8"));
+  if (!packageJson.name.startsWith(`@${npmOrganization}`)) {
+    packageJson.name = `@${npmOrganization}/${packageJson.name}`;
+  }
+  packageJson.repository = "https://github.com/BlastLauncher/extensions.git";
+  packageJson.version = version;
+  import_fs_extra.default.writeFileSync(packagePath, JSON.stringify(packageJson, null, 2), "utf8");
+}
+var program = new import_commander.Command();
+program.name("blast-cli").description(`CLI for Blast Launcher
+
+Example Usage:
+  blast build ./extensions/todo-list -o ./extensions/todo-list/dist
+  blast publish ./extensions/todo-list blast-extensions`);
+program.command("publish").description("Publish extensions").argument("<path>", "Path to extensions folder").argument("<organization>", "NPM organization to publish to, e.g. blast-extensions").option("-r, --registry <registry>", "NPM registry to publish to", "https://registry.npmjs.org").action((dir, organization, options) => {
+  return publishExtensions(dir, organization, options.registry);
+});
+program.command("build").description("Build extensions").argument("<path>", "Path to extension").option("-o, --output <output>", "Output directory").action((path3, options) => {
+  return buildExtension(path3, options.output);
+});
+program.parse();

package/index.js

@@ -0,0 +1,249 @@
+#!/usr/bin/env node
+import { execSync } from "child_process";
+import https from "https";
+import path from "path";
+
+import { Command } from "commander";
+import esbuild from "esbuild";
+import fs from "fs-extra";
+import semver from "semver";
+import { temporaryFile } from "tempy";
+
+function getJSON(url) {
+  return new Promise((resolve, reject) => {
+    https
+      .get(url, (res) => {
+        let body = "";
+        res.on("data", (chunk) => {
+          body += chunk;
+        });
+        res.on("end", () => {
+          try {
+            resolve(JSON.parse(body));
+          } catch (e) {
+            reject(e);
+          }
+        });
+      })
+      .on("error", (e) => {
+        reject(e);
+      });
+  });
+}
+
+class PackageVersionHelper {
+  constructor(npmOrg, registryUrl = "https://registry.npmjs.org") {
+    this.npmOrg = npmOrg;
+    this.registryUrl = registryUrl;
+  }
+
+  async fetchPackageVersions(packageName) {
+    let res;
+    try {
+      console.log(`fetching ${this.registryUrl}/@${this.npmOrg}/${packageName}`);
+      res = await getJSON(`${this.registryUrl}/@${this.npmOrg}/${packageName}`);
+
+      if (res.error) {
+        return null;
+      }
+
+      return Object.keys(res.versions);
+    } catch (e) {
+      // pacakge not found
+      return null;
+    }
+  }
+
+  async getLatestVersion(versions) {
+    const sortedVersions = versions.sort((a, b) => semver.compare(a, b));
+    return sortedVersions[sortedVersions.length - 1];
+  }
+
+  async getPackageVersion(packageName) {
+    const versions = await this.fetchPackageVersions(packageName);
+    if (!versions) {
+      return null;
+    }
+
+    return this.getLatestVersion(versions);
+  }
+
+  getPackageName(extensionFolder) {
+    const packageJson = JSON.parse(fs.readFileSync(path.resolve(extensionFolder, "package.json"), "utf8"));
+    let packageName = packageJson.name;
+    if (packageName.startsWith("@")) {
+      packageName = packageName.split("/")[1];
+    }
+    packageName = packageName.toLowerCase();
+
+    console.debug(`package name is ${packageName}`);
+
+    return packageName;
+  }
+}
+
+/**
+ * @param {string} extensionFolder
+ * @param {string} npmOrganization
+ * @param {string} npmRegistry
+ */
+async function publishExtensions(extensionFolder, npmOrganization, npmRegistry) {
+  const versionHelper = new PackageVersionHelper(npmOrganization, npmRegistry);
+
+  console.log(`\nEntering ${extensionFolder}\n`);
+  execSync(`cd "${extensionFolder}"`);
+
+  const distDir = path.resolve(extensionFolder, "dist");
+
+  if (!fs.existsSync(distDir)) {
+    console.error(`dist directory does not exist at ${distDir}`);
+    process.exit(1);
+  }
+
+  const packageName = versionHelper.getPackageName(extensionFolder);
+  let version = await versionHelper.getPackageVersion(packageName);
+  if (version) {
+    console.info(`current version is ${version}`);
+    version = semver.inc(version, "major");
+  } else {
+    console.info(`no version found, using 1.0.0`);
+    version = "1.0.0";
+  }
+
+  updatePackageInfo(distDir, version, npmOrganization);
+
+  console.info(`publishing version ${version}`);
+
+  // publish to npm
+  execSync(`npm publish --access public`, {
+    cwd: distDir,
+  });
+}
+
+function getTSConfigPath(extensionDir) {
+  const originalTSconfigPath = path.resolve(extensionDir, "tsconfig.json");
+  const tsconfigJson = JSON.parse(fs.readFileSync(originalTSconfigPath, "utf8"));
+
+  tsconfigJson.compilerOptions.jsx = "react";
+  tsconfigJson.compilerOptions.strict = false;
+
+  const tempTSconfigPath = temporaryFile({ extension: "json" });
+
+  fs.writeFileSync(tempTSconfigPath, JSON.stringify(tsconfigJson, null, 2));
+
+  return tempTSconfigPath;
+}
+
+async function buildExtension(extensionDir, outputFolder) {
+  // Gather entry points from target extension's packages.json
+  const packageJson = JSON.parse(fs.readFileSync(path.resolve(extensionDir, "package.json"), "utf8"));
+
+  const commandNames = packageJson.commands.map((command) => command.name);
+
+  const supportedExts = [".js", ".ts", ".tsx", ".jsx"];
+
+  const tsconfigPath = getTSConfigPath(extensionDir);
+
+  const esbuildConfigs = commandNames.map((commandName) => {
+    const files = fs.readdirSync(path.join(extensionDir, "src"));
+    const entry = files.find((file) => {
+      return supportedExts.some((ext) => file === `${commandName}${ext}`);
+    });
+
+    if (!entry) {
+      throw new Error(`No entry point found for ${commandName}`);
+    }
+
+    const entryPath = path.join(extensionDir, "src", entry);
+    const outputPath = path.join(outputFolder, `${commandName}.js`);
+
+    console.debug(`entry point for ${commandName} is ${entryPath}`);
+
+    return {
+      input: entryPath,
+      output: outputPath,
+    };
+  });
+
+  console.info(`entry points [${esbuildConfigs.map((config) => config.input).join(", ")}]`);
+
+  // Build each entry point
+  for (const config of esbuildConfigs) {
+    await esbuild.build({
+      entryPoints: [config.input],
+      bundle: true,
+      platform: "node",
+      outfile: config.output,
+      external: ["@raycast/api", "react"],
+      jsx: "transform",
+      jsxFactory: "_jsx",
+      jsxFragment: "_jsxFragment",
+      tsconfig: tsconfigPath,
+      minify: true,
+    });
+  }
+
+  // copy the package.json to the output folder
+  fs.copyFileSync(path.join(extensionDir, "package.json"), path.join(outputFolder, "package.json"));
+
+  // copy assets directory to the output folder
+  const assetsDir = path.join(extensionDir, "assets");
+  if (fs.existsSync(assetsDir)) {
+    fs.copySync(assetsDir, path.join(outputFolder, "assets"));
+  }
+}
+
+/**
+ * @param {string} targetDir
+ * @param {string} version
+ * @param {string} npmOrganization
+ * @returns {void}
+ * add extra information to package.json
+ **/
+function updatePackageInfo(targetDir, version, npmOrganization) {
+  const packagePath = path.join(targetDir, "package.json");
+  const packageJson = JSON.parse(fs.readFileSync(packagePath, "utf8"));
+
+  // prepend @BlastLauncher to name if it's not already there
+  if (!packageJson.name.startsWith(`@${npmOrganization}`)) {
+    packageJson.name = `@${npmOrganization}/${packageJson.name}`;
+  }
+
+  // add repository field
+  packageJson.repository = "https://github.com/BlastLauncher/extensions.git";
+
+  // add version
+  packageJson.version = version;
+
+  // write package.json
+  fs.writeFileSync(packagePath, JSON.stringify(packageJson, null, 2), "utf8");
+}
+
+const program = new Command();
+
+program.name("blast-cli").description(`CLI for Blast Launcher
+
+Example Usage:
+  blast build ./extensions/todo-list -o ./extensions/todo-list/dist
+  blast publish ./extensions/todo-list blast-extensions`);
+
+program
+  .command("publish")
+  .description("Publish extensions")
+  .argument("<path>", "Path to extensions folder")
+  .argument("<organization>", "NPM organization to publish to, e.g. blast-extensions")
+  .option("-r, --registry <registry>", "NPM registry to publish to", "https://registry.npmjs.org")
+  .action((dir, organization, options) => {
+    return publishExtensions(dir, organization, options.registry);
+  });
+
+program
+  .command("build")
+  .description("Build extensions")
+  .argument("<path>", "Path to extension")
+  .option("-o, --output <output>", "Output directory")
+  .action((path, options) => {
+    return buildExtension(path, options.output);
+  });
+
+program.parse();

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@blastlauncher/cli",
+  "version": "1.0.1",
+  "description": "Blast CLI Tools",
+  "main": "dist/index.cjs",
+  "bin": {
+    "blast": "dist/index.cjs"
+  },
+  "dependencies": {
+    "commander": "^10.0.0",
+    "esbuild": "^0.17.5",
+    "esbuild-node-externals": "^1.6.0",
+    "fast-glob": "^3.2.12",
+    "fs-extra": "^11.1.0",
+    "semver": "^7.3.8",
+    "tempy": "^3.0.0"
+  },
+  "repository": "https://github.com/BlastLauncher/blast.git",
+  "devDependencies": {
+    "@types/fs-extra": "^9.0.13",
+    "pkg": "^5.8.0"
+  },
+  "pkg": {
+    "outputPath": "dist",
+    "outputName": "blast"
+  },
+  "scripts": {
+    "build": "node build.js",
+    "package": "pkg ."
+  }
+}