@sevenvip666/rop 0.0.3 → 0.0.6

package/dist/index.d.ts

@@ -0,0 +1,44 @@
+declare type Arch = 'aarch64' | 'x86_64' | 'x64' | 'i686' | string;
+
+export declare const getTauriEnv: (projectPath?: string) => {
+    basePath: string;
+    appName: string;
+    version: string;
+    wixLanguage: string | string[] | {
+        [language: string]: unknown;
+    };
+    wixAppVersion: string;
+    rpmRelease: string;
+};
+
+declare type Platform = 'android' | 'ios' | 'windows' | 'macos' | 'linux' | 'h5';
+
+export declare class RopUpload {
+    baseDomain: string;
+    constructor({ baseDomain }: {
+        baseDomain: string;
+    });
+    upload(_config: UploadType): Promise<{
+        success: boolean;
+        body: unknown;
+    }>;
+    private checkParams;
+}
+
+declare interface UploadDto {
+    platform: Platform;
+    accessKey: string;
+    branch?: string;
+    version?: string;
+    arch: Arch;
+}
+
+declare type UploadType = UploadDto & {
+    targetPath: string;
+    targetName?: string;
+    updatePath?: string;
+    updateName?: string;
+    signature?: string;
+};
+
+export { }

package/dist/rop.js

@@ -0,0 +1,585 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const commander = require("commander");
+const fs = require("node:fs");
+const fetch = require("node-fetch");
+const FormData = require("form-data");
+const child_process = require("child_process");
+const path = require("node:path");
+const yaml = require("js-yaml");
+const os = require("node:os");
+const process = require("vite-plugin-node-polyfills/shims/process");
+const toml = require("@iarna/toml");
+const globby = require("globby");
+const JSON5 = require("json5");
+const cliProgress = require("cli-progress");
+const colors = require("ansi-colors");
+const prompts = require("@inquirer/prompts");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const fs__namespace = /* @__PURE__ */ _interopNamespaceDefault(fs);
+const yaml__namespace = /* @__PURE__ */ _interopNamespaceDefault(yaml);
+const os__namespace = /* @__PURE__ */ _interopNamespaceDefault(os);
+var Framework = /* @__PURE__ */ ((Framework2) => {
+  Framework2["TAURI"] = "TAURI";
+  Framework2["IONIC"] = "IONIC";
+  Framework2["FLUTTER"] = "FLUTTER";
+  return Framework2;
+})(Framework || {});
+function getWorkspaceDir(dir) {
+  var _a;
+  const rootPath = dir;
+  while (dir.length && dir[dir.length - 1] !== path.sep) {
+    const manifestPath = path.join(dir, "Cargo.toml");
+    if (fs.existsSync(manifestPath)) {
+      const toml$1 = toml.parse(fs.readFileSync(manifestPath).toString());
+      if ((_a = toml$1.workspace) == null ? void 0 : _a.members) {
+        const ignore = ["**/target", "**/node_modules"];
+        if (toml$1.workspace.exclude) ignore.push(...toml$1.workspace.exclude);
+        const memberPaths = globby.globbySync(toml$1.workspace.members, {
+          cwd: dir,
+          ignore,
+          expandDirectories: false,
+          onlyFiles: false
+        });
+        if (memberPaths.some((m) => path.resolve(dir, m) === rootPath)) {
+          return dir;
+        }
+      }
+    }
+    dir = path.normalize(path.join(dir, ".."));
+  }
+  return null;
+}
+function getTauriDir(root) {
+  const tauriConfPaths = globby.globbySync(["**/tauri.conf.json", "**/tauri.conf.json5", "**/Tauri.toml"], {
+    gitignore: true,
+    cwd: root,
+    // Forcefully ignore target and node_modules dirs
+    ignore: ["**/target", "**/node_modules"]
+  });
+  if (tauriConfPaths.length === 0) {
+    return null;
+  }
+  return path.resolve(root, tauriConfPaths[0], "..");
+}
+function getCargoManifest(dir) {
+  var _a, _b, _c, _d;
+  const manifestPath = path.join(dir, "Cargo.toml");
+  const cargoManifest = toml.parse(fs.readFileSync(manifestPath).toString());
+  let name = cargoManifest.package.name;
+  let version = cargoManifest.package.version;
+  if (typeof cargoManifest.package.version == "object" || typeof cargoManifest.package.name == "object") {
+    const workspaceDir = getWorkspaceDir(dir);
+    if (!workspaceDir) {
+      throw new Error(
+        "Could not find workspace directory, but version and/or name specifies to use workspace package"
+      );
+    }
+    const manifestPath2 = path.join(workspaceDir, "Cargo.toml");
+    const workspaceManifest = toml.parse(fs.readFileSync(manifestPath2).toString());
+    if (typeof name === "object" && ((_b = (_a = workspaceManifest == null ? void 0 : workspaceManifest.workspace) == null ? void 0 : _a.package) == null ? void 0 : _b.name) !== void 0) {
+      name = workspaceManifest.workspace.package.name;
+    }
+    if (typeof version === "object" && ((_d = (_c = workspaceManifest == null ? void 0 : workspaceManifest.workspace) == null ? void 0 : _c.package) == null ? void 0 : _d.version) !== void 0) {
+      version = workspaceManifest.workspace.package.version;
+    }
+  }
+  return {
+    ...cargoManifest,
+    package: {
+      ...cargoManifest.package,
+      name,
+      version
+    }
+  };
+}
+function _tryParseJsonConfig(contents) {
+  try {
+    const config = JSON.parse(contents);
+    return config;
+  } catch (e) {
+    const msg = e.message;
+    console.error(
+      `Couldn't parse --config flag as inline JSON. This is not an error if it's a file path. Source: "${msg}"`
+    );
+    return null;
+  }
+}
+function _tryParseJson5Config(contents) {
+  try {
+    const config = JSON5.parse(contents);
+    return config;
+  } catch (e) {
+    const msg = e.message;
+    console.error(
+      `Couldn't parse --config flag as inline JSON. This is not an error if it's a file path. Source: "${msg}"`
+    );
+    return null;
+  }
+}
+function _tryParseTomlConfig(contents) {
+  try {
+    const config = toml.parse(contents);
+    return config;
+  } catch (e) {
+    const msg = e.message;
+    console.error(
+      `Couldn't parse --config flag as inline JSON. This is not an error if it's a file path. Source: "${msg}"`
+    );
+    return null;
+  }
+}
+class TauriConfig {
+  constructor(identifier) {
+    this.identifier = identifier;
+  }
+  static fromBaseConfig(tauriDir) {
+    console.log(tauriDir);
+    if (fs.existsSync(path.join(tauriDir, "tauri.conf.json"))) {
+      const contents = fs.readFileSync(path.join(tauriDir, "tauri.conf.json")).toString();
+      const config = _tryParseJsonConfig(contents);
+      if (config) {
+        if ("identifier" in config) {
+          return this.fromV2Base(config);
+        } else {
+          return this.fromV1Base(config);
+        }
+      }
+      console.error("Found tauri.conf.json file but couldn't parse it as JSON.");
+    }
+    if (fs.existsSync(path.join(tauriDir, "tauri.conf.json5"))) {
+      const contents = fs.readFileSync(path.join(tauriDir, "tauri.conf.json5")).toString();
+      const config = _tryParseJson5Config(contents);
+      if (config) {
+        if ("identifier" in config) {
+          return this.fromV2Base(config);
+        } else {
+          return this.fromV1Base(config);
+        }
+      }
+      console.error("Found tauri.conf.json5 file but couldn't parse it as JSON5.");
+    }
+    if (fs.existsSync(path.join(tauriDir, "Tauri.toml"))) {
+      const contents = fs.readFileSync(path.join(tauriDir, "Tauri.toml")).toString();
+      const config = _tryParseTomlConfig(contents);
+      if (config) {
+        if ("identifier" in config) {
+          return this.fromV2Base(config);
+        } else {
+          return this.fromV1Base(config);
+        }
+      }
+      console.error("Found Tauri.toml file but couldn't parse it as TOML.");
+    }
+    throw new Error("Couldn't locate or parse tauri config.");
+  }
+  static fromV1Base(config) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+    if (!((_b = (_a = config.tauri) == null ? void 0 : _a.bundle) == null ? void 0 : _b.identifier)) {
+      throw Error("base config has no bundle identifier.");
+    }
+    const c = new TauriConfig((_d = (_c = config.tauri) == null ? void 0 : _c.bundle) == null ? void 0 : _d.identifier);
+    c.productName = (_e = config.package) == null ? void 0 : _e.productName;
+    c.version = (_f = config.package) == null ? void 0 : _f.version;
+    c.frontendDist = (_g = config.build) == null ? void 0 : _g.distDir;
+    c.beforeBuildCommand = (_h = config.build) == null ? void 0 : _h.beforeBuildCommand;
+    c.rpmRelease = (_i = config.tauri.bundle.rpm) == null ? void 0 : _i.release;
+    c.wixLanguage = (_k = (_j = config.tauri.bundle.windows) == null ? void 0 : _j.wix) == null ? void 0 : _k.language;
+    return c;
+  }
+  static fromV2Base(config) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    if (!config.identifier) {
+      throw Error("base config has no bundle identifier.");
+    }
+    const c = new TauriConfig(config.identifier);
+    c.productName = config.productName;
+    c.version = config.version;
+    c.frontendDist = (_a = config.build) == null ? void 0 : _a.frontendDist;
+    c.beforeBuildCommand = (_b = config.build) == null ? void 0 : _b.beforeBuildCommand;
+    c.rpmRelease = (_e = (_d = (_c = config.bundle) == null ? void 0 : _c.linux) == null ? void 0 : _d.rpm) == null ? void 0 : _e.release;
+    c.wixLanguage = (_h = (_g = (_f = config.bundle) == null ? void 0 : _f.windows) == null ? void 0 : _g.wix) == null ? void 0 : _h.language;
+    return c;
+  }
+}
+const getTauriEnv = (projectPath) => {
+  var _a;
+  const tauriDir = getTauriDir(projectPath ?? ".");
+  if (tauriDir !== null) {
+    let name;
+    let version;
+    let wixLanguage = "en-US";
+    let rpmRelease = "1";
+    const config = TauriConfig.fromBaseConfig(tauriDir);
+    name = config == null ? void 0 : config.productName;
+    if ((_a = config.version) == null ? void 0 : _a.endsWith(".json")) {
+      const packageJsonPath = path.join(tauriDir, config == null ? void 0 : config.version);
+      const contents = fs.readFileSync(packageJsonPath).toString();
+      version = JSON.parse(contents).version;
+    } else {
+      version = config == null ? void 0 : config.version;
+    }
+    if (!(name && version)) {
+      const cargoManifest = getCargoManifest(tauriDir);
+      name = name ?? cargoManifest.package.name;
+      version = version ?? cargoManifest.package.version;
+    }
+    if (!(name && version)) {
+      console.error("Could not determine package name and version.");
+      process.exit(1);
+    }
+    const wixAppVersion = version.replace(/[-+]/g, ".");
+    if (config.wixLanguage) {
+      wixLanguage = config.wixLanguage;
+    }
+    if (config.rpmRelease) {
+      rpmRelease = config.rpmRelease;
+    }
+    return {
+      basePath: tauriDir + "/target",
+      appName: name,
+      version,
+      wixLanguage,
+      wixAppVersion,
+      rpmRelease
+    };
+  } else {
+    throw Error("Couldn't detect Tauri dir");
+  }
+};
+const getBranch = async () => new Promise((resolve) => {
+  return child_process.exec("git rev-parse --abbrev-ref HEAD", (err, stdout, stderr) => {
+    if (err) {
+      console.log(`getBranch Error: ${err}`);
+    } else if (stdout) {
+      resolve(stdout.trim());
+      return;
+    }
+    resolve(void 0);
+  });
+});
+function loadYamlWithEnv({
+  platform,
+  arch,
+  optionAccessKey
+}) {
+  const configFilePath = path.join(".", "rop.yml");
+  const configData = fs.readFileSync(configFilePath, "utf8");
+  const config = yaml__namespace.load(configData);
+  let _arch;
+  if (arch == "x86_64") {
+    _arch = "x64";
+  } else if (arch) {
+    _arch = arch;
+  } else {
+    _arch = "x64";
+  }
+  let env = {
+    arch: _arch
+  };
+  if (!config.framework.name) {
+    throw new Error('Missing "framework.name" property in the configuration file.');
+  }
+  const _autoEnv = getAutoEnvByFramework(config.framework.name, config.projectPath);
+  if (!_autoEnv && !config.framework.env) {
+    throw new Error(
+      `The [${config.framework.name}] framework is not supported, please specify the [framework.env] attribute.`
+    );
+  }
+  env = {
+    ...env,
+    ..._autoEnv,
+    ...config.framework.env ?? {}
+  };
+  if (!env.appName) {
+    throw new Error('Missing "appName" property in the configuration file.');
+  }
+  if (!env.version) {
+    throw new Error('Missing "version" property in the configuration file.');
+  }
+  function replaceEnvInObject(obj) {
+    Object.keys(obj).forEach((key) => {
+      if (typeof obj[key] === "string") {
+        obj[key] = obj[key].replace(/\$\{(\w+)\}/g, (_, envVar) => env[envVar] || "");
+      } else if (typeof obj[key] === "object" && obj[key] !== null) {
+        replaceEnvInObject(obj[key]);
+      }
+    });
+  }
+  replaceEnvInObject(config);
+  const targetInfo = config.platforms[platform][_arch];
+  console.log("find target file:");
+  console.log(targetInfo);
+  const accessKey = getAccessKey(optionAccessKey, config.access);
+  return { config, targetInfo, accessKey, version: env.version };
+}
+const getAccessKey = (accessKey, access) => {
+  if (accessKey) {
+    return accessKey;
+  }
+  if (access == null ? void 0 : access.key) {
+    return access == null ? void 0 : access.key;
+  }
+  if (access == null ? void 0 : access.name) {
+    const configData = fs.readFileSync(`${os__namespace.homedir()}/.rop/config`, "utf8");
+    const regex = `\\[${access.name}]\\n(.+)`;
+    const match = new RegExp(regex).exec(configData);
+    if (match) {
+      return match[1];
+    }
+  }
+  throw new Error("missing access-key");
+};
+const getAutoEnvByFramework = (framework, projectPath) => {
+  switch (framework.toLowerCase()) {
+    case Framework.TAURI.toLowerCase():
+      return getTauriEnv(projectPath);
+    default:
+      return void 0;
+  }
+};
+class RopUpload {
+  constructor({ baseDomain }) {
+    this.checkParams = async (config) => {
+      if (!config.accessKey) {
+        throw new Error("accessKey not null");
+      }
+      const branch = config.branch ?? await getBranch();
+      if (!branch) {
+        throw new Error("branch not null");
+      } else {
+        config.branch = branch;
+      }
+      if (!config.platform) {
+        throw new Error("platform not null");
+      }
+      if (!config.arch) {
+        throw new Error("arch not null");
+      }
+      if (!config.targetPath) {
+        throw new Error("target path not null");
+      }
+      if (!fs.existsSync(config.targetPath)) {
+        throw new Error(`target file not found, file path: ${config.targetPath}`);
+      }
+      if (config.updatePath && !fs.existsSync(config.updatePath)) {
+        throw new Error(`update file not found， file path: ${config.updatePath}`);
+      }
+      if (!config.version) {
+        throw new Error("version not null");
+      }
+      return config;
+    };
+    this.baseDomain = baseDomain;
+  }
+  async upload(_config) {
+    const config = await this.checkParams(_config);
+    const formData = new FormData();
+    const fileStream = fs.createReadStream(config.targetPath);
+    const multibar = new cliProgress.MultiBar({
+      format: "Upload Progress |" + colors.cyan("{bar}") + "| {percentage}% | {filename}",
+      barCompleteChar: "█",
+      barIncompleteChar: "░",
+      hideCursor: true
+    });
+    const bar1 = multibar.create(fs.statSync(config.targetPath).size, 0);
+    let totalUploaded = 0;
+    fileStream.on("data", (chunk) => {
+      totalUploaded += chunk.length;
+      bar1.update(totalUploaded, { filename: path.basename(config.targetPath) });
+    });
+    formData.append("targetFile", fileStream, {
+      filename: config.targetName ?? path.basename(config.targetPath)
+    });
+    let updateFileStream;
+    if (config.updatePath) {
+      const bar2 = multibar.create(fs.statSync(config.updatePath).size, 0);
+      updateFileStream = fs.createReadStream(config.updatePath);
+      let totalUpdateUploaded = 0;
+      updateFileStream.on("data", (chunk) => {
+        totalUpdateUploaded += chunk.length;
+        bar2.update(totalUpdateUploaded, { filename: path.basename(config.updatePath) });
+      });
+      formData.append("updateFile", updateFileStream, {
+        filename: config.updateName ?? path.basename(config.updatePath)
+      });
+    }
+    formData.append("accessKey", config.accessKey);
+    formData.append("branch", config.branch);
+    formData.append("version", config.version);
+    formData.append("platform", config.platform);
+    formData.append("arch", config.arch);
+    if (config.signature) {
+      formData.append("signature", config.signature);
+    }
+    const res = await fetch(`${this.baseDomain}/api/upload`, {
+      method: "POST",
+      headers: formData.getHeaders(),
+      body: formData
+    });
+    const body = await res.json();
+    if (!res.ok) {
+      console.log(res.status, res.statusText, body);
+    }
+    multibar.stop();
+    fileStream.destroy();
+    updateFileStream == null ? void 0 : updateFileStream.destroy();
+    return { success: res.ok, body };
+  }
+}
+class Init {
+  async initYaml(accessKey) {
+    const __dirname = path.resolve();
+    const projectName = path.basename(__dirname);
+    const ymlConfigPath = path.join(".", "rop.yml");
+    let ymlConfigJson = {};
+    if (fs.existsSync(ymlConfigPath)) {
+      let flag = false;
+      try {
+        flag = await prompts.confirm({
+          message: `${colors.cyan("rop.yml")} already exists, does it need to be overwritten?`
+        });
+      } catch (error) {
+        console.log("cancel");
+        return false;
+      }
+      if (!flag) {
+        console.log("cancel");
+        return false;
+      }
+      const ymlContent = fs.readFileSync(ymlConfigPath, "utf8");
+      ymlConfigJson = yaml__namespace.load(ymlContent);
+    }
+    if (!ymlConfigJson.access) {
+      ymlConfigJson.access = {
+        name: projectName
+      };
+    } else {
+      ymlConfigJson.access.name = projectName;
+    }
+    const yamlData = yaml__namespace.dump(ymlConfigJson, {
+      lineWidth: 500
+    });
+    fs.writeFileSync(ymlConfigPath, yamlData, "utf8");
+    return true;
+  }
+  async initRopConfig(accessKey) {
+    const ropConfigDirPath = path.join(".", ".rop");
+    if (!fs.existsSync(ropConfigDirPath)) {
+      fs.mkdirSync(ropConfigDirPath);
+    }
+    const ropConfigPath = path.join(ropConfigDirPath, "config.json");
+    let ropConfigData = {};
+    if (fs.existsSync(ropConfigPath)) {
+      ropConfigData = JSON.parse(fs.readFileSync(ropConfigPath, "utf8"));
+    }
+    ropConfigData.accessKey = accessKey;
+    fs.writeFileSync(ropConfigPath, JSON.stringify(ropConfigData, null, 2), "utf8");
+  }
+  async initGitignore() {
+    const gitignorePath = path.join(".", ".gitignore");
+    if (fs.existsSync(gitignorePath)) {
+      const gitignoreData = fs.readFileSync(gitignorePath, "utf8");
+      if (!gitignoreData.includes(".rop")) {
+        fs.appendFileSync(gitignorePath, `
+.rop`, "utf8");
+      }
+    } else {
+      fs.writeFileSync(gitignorePath, `.rop`, "utf8");
+    }
+  }
+}
+const program = new commander.Command();
+program.name("rop").description("CLI to some JavaScript string utilities").version("0.1.0");
+program.command("init").description("init rop").action(async () => {
+  let accessKey = "";
+  while (!accessKey) {
+    try {
+      accessKey = await prompts.input({ message: `Please enter ${colors.cyan("access-key")}` });
+    } catch (error) {
+      console.log("cancel");
+      return;
+    }
+  }
+  const init = new Init();
+  if (await init.initYaml(accessKey)) {
+    await init.initRopConfig(accessKey);
+    await init.initGitignore();
+    console.log("done");
+  }
+});
+program.command("set-key").description("set access-key").argument("<string>", "projectAccessKey").action(async (projectAccessKey) => {
+  try {
+    const array = projectAccessKey.split("=");
+    if (array.length != 2) {
+      throw new Error("parameter format error");
+    }
+    const [projectName, accessKey] = array;
+    const homeDirectory = os__namespace.homedir();
+    const homedir = `${homeDirectory}/.rop`;
+    if (!fs__namespace.existsSync(homedir)) {
+      fs__namespace.mkdirSync(homedir);
+    }
+    const filePath = `${homedir}/config`;
+    const content = `[${projectName}]
+${accessKey}`;
+    if (!fs__namespace.existsSync(filePath)) {
+      fs__namespace.writeFileSync(filePath, content);
+    } else {
+      const configData = fs__namespace.readFileSync(filePath, "utf8");
+      const regex = `\\[${projectName}]\\n(.+)`;
+      const match = new RegExp(regex).exec(configData);
+      if (match) {
+        fs__namespace.writeFileSync(filePath, configData.replace(match[0], content));
+      } else {
+        fs__namespace.appendFileSync(filePath, "\n" + content);
+      }
+    }
+  } catch (error) {
+    console.error("Error reading configuration file or missing required properties:", error);
+  }
+});
+program.command("upload").description("Upload some framework build").argument("<string>", "platform").argument("[string]", "arch").option("-a, --accessKey <string>", "accessKey path").action(async (platform, arch, options) => {
+  var _a, _b, _c, _d;
+  const { config, targetInfo, accessKey, version } = loadYamlWithEnv({
+    platform,
+    arch,
+    optionAccessKey: options.accessKey
+  });
+  if (!config.host) {
+    throw new Error('Missing "host" property in the configuration file.');
+  }
+  if (!targetInfo) {
+    throw new Error('Missing "targetInfo" property in the configuration file.');
+  }
+  const uploadClient = new RopUpload({ baseDomain: config.host });
+  await uploadClient.upload({
+    accessKey,
+    arch,
+    platform,
+    version,
+    targetPath: targetInfo.target.path,
+    targetName: (_a = targetInfo.target) == null ? void 0 : _a.name,
+    updatePath: (_b = targetInfo.update) == null ? void 0 : _b.path,
+    updateName: (_c = targetInfo.update) == null ? void 0 : _c.name,
+    signature: ((_d = targetInfo.sig) == null ? void 0 : _d.path) ? fs__namespace.readFileSync(targetInfo.sig.path, "utf8") : void 0
+  });
+});
+program.parse();
+exports.RopUpload = RopUpload;
+exports.getTauriEnv = getTauriEnv;

package/package.json

@@ -1,30 +1,27 @@
 {
   "name": "@sevenvip666/rop",
-  "version": "0.0.3",
+  "version": "0.0.6",
   "type": "module",
   "files": [
     "dist",
     "index.d.ts"
   ],
   "bin": {
-    "rop": "dist/index.js"
+    "rop": "dist/rop.js"
   },
-  "main": "dist/index.js",
-  "module": "dist/index.js",
+  "main": "dist/rop.js",
+  "module": "dist/rop.js",
   "types": "dist/index.d.ts",
   "exports": {
     "types": "./dist/index.d.ts",
-    "import": "./dist/index.js"
+    "import": "./dist/rop.js"
   },
   "scripts": {
-    "test": "vitest",
-    "build2": "tsc --p ./tsconfig-build.json && vite build",
-    "build": "ncc build lib/rop.ts -o dist"
+    "build": "vite build"
   },
   "dependencies": {
     "@iarna/toml": "^2.2.5",
     "@inquirer/prompts": "^5.3.5",
-    "@vercel/ncc": "^0.38.1",
     "ansi-colors": "^4.1.3",
     "cli-progress": "^3.12.0",
     "commander": "^12.1.0",
@@ -32,7 +29,8 @@
     "globby": "^14.0.2",
     "js-yaml": "^4.1.0",
     "json5": "^2.2.3",
-    "node-fetch": "^3.3.2"
+    "node-fetch": "^3.3.2",
+    "vite-plugin-node-polyfills": "^0.22.0"
   },
   "devDependencies": {
     "@repo/api-types": "workspace:*",
@@ -43,7 +41,6 @@
     "typescript": "^5.4.5",
     "vite": "^5.2.10",
     "vite-plugin-dts": "^3.9.1",
-    "vite-plugin-node-polyfills": "^0.22.0",
     "vitest": "^2.0.2"
   }
 }