@sevenvip666/rop 0.0.3 → 0.0.5

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,385 @@
+import { Command as T } from "commander";
+import * as h from "node:fs";
+import c, { readFileSync as w, existsSync as S } from "node:fs";
+import D from "node-fetch";
+import B from "form-data";
+import { exec as $ } from "child_process";
+import p, { resolve as x, join as m, sep as R, normalize as O } from "node:path";
+import * as P from "js-yaml";
+import * as E from "node:os";
+import J from "vite-plugin-node-polyfills/shims/process";
+import { parse as v } from "@iarna/toml";
+import { globbySync as N } from "globby";
+import K from "json5";
+import I from "cli-progress";
+import C from "ansi-colors";
+import { confirm as U, input as L } from "@inquirer/prompts";
+var F = /* @__PURE__ */ ((n) => (n.TAURI = "TAURI", n.IONIC = "IONIC", n.FLUTTER = "FLUTTER", n))(F || {});
+function M(n) {
+  const t = n;
+  for (; n.length && n[n.length - 1] !== R; ) {
+    const e = m(n, "Cargo.toml");
+    if (S(e)) {
+      const r = v(w(e).toString());
+      if (r.workspace?.members) {
+        const o = ["**/target", "**/node_modules"];
+        if (r.workspace.exclude && o.push(...r.workspace.exclude), N(r.workspace.members, {
+          cwd: n,
+          ignore: o,
+          expandDirectories: !1,
+          onlyFiles: !1
+        }).some((i) => x(n, i) === t))
+          return n;
+      }
+    }
+    n = O(m(n, ".."));
+  }
+  return null;
+}
+function _(n) {
+  const t = N(["**/tauri.conf.json", "**/tauri.conf.json5", "**/Tauri.toml"], {
+    gitignore: !0,
+    cwd: n,
+    // Forcefully ignore target and node_modules dirs
+    ignore: ["**/target", "**/node_modules"]
+  });
+  return t.length === 0 ? null : x(n, t[0], "..");
+}
+function A(n) {
+  const t = m(n, "Cargo.toml"), e = v(w(t).toString());
+  let r = e.package.name, o = e.package.version;
+  if (typeof e.package.version == "object" || typeof e.package.name == "object") {
+    const a = M(n);
+    if (!a)
+      throw new Error(
+        "Could not find workspace directory, but version and/or name specifies to use workspace package"
+      );
+    const i = m(a, "Cargo.toml"), s = v(w(i).toString());
+    typeof r == "object" && s?.workspace?.package?.name !== void 0 && (r = s.workspace.package.name), typeof o == "object" && s?.workspace?.package?.version !== void 0 && (o = s.workspace.package.version);
+  }
+  return {
+    ...e,
+    package: {
+      ...e.package,
+      name: r,
+      version: o
+    }
+  };
+}
+function V(n) {
+  try {
+    return JSON.parse(n);
+  } catch (t) {
+    const e = t.message;
+    return console.error(
+      `Couldn't parse --config flag as inline JSON. This is not an error if it's a file path. Source: "${e}"`
+    ), null;
+  }
+}
+function W(n) {
+  try {
+    return K.parse(n);
+  } catch (t) {
+    const e = t.message;
+    return console.error(
+      `Couldn't parse --config flag as inline JSON. This is not an error if it's a file path. Source: "${e}"`
+    ), null;
+  }
+}
+function z(n) {
+  try {
+    return v(n);
+  } catch (t) {
+    const e = t.message;
+    return console.error(
+      `Couldn't parse --config flag as inline JSON. This is not an error if it's a file path. Source: "${e}"`
+    ), null;
+  }
+}
+class k {
+  constructor(t) {
+    this.identifier = t;
+  }
+  static fromBaseConfig(t) {
+    if (console.log(t), S(m(t, "tauri.conf.json"))) {
+      const e = w(m(t, "tauri.conf.json")).toString(), r = V(e);
+      if (r)
+        return "identifier" in r ? this.fromV2Base(r) : this.fromV1Base(r);
+      console.error("Found tauri.conf.json file but couldn't parse it as JSON.");
+    }
+    if (S(m(t, "tauri.conf.json5"))) {
+      const e = w(m(t, "tauri.conf.json5")).toString(), r = W(e);
+      if (r)
+        return "identifier" in r ? this.fromV2Base(r) : this.fromV1Base(r);
+      console.error("Found tauri.conf.json5 file but couldn't parse it as JSON5.");
+    }
+    if (S(m(t, "Tauri.toml"))) {
+      const e = w(m(t, "Tauri.toml")).toString(), r = z(e);
+      if (r)
+        return "identifier" in r ? this.fromV2Base(r) : this.fromV1Base(r);
+      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(t) {
+    if (!t.tauri?.bundle?.identifier)
+      throw Error("base config has no bundle identifier.");
+    const e = new k(t.tauri?.bundle?.identifier);
+    return e.productName = t.package?.productName, e.version = t.package?.version, e.frontendDist = t.build?.distDir, e.beforeBuildCommand = t.build?.beforeBuildCommand, e.rpmRelease = t.tauri.bundle.rpm?.release, e.wixLanguage = t.tauri.bundle.windows?.wix?.language, e;
+  }
+  static fromV2Base(t) {
+    if (!t.identifier)
+      throw Error("base config has no bundle identifier.");
+    const e = new k(t.identifier);
+    return e.productName = t.productName, e.version = t.version, e.frontendDist = t.build?.frontendDist, e.beforeBuildCommand = t.build?.beforeBuildCommand, e.rpmRelease = t.bundle?.linux?.rpm?.release, e.wixLanguage = t.bundle?.windows?.wix?.language, e;
+  }
+}
+const Y = (n) => {
+  const t = _(n ?? ".");
+  if (t !== null) {
+    let e, r, o = "en-US", a = "1";
+    const i = k.fromBaseConfig(t);
+    if (e = i?.productName, i.version?.endsWith(".json")) {
+      const l = m(t, i?.version), f = w(l).toString();
+      r = JSON.parse(f).version;
+    } else
+      r = i?.version;
+    if (!(e && r)) {
+      const l = A(t);
+      e = e ?? l.package.name, r = r ?? l.package.version;
+    }
+    e && r || (console.error("Could not determine package name and version."), J.exit(1));
+    const s = r.replace(/[-+]/g, ".");
+    return i.wixLanguage && (o = i.wixLanguage), i.rpmRelease && (a = i.rpmRelease), {
+      basePath: t + "/target",
+      appName: e,
+      version: r,
+      wixLanguage: o,
+      wixAppVersion: s,
+      rpmRelease: a
+    };
+  } else
+    throw Error("Couldn't detect Tauri dir");
+}, G = async () => new Promise((n) => $("git rev-parse --abbrev-ref HEAD", (t, e, r) => {
+  if (t)
+    console.log(`getBranch Error: ${t}`);
+  else if (e) {
+    n(e.trim());
+    return;
+  }
+  n(void 0);
+}));
+function H({
+  platform: n,
+  arch: t,
+  optionAccessKey: e
+}) {
+  const r = p.join(".", "rop.yml"), o = c.readFileSync(r, "utf8"), a = P.load(o);
+  let i;
+  t == "x86_64" ? i = "x64" : t ? i = t : i = "x64";
+  let s = {
+    arch: i
+  };
+  if (!a.framework.name)
+    throw new Error('Missing "framework.name" property in the configuration file.');
+  const l = Q(a.framework.name, a.projectPath);
+  if (!l && !a.framework.env)
+    throw new Error(
+      `The [${a.framework.name}] framework is not supported, please specify the [framework.env] attribute.`
+    );
+  if (s = {
+    ...s,
+    ...l,
+    ...a.framework.env ?? {}
+  }, !s.appName)
+    throw new Error('Missing "appName" property in the configuration file.');
+  if (!s.version)
+    throw new Error('Missing "version" property in the configuration file.');
+  function f(u) {
+    Object.keys(u).forEach((d) => {
+      typeof u[d] == "string" ? u[d] = u[d].replace(/\$\{(\w+)\}/g, (ee, j) => s[j] || "") : typeof u[d] == "object" && u[d] !== null && f(u[d]);
+    });
+  }
+  f(a);
+  const g = a.platforms[n][i];
+  console.log("find target file:"), console.log(g);
+  const y = q(e, a.access);
+  return { config: a, targetInfo: g, accessKey: y, version: s.version };
+}
+const q = (n, t) => {
+  if (n)
+    return n;
+  if (t?.key)
+    return t?.key;
+  if (t?.name) {
+    const e = c.readFileSync(`${E.homedir()}/.rop/config`, "utf8"), r = `\\[${t.name}]\\n(.+)`, o = new RegExp(r).exec(e);
+    if (o)
+      return o[1];
+  }
+  throw new Error("missing access-key");
+}, Q = (n, t) => {
+  switch (n.toLowerCase()) {
+    case F.TAURI.toLowerCase():
+      return Y(t);
+    default:
+      return;
+  }
+};
+class X {
+  constructor({ baseDomain: t }) {
+    this.checkParams = async (e) => {
+      if (!e.accessKey)
+        throw new Error("accessKey not null");
+      const r = e.branch ?? await G();
+      if (r)
+        e.branch = r;
+      else
+        throw new Error("branch not null");
+      if (!e.platform)
+        throw new Error("platform not null");
+      if (!e.arch)
+        throw new Error("arch not null");
+      if (!e.targetPath)
+        throw new Error("target path not null");
+      if (!c.existsSync(e.targetPath))
+        throw new Error(`target file not found, file path: ${e.targetPath}`);
+      if (e.updatePath && !c.existsSync(e.updatePath))
+        throw new Error(`update file not found， file path: ${e.updatePath}`);
+      if (!e.version)
+        throw new Error("version not null");
+      return e;
+    }, this.baseDomain = t;
+  }
+  async upload(t) {
+    const e = await this.checkParams(t), r = new B(), o = c.createReadStream(e.targetPath), a = new I.MultiBar({
+      format: "Upload Progress |" + C.cyan("{bar}") + "| {percentage}% | {filename}",
+      barCompleteChar: "█",
+      barIncompleteChar: "░",
+      hideCursor: !0
+    }), i = a.create(c.statSync(e.targetPath).size, 0);
+    let s = 0;
+    o.on("data", (y) => {
+      s += y.length, i.update(s, { filename: p.basename(e.targetPath) });
+    }), r.append("targetFile", o, {
+      filename: e.targetName ?? p.basename(e.targetPath)
+    });
+    let l;
+    if (e.updatePath) {
+      const y = a.create(c.statSync(e.updatePath).size, 0);
+      l = c.createReadStream(e.updatePath);
+      let u = 0;
+      l.on("data", (d) => {
+        u += d.length, y.update(u, { filename: p.basename(e.updatePath) });
+      }), r.append("updateFile", l, {
+        filename: e.updateName ?? p.basename(e.updatePath)
+      });
+    }
+    r.append("accessKey", e.accessKey), r.append("branch", e.branch), r.append("version", e.version), r.append("platform", e.platform), r.append("arch", e.arch), e.signature && r.append("signature", e.signature);
+    const f = await D(`${this.baseDomain}/api/upload`, {
+      method: "POST",
+      headers: r.getHeaders(),
+      body: r
+    }), g = await f.json();
+    return f.ok || console.log(f.status, f.statusText, g), a.stop(), o.destroy(), l?.destroy(), { success: f.ok, body: g };
+  }
+}
+class Z {
+  async initYaml(t) {
+    const e = p.resolve(), r = p.basename(e), o = p.join(".", "rop.yml");
+    let a = {};
+    if (c.existsSync(o)) {
+      let s = !1;
+      try {
+        s = await U({
+          message: `${C.cyan("rop.yml")} already exists, does it need to be overwritten?`
+        });
+      } catch {
+        return console.log("cancel"), !1;
+      }
+      if (!s)
+        return console.log("cancel"), !1;
+      const l = c.readFileSync(o, "utf8");
+      a = P.load(l);
+    }
+    a.access ? a.access.name = r : a.access = {
+      name: r
+    };
+    const i = P.dump(a, {
+      lineWidth: 500
+    });
+    return c.writeFileSync(o, i, "utf8"), !0;
+  }
+  async initRopConfig(t) {
+    const e = p.join(".", ".rop");
+    c.existsSync(e) || c.mkdirSync(e);
+    const r = p.join(e, "config.json");
+    let o = {};
+    c.existsSync(r) && (o = JSON.parse(c.readFileSync(r, "utf8"))), o.accessKey = t, c.writeFileSync(r, JSON.stringify(o, null, 2), "utf8");
+  }
+  async initGitignore() {
+    const t = p.join(".", ".gitignore");
+    c.existsSync(t) ? c.readFileSync(t, "utf8").includes(".rop") || c.appendFileSync(t, `
+.rop`, "utf8") : c.writeFileSync(t, ".rop", "utf8");
+  }
+}
+const b = new T();
+b.name("rop").description("CLI to some JavaScript string utilities").version("0.1.0");
+b.command("init").description("init rop").action(async () => {
+  let n = "";
+  for (; !n; )
+    try {
+      n = await L({ message: `Please enter ${C.cyan("access-key")}` });
+    } catch {
+      console.log("cancel");
+      return;
+    }
+  const t = new Z();
+  await t.initYaml(n) && (await t.initRopConfig(n), await t.initGitignore(), console.log("done"));
+});
+b.command("set-key").description("set access-key").argument("<string>", "projectAccessKey").action(async (n) => {
+  try {
+    const t = n.split("=");
+    if (t.length != 2)
+      throw new Error("parameter format error");
+    const [e, r] = t, a = `${E.homedir()}/.rop`;
+    h.existsSync(a) || h.mkdirSync(a);
+    const i = `${a}/config`, s = `[${e}]
+${r}`;
+    if (!h.existsSync(i))
+      h.writeFileSync(i, s);
+    else {
+      const l = h.readFileSync(i, "utf8"), f = `\\[${e}]\\n(.+)`, g = new RegExp(f).exec(l);
+      g ? h.writeFileSync(i, l.replace(g[0], s)) : h.appendFileSync(i, `
+` + s);
+    }
+  } catch (t) {
+    console.error("Error reading configuration file or missing required properties:", t);
+  }
+});
+b.command("upload").description("Upload some framework build").argument("<string>", "platform").argument("[string]", "arch").option("-a, --accessKey <string>", "accessKey path").action(async (n, t, e) => {
+  const { config: r, targetInfo: o, accessKey: a, version: i } = H({
+    platform: n,
+    arch: t,
+    optionAccessKey: e.accessKey
+  });
+  if (!r.host)
+    throw new Error('Missing "host" property in the configuration file.');
+  if (!o)
+    throw new Error('Missing "targetInfo" property in the configuration file.');
+  await new X({ baseDomain: r.host }).upload({
+    accessKey: a,
+    arch: t,
+    platform: n,
+    version: i,
+    targetPath: o.target.path,
+    targetName: o.target?.name,
+    updatePath: o.update?.path,
+    updateName: o.update?.name,
+    signature: o.sig?.path ? h.readFileSync(o.sig.path, "utf8") : void 0
+  });
+});
+b.parse();
+export {
+  X as RopUpload,
+  Y as getTauriEnv
+};

package/package.json

@@ -1,30 +1,27 @@
 {
   "name": "@sevenvip666/rop",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "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"
   }
 }