rn-update-cli 1.0.0

package/lib/utils/index.js

@@ -0,0 +1,545 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkPlugins = exports.IpaBundleFileName = exports.ApkBundleFileName = void 0;
+exports.loadTtyTable = loadTtyTable;
+exports.isNonInteractive = isNonInteractive;
+exports.question = question;
+exports.translateOptions = translateOptions;
+exports.getApkInfo = getApkInfo;
+exports.getAppInfo = getAppInfo;
+exports.getIpaInfo = getIpaInfo;
+exports.getAabInfo = getAabInfo;
+exports.printVersionCommand = printVersionCommand;
+/**
+ * [INPUT]: 依赖 ZIP/APK/AAB/IPA/Harmony 解析器和摘要计算
+ * [OUTPUT]: 对外提供原生包版本、channel、bundleHash 与 opaque buildTime 读取器
+ * [POS]: CLI 构建身份解析层，永不把原生构建标识转换成数字
+ */
+const chalk_1 = __importDefault(require("chalk"));
+const compare_versions_1 = require("compare-versions");
+const crypto_1 = require("crypto");
+const path_1 = __importDefault(require("path"));
+const read_1 = require("read");
+const yauzl_1 = require("yauzl");
+const package_json_1 = __importDefault(require("../../package.json"));
+const check_plugin_1 = require("./check-plugin");
+Object.defineProperty(exports, "checkPlugins", { enumerable: true, get: function () { return check_plugin_1.checkPlugins; } });
+const dep_versions_1 = require("./dep-versions");
+const http_helper_1 = require("./http-helper");
+const i18n_1 = require("./i18n");
+// app-info-parser (and its zip/plist/protobuf stack) is only needed by the
+// package commands; load it on first use instead of on every CLI start.
+function createAppInfoParser(fn) {
+    const { default: AppInfoParser } = require('./app-info-parser');
+    return new AppInfoParser(fn);
+}
+/**
+ * tty-table (~25 ms to load) only when a table is rendered. Bun's require of
+ * a CJS module can hand back a namespace object, so unwrap `default`.
+ */
+function loadTtyTable() {
+    const mod = require('tty-table');
+    return (mod.default ?? mod);
+}
+/** True when prompts cannot or must not be shown. */
+function isNonInteractive(env = process.env, stdinIsTTY = process.stdin.isTTY, globalFlag = global.NO_INTERACTIVE) {
+    const envValue = env.NO_INTERACTIVE?.toLowerCase();
+    return (globalFlag === true ||
+        envValue === 'true' ||
+        envValue === '1' ||
+        stdinIsTTY !== true);
+}
+async function question(query, password) {
+    if (isNonInteractive()) {
+        return '';
+    }
+    return (0, read_1.read)({
+        prompt: query,
+        silent: password,
+        replace: password ? '*' : undefined,
+    });
+}
+function translateOptions(options, map) {
+    if (!map) {
+        // Existing logic for template replacement if no map is provided
+        const ret = {};
+        for (const key in options) {
+            const value = options[key];
+            if (typeof value === 'string') {
+                ret[key] = value.replace(/\$\{(\w+)\}/g, (placeholder, name) => {
+                    const replacement = options[name] ?? process.env[name];
+                    if (typeof replacement === 'string' ||
+                        typeof replacement === 'number' ||
+                        typeof replacement === 'boolean') {
+                        return String(replacement);
+                    }
+                    return placeholder;
+                });
+            }
+            else {
+                ret[key] = value;
+            }
+        }
+        return ret;
+    }
+    const result = { ...options };
+    for (const [key, value] of Object.entries(map)) {
+        if (result[key] !== undefined) {
+            result[value] = result[key];
+            delete result[key];
+        }
+    }
+    return result;
+}
+// bundleHash: sha256 of the raw bundle bytes extracted from the package. Must
+// stay byte-identical with what the client hashes at runtime (its embedded
+// bundle, which is also the pdiff source) — the server compares the two to
+// decide pdiff applicability. Raw bytes, no normalization of any kind.
+// getEntries is typed Buffer | Blob (app-info-parser's browser/node duality);
+// under Node it is always a Buffer, but handle both.
+async function sha256(data) {
+    const buffer = Buffer.isBuffer(data)
+        ? data
+        : Buffer.from(await data.arrayBuffer());
+    return (0, crypto_1.createHash)('sha256').update(buffer).digest('hex');
+}
+// Anchored exact paths: unanchored/unescaped patterns also matched entries
+// like index.android.bundle.map or .backup, and a later match would silently
+// overwrite the real bundle, registering a wrong bundleHash.
+exports.ApkBundleFileName = /^assets\/index\.android\.bundle$/;
+const ApkUpdateJsonName = /^res\/raw\/update\.json$/;
+async function getApkInfo(fn) {
+    const appInfoParser = createAppInfoParser(fn);
+    // read both entries in a single scan over the archive
+    const entries = await appInfoParser.parser.getEntries([
+        exports.ApkBundleFileName,
+        ApkUpdateJsonName,
+    ]);
+    const bundleFile = entries[String(exports.ApkBundleFileName)];
+    if (!bundleFile) {
+        throw new Error((0, i18n_1.t)('bundleNotFound', {
+            packageType: 'apk',
+            entryFile: 'index.android.bundle',
+        }));
+    }
+    const updateJsonFile = entries[String(ApkUpdateJsonName)];
+    let appCredential = {};
+    if (updateJsonFile) {
+        appCredential = JSON.parse(updateJsonFile.toString()).android;
+    }
+    const { versionName, application } = await appInfoParser.parse();
+    let buildTime = '';
+    let channel = 'default';
+    if (Array.isArray(application.metaData)) {
+        for (const meta of application.metaData) {
+            if (meta.name === 'pakta_build_time') {
+                if (Array.isArray(meta.value)) {
+                    const firstValue = meta.value[0];
+                    buildTime = String(firstValue);
+                }
+                else if (meta.value !== undefined) {
+                    buildTime = String(meta.value);
+                }
+            }
+            if (meta.name === 'channel' && meta.value !== undefined) {
+                const value = Array.isArray(meta.value) ? meta.value[0] : meta.value;
+                channel = String(value).trim() || 'default';
+            }
+        }
+    }
+    if (!buildTime || buildTime === '0') {
+        throw new Error((0, i18n_1.t)('buildTimeNotFound'));
+    }
+    return {
+        versionName,
+        buildTime,
+        bundleHash: await sha256(bundleFile),
+        bundleFile,
+        ...appCredential,
+        channel,
+    };
+}
+async function getAppInfo(fn) {
+    const appInfoParser = createAppInfoParser(fn);
+    // single scan (and single nested .hap extraction) for all three entries
+    const [bundleFile, updateJsonFile, metaJsonFile] = await appInfoParser.parser.getEntriesFromHarmonyApp([
+        /^resources\/rawfile\/bundle\.harmony\.js$/,
+        /^resources\/rawfile\/update\.json$/,
+        /^resources\/rawfile\/meta\.json$/,
+    ]);
+    if (!bundleFile) {
+        throw new Error((0, i18n_1.t)('bundleNotFound', {
+            packageType: 'app',
+            entryFile: 'bundle.harmony.js',
+        }));
+    }
+    let appCredential = {};
+    if (updateJsonFile) {
+        appCredential = JSON.parse(updateJsonFile.toString()).harmony;
+    }
+    let metaData = {};
+    if (metaJsonFile) {
+        metaData = JSON.parse(metaJsonFile.toString());
+    }
+    const { versionName, pakta_build_time, channel: parsedChannel } = metaData;
+    const buildTime = pakta_build_time === undefined ? '' : String(pakta_build_time);
+    const channel = typeof parsedChannel === 'string' && parsedChannel.trim() ? parsedChannel.trim() : 'default';
+    if (!buildTime || buildTime === '0') {
+        throw new Error((0, i18n_1.t)('buildTimeNotFound'));
+    }
+    return {
+        versionName,
+        buildTime,
+        bundleHash: await sha256(bundleFile),
+        bundleFile,
+        ...appCredential,
+        channel,
+    };
+}
+// lowercase because the zip reader also matches against the lowercased entry
+// name (real IPAs use "Payload/")
+exports.IpaBundleFileName = /^payload\/[^/]+\.app\/main\.jsbundle$/;
+const IpaUpdateJsonName = /^payload\/[^/]+\.app\/assets\/update\.json$/;
+const IpaBuildTimeName = /^payload\/[^/]+\.app\/pakta_build_time\.txt$/;
+// Not in root bundle when use `use_frameworks`
+const IpaBuildTimeFrameworkName = /^payload\/[^/]+\.app\/frameworks\/react_native_update\.framework\/pakta_build_time\.txt$/;
+async function getIpaInfo(fn) {
+    const appInfoParser = createAppInfoParser(fn);
+    // read all four entries in a single scan over the archive
+    const entries = await appInfoParser.parser.getEntries([
+        exports.IpaBundleFileName,
+        IpaUpdateJsonName,
+        IpaBuildTimeName,
+        IpaBuildTimeFrameworkName,
+    ]);
+    const bundleFile = entries[String(exports.IpaBundleFileName)];
+    if (!bundleFile) {
+        throw new Error((0, i18n_1.t)('bundleNotFound', {
+            packageType: 'ipa',
+            entryFile: 'main.jsbundle',
+        }));
+    }
+    const updateJsonFile = entries[String(IpaUpdateJsonName)];
+    let appCredential = {};
+    if (updateJsonFile) {
+        appCredential = JSON.parse(updateJsonFile.toString()).ios;
+    }
+    const { CFBundleShortVersionString: versionName, channel: parsedChannel } = await appInfoParser.parse();
+    const buildTimeTxtBuffer = entries[String(IpaBuildTimeName)] ??
+        entries[String(IpaBuildTimeFrameworkName)];
+    if (!buildTimeTxtBuffer) {
+        throw new Error((0, i18n_1.t)('buildTimeNotFound'));
+    }
+    const buildTime = buildTimeTxtBuffer.toString().trim();
+    if (!buildTime || buildTime === '0') {
+        throw new Error((0, i18n_1.t)('buildTimeNotFound'));
+    }
+    return {
+        versionName,
+        buildTime,
+        bundleHash: await sha256(bundleFile),
+        bundleFile,
+        ...appCredential,
+        channel: typeof parsedChannel === 'string' && parsedChannel.trim() ? parsedChannel.trim() : 'default',
+    };
+}
+async function getAabInfo(fn) {
+    const protobuf = require('protobufjs');
+    const root = await protobuf.load(path_1.default.join(__dirname, '../../proto/Resources.proto'));
+    const XmlNode = root.lookupType('aapt.pb.XmlNode');
+    const buffer = await readZipEntry(fn, 'base/manifest/AndroidManifest.xml');
+    const message = XmlNode.decode(buffer);
+    const object = XmlNode.toObject(message, {
+        enums: String,
+        longs: String,
+        bytes: String,
+        defaults: true,
+        arrays: true,
+    });
+    const manifestElement = object.element;
+    if (manifestElement.name !== 'manifest') {
+        throw new Error((0, i18n_1.t)('invalidManifest'));
+    }
+    let versionName = '';
+    for (const attr of manifestElement.attribute) {
+        if (attr.name === 'versionName') {
+            versionName = attr.value;
+        }
+    }
+    let buildTime = '';
+    let channel = 'default';
+    const appCredential = {};
+    // Find application node
+    const applicationNode = manifestElement.child.find((child) => child.element?.name === 'application');
+    const applicationElement = applicationNode?.element;
+    if (applicationElement) {
+        const metaDataNodes = applicationElement.child.filter((child) => child.element?.name === 'meta-data');
+        for (const meta of metaDataNodes) {
+            let name = '';
+            let value = '';
+            let resourceId = 0;
+            const metaElement = meta.element;
+            if (!metaElement) {
+                continue;
+            }
+            for (const attr of metaElement.attribute) {
+                if (attr.name === 'name') {
+                    name = attr.value;
+                }
+                if (attr.name === 'value') {
+                    value = attr.value;
+                    if (attr.compiledItem?.ref?.id) {
+                        resourceId = attr.compiledItem.ref.id;
+                    }
+                    else if (attr.compiledItem?.prim?.intDecimalValue) {
+                        value = attr.compiledItem.prim.intDecimalValue.toString();
+                    }
+                }
+            }
+            if (name === 'pakta_build_time') {
+                if (resourceId > 0) {
+                    const resolvedValue = await resolveResource(fn, resourceId, root);
+                    if (resolvedValue) {
+                        value = resolvedValue;
+                    }
+                }
+                buildTime = String(value);
+            }
+            if (name === 'channel') {
+                channel = value.trim() || 'default';
+            }
+        }
+    }
+    if (!buildTime || buildTime === '0') {
+        throw new Error((0, i18n_1.t)('buildTimeNotFound'));
+    }
+    // The JS bundle lives in the base module; these are the same bytes the
+    // extracted APK carries (extractApk copies entries verbatim), so the hash
+    // matches what uploadAab ends up registering via getApkInfo. Lenient on
+    // absence — getAabInfo is display-only (parseAab); the upload path goes
+    // through extractApk → getApkInfo which enforces the bundle's presence.
+    let bundleHash;
+    try {
+        bundleHash = await sha256(await readZipEntry(fn, 'base/assets/index.android.bundle'));
+    }
+    catch {
+        // no embedded bundle (e.g. debug AAB); omit the field
+    }
+    return {
+        versionName,
+        buildTime,
+        ...(bundleHash ? { bundleHash } : {}),
+        ...appCredential,
+        channel,
+    };
+}
+async function readZipEntry(fn, entryName) {
+    return new Promise((resolve, reject) => {
+        (0, yauzl_1.open)(fn, { lazyEntries: true }, (err, zipfile) => {
+            if (err || !zipfile) {
+                reject(err ?? new Error('Failed to open zip file'));
+                return;
+            }
+            let found = false;
+            zipfile.readEntry();
+            zipfile.on('entry', (entry) => {
+                if (entry.fileName === entryName) {
+                    found = true;
+                    zipfile.openReadStream(entry, (streamError, readStream) => {
+                        if (streamError || !readStream) {
+                            zipfile.close();
+                            reject(streamError ?? new Error('Failed to read zip entry'));
+                            return;
+                        }
+                        const chunks = [];
+                        readStream.on('data', (chunk) => chunks.push(chunk));
+                        readStream.on('end', () => {
+                            zipfile.close();
+                            resolve(Buffer.concat(chunks));
+                        });
+                        readStream.on('error', (error) => {
+                            zipfile.close();
+                            reject(error);
+                        });
+                    });
+                }
+                else {
+                    zipfile.readEntry();
+                }
+            });
+            zipfile.on('end', () => {
+                if (!found)
+                    reject(new Error(`${entryName} not found in AAB`));
+            });
+            zipfile.on('error', reject);
+        });
+    });
+}
+async function resolveResource(fn, resourceId, root) {
+    const pkgId = (resourceId >> 24) & 0xff;
+    const typeId = (resourceId >> 16) & 0xff;
+    const entryId = resourceId & 0xffff;
+    try {
+        const buffer = await readZipEntry(fn, 'base/resources.pb');
+        const ResourceTable = root.lookupType('aapt.pb.ResourceTable');
+        const message = ResourceTable.decode(buffer);
+        const object = ResourceTable.toObject(message, {
+            enums: String,
+            longs: String,
+            bytes: String,
+            defaults: true,
+            arrays: true,
+        });
+        // Find package
+        const pkg = object.package.find((pkgItem) => pkgItem.packageId === pkgId);
+        if (!pkg)
+            return null;
+        // Find type
+        const type = pkg.type.find((typeItem) => typeItem.typeId === typeId);
+        if (!type)
+            return null;
+        // Find entry
+        const entry = type.entry.find((entryItem) => entryItem.entryId === entryId);
+        if (!entry)
+            return null;
+        // Get value from configValue
+        if (entry.configValue && entry.configValue.length > 0) {
+            const val = entry.configValue[0]?.value;
+            const stringValue = val?.item?.str?.value;
+            if (typeof stringValue === 'string') {
+                return stringValue;
+            }
+        }
+    }
+    catch (e) {
+        console.warn((0, i18n_1.t)('failedToResolveResource', { error: e }));
+    }
+    return null;
+}
+const VERSION_CHECK_PACKAGES = ['rn-update-cli', 'rn-update'];
+/**
+ * Latest registry versions of the CLI and the client library, in that order
+ * (`undefined` where unknown). Never rejects.
+ *
+ * `background: true` answers from a 1-day cache when possible and otherwise
+ * refreshes it with an unref'd request, so the process is free to exit before
+ * the registry answers; `background: false` always asks the registry and
+ * waits (refreshing the cache on the way).
+ */
+async function getLatestVersions(background) {
+    // the registry client pulls in global-dirs/registry-auth-token/semver: only
+    // pay for them when actually checking
+    const { default: latestVersion } = require('./latest-version');
+    return latestVersion(VERSION_CHECK_PACKAGES, {
+        useCache: true,
+        ...(background ? { unref: true } : { cacheMaxAge: 0 }),
+        requestOptions: {
+            timeout: 2000,
+        },
+    })
+        .then((pkgs) => pkgs.map((pkg) => pkg.latest))
+        .catch(() => VERSION_CHECK_PACKAGES.map(() => undefined));
+}
+function isNewer(latest, current) {
+    if (!latest || !current) {
+        return false;
+    }
+    try {
+        return (0, compare_versions_1.compare)(latest, current, '>');
+    }
+    catch {
+        return false;
+    }
+}
+function latestTag(version) {
+    return version
+        ? ` ${(0, i18n_1.t)('latestVersionTag', { version: chalk_1.default.green(version) })}`
+        : '';
+}
+/**
+ * Print the installed CLI / rn-update versions (and refuse or warn
+ * about unsupported client versions) immediately, without touching the
+ * network.
+ *
+ * With `wait: true` (the `-v`/`version` command) the registry is queried
+ * first and the latest versions are printed inline. Otherwise the registry
+ * check runs in the background and the returned `printHints` shows what is
+ * newer once the command is done — the command itself is never delayed by it.
+ */
+async function printVersionCommand({ wait = true, } = {}) {
+    // one dependency, not the whole map: this runs before every command
+    const rnuVersion = (0, dep_versions_1.getDepVersion)('rn-update');
+    const standalone = (0, http_helper_1.isStandaloneService)();
+    let latest;
+    const check = (standalone ? Promise.resolve([]) : getLatestVersions(!wait)).then((versions) => {
+        latest = versions;
+    });
+    if (wait) {
+        await check;
+    }
+    const [latestCliVersion, latestRnuVersion] = latest ?? [];
+    console.log(`rn-update-cli: ${package_json_1.default.version}${latestTag(latestCliVersion)}`);
+    try {
+        const { consumeAutoUpdateNotice } = require('../auto-update');
+        const notice = standalone ? undefined : consumeAutoUpdateNotice(package_json_1.default.version);
+        if (notice?.kind === 'updated') {
+            console.log((0, i18n_1.t)('autoUpdateSuccess', {
+                from: notice.currentVersion,
+                to: notice.targetVersion,
+            }));
+        }
+        else if (notice?.kind === 'permission') {
+            console.warn((0, i18n_1.t)('autoUpdatePermission', {
+                command: notice.command,
+            }));
+        }
+    }
+    catch {
+        // A corrupt/unwritable updater cache cannot affect normal commands.
+    }
+    if (rnuVersion) {
+        console.log(`rn-update: ${rnuVersion}${latestTag(latestRnuVersion)}`);
+    }
+    else {
+        console.log((0, i18n_1.t)('rnuVersionNotFound'));
+    }
+    let hinted = wait; // inline tags already shown
+    const printHints = () => {
+        if (hinted || !latest) {
+            return;
+        }
+        hinted = true;
+        const [cliLatest, rnuLatest] = latest;
+        if (isNewer(cliLatest, package_json_1.default.version)) {
+            console.log(`rn-update-cli: ${package_json_1.default.version}${latestTag(cliLatest)}`);
+        }
+        if (rnuVersion && isNewer(rnuLatest, rnuVersion)) {
+            console.log(`rn-update: ${rnuVersion}${latestTag(rnuLatest)}`);
+        }
+    };
+    const settle = (graceMs) => {
+        let timer;
+        const grace = new Promise((resolve) => {
+            timer = setTimeout(resolve, graceMs);
+        });
+        return Promise.race([check, grace]).then(() => clearTimeout(timer));
+    };
+    let autoUpdateStarted = false;
+    const startAutoUpdate = () => {
+        if (standalone || autoUpdateStarted || !isNewer(latest?.[0], package_json_1.default.version)) {
+            return;
+        }
+        autoUpdateStarted = true;
+        try {
+            const { launchAutoUpdate } = require('../auto-update');
+            launchAutoUpdate(package_json_1.default.version, latest?.[0]);
+        }
+        catch {
+            // Self-update is strictly opportunistic and never affects the command.
+        }
+    };
+    return { done: check, settle, startAutoUpdate, printHints };
+}