hot-updater 0.1.1 → 0.1.2

package/dist/index.cjs

@@ -179,66 +179,72 @@ 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."
+  try {
+    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
     );
-  }
-  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;
+    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);
+  } catch (e) {
+    s.stop("Uploading Failed !", -1);
+    console.error(e);
+    process.exit(-1);
   }
-  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
@@ -258,35 +264,41 @@ 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}`);
+  try {
+    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");
+  } catch (e) {
+    s.stop("Pruning Failed !", -1);
+    console.error(e);
+    process.exit(-1);
   }
-  s.stop("Done");
 };
 
 // src/packageJson.ts

package/dist/index.js

@@ -159,66 +159,72 @@ import { getCwd, loadConfig } from "@hot-updater/plugin-core";
 import { filterTargetVersion } from "@hot-updater/utils";
 var deploy = async (options) => {
   const s = spinner();
-  const config = await loadConfig();
-  if (!config) {
-    console.error("No config found. Please run `hot-updater init` first.");
-    process.exit(1);
-  }
-  intro("Please provide a description for the bundle.");
-  const description = await text({ message: "Description" });
-  const cwd = getCwd();
-  const targetVersion = options.targetVersion ?? await getDefaultTargetVersion(cwd, options.platform);
-  if (!targetVersion) {
-    throw new Error(
-      "Target version not found. Please provide a target version."
+  try {
+    const config = await loadConfig();
+    if (!config) {
+      console.error("No config found. Please run `hot-updater init` first.");
+      process.exit(1);
+    }
+    intro("Please provide a description for the bundle.");
+    const description = await text({ message: "Description" });
+    const cwd = 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 = filterTargetVersion(
+      updateSources ?? [],
+      targetVersion,
+      options.platform
     );
-  }
-  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 = 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;
+    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 fs4.rm(bundlePath);
+    s.stop("Uploading Success !", 0);
+  } catch (e) {
+    s.stop("Uploading Failed !", -1);
+    console.error(e);
+    process.exit(-1);
   }
-  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 fs4.rm(bundlePath);
-  s.stop("Uploading Success !", 0);
 };
 
 // src/commands/generateSecretKey.ts
@@ -238,35 +244,41 @@ import { getCwd as getCwd2 } from "@hot-updater/plugin-core";
 import { loadConfig as loadConfig2 } from "@hot-updater/plugin-core";
 var prune = async (options) => {
   const s = p.spinner();
-  const config = await loadConfig2();
-  if (!config) {
-    console.error("No config found. Please run `hot-updater init` first.");
-    process.exit(1);
-  }
-  const cwd = getCwd2();
-  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}`);
+  try {
+    const config = await loadConfig2();
+    if (!config) {
+      console.error("No config found. Please run `hot-updater init` first.");
+      process.exit(1);
+    }
+    const cwd = getCwd2();
+    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");
+  } catch (e) {
+    s.stop("Pruning Failed !", -1);
+    console.error(e);
+    process.exit(-1);
   }
-  s.stop("Done");
 };
 
 // src/packageJson.ts

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "hot-updater",
   "type": "module",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "bin": {
     "hot-updater": "./dist/index.js"
   },
@@ -14,6 +14,7 @@
   },
   "files": [
     "dist",
+    "src",
     "package.json"
   ],
   "description": "React Native OTA solution for self-hosted",
@@ -30,7 +31,7 @@
   "dependencies": {
     "@clack/prompts": "^0.7.0",
     "@hono/node-server": "^1.13.4",
-    "@hot-updater/console": "0.1.1",
+    "@hot-updater/console": "0.1.2",
     "boxen": "^8.0.1",
     "commander": "^11.1.0",
     "cosmiconfig": "^9.0.0",
@@ -40,8 +41,8 @@
     "plist": "^3.1.0",
     "read-package-up": "^11.0.0",
     "workspace-tools": "^0.36.4",
-    "@hot-updater/plugin-core": "0.1.1",
-    "@hot-updater/utils": "0.1.1"
+    "@hot-updater/plugin-core": "0.1.2",
+    "@hot-updater/utils": "0.1.2"
   },
   "devDependencies": {
     "@types/connect": "^3.4.38",

package/src/commands/console.ts

@@ -0,0 +1,15 @@
+import { serve } from "@hono/node-server";
+
+import app from "@hot-updater/console";
+
+export const openConsole = () => {
+  serve(
+    {
+      fetch: app.fetch,
+      port: 1422,
+    },
+    (info) => {
+      console.log(`Server running on port ${info.port}`);
+    },
+  );
+};

package/src/commands/deploy.ts

@@ -0,0 +1,105 @@
+import fs from "node:fs/promises";
+import { intro, spinner, text } from "@clack/prompts";
+
+import { createZip } from "@/utils/createZip";
+import { formatDate } from "@/utils/formatDate";
+import { getDefaultTargetVersion } from "@/utils/getDefaultTargetVersion";
+import { getFileHashFromFile } from "@/utils/getFileHash";
+import { getCwd, loadConfig } from "@hot-updater/plugin-core";
+import { type Platform, filterTargetVersion } from "@hot-updater/utils";
+
+export interface DeployOptions {
+  targetVersion?: string;
+  platform: Platform;
+  forceUpdate: boolean;
+}
+
+export const deploy = async (options: DeployOptions) => {
+  const s = spinner();
+
+  try {
+    const config = await loadConfig();
+    if (!config) {
+      console.error("No config found. Please run `hot-updater init` first.");
+      process.exit(1);
+    }
+
+    intro("Please provide a description for the bundle.");
+    const description = await text({ message: "Description" });
+
+    const cwd = 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(new Date());
+
+    const deployPlugin = config.deploy({
+      cwd,
+    });
+
+    const updateSources = await deployPlugin.getUpdateSources();
+    const targetVersions = filterTargetVersion(
+      updateSources ?? [],
+      targetVersion,
+      options.platform,
+    );
+
+    // hash check
+    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 fs.rm(bundlePath);
+    s.stop("Uploading Success !", 0);
+  } catch (e) {
+    s.stop("Uploading Failed !", -1);
+    console.error(e);
+    process.exit(-1);
+  }
+};

package/src/commands/generateSecretKey.ts

@@ -0,0 +1,11 @@
+import crypto from "crypto";
+import { text } from "@clack/prompts";
+
+export const generateSecretKey = async () => {
+  const secretKey = crypto.randomBytes(32).toString("hex");
+
+  await text({
+    message: "Secret Key: ",
+    initialValue: secretKey,
+  });
+};

package/src/commands/prune.ts

@@ -0,0 +1,56 @@
+import * as p from "@clack/prompts";
+import { type Platform, getCwd } from "@hot-updater/plugin-core";
+import { loadConfig } from "@hot-updater/plugin-core";
+
+export interface PruneOptions {
+  platform: Platform;
+}
+
+export const prune = async (options: PruneOptions) => {
+  const s = p.spinner();
+
+  try {
+    const config = await loadConfig();
+    if (!config) {
+      console.error("No config found. Please run `hot-updater init` first.");
+      process.exit(1);
+    }
+
+    const cwd = 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");
+  } catch (e) {
+    s.stop("Pruning Failed !", -1);
+    console.error(e);
+    process.exit(-1);
+  }
+};

package/src/components/banner.tsx

@@ -0,0 +1,20 @@
+import { version } from "@/packageJson";
+import boxen from "boxen";
+import picocolors from "picocolors";
+
+export const banner = boxen(
+  [
+    `${picocolors.bold("Hot Updater - React Native OTA Solution")} v${version}`,
+    "",
+    `Github: ${picocolors.magenta(
+      picocolors.underline("https://github.com/gronxb/hot-updater"),
+    )}`,
+    "Give a ⭐️ if you like it!",
+  ].join("\n"),
+  {
+    padding: 1,
+    borderStyle: "round",
+    borderColor: "redBright",
+    textAlignment: "center",
+  },
+);

package/src/config.ts

@@ -0,0 +1,4 @@
+import type { Config } from "@hot-updater/plugin-core";
+
+export const defineConfig = (config: Config | (() => Config)): Config =>
+  typeof config === "function" ? config() : config;

package/src/index.ts

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+import { openConsole } from "@/commands/console";
+import { type DeployOptions, deploy } from "@/commands/deploy";
+import { generateSecretKey } from "@/commands/generateSecretKey";
+import { prune } from "@/commands/prune";
+import { banner } from "@/components/banner";
+import { version } from "@/packageJson";
+import { getPlatform } from "@/prompts/getPlatform";
+import { getDefaultTargetVersion } from "@/utils/getDefaultTargetVersion";
+import { getCwd, log } from "@hot-updater/plugin-core";
+import { Command, Option } from "commander";
+
+const program = new Command();
+
+program
+  .name("hot-updater")
+  .description(banner)
+  .version(version as string);
+
+program
+  .command("init")
+  .description("Initialize Hot Updater")
+  .action(() => {
+    console.log("Initializing Hot Updater");
+  });
+
+program
+  .command("deploy")
+  .description("deploy a new version")
+  .addOption(
+    new Option("-p, --platform <platform>", "specify the platform").choices([
+      "ios",
+      "android",
+    ]),
+  )
+  .addOption(
+    new Option("-t, --target-version <targetVersion>", "specify the platform"),
+  )
+  .addOption(
+    new Option("-f, --force-update", "force update the app").default(false),
+  )
+  .action(async (options: DeployOptions) => {
+    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 path = getCwd();
+    const androidVersion = await getDefaultTargetVersion(path, "android");
+    const iosVersion = await getDefaultTargetVersion(path, "ios");
+
+    log.info(`Android version: ${androidVersion}`);
+    log.info(`iOS version: ${iosVersion}`);
+  });
+
+program
+  .command("prune")
+  .description("prune all the inactive versions")
+  .addOption(
+    new 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/src/packageJson.ts

@@ -0,0 +1,7 @@
+import { readPackageUpSync } from "read-package-up";
+
+export const packageJsonData = readPackageUpSync({
+  cwd: __dirname,
+});
+
+export const version = packageJsonData?.packageJson.version;

package/src/prompts/getPlatform.ts

@@ -0,0 +1,19 @@
+import { select } from "@clack/prompts";
+import type { Platform } from "@hot-updater/utils";
+
+export const getPlatform = async (message: string) => {
+  const platform = await select({
+    message: message,
+    initialValue: "ios" as Platform,
+    options: [
+      { label: "ios", value: "ios" },
+      { label: "android", value: "android" },
+    ],
+  });
+
+  if (typeof platform !== "string") {
+    throw new Error("Invalid platform");
+  }
+
+  return platform;
+};

package/src/utils/createZip.ts

@@ -0,0 +1,47 @@
+import path from "path";
+import fs from "fs/promises";
+
+import JSZip from "jszip";
+
+export const createZip = async (dirPath: string, filename: string) => {
+  const zip = new JSZip();
+
+  async function addFiles(dir: string, zipFolder: JSZip) {
+    const files = await fs.readdir(dir);
+    files.sort();
+    for (const file of files) {
+      const fullPath = path.join(dir, file);
+      const stats = await fs.stat(fullPath);
+
+      if (stats.isDirectory()) {
+        const folder = zipFolder.folder(file);
+        if (!folder) {
+          continue;
+        }
+
+        await addFiles(fullPath, folder);
+      } else {
+        const data = await fs.readFile(fullPath);
+        zipFolder.file(file, data);
+      }
+    }
+  }
+
+  await addFiles(dirPath, zip);
+
+  // fix hash
+  zip.forEach((_, file) => {
+    file.date = new Date(0);
+  });
+
+  const content = await zip.generateAsync({
+    type: "nodebuffer",
+    compression: "DEFLATE",
+    compressionOptions: {
+      level: 9,
+    },
+    platform: "UNIX",
+  });
+
+  await fs.writeFile(filename, content);
+};

package/src/utils/delay.ts

@@ -0,0 +1,2 @@
+export const delay = (ms: number) =>
+  new Promise((resolve) => setTimeout(resolve, ms));

package/src/utils/formatDate.ts

@@ -0,0 +1,21 @@
+export const formatDate = (date: 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}`);
+};
+
+export function formatDateTimeFromBundleVersion(input: string): string {
+  const year = input.substring(0, 4);
+  const month = input.substring(4, 6);
+  const day = input.substring(6, 8);
+  const hour = input.substring(8, 10);
+  const minute = input.substring(10, 12);
+  const second = input.substring(12, 14);
+
+  return `${year}/${month}/${day} ${hour}:${minute}:${second}`;
+}

package/src/utils/getDefaultTargetVersion.ts

@@ -0,0 +1,76 @@
+import { exec } from "child_process";
+import path from "path";
+import util from "util";
+import type { Platform } from "@hot-updater/plugin-core";
+import fs from "fs/promises";
+
+const findXCodeProjectFilename = async (
+  cwd: string,
+): Promise<string | null> => {
+  try {
+    const iosDirPath = path.join(cwd, "ios");
+    const dirContent = await fs.readdir(iosDirPath);
+    for (const item of dirContent) {
+      const itemPath = path.join(iosDirPath, item);
+      const stats = await fs.stat(itemPath);
+      if (stats.isDirectory()) {
+        const pbxprojPath = path.join(itemPath, "project.pbxproj");
+        try {
+          await fs.access(pbxprojPath);
+          return item;
+        } catch {
+          // Not the directory we are looking for
+        }
+      }
+    }
+    return null;
+  } catch (error) {
+    return null;
+  }
+};
+
+export const getIOSVersion = async (cwd: string): Promise<string | null> => {
+  const filename = await findXCodeProjectFilename(cwd);
+  if (!filename) return null;
+
+  const projectPath = path.join(cwd, "ios", filename);
+  try {
+    const execPromise = util.promisify(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;
+  }
+};
+
+export const getAndroidVersion = async (
+  cwd: string,
+): Promise<string | null> => {
+  const buildGradlePath = path.join(cwd, "android", "app", "build.gradle");
+  try {
+    const buildGradleContent = await fs.readFile(buildGradlePath, "utf8");
+    const versionNameMatch = buildGradleContent.match(
+      /versionName\s+"([\d.]+)"/,
+    );
+    return versionNameMatch?.[1] ? versionNameMatch[1] : null;
+  } catch (error) {
+    return null;
+  }
+};
+
+export const getDefaultTargetVersion = async (
+  cwd: string,
+  platform: Platform,
+): Promise<string | null> => {
+  switch (platform) {
+    case "ios":
+      return getIOSVersion(cwd);
+    case "android":
+      return getAndroidVersion(cwd);
+  }
+  return null;
+};

package/src/utils/getFileHash.ts

@@ -0,0 +1,22 @@
+import crypto from "crypto";
+import fs from "fs/promises";
+
+export const getFileHashFromFile = async (filepath: string) => {
+  try {
+    // Read the file
+    const fileBuffer = await fs.readFile(filepath).catch((error) => {
+      console.error("Error reading the file:", error);
+      throw error;
+    });
+
+    // Calculate the hash
+    const hash = crypto.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;
+  }
+};

package/src/utils/toRotated.tsx

@@ -0,0 +1,26 @@
+export function toRotated<T>(array: T[], steps: number): T[] {
+  if (!Array.isArray(array)) {
+    throw new TypeError(`Expected an array, got \`${typeof array}\`.`);
+  }
+
+  if (!Number.isSafeInteger(steps)) {
+    throw new TypeError(
+      `The \`steps\` parameter must be an integer, got ${steps}.`,
+    );
+  }
+
+  const { length } = array;
+  if (length === 0) {
+    return [...array];
+  }
+
+  const normalizedSteps = ((steps % length) + length) % length;
+  if (normalizedSteps === 0) {
+    return [...array];
+  }
+
+  return [
+    ...array.slice(-normalizedSteps),
+    ...array.slice(0, -normalizedSteps),
+  ];
+}