rn-update-cli 1.0.0

package/lib/bundle.d.ts

@@ -0,0 +1,45 @@
+/**
+ * [INPUT]: 依赖 CLI 参数/应用选择、Metro/Hermes bundle runner、PPK packer、版本 API 与本地构建工具
+ * [OUTPUT]: 对外提供 bundleCommands 及标准化 bundle 选项/发布编排，并传递 Hermes 校验元数据
+ * [POS]: CLI bundle 领域入口，串联打包、源码映射、Hermes base、应用绑定和版本发布，不实现底层压缩与网络协议
+ */
+type NormalizedBundleOptions = {
+    bundleName: string;
+    entryFile: string;
+    intermediaDir: string;
+    output: string;
+    dev: string;
+    sourcemap: boolean;
+    taro: boolean;
+    expo: boolean;
+    rncli: boolean;
+    hermes: boolean;
+    hermesBase: string;
+    verifyHermesBase: boolean;
+    resetCache: boolean;
+    cacheMaxMb?: number;
+    appId?: string;
+    config?: string;
+    name?: string;
+    description?: string;
+    metaInfo?: string;
+    packageId?: string;
+    packageVersion?: string;
+    minPackageVersion?: string;
+    maxPackageVersion?: string;
+    packageVersionRange?: string;
+    rollout?: string;
+    dryRun: boolean;
+    sentryRelease?: string;
+    sentryDist?: string;
+};
+/** Normalize translated CLI values into the bundle command's typed options. */
+export declare function normalizeBundleOptions(translatedOptions: Record<string, unknown>, platform: string): NormalizedBundleOptions;
+export declare const bundleCommands: {
+    /** Build a bundle and optionally publish it to one operation-scoped app. */
+    bundle: ({ args, options, }: {
+        args?: string[];
+        options: Record<string, unknown>;
+    }) => Promise<void>;
+};
+export {};

package/lib/bundle.js

@@ -0,0 +1,226 @@
+"use strict";
+/**
+ * [INPUT]: 依赖 CLI 参数/应用选择、Metro/Hermes bundle runner、PPK packer、版本 API 与本地构建工具
+ * [OUTPUT]: 对外提供 bundleCommands 及标准化 bundle 选项/发布编排，并传递 Hermes 校验元数据
+ * [POS]: CLI bundle 领域入口，串联打包、源码映射、Hermes base、应用绑定和版本发布，不实现底层压缩与网络协议
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bundleCommands = void 0;
+exports.normalizeBundleOptions = normalizeBundleOptions;
+const path_1 = __importDefault(require("path"));
+const app_1 = require("./app");
+const bundle_pack_1 = require("./bundle-pack");
+const bundle_runner_1 = require("./bundle-runner");
+const utils_1 = require("./utils");
+const add_gitignore_1 = require("./utils/add-gitignore");
+const check_lockfile_1 = require("./utils/check-lockfile");
+const constants_1 = require("./utils/constants");
+const dep_versions_1 = require("./utils/dep-versions");
+const hermes_base_1 = require("./utils/hermes-base");
+const i18n_1 = require("./utils/i18n");
+const options_1 = require("./utils/options");
+const versions_1 = require("./versions");
+/** `--no-<flag>` as parsed by cli-arguments: the key is present without a value. */
+function isClearedFlag(options, key) {
+    return key in options && options[key] === undefined;
+}
+/** Parse a positive cache-size option expressed in megabytes. */
+function parseCacheMaxMb(value) {
+    const parsed = typeof value === 'string' ? Number(value) : value;
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+}
+/** Read either spelling of an aliased optional CLI string option. */
+function getAliasedOptionalStringOption(options, key, alias) {
+    return ((0, options_1.getOptionalStringOption)(options, key) ??
+        (0, options_1.getOptionalStringOption)(options, alias));
+}
+/** Normalize translated CLI values into the bundle command's typed options. */
+function normalizeBundleOptions(translatedOptions, platform) {
+    return {
+        // harmony bundles always use this fixed name (runReactNativeBundleCommand
+        // forces it), so sourcemap paths and Sentry uploads must match
+        bundleName: platform === 'harmony'
+            ? 'bundle.harmony.js'
+            : (0, options_1.getStringOption)(translatedOptions, 'bundleName', 'index.bundlejs'),
+        entryFile: (0, options_1.getStringOption)(translatedOptions, 'entryFile', 'index.js'),
+        intermediaDir: (0, options_1.getStringOption)(translatedOptions, 'intermediaDir', `${constants_1.tempDir}/intermedia/${platform}`),
+        output: (0, options_1.getStringOption)(translatedOptions, 'output', `${constants_1.tempDir}/output/${platform}.\${time}.ppk`),
+        dev: (0, options_1.getBooleanOption)(translatedOptions, 'dev', false) ? 'true' : 'false',
+        // On by default since 2.23: the map is archived with the published
+        // version (pakta symbolicate). `--no-sourcemap` opts out: cli-arguments
+        // implements `--no-<flag>` by clearing the flag's value, so a key that is
+        // present but undefined is the opt-out and only a missing key means
+        // "default" (`--sourcemap false` would leave the flag on, see `bundle`).
+        sourcemap: isClearedFlag(translatedOptions, 'sourcemap')
+            ? false
+            : (0, options_1.getBooleanOption)(translatedOptions, 'sourcemap', true),
+        taro: (0, options_1.getBooleanOption)(translatedOptions, 'taro', false),
+        expo: (0, options_1.getBooleanOption)(translatedOptions, 'expo', false),
+        rncli: (0, options_1.getBooleanOption)(translatedOptions, 'rncli', false),
+        hermes: (0, options_1.getBooleanOption)(translatedOptions, 'hermes', false),
+        hermesBase: (0, options_1.getStringOption)(translatedOptions, 'hermesBase', 'auto'),
+        verifyHermesBase: (0, options_1.getBooleanOption)(translatedOptions, 'verifyHermesBase', true),
+        resetCache: (0, options_1.getBooleanOption)(translatedOptions, 'resetCache', true),
+        cacheMaxMb: parseCacheMaxMb(translatedOptions.cacheMaxMb),
+        appId: (0, options_1.getOptionalStringOption)(translatedOptions, 'appId'),
+        config: (0, options_1.getOptionalStringOption)(translatedOptions, 'config'),
+        name: (0, options_1.getOptionalStringOption)(translatedOptions, 'name'),
+        description: (0, options_1.getOptionalStringOption)(translatedOptions, 'description'),
+        metaInfo: (0, options_1.getOptionalStringOption)(translatedOptions, 'metaInfo'),
+        packageId: (0, options_1.getOptionalStringOption)(translatedOptions, 'packageId'),
+        packageVersion: (0, options_1.getOptionalStringOption)(translatedOptions, 'packageVersion'),
+        minPackageVersion: (0, options_1.getOptionalStringOption)(translatedOptions, 'minPackageVersion'),
+        maxPackageVersion: (0, options_1.getOptionalStringOption)(translatedOptions, 'maxPackageVersion'),
+        packageVersionRange: (0, options_1.getOptionalStringOption)(translatedOptions, 'packageVersionRange'),
+        rollout: (0, options_1.getOptionalStringOption)(translatedOptions, 'rollout'),
+        dryRun: (0, options_1.getBooleanOption)(translatedOptions, 'dryRun', false),
+        sentryRelease: getAliasedOptionalStringOption(translatedOptions, 'sentry-release', 'sentryRelease'),
+        sentryDist: getAliasedOptionalStringOption(translatedOptions, 'sentry-dist', 'sentryDist'),
+    };
+}
+/** Upload generated Sentry artifacts when the detected plugin requires them. */
+async function uploadSentryArtifactsIfNeeded(shouldUpload, bundleName, intermediaDir, sourcemapOutput, platform, sentryOptions) {
+    if (!shouldUpload) {
+        return;
+    }
+    await (0, bundle_runner_1.copyDebugidForSentry)(bundleName, intermediaDir, sourcemapOutput);
+    await (0, bundle_runner_1.uploadSourcemapForSentry)(bundleName, intermediaDir, sourcemapOutput, platform, sentryOptions);
+}
+/** Publish a packed bundle through the version command implementation. */
+async function publishBundleVersion(outputPath, platform, payload) {
+    return versions_1.versionCommands.publish({
+        args: [outputPath],
+        options: {
+            platform,
+            ...payload,
+        },
+    });
+}
+exports.bundleCommands = {
+    /** Build a bundle and optionally publish it to one operation-scoped app. */
+    bundle: async ({ args = [], options, }) => {
+        // Boolean flags take no value: `--sourcemap false` leaves the flag on and
+        // turns "false" into a stray argument. Refuse it rather than silently
+        // bundling with the wrong settings (a flag is switched off with
+        // `--no-<flag>`).
+        if (args.length > 0) {
+            throw new Error((0, i18n_1.t)('bundleUnexpectedArgs', { args: args.join(' ') }));
+        }
+        const platform = await (0, app_1.getPlatform)(typeof options.platform === 'string' ? options.platform : undefined);
+        const translatedOptions = (0, utils_1.translateOptions)({
+            ...options,
+            tempDir: constants_1.tempDir,
+            platform,
+        });
+        const normalized = normalizeBundleOptions(translatedOptions, platform);
+        // One app per operation: the Hermes base lookup and the publish step must
+        // never see different apps, so the target is resolved once and reused.
+        let appId;
+        const getAppId = async () => (appId ??= await (0, app_1.resolveAppId)({
+            appId: normalized.appId,
+            config: normalized.config,
+            platform,
+        }));
+        const hermesBase = normalized.dev === 'true'
+            ? undefined
+            : {
+                option: normalized.hermesBase,
+                verify: normalized.verifyHermesBase,
+                cacheMaxMb: normalized.cacheMaxMb,
+            };
+        // Resolve before any side effect or expensive work. A named bundle is
+        // published, so a missing app fails right here; a bundle-only run only
+        // needs the app for the remote Hermes base lookup and may go on without
+        // one (it then compiles a full bundle). Any other config error (e.g.
+        // malformed JSON) is reported immediately either way.
+        if (normalized.name) {
+            await getAppId();
+        }
+        else if (hermesBase?.option === 'auto') {
+            try {
+                await getAppId();
+            }
+            catch (error) {
+                if (!(error instanceof app_1.AppNotSelectedError)) {
+                    throw error;
+                }
+            }
+        }
+        (0, check_lockfile_1.checkLockFiles)();
+        (0, add_gitignore_1.addGitIgnore)();
+        const [bundleParams] = await Promise.all([
+            (0, utils_1.checkPlugins)(),
+            (0, hermes_base_1.cleanStaleTmp)().catch(() => { }),
+        ]);
+        const sourcemapOutput = path_1.default.join(normalized.intermediaDir, `${normalized.bundleName}.map`);
+        const realOutput = normalized.output.replace(/\$\{time\}/g, `${Date.now()}`);
+        console.log((0, i18n_1.t)('bundlingWithRN', { version: dep_versions_1.depVersions['react-native'] }));
+        const hermesResult = await (0, bundle_runner_1.runReactNativeBundleCommand)({
+            bundleName: normalized.bundleName,
+            dev: normalized.dev,
+            entryFile: normalized.entryFile,
+            outputFolder: normalized.intermediaDir,
+            platform,
+            sourcemapOutput: normalized.sourcemap || bundleParams.sourcemap ? sourcemapOutput : '',
+            forceHermes: normalized.hermes,
+            hermesBase: hermesBase ? { ...hermesBase, appId } : undefined,
+            resetCache: normalized.resetCache,
+            cli: {
+                taro: normalized.taro,
+                expo: normalized.expo,
+                rncli: normalized.rncli,
+            },
+            isSentry: bundleParams.sentry,
+        });
+        await (0, bundle_pack_1.packBundle)(path_1.default.resolve(normalized.intermediaDir), realOutput, normalized.bundleName);
+        const baseMeta = hermesResult
+            ? (0, hermes_base_1.hermesBaseMeta)(hermesResult.base, hermesResult.bytecodeVersion, {
+                outcome: hermesResult.outcome,
+                detail: hermesResult.outcomeDetail,
+            })
+            : undefined;
+        if (normalized.name) {
+            await publishBundleVersion(realOutput, platform, {
+                appId: await getAppId(),
+                name: normalized.name,
+                description: normalized.description,
+                metaInfo: normalized.metaInfo,
+                packageId: normalized.packageId,
+                packageVersion: normalized.packageVersion,
+                minPackageVersion: normalized.minPackageVersion,
+                maxPackageVersion: normalized.maxPackageVersion,
+                packageVersionRange: normalized.packageVersionRange,
+                rollout: normalized.rollout,
+                dryRun: normalized.dryRun,
+                hermesBase: baseMeta,
+                sourcemap: normalized.sourcemap || bundleParams.sourcemap
+                    ? sourcemapOutput
+                    : undefined,
+            });
+            await uploadSentryArtifactsIfNeeded(bundleParams.sentry, normalized.bundleName, normalized.intermediaDir, sourcemapOutput, platform, {
+                sentryRelease: normalized.sentryRelease,
+                sentryDist: normalized.sentryDist,
+            });
+            return;
+        }
+        if (!(0, options_1.getBooleanOption)(options, 'no-interactive', false)) {
+            const v = await (0, utils_1.question)((0, i18n_1.t)('uploadBundlePrompt'));
+            if (v.toLowerCase() === 'y') {
+                await publishBundleVersion(realOutput, platform, {
+                    appId: await getAppId(),
+                    hermesBase: baseMeta,
+                    sourcemap: normalized.sourcemap || bundleParams.sourcemap
+                        ? sourcemapOutput
+                        : undefined,
+                });
+                await uploadSentryArtifactsIfNeeded(bundleParams.sentry, normalized.bundleName, normalized.intermediaDir, sourcemapOutput, platform, {
+                    sentryRelease: normalized.sentryRelease,
+                    sentryDist: normalized.sentryDist,
+                });
+            }
+        }
+    },
+};

package/lib/cache.d.ts

@@ -0,0 +1,10 @@
+/**
+ * [INPUT]: 依赖 Hermes base 缓存统计/清理能力与本地化文案
+ * [OUTPUT]: 对外提供 cacheCommands，暴露 CLI 缓存查询和清理命令
+ * [POS]: CLI 缓存命令适配层，只编排用户输出，不持有缓存实现细节
+ */
+export declare const cacheCommands: {
+    cache: ({ args }: {
+        args?: string[];
+    }) => Promise<void>;
+};

package/lib/cache.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * [INPUT]: 依赖 Hermes base 缓存统计/清理能力与本地化文案
+ * [OUTPUT]: 对外提供 cacheCommands，暴露 CLI 缓存查询和清理命令
+ * [POS]: CLI 缓存命令适配层，只编排用户输出，不持有缓存实现细节
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cacheCommands = void 0;
+const hermes_base_1 = require("./utils/hermes-base");
+const i18n_1 = require("./utils/i18n");
+exports.cacheCommands = {
+    cache: async ({ args }) => {
+        if (args?.[0] === 'clean') {
+            const removed = await (0, hermes_base_1.cleanCache)();
+            console.log((0, i18n_1.t)('cacheCleaned', { count: removed }));
+            return;
+        }
+        const stats = await (0, hermes_base_1.cacheStats)();
+        console.log((0, i18n_1.t)('cacheStats', {
+            dir: stats.dir,
+            files: stats.files,
+            mb: (stats.bytes / 1024 / 1024).toFixed(1),
+        }));
+    },
+};

package/lib/commands.d.ts

@@ -0,0 +1,11 @@
+/**
+ * [INPUT]: 依赖各 CLI 命令组的惰性加载器与命令名/参数约定
+ * [OUTPUT]: 对外提供 commandNames、loadCommandHandler 与命令处理器类型
+ * [POS]: CLI 命令注册表，以按需加载隔离各命令依赖，避免入口提前加载完整工具链
+ */
+type CliCommandHandler = (argv: any) => Promise<unknown> | unknown;
+/** names of all commands, in the order they are listed by `help` */
+export declare const commandNames: readonly string[];
+/** the handler of `name`, loading its module now; undefined for unknown names */
+export declare function loadCommandHandler(name: string): CliCommandHandler | undefined;
+export {};

package/lib/commands.js

@@ -0,0 +1,72 @@
+"use strict";
+/**
+ * [INPUT]: 依赖各 CLI 命令组的惰性加载器与命令名/参数约定
+ * [OUTPUT]: 对外提供 commandNames、loadCommandHandler 与命令处理器类型
+ * [POS]: CLI 命令注册表，以按需加载隔离各命令依赖，避免入口提前加载完整工具链
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commandNames = void 0;
+exports.loadCommandHandler = loadCommandHandler;
+const groups = {
+    app: () => require('./app').getAppCommands(),
+    bundle: () => require('./bundle').bundleCommands,
+    cache: () => require('./cache').cacheCommands,
+    diff: () => require('./diff').diffCommands,
+    install: () => require('./install').installCommands,
+    package: () => require('./package').packageCommands,
+    symbolicate: () => require('./symbolicate').symbolicateCommands,
+    user: () => require('./user').userCommands,
+    versions: () => require('./versions').versionCommands,
+};
+/**
+ * command name → group. Kept in sync with cli.json by tests/commands.test.ts,
+ * so a command added to one place but not the other fails the suite.
+ */
+const commandGroups = {
+    login: 'user',
+    logout: 'user',
+    me: 'user',
+    createApp: 'app',
+    apps: 'app',
+    channels: 'app',
+    createChannel: 'app',
+    updateChannel: 'app',
+    deleteChannel: 'app',
+    deleteApp: 'app',
+    selectApp: 'app',
+    uploadIpa: 'package',
+    uploadApk: 'package',
+    uploadAab: 'package',
+    uploadApp: 'package',
+    parseApp: 'package',
+    parseIpa: 'package',
+    parseApk: 'package',
+    parseAab: 'package',
+    extractApk: 'package',
+    packages: 'package',
+    deletePackage: 'package',
+    registerPdiff: 'versions',
+    publish: 'versions',
+    versions: 'versions',
+    update: 'versions',
+    updateVersionInfo: 'versions',
+    deleteVersion: 'versions',
+    bundle: 'bundle',
+    hdiff: 'diff',
+    hdiffFromApk: 'diff',
+    hdiffFromApp: 'diff',
+    hdiffFromIpa: 'diff',
+    install: 'install',
+    cache: 'cache',
+    symbolicate: 'symbolicate',
+};
+/** names of all commands, in the order they are listed by `help` */
+exports.commandNames = Object.keys(commandGroups);
+/** the handler of `name`, loading its module now; undefined for unknown names */
+function loadCommandHandler(name) {
+    const group = commandGroups[name];
+    if (!group) {
+        return undefined;
+    }
+    return groups[group]()[name];
+}

package/lib/diff.d.ts

@@ -0,0 +1,18 @@
+import type { Entry } from 'yauzl';
+import type { CommandContext } from './types';
+import { enumZipEntries, readEntry } from './utils/zip-entries';
+type ZipEntryContent = Pick<Entry, 'crc32' | 'uncompressedSize'>;
+export { enumZipEntries, readEntry };
+/**
+ * 判定两个 zip entry 内容相同的键:crc32 单独并不足以证明内容一致(32 位
+ * 校验和碰撞并不罕见,尤其是长度不同的文件),必须同时要求解压后长度相等。
+ * 仅用于生成端匹配,manifest 里的 copies / copiesCrc 格式不变。
+ */
+export declare function zipEntryContentKey(entry: ZipEntryContent): string;
+export declare function zipEntriesHaveSameContent(left: ZipEntryContent, right: ZipEntryContent): boolean;
+export declare const diffCommands: {
+    hdiff: ({ args, options }: CommandContext) => Promise<void>;
+    hdiffFromApk: ({ args, options }: CommandContext) => Promise<void>;
+    hdiffFromApp: ({ args, options }: CommandContext) => Promise<void>;
+    hdiffFromIpa: ({ args, options }: CommandContext) => Promise<void>;
+};