hot-updater 0.0.4 → 0.1.0

package/dist/config.cjs

@@ -0,0 +1,30 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/config.ts
+var config_exports = {};
+__export(config_exports, {
+  defineConfig: () => defineConfig
+});
+module.exports = __toCommonJS(config_exports);
+var defineConfig = (config) => typeof config === "function" ? config() : config;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defineConfig
+});

package/dist/config.d.cts

@@ -0,0 +1,5 @@
+import { Config } from '@hot-updater/plugin-core';
+
+declare const defineConfig: (config: Config | (() => Config)) => Config;
+
+export { defineConfig };

package/dist/config.js

@@ -1,5 +1,3 @@
-import "./chunk-JSBRDJBE.js";
-
 // src/config.ts
 var defineConfig = (config) => typeof config === "function" ? config() : config;
 export {

package/dist/index.cjs

@@ -0,0 +1,386 @@
+#!/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 __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
+));
+
+// src/commands/console.ts
+var import_node_server = require("@hono/node-server");
+var import_console = __toESM(require("@hot-updater/console"), 1);
+var openConsole = () => {
+  (0, import_node_server.serve)(
+    {
+      fetch: import_console.default.fetch,
+      port: 1422
+    },
+    (info) => {
+      console.log(`Server running on port ${info.port}`);
+    }
+  );
+};
+
+// src/commands/deploy.ts
+var import_promises4 = __toESM(require("fs/promises"), 1);
+var import_prompts = require("@clack/prompts");
+
+// src/utils/createZip.ts
+var import_path = __toESM(require("path"), 1);
+var import_promises = __toESM(require("fs/promises"), 1);
+var import_jszip = __toESM(require("jszip"), 1);
+var createZip = async (dirPath, filename) => {
+  const zip = new import_jszip.default();
+  async function addFiles(dir, zipFolder) {
+    const files = await import_promises.default.readdir(dir);
+    files.sort();
+    for (const file of files) {
+      const fullPath = import_path.default.join(dir, file);
+      const stats = await import_promises.default.stat(fullPath);
+      if (stats.isDirectory()) {
+        const folder = zipFolder.folder(file);
+        if (!folder) {
+          continue;
+        }
+        await addFiles(fullPath, folder);
+      } else {
+        const data = await import_promises.default.readFile(fullPath);
+        zipFolder.file(file, data);
+      }
+    }
+  }
+  await addFiles(dirPath, zip);
+  zip.forEach((_, file) => {
+    file.date = /* @__PURE__ */ new Date(0);
+  });
+  const content = await zip.generateAsync({
+    type: "nodebuffer",
+    compression: "DEFLATE",
+    compressionOptions: {
+      level: 9
+    },
+    platform: "UNIX"
+  });
+  await import_promises.default.writeFile(filename, content);
+};
+
+// src/utils/formatDate.ts
+var formatDate = (date) => {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  const hours = String(date.getHours()).padStart(2, "0");
+  const minutes = String(date.getMinutes()).padStart(2, "0");
+  const seconds = String(date.getSeconds()).padStart(2, "0");
+  return Number(`${year}${month}${day}${hours}${minutes}${seconds}`);
+};
+
+// src/utils/getDefaultTargetVersion.ts
+var import_child_process = require("child_process");
+var import_path2 = __toESM(require("path"), 1);
+var import_util = __toESM(require("util"), 1);
+var import_promises2 = __toESM(require("fs/promises"), 1);
+var findXCodeProjectFilename = async (cwd) => {
+  try {
+    const iosDirPath = import_path2.default.join(cwd, "ios");
+    const dirContent = await import_promises2.default.readdir(iosDirPath);
+    for (const item of dirContent) {
+      const itemPath = import_path2.default.join(iosDirPath, item);
+      const stats = await import_promises2.default.stat(itemPath);
+      if (stats.isDirectory()) {
+        const pbxprojPath = import_path2.default.join(itemPath, "project.pbxproj");
+        try {
+          await import_promises2.default.access(pbxprojPath);
+          return item;
+        } catch {
+        }
+      }
+    }
+    return null;
+  } catch (error) {
+    return null;
+  }
+};
+var getIOSVersion = async (cwd) => {
+  const filename = await findXCodeProjectFilename(cwd);
+  if (!filename) return null;
+  const projectPath = import_path2.default.join(cwd, "ios", filename);
+  try {
+    const execPromise = import_util.default.promisify(import_child_process.exec);
+    const { stdout } = await execPromise(
+      `xcodebuild -project ${projectPath} -showBuildSettings | grep MARKETING_VERSION`
+    );
+    const versionMatch = stdout.match(/MARKETING_VERSION = ([\d.]+)/);
+    return versionMatch?.[1] ? versionMatch[1] : null;
+  } catch (error) {
+    return null;
+  }
+};
+var getAndroidVersion = async (cwd) => {
+  const buildGradlePath = import_path2.default.join(cwd, "android", "app", "build.gradle");
+  try {
+    const buildGradleContent = await import_promises2.default.readFile(buildGradlePath, "utf8");
+    const versionNameMatch = buildGradleContent.match(
+      /versionName\s+"([\d.]+)"/
+    );
+    return versionNameMatch?.[1] ? versionNameMatch[1] : null;
+  } catch (error) {
+    return null;
+  }
+};
+var getDefaultTargetVersion = async (cwd, platform) => {
+  switch (platform) {
+    case "ios":
+      return getIOSVersion(cwd);
+    case "android":
+      return getAndroidVersion(cwd);
+  }
+  return null;
+};
+
+// src/utils/getFileHash.ts
+var import_crypto = __toESM(require("crypto"), 1);
+var import_promises3 = __toESM(require("fs/promises"), 1);
+var getFileHashFromFile = async (filepath) => {
+  try {
+    const fileBuffer = await import_promises3.default.readFile(filepath).catch((error) => {
+      console.error("Error reading the file:", error);
+      throw error;
+    });
+    const hash = import_crypto.default.createHash("sha256");
+    hash.update(fileBuffer);
+    const fileHash = hash.digest("hex");
+    return fileHash;
+  } catch (error) {
+    console.error("Error fetching or processing the file:", error);
+    throw error;
+  }
+};
+
+// src/commands/deploy.ts
+var import_plugin_core = require("@hot-updater/plugin-core");
+var import_utils = require("@hot-updater/utils");
+var deploy = async (options) => {
+  const s = (0, import_prompts.spinner)();
+  const config = await (0, import_plugin_core.loadConfig)();
+  if (!config) {
+    console.error("No config found. Please run `hot-updater init` first.");
+    process.exit(1);
+  }
+  (0, import_prompts.intro)("Please provide a description for the bundle.");
+  const description = await (0, import_prompts.text)({ message: "Description" });
+  const cwd = (0, import_plugin_core.getCwd)();
+  const targetVersion = options.targetVersion ?? await getDefaultTargetVersion(cwd, options.platform);
+  if (!targetVersion) {
+    throw new Error(
+      "Target version not found. Please provide a target version."
+    );
+  }
+  s.start("Build in progress");
+  const { buildPath } = await config.build({
+    cwd,
+    platform: options.platform
+  });
+  s.message("Checking existing updates...");
+  await createZip(buildPath, "build.zip");
+  const bundlePath = buildPath.concat(".zip");
+  const hash = await getFileHashFromFile(bundlePath);
+  const newBundleVersion = formatDate(/* @__PURE__ */ new Date());
+  const deployPlugin = config.deploy({
+    cwd
+  });
+  const updateSources = await deployPlugin.getUpdateSources();
+  const targetVersions = (0, import_utils.filterTargetVersion)(
+    updateSources ?? [],
+    targetVersion,
+    options.platform
+  );
+  if (targetVersions.length > 0) {
+    const recentVersion = targetVersions[0];
+    const recentHash = recentVersion?.hash;
+    if (recentHash === hash) {
+      s.stop("The update already exists.", -1);
+      return;
+    }
+  }
+  s.message("Uploading bundle...");
+  const { file } = await deployPlugin.uploadBundle(
+    options.platform,
+    newBundleVersion,
+    bundlePath
+  );
+  await deployPlugin.appendUpdateSource({
+    forceUpdate: options.forceUpdate,
+    platform: options.platform,
+    file,
+    hash,
+    description: String(description),
+    targetVersion,
+    bundleVersion: newBundleVersion,
+    enabled: true
+  });
+  await deployPlugin.commitUpdateSource();
+  await import_promises4.default.rm(bundlePath);
+  s.stop("Uploading Success !", 0);
+};
+
+// src/commands/generateSecretKey.ts
+var import_crypto2 = __toESM(require("crypto"), 1);
+var import_prompts2 = require("@clack/prompts");
+var generateSecretKey = async () => {
+  const secretKey = import_crypto2.default.randomBytes(32).toString("hex");
+  await (0, import_prompts2.text)({
+    message: "Secret Key: ",
+    initialValue: secretKey
+  });
+};
+
+// src/commands/prune.ts
+var p = __toESM(require("@clack/prompts"), 1);
+var import_plugin_core2 = require("@hot-updater/plugin-core");
+var import_plugin_core3 = require("@hot-updater/plugin-core");
+var prune = async (options) => {
+  const s = p.spinner();
+  const config = await (0, import_plugin_core3.loadConfig)();
+  if (!config) {
+    console.error("No config found. Please run `hot-updater init` first.");
+    process.exit(1);
+  }
+  const cwd = (0, import_plugin_core2.getCwd)();
+  const deployPlugin = config.deploy({
+    cwd
+    // spinner: s,
+  });
+  s.start("Checking existing updates");
+  const updateSources = await deployPlugin.getUpdateSources();
+  const activeSources = updateSources.filter((source) => source.enabled);
+  const inactiveSources = updateSources.filter((source) => !source.enabled);
+  if (inactiveSources.length === 0) {
+    s.stop("No inactive versions found", -1);
+    return;
+  }
+  s.message("Pruning updates");
+  await deployPlugin.setUpdateSources(activeSources);
+  await deployPlugin.commitUpdateSource();
+  for (const source of inactiveSources) {
+    const key = await deployPlugin.deleteBundle(
+      options.platform,
+      source.bundleVersion
+    );
+    p.log.info(`deleting: ${key}`);
+  }
+  s.stop("Done");
+};
+
+// src/packageJson.ts
+var import_url = require("url");
+var import_read_package_up = require("read-package-up");
+var import_meta = {};
+var __dirname = (0, import_url.fileURLToPath)(new URL(".", import_meta.url));
+var packageJsonData = (0, import_read_package_up.readPackageUpSync)({
+  cwd: __dirname
+});
+var version = packageJsonData?.packageJson.version;
+
+// src/components/banner.tsx
+var import_boxen = __toESM(require("boxen"), 1);
+var import_picocolors = __toESM(require("picocolors"), 1);
+var banner = (0, import_boxen.default)(
+  [
+    `${import_picocolors.default.bold("Hot Updater - React Native OTA Solution")} v${version}`,
+    "",
+    `Github: ${import_picocolors.default.magenta(
+      import_picocolors.default.underline("https://github.com/gronxb/hot-updater")
+    )}`,
+    "Give a \u2B50\uFE0F if you like it!"
+  ].join("\n"),
+  {
+    padding: 1,
+    borderStyle: "round",
+    borderColor: "redBright",
+    textAlignment: "center"
+  }
+);
+
+// src/prompts/getPlatform.ts
+var import_prompts3 = require("@clack/prompts");
+var getPlatform = async (message) => {
+  const platform = await (0, import_prompts3.select)({
+    message,
+    initialValue: "ios",
+    options: [
+      { label: "ios", value: "ios" },
+      { label: "android", value: "android" }
+    ]
+  });
+  if (typeof platform !== "string") {
+    throw new Error("Invalid platform");
+  }
+  return platform;
+};
+
+// src/index.ts
+var import_plugin_core4 = require("@hot-updater/plugin-core");
+var import_commander = require("commander");
+var program = new import_commander.Command();
+program.name("hot-updater").description(banner).version(version);
+program.command("init").description("Initialize Hot Updater").action(() => {
+  console.log("Initializing Hot Updater");
+});
+program.command("deploy").description("deploy a new version").addOption(
+  new import_commander.Option("-p, --platform <platform>", "specify the platform").choices([
+    "ios",
+    "android"
+  ])
+).addOption(
+  new import_commander.Option("-t, --target-version <targetVersion>", "specify the platform")
+).addOption(
+  new import_commander.Option("-f, --force-update", "force update the app").default(false)
+).action(async (options) => {
+  if (!options.platform) {
+    options.platform = await getPlatform(
+      "Which platform do you want to deploy?"
+    );
+  }
+  deploy(options);
+});
+program.command("console").description("open the console").action(openConsole);
+program.command("generate-secret-key").description("generate a new secret key").action(generateSecretKey);
+program.command("app-version").description("get the current app version").action(async () => {
+  const path3 = (0, import_plugin_core4.getCwd)();
+  const androidVersion = await getDefaultTargetVersion(path3, "android");
+  const iosVersion = await getDefaultTargetVersion(path3, "ios");
+  import_plugin_core4.log.info(`Android version: ${androidVersion}`);
+  import_plugin_core4.log.info(`iOS version: ${iosVersion}`);
+});
+program.command("prune").description("prune all the inactive versions").addOption(
+  new import_commander.Option("-p, --platform <platform>", "specify the platform").choices([
+    "ios",
+    "android"
+  ])
+).action(async (options) => {
+  if (!options.platform) {
+    options.platform = await getPlatform(
+      "Which platform do you want to prune?"
+    );
+  }
+  prune(options);
+});
+program.parse(process.argv);

package/dist/index.d.cts

@@ -0,0 +1 @@
+#!/usr/bin/env node