react-native-update-cli 2.7.0 → 2.7.2

package/lib/esm/utils/latest-version/index..mjs

@@ -0,0 +1,238 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join, parse, resolve as pathResolve } from "path";
+import { URL } from "url";
+import { npm, yarn } from "global-dirs";
+import registryAuthToken from "registry-auth-token";
+import getRegistryUrl from "registry-auth-token/registry-url";
+import gt from "semver/functions/gt";
+import maxSatisfying from "semver/ranges/max-satisfying";
+export const ONE_DAY = 1000 * 60 * 60 * 24; // eslint-disable-line @typescript-eslint/naming-convention
+const isPackageJson = (obj)=>{
+    return obj.dependencies !== undefined || obj.devDependencies !== undefined || obj.peerDependencies !== undefined;
+};
+const downloadMetadata = (pkgName, options)=>{
+    return new Promise((resolve, reject)=>{
+        const i = pkgName.indexOf('/');
+        const pkgScope = i !== -1 ? pkgName.slice(0, i) : '';
+        var _options_registryUrl;
+        const registryUrl = (_options_registryUrl = options == null ? void 0 : options.registryUrl) != null ? _options_registryUrl : getRegistryUrl(pkgScope);
+        const pkgUrl = new URL(encodeURIComponent(pkgName).replace(/^%40/, '@'), registryUrl);
+        let requestOptions = {
+            headers: {
+                accept: 'application/vnd.npm.install-v1+json; q=1.0, application/json; q=0.8, */*'
+            },
+            host: pkgUrl.hostname,
+            path: pkgUrl.pathname,
+            port: pkgUrl.port
+        };
+        const authInfo = registryAuthToken(pkgUrl.toString(), {
+            recursive: true
+        });
+        if (authInfo && requestOptions.headers) {
+            requestOptions.headers.authorization = `${authInfo.type} ${authInfo.token}`;
+        }
+        if (options == null ? void 0 : options.requestOptions) {
+            requestOptions = {
+                ...requestOptions,
+                ...options.requestOptions
+            };
+        }
+        const { get } = require(pkgUrl.protocol === 'https:' ? 'https' : 'http');
+        const request = get(requestOptions, (res)=>{
+            if (res.statusCode === 200) {
+                let rawData = '';
+                res.setEncoding('utf8');
+                res.on('data', (chunk)=>rawData += chunk);
+                res.once('error', (err)=>{
+                    res.removeAllListeners();
+                    reject(`Request error (${err.message}): ${pkgUrl}`);
+                });
+                res.once('end', ()=>{
+                    res.removeAllListeners();
+                    try {
+                        const pkgMetadata = JSON.parse(rawData);
+                        resolve({
+                            name: pkgName,
+                            lastUpdateDate: Date.now(),
+                            versions: Object.keys(pkgMetadata.versions),
+                            distTags: pkgMetadata['dist-tags']
+                        });
+                        return;
+                    } catch (err) {
+                        reject(err);
+                        return;
+                    }
+                });
+            } else {
+                res.removeAllListeners();
+                res.resume(); // consume response data to free up memory
+                reject(`Request error (${res.statusCode}): ${pkgUrl}`);
+                return;
+            }
+        });
+        const abort = (error)=>{
+            request.destroy();
+            reject(error);
+        };
+        request.once('timeout', ()=>{
+            abort(`Request timed out: ${pkgUrl}`);
+        });
+        request.once('error', (err)=>{
+            abort(err);
+        });
+        request.on('close', ()=>{
+            request.removeAllListeners();
+        });
+    });
+};
+const getCacheDir = (name = '@badisi/latest-version')=>{
+    const homeDir = homedir();
+    switch(process.platform){
+        case 'darwin':
+            return join(homeDir, 'Library', 'Caches', name);
+        case 'win32':
+            var _process_env_LOCALAPPDATA;
+            return join((_process_env_LOCALAPPDATA = process.env.LOCALAPPDATA) != null ? _process_env_LOCALAPPDATA : join(homeDir, 'AppData', 'Local'), name, 'Cache');
+        default:
+            var _process_env_XDG_CACHE_HOME;
+            return join((_process_env_XDG_CACHE_HOME = process.env.XDG_CACHE_HOME) != null ? _process_env_XDG_CACHE_HOME : join(homeDir, '.cache'), name);
+    }
+};
+const saveMetadataToCache = (pkg)=>{
+    const filePath = join(getCacheDir(), `${pkg.name}.json`);
+    if (!existsSync(dirname(filePath))) {
+        mkdirSync(dirname(filePath), {
+            recursive: true
+        });
+    }
+    writeFileSync(filePath, JSON.stringify(pkg));
+};
+const getMetadataFromCache = (pkgName, options)=>{
+    var _options_cacheMaxAge;
+    const maxAge = (_options_cacheMaxAge = options == null ? void 0 : options.cacheMaxAge) != null ? _options_cacheMaxAge : ONE_DAY;
+    if (maxAge !== 0) {
+        const pkgCacheFilePath = join(getCacheDir(), `${pkgName}.json`);
+        if (existsSync(pkgCacheFilePath)) {
+            const pkg = JSON.parse(readFileSync(pkgCacheFilePath).toString());
+            if (Date.now() - pkg.lastUpdateDate < maxAge) {
+                return pkg;
+            }
+        }
+    }
+    return undefined; // invalidates cache
+};
+const getRegistryVersions = async (pkgName, tagOrRange, options)=>{
+    let pkgMetadata;
+    if (pkgName.length && (options == null ? void 0 : options.useCache)) {
+        pkgMetadata = getMetadataFromCache(pkgName, options);
+        if (!pkgMetadata) {
+            pkgMetadata = await downloadMetadata(pkgName, options);
+            saveMetadataToCache(pkgMetadata);
+        }
+    } else if (pkgName.length) {
+        pkgMetadata = await downloadMetadata(pkgName, options);
+    }
+    const versions = {
+        latest: pkgMetadata == null ? void 0 : pkgMetadata.distTags.latest,
+        next: pkgMetadata == null ? void 0 : pkgMetadata.distTags.next
+    };
+    if (tagOrRange && (pkgMetadata == null ? void 0 : pkgMetadata.distTags[tagOrRange])) {
+        versions.wanted = pkgMetadata.distTags[tagOrRange];
+    } else if (tagOrRange && (pkgMetadata == null ? void 0 : pkgMetadata.versions.length)) {
+        var _maxSatisfying;
+        versions.wanted = (_maxSatisfying = maxSatisfying(pkgMetadata.versions, tagOrRange)) != null ? _maxSatisfying : undefined;
+    }
+    return versions;
+};
+const getInstalledVersion = (pkgName, location = 'local')=>{
+    try {
+        if (location === 'globalNpm') {
+            var _require;
+            return (_require = require(join(npm.packages, pkgName, 'package.json'))) == null ? void 0 : _require.version;
+        } else if (location === 'globalYarn') {
+            var _yarnGlobalPkg_dependencies, _require1;
+            // Make sure package is globally installed by Yarn
+            const yarnGlobalPkg = require(pathResolve(yarn.packages, '..', 'package.json'));
+            if (!(yarnGlobalPkg == null ? void 0 : (_yarnGlobalPkg_dependencies = yarnGlobalPkg.dependencies) == null ? void 0 : _yarnGlobalPkg_dependencies[pkgName])) {
+                return undefined;
+            }
+            return (_require1 = require(join(yarn.packages, pkgName, 'package.json'))) == null ? void 0 : _require1.version;
+        } else {
+            /**
+       * Compute the local paths manually as require.resolve() and require.resolve.paths()
+       * cannot be trusted anymore.
+       * @see https://github.com/nodejs/node/issues/33460
+       * @see https://github.com/nodejs/loaders/issues/26
+       */ const { root } = parse(process.cwd());
+            let path = process.cwd();
+            const localPaths = [
+                join(path, 'node_modules')
+            ];
+            while(path !== root){
+                path = dirname(path);
+                localPaths.push(join(path, 'node_modules'));
+            }
+            for (const localPath of localPaths){
+                const pkgPath = join(localPath, pkgName, 'package.json');
+                if (existsSync(pkgPath)) {
+                    var _require2;
+                    return (_require2 = require(pkgPath)) == null ? void 0 : _require2.version;
+                }
+            }
+        }
+        return undefined;
+    } catch (e) {
+        return undefined;
+    }
+};
+const getInfo = async (pkg, options)=>{
+    const i = pkg.lastIndexOf('@');
+    let pkgInfo = {
+        name: i > 1 ? pkg.slice(0, i) : pkg,
+        wantedTagOrRange: i > 1 ? pkg.slice(i + 1) : 'latest',
+        updatesAvailable: false
+    };
+    try {
+        pkgInfo = {
+            ...pkgInfo,
+            local: getInstalledVersion(pkgInfo.name, 'local'),
+            globalNpm: getInstalledVersion(pkgInfo.name, 'globalNpm'),
+            globalYarn: getInstalledVersion(pkgInfo.name, 'globalYarn'),
+            ...await getRegistryVersions(pkgInfo.name, pkgInfo.wantedTagOrRange, options)
+        };
+        const local = pkgInfo.local && pkgInfo.wanted ? gt(pkgInfo.wanted, pkgInfo.local) ? pkgInfo.wanted : false : false;
+        const globalNpm = pkgInfo.globalNpm && pkgInfo.wanted ? gt(pkgInfo.wanted, pkgInfo.globalNpm) ? pkgInfo.wanted : false : false;
+        const globalYarn = pkgInfo.globalYarn && pkgInfo.wanted ? gt(pkgInfo.wanted, pkgInfo.globalYarn) ? pkgInfo.wanted : false : false;
+        pkgInfo.updatesAvailable = local || globalNpm || globalYarn ? {
+            local,
+            globalNpm,
+            globalYarn
+        } : false;
+    } catch (err) {
+        var _err_message;
+        pkgInfo.error = (_err_message = err == null ? void 0 : err.message) != null ? _err_message : err;
+    }
+    return pkgInfo;
+};
+const latestVersion = async (arg, options)=>{
+    const pkgs = [];
+    if (typeof arg === 'string') {
+        pkgs.push(arg);
+    } else if (Array.isArray(arg)) {
+        pkgs.push(...arg);
+    } else if (isPackageJson(arg)) {
+        const addDeps = (deps)=>{
+            if (deps) {
+                pkgs.push(...Object.keys(deps).map((key)=>`${key}@${deps[key]}`));
+            }
+        };
+        addDeps(arg.dependencies);
+        addDeps(arg.devDependencies);
+        addDeps(arg.peerDependencies);
+    }
+    const jobs = await Promise.allSettled(pkgs.map((pkg)=>getInfo(pkg, options)));
+    const results = jobs.map((jobResult)=>jobResult.value);
+    return typeof arg === 'string' ? results[0] : results;
+};
+export default latestVersion;

package/lib/esm/utils/plugin-config..mjs

@@ -0,0 +1,23 @@
+import fs from "fs-extra";
+export const plugins = [
+    {
+        name: 'sentry',
+        bundleParams: {
+            sentry: true,
+            sourcemap: true
+        },
+        detect: async ()=>{
+            try {
+                await fs.access('ios/sentry.properties');
+                return true;
+            } catch (e) {
+                try {
+                    await fs.access('android/sentry.properties');
+                    return true;
+                } catch (e) {
+                    return false;
+                }
+            }
+        }
+    }
+];

package/lib/esm/versions..mjs

@@ -0,0 +1,290 @@
+import { get, getAllPackages, post, put, uploadFile, doDelete } from "./api";
+import { question, saveToLocal } from "./utils";
+import { t } from "./utils/i18n";
+import chalk from "chalk";
+import { satisfies } from "compare-versions";
+import { getPlatform, getSelectedApp } from "./app";
+import { choosePackage } from "./package";
+import { depVersions } from "./utils/dep-versions";
+import { getCommitInfo } from "./utils/git";
+async function showVersion(appId, offset) {
+    const { data, count } = await get(`/app/${appId}/version/list`);
+    console.log(t('offset', {
+        offset
+    }));
+    for (const version of data){
+        var _version_packages;
+        const pkgCount = ((_version_packages = version.packages) == null ? void 0 : _version_packages.length) || 0;
+        let packageInfo = '';
+        if (pkgCount === 0) {
+            packageInfo = 'no package';
+        } else {
+            var _version_packages1;
+            packageInfo = (_version_packages1 = version.packages) == null ? void 0 : _version_packages1.slice(0, 3).map((pkg)=>pkg.name).join(', ');
+            if (pkgCount > 3) {
+                packageInfo += `...and ${pkgCount - 3} more`;
+            } else {
+                packageInfo = `[${packageInfo}]`;
+            }
+        }
+        console.log(`${version.id}) ${version.hash.slice(0, 8)} ${version.name} ${packageInfo}`);
+    }
+    return data;
+}
+async function listVersions(appId) {
+    let offset = 0;
+    while(true){
+        await showVersion(appId, offset);
+        const cmd = await question('page Up/page Down/Begin/Quit(U/D/B/Q)');
+        switch(cmd.toLowerCase()){
+            case 'u':
+                offset = Math.max(0, offset - 10);
+                break;
+            case 'd':
+                offset += 10;
+                break;
+            case 'b':
+                offset = 0;
+                break;
+            case 'q':
+                return;
+        }
+    }
+}
+async function chooseVersion(appId) {
+    let offset = 0;
+    while(true){
+        const data = await showVersion(appId, offset);
+        const cmd = await question('Enter versionId or page Up/page Down/Begin(U/D/B)');
+        switch(cmd.toUpperCase()){
+            case 'U':
+                offset = Math.max(0, offset - 10);
+                break;
+            case 'D':
+                offset += 10;
+                break;
+            case 'B':
+                offset = 0;
+                break;
+            default:
+                {
+                    const versionId = Number.parseInt(cmd, 10);
+                    const v = data.find((version)=>version.id === String(versionId));
+                    if (v) {
+                        return v;
+                    }
+                }
+        }
+    }
+}
+export const bindVersionToPackages = async ({ appId, versionId, pkgs, rollout, dryRun })=>{
+    if (dryRun) {
+        console.log(chalk.yellow(t('dryRun')));
+    }
+    if (rollout !== undefined) {
+        console.log(`${t('rolloutConfigSet', {
+            versions: pkgs.map((pkg)=>pkg.name).join(', '),
+            rollout: rollout
+        })}`);
+    }
+    for (const pkg of pkgs){
+        if (!dryRun) {
+            await post(`/app/${appId}/binding`, {
+                versionId,
+                rollout,
+                packageId: pkg.id
+            });
+        }
+        console.log(`${t('versionBind', {
+            version: versionId,
+            nativeVersion: pkg.name,
+            id: pkg.id
+        })}`);
+    }
+    console.log(t('operationComplete', {
+        count: pkgs.length
+    }));
+};
+export const versionCommands = {
+    publish: async function({ args, options }) {
+        const fn = args[0];
+        const { name, description, metaInfo } = options;
+        if (!fn || !fn.endsWith('.ppk')) {
+            throw new Error(t('publishUsage'));
+        }
+        const platform = await getPlatform(options.platform);
+        const { appId } = await getSelectedApp(platform);
+        const { hash } = await uploadFile(fn);
+        const versionName = name || await question(t('versionNameQuestion')) || t('unnamed');
+        const { id } = await post(`/app/${appId}/version/create`, {
+            name: versionName,
+            hash,
+            description: description || await question(t('versionDescriptionQuestion')),
+            metaInfo: metaInfo || await question(t('versionMetaInfoQuestion')),
+            deps: depVersions,
+            commit: await getCommitInfo()
+        });
+        // TODO local diff
+        saveToLocal(fn, `${appId}/ppk/${id}.ppk`);
+        console.log(t('packageUploadSuccess', {
+            id
+        }));
+        const { packageId, packageVersion, packageVersionRange, minPackageVersion, maxPackageVersion, rollout, dryRun } = options;
+        if (packageId || packageVersion || packageVersionRange || minPackageVersion || maxPackageVersion) {
+            await this.update({
+                options: {
+                    versionId: id,
+                    platform,
+                    packageId,
+                    packageVersion,
+                    packageVersionRange,
+                    minPackageVersion,
+                    maxPackageVersion,
+                    rollout,
+                    dryRun
+                }
+            });
+        } else {
+            const q = await question(t('updateNativePackageQuestion'));
+            if (q.toLowerCase() === 'y') {
+                await this.update({
+                    options: {
+                        versionId: id,
+                        platform
+                    }
+                });
+            }
+        }
+        return versionName;
+    },
+    versions: async ({ options })=>{
+        const platform = await getPlatform(options.platform);
+        const { appId } = await getSelectedApp(platform);
+        await listVersions(appId);
+    },
+    update: async ({ options })=>{
+        const platform = await getPlatform(options.platform);
+        const appId = options.appId || (await getSelectedApp(platform)).appId;
+        let versionId = options.versionId || (await chooseVersion(appId)).id;
+        if (versionId === 'null') {
+            versionId = undefined;
+        }
+        let pkgId = options.packageId;
+        let pkgVersion = options.packageVersion;
+        let minPkgVersion = options.minPackageVersion;
+        let maxPkgVersion = options.maxPackageVersion;
+        let packageVersionRange = options.packageVersionRange;
+        let rollout = undefined;
+        if (options.rollout !== undefined) {
+            try {
+                rollout = Number.parseInt(options.rollout);
+            } catch (e) {
+                throw new Error(t('rolloutRangeError'));
+            }
+            if (rollout < 1 || rollout > 100) {
+                throw new Error(t('rolloutRangeError'));
+            }
+        }
+        const allPkgs = await getAllPackages(appId);
+        if (!allPkgs) {
+            throw new Error(t('noPackagesFound', {
+                appId
+            }));
+        }
+        let pkgsToBind = [];
+        if (minPkgVersion) {
+            minPkgVersion = String(minPkgVersion).trim();
+            pkgsToBind = allPkgs.filter((pkg)=>satisfies(pkg.name, `>=${minPkgVersion}`));
+            if (pkgsToBind.length === 0) {
+                throw new Error(t('nativeVersionNotFoundGte', {
+                    version: minPkgVersion
+                }));
+            }
+        } else if (maxPkgVersion) {
+            maxPkgVersion = String(maxPkgVersion).trim();
+            pkgsToBind = allPkgs.filter((pkg)=>satisfies(pkg.name, `<=${maxPkgVersion}`));
+            if (pkgsToBind.length === 0) {
+                throw new Error(t('nativeVersionNotFoundLte', {
+                    version: maxPkgVersion
+                }));
+            }
+        } else if (pkgVersion) {
+            pkgVersion = pkgVersion.trim();
+            const pkg = allPkgs.find((pkg)=>pkg.name === pkgVersion);
+            if (pkg) {
+                pkgsToBind = [
+                    pkg
+                ];
+            } else {
+                throw new Error(t('nativeVersionNotFoundMatch', {
+                    version: pkgVersion
+                }));
+            }
+        } else if (packageVersionRange) {
+            packageVersionRange = packageVersionRange.trim();
+            pkgsToBind = allPkgs.filter((pkg)=>satisfies(pkg.name, packageVersionRange));
+            if (pkgsToBind.length === 0) {
+                throw new Error(t('nativeVersionNotFoundMatch', {
+                    version: packageVersionRange
+                }));
+            }
+        } else {
+            if (!pkgId) {
+                pkgId = (await choosePackage(appId)).id;
+            }
+            if (!pkgId) {
+                throw new Error(t('packageIdRequired'));
+            }
+            const pkg = allPkgs.find((pkg)=>String(pkg.id) === String(pkgId));
+            if (pkg) {
+                pkgsToBind = [
+                    pkg
+                ];
+            } else {
+                throw new Error(t('nativePackageIdNotFound', {
+                    id: pkgId
+                }));
+            }
+        }
+        await bindVersionToPackages({
+            appId,
+            versionId,
+            pkgs: pkgsToBind,
+            rollout,
+            dryRun: options.dryRun
+        });
+    },
+    updateVersionInfo: async ({ options })=>{
+        const platform = await getPlatform(options.platform);
+        const { appId } = await getSelectedApp(platform);
+        const versionId = options.versionId || (await chooseVersion(appId)).id;
+        const updateParams = {};
+        if (options.name) updateParams.name = options.name;
+        if (options.description) updateParams.description = options.description;
+        if (options.metaInfo) updateParams.metaInfo = options.metaInfo;
+        await put(`/app/${appId}/version/${versionId}`, updateParams);
+        console.log(t('operationSuccess'));
+    },
+    deleteVersion: async ({ options })=>{
+        let appId = options.appId;
+        if (!appId) {
+            const platform = await getPlatform(options.platform);
+            appId = (await getSelectedApp(platform)).appId;
+        }
+        let versionId = options.versionId;
+        if (!versionId) {
+            versionId = (await chooseVersion(appId)).id;
+        }
+        try {
+            await doDelete(`/app/${appId}/version/${versionId}`);
+            console.log(t('deleteVersionSuccess', {
+                versionId
+            }));
+        } catch (error) {
+            throw new Error(t('deleteVersionError', {
+                versionId,
+                error: error.message
+            }));
+        }
+    }
+};

package/lib/package.js

@@ -233,7 +233,7 @@ const packageCommands = {
         const { id } = await (0, _api.post)(`/app/${appId}/package/create`, {
             name: versionName,
             hash,
-            buildTime,
+            buildTime: String(buildTime),
             deps: _depversions.depVersions,
             commit: await (0, _git.getCommitInfo)()
         });

package/package.json

@@ -1,15 +1,32 @@
 {
   "name": "react-native-update-cli",
-  "version": "2.7.0",
+  "version": "2.7.2",
   "description": "command line tool for react-native-update (remote updates for react native)",
   "main": "index.js",
+  "exports": {
+    ".": {
+      "import": "./lib/esm/index.mjs",
+      "require": "./lib/index.js"
+    },
+    "./cli.json": "./cli.json",
+    "./package.json": "./package.json",
+    "./lib/*": "./lib/*",
+    "./src/*": "./src/*",
+    "./proto/*": "./proto/*",
+    "./*": {
+      "import": "./lib/esm/*.mjs",
+      "require": "./lib/*.js"
+    }
+  },
   "bin": {
     "pushy": "lib/index.js",
     "cresc": "lib/index.js"
   },
   "files": ["lib", "src", "proto", "cli.json"],
   "scripts": {
-    "build": "swc src -d lib --strip-leading-paths",
+    "build:cjs": "swc src -d lib --strip-leading-paths",
+    "build:esm": "swc src -d lib/esm --strip-leading-paths --out-file-extension .mjs -C module.type=es6",
+    "build": "npm run build:cjs && npm run build:esm",
     "prepublishOnly": "npm run build && chmod +x lib/index.js",
     "lint": "tsc --noEmit & biome check --write ."
   },

package/src/api.ts

@@ -191,6 +191,9 @@ export async function uploadFile(fn: string, key?: string) {
     form.append('key', key);
   }
   form.append('file', fileStream);
+  // form.append('file', fileStream, {
+  //   contentType: 'application/octet-stream',
+  // });
 
   const res = await fetch(realUrl, {
     method: 'POST',

package/src/package.ts

@@ -229,7 +229,7 @@ export const packageCommands = {
     const { id } = await post(`/app/${appId}/package/create`, {
       name: versionName,
       hash,
-      buildTime,
+      buildTime: String(buildTime),
       deps: depVersions,
       commit: await getCommitInfo(),
     });