rn-update-cli 1.0.0

package/lib/package.js

@@ -0,0 +1,487 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packageCommands = void 0;
+exports.normalizeUploadBuildTime = normalizeUploadBuildTime;
+exports.listPackage = listPackage;
+exports.choosePackage = choosePackage;
+/**
+ * [INPUT]: 依赖原生包解析器、对象上传 API、应用选择与 channel 自动创建/断言
+ * [OUTPUT]: 对外提供三端原生包登记/列表/删除/解析命令，上传前执行版本组 JS 一致性与精确身份幂等检查
+ * [POS]: CLI 原生构建边界，在上传字节前阻断同版本换 JS，并把合法精简制品、Range 与 buildTime 绑定到 NativeVersion
+ */
+const fs = __importStar(require("fs-extra"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const api_1 = require("./api");
+const app_1 = require("./app");
+const native_package_1 = require("./native-package");
+const utils_1 = require("./utils");
+const constants_1 = require("./utils/constants");
+const http_helper_1 = require("./utils/http-helper");
+const dep_versions_1 = require("./utils/dep-versions");
+const git_1 = require("./utils/git");
+const hermes_base_1 = require("./utils/hermes-base");
+const i18n_1 = require("./utils/i18n");
+const options_1 = require("./utils/options");
+const zip_range_1 = require("./utils/zip-range");
+// the AAB parser drags in protobufjs; load it only for the aab commands
+function createAabParser(source) {
+    const { AabParser } = require('./utils/app-info-parser/aab');
+    return new AabParser(source);
+}
+function normalizeUploadBuildTime(value) {
+    return String(value);
+}
+function ensureFileByExt(filePath, extension, usageKey) {
+    if (!filePath?.endsWith(extension)) {
+        throw new Error((0, i18n_1.t)(usageKey));
+    }
+    return filePath;
+}
+async function assertNativePackageSize(filePath, appId) {
+    if (!(0, http_helper_1.isStandaloneService)())
+        return;
+    // An unauthenticated legacy invocation cannot read account entitlements;
+    // let the existing upload endpoint enforce its server-side limit. As soon
+    // as a session or API key is present, fail before parsing/slimming bytes.
+    if (!(0, api_1.getApiToken)() && !(0, api_1.getSession)())
+        return;
+    // Harmony .app is a directory containing nested .hap archives. statSync on
+    // the directory only returns filesystem metadata, so quota checks must sum
+    // every regular file before any parser, slimming, or upload side effect.
+    const fileSize = measurePackageBytes(filePath);
+    const entitlement = await (0, api_1.getMembershipEntitlement)(appId);
+    const maxBytes = Number(entitlement.nativePackageMaxBytes);
+    if (!Number.isFinite(maxBytes) || maxBytes <= 0) {
+        throw new Error('服务端未返回有效的原生包大小额度，请升级服务端后重试。');
+    }
+    if (fileSize > maxBytes) {
+        throw new Error((0, i18n_1.t)('fileSizeExceeded', {
+            fileSize: `${(fileSize / 1048576).toFixed(1)} MB`,
+            maxSize: `${(maxBytes / 1048576).toFixed(0)} MB`,
+            pricingPageUrl: constants_1.pricingPageUrl,
+        }));
+    }
+}
+function measurePackageBytes(filePath) {
+    const stat = fs.lstatSync(filePath);
+    if (!stat.isDirectory()) {
+        return stat.size;
+    }
+    return fs
+        .readdirSync(filePath)
+        .reduce((total, entry) => total + measurePackageBytes(path_1.default.join(filePath, entry)), 0);
+}
+function parseBooleanOption(value) {
+    return value === true || value === 'true';
+}
+function parseCsvOption(value) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const parsed = value
+        .split(',')
+        .map((item) => item.trim())
+        .filter(Boolean);
+    return parsed.length > 0 ? parsed : null;
+}
+function toNumericIds(ids) {
+    return ids.map((id) => {
+        const numericId = Number(id);
+        if (!Number.isInteger(numericId) || numericId <= 0) {
+            throw new Error((0, i18n_1.t)('invalidId', { id }));
+        }
+        return numericId;
+    });
+}
+function getVersionBinding(version) {
+    if (!version || typeof version !== 'object') {
+        return undefined;
+    }
+    const v = version;
+    return { id: v.id, name: v.name };
+}
+async function uploadNativePackage(filePath, options, config) {
+    const selectedApp = options.appId
+        ? {
+            appId: String(options.appId),
+            appKey: typeof options.appKey === 'string' ? options.appKey : undefined,
+        }
+        : await (0, app_1.getSelectedApp)(config.platform, options.config);
+    const { appId, appKey } = selectedApp;
+    await assertNativePackageSize(filePath, appId);
+    const info = await config.getInfo(filePath);
+    const { versionName: extractedVersionName, buildTime, bundleHash, channel: rawChannel = 'default', } = info;
+    // 与服务端 resolveChannel 的归一规则同构：渠道 code 一律小写比较。
+    const channel = String(rawChannel).trim().toLowerCase();
+    const bundleFile = info.bundleFile;
+    const { appId: appIdInPkg, appKey: appKeyInPkg } = info;
+    // where the expected app came from, for the mismatch messages
+    const source = options.appId ? '--appId' : options.config || constants_1.updateJson;
+    if (options.channel !== undefined && options.channel !== channel) {
+        throw new Error(`渠道断言失败：安装包内为 ${channel}，而 --channel 为 ${options.channel}。--channel 不会覆盖包内渠道。`);
+    }
+    if (appIdInPkg && String(appIdInPkg) !== appId) {
+        throw new Error((0, i18n_1.t)(config.appIdMismatchKey, { appIdInPkg, appId, source }));
+    }
+    if (appKeyInPkg && appKey && appKeyInPkg !== appKey) {
+        throw new Error((0, i18n_1.t)(config.appKeyMismatchKey, { appKeyInPkg, appKey, source }));
+    }
+    const customVersion = typeof options.version === 'string' && options.version
+        ? options.version
+        : undefined;
+    const versionName = customVersion ?? extractedVersionName;
+    if (customVersion !== undefined) {
+        console.log((0, i18n_1.t)('usingCustomVersion', { version: versionName }));
+    }
+    const normalizedBuildTime = config.normalizeBuildTime
+        ? config.normalizeBuildTime(buildTime)
+        : buildTime;
+    const uploadBuildTime = normalizeUploadBuildTime(normalizedBuildTime);
+    let standaloneChannelId;
+    if ((0, http_helper_1.isStandaloneService)()) {
+        if (!bundleHash) {
+            throw new Error('独立服务登记原生包体必须包含 bundleHash。');
+        }
+        const resolvedChannel = await (0, app_1.getOrCreateChannel)(appId, channel);
+        if (resolvedChannel.created) {
+            console.log((0, i18n_1.t)('channelAutoCreated', { channel }));
+        }
+        standaloneChannelId = resolvedChannel.channel.id;
+        const versionGroup = ((await (0, api_1.getAllPackages)(appId)) ?? []).filter((item) => item.channelId === standaloneChannelId &&
+            String(item.versionName ?? item.name) === String(versionName));
+        if (versionGroup.some((item) => item.bundleHash !== bundleHash)) {
+            throw new Error((0, i18n_1.t)('nativeVersionBundleConflict', { version: versionName }));
+        }
+        const duplicate = versionGroup.find((item) => item.bundleHash === bundleHash &&
+            String(item.buildTime ?? '') === uploadBuildTime);
+        if (duplicate) {
+            console.log((0, i18n_1.t)('nativeVersionAlreadyRegistered', {
+                version: versionName,
+                id: duplicate.id,
+            }));
+            return;
+        }
+    }
+    const tempRoot = await fs.mkdtemp(path_1.default.join(os_1.default.tmpdir(), 'rnu-native-package-upload-'));
+    const slimPackagePath = path_1.default.join(tempRoot, `package${config.extension}`);
+    try {
+        await (0, native_package_1.createSlimNativePackage)(filePath, slimPackagePath, config.platform);
+        const uploaded = await (0, api_1.uploadFile)(slimPackagePath, undefined, appId);
+        const { hash } = uploaded;
+        // where the bundle sits inside the uploaded (slim) archive, so a later
+        // `bundle` that falls back to this package as hermes base fetches only
+        // the bundle with one HTTP Range request. Harmony .app nests a second
+        // zip, so no location is reported for it.
+        const bundleLocation = config.extension === '.app'
+            ? {}
+            : (0, zip_range_1.bundleLocationFields)(await (0, zip_range_1.locateZipEntry)(slimPackagePath, (0, hermes_base_1.bundleEntryMatcher)(config.extension.slice(1))).catch(() => null));
+        if (bundleFile) {
+            // keep the embedded bundle locally so a later `bundle` can use it as
+            // hermes base without downloading it back (see hermes-base.ts); getInfo
+            // already hashed the bundle, so pass that hash instead of hashing twice
+            await (0, hermes_base_1.cachePut)(bundleFile, undefined, bundleHash).catch(() => { });
+        }
+        let id;
+        if ((0, http_helper_1.isStandaloneService)()) {
+            const nativeVersion = (0, api_1.unwrapData)(await (0, api_1.post)((0, api_1.servicePath)(`/apps/${encodeURIComponent(appId)}/versions`), {
+                channelId: standaloneChannelId,
+                packageVersion: String(versionName),
+                bundleHash,
+                buildTime: uploadBuildTime,
+                packageKey: uploaded.key || uploaded.hash,
+                downloadUrl: uploaded.url,
+                ...bundleLocation,
+            }));
+            id = nativeVersion.id;
+        }
+        else {
+            const result = await (0, api_1.post)(`/app/${appId}/package/create`, {
+                name: versionName,
+                hash,
+                buildTime: uploadBuildTime,
+                channel,
+                // Content identity of the embedded JS bundle; the server matches it
+                // against the client-reported bundleHash to decide pdiff applicability.
+                // Old servers strip unknown fields, so this is forward-compatible.
+                ...(bundleHash ? { bundleHash } : {}),
+                ...bundleLocation,
+                deps: (0, dep_versions_1.getDepVersions)(),
+                commit: await (0, git_1.getCommitInfo)(),
+            });
+            id = result.id;
+        }
+        console.log((0, i18n_1.t)(config.successKey, {
+            id,
+            version: versionName,
+            buildTime: uploadBuildTime,
+        }));
+    }
+    finally {
+        await fs.remove(tempRoot);
+    }
+}
+/**
+ * Print the app's native packages. Pass `packages` when the caller already
+ * fetched them (every page of the list), to skip fetching them again.
+ */
+async function listPackage(appId, packages) {
+    const allPkgs = packages ?? (await (0, api_1.getAllPackages)(appId)) ?? [];
+    const header = [
+        { value: (0, i18n_1.t)('nativePackageId') },
+        { value: (0, i18n_1.t)('nativeVersion') },
+    ];
+    const rows = [];
+    for (const pkg of allPkgs) {
+        const { version } = pkg;
+        let versionInfo = '';
+        if (version) {
+            const versionObj = getVersionBinding(version);
+            versionInfo = (0, i18n_1.t)('boundTo', {
+                name: versionObj?.name ?? version,
+                id: versionObj?.id ?? version,
+            });
+        }
+        let output = pkg.name;
+        if (pkg.status === 'paused') {
+            output += (0, i18n_1.t)('pausedStatus');
+        }
+        if (pkg.status === 'expired') {
+            output += (0, i18n_1.t)('expiredStatus');
+        }
+        output += versionInfo;
+        if (pkg.channel)
+            output += ` · channel=${pkg.channel}`;
+        rows.push([pkg.id, output]);
+    }
+    // tty-table is ~25 ms to load; only pay for it when a table is rendered
+    const Table = (0, utils_1.loadTtyTable)();
+    console.log(Table(header, rows).render());
+    console.log((0, i18n_1.t)('totalPackages', { count: allPkgs.length }));
+    return allPkgs;
+}
+async function choosePackage(appId, packages) {
+    // Fail before fetching or rendering the package list when no prompt exists.
+    if ((0, utils_1.isNonInteractive)()) {
+        throw new Error((0, i18n_1.t)('packageIdRequired'));
+    }
+    const list = await listPackage(appId, packages);
+    const packageMap = new Map(list?.map((v) => [v.id.toString(), v]));
+    while (true) {
+        const id = await (0, utils_1.question)((0, i18n_1.t)('enterNativePackageId'));
+        const app = packageMap.get(id);
+        if (app) {
+            return app;
+        }
+    }
+}
+exports.packageCommands = {
+    uploadIpa: async ({ args, options, }) => {
+        const fn = ensureFileByExt(args[0], '.ipa', 'usageUploadIpa');
+        await uploadNativePackage(fn, options, {
+            extension: '.ipa',
+            platform: 'ios',
+            appIdMismatchKey: 'appIdMismatchIpa',
+            appKeyMismatchKey: 'appKeyMismatchIpa',
+            successKey: 'ipaUploadSuccess',
+            getInfo: (filePath) => (0, utils_1.getIpaInfo)(filePath),
+        });
+    },
+    uploadApk: async ({ args, options, }) => {
+        const fn = ensureFileByExt(args[0], '.apk', 'usageUploadApk');
+        await uploadNativePackage(fn, options, {
+            extension: '.apk',
+            platform: 'android',
+            appIdMismatchKey: 'appIdMismatchApk',
+            appKeyMismatchKey: 'appKeyMismatchApk',
+            successKey: 'apkUploadSuccess',
+            getInfo: (filePath) => (0, utils_1.getApkInfo)(filePath),
+        });
+    },
+    uploadAab: async ({ args, options, }) => {
+        const source = ensureFileByExt(args[0], '.aab', 'usageUploadAab');
+        const selectedApp = options.appId
+            ? { appId: String(options.appId) }
+            : await (0, app_1.getSelectedApp)('android', options.config);
+        await assertNativePackageSize(source, selectedApp.appId);
+        // private temp dir: unpredictable path, safe against symlink squatting in
+        // the shared tmpdir and against concurrent uploads of same-named AABs
+        const tempRoot = await fs.mkdtemp(path_1.default.join(os_1.default.tmpdir(), 'rnu-aab-upload-'));
+        const output = path_1.default.join(tempRoot, 'universal.apk');
+        const includeAllSplits = parseBooleanOption(options.includeAllSplits);
+        const splits = parseCsvOption(options.splits);
+        const parser = createAabParser(source);
+        try {
+            await parser.extractApk(output, {
+                includeAllSplits,
+                splits,
+            });
+            await exports.packageCommands.uploadApk({
+                args: [output],
+                options,
+            });
+        }
+        finally {
+            await fs.remove(tempRoot);
+        }
+    },
+    uploadApp: async ({ args, options, }) => {
+        const fn = ensureFileByExt(args[0], '.app', 'usageUploadApp');
+        await uploadNativePackage(fn, options, {
+            extension: '.app',
+            platform: 'harmony',
+            appIdMismatchKey: 'appIdMismatchApp',
+            appKeyMismatchKey: 'appKeyMismatchApp',
+            successKey: 'appUploadSuccess',
+            getInfo: (filePath) => (0, utils_1.getAppInfo)(filePath),
+            normalizeBuildTime: (buildTime) => String(buildTime),
+        });
+    },
+    parseApp: async ({ args }) => {
+        const fn = args[0];
+        if (!fn?.endsWith('.app')) {
+            throw new Error((0, i18n_1.t)('usageParseApp'));
+        }
+        console.log(await (0, utils_1.getAppInfo)(fn));
+    },
+    parseIpa: async ({ args }) => {
+        const fn = args[0];
+        if (!fn?.endsWith('.ipa')) {
+            throw new Error((0, i18n_1.t)('usageParseIpa'));
+        }
+        console.log(await (0, utils_1.getIpaInfo)(fn));
+    },
+    parseApk: async ({ args }) => {
+        const fn = args[0];
+        if (!fn?.endsWith('.apk')) {
+            throw new Error((0, i18n_1.t)('usageParseApk'));
+        }
+        console.log(await (0, utils_1.getApkInfo)(fn));
+    },
+    parseAab: async ({ args }) => {
+        const fn = args[0];
+        if (!fn?.endsWith('.aab')) {
+            throw new Error((0, i18n_1.t)('usageParseAab'));
+        }
+        console.log(await (0, utils_1.getAabInfo)(fn));
+    },
+    extractApk: async ({ args, options, }) => {
+        const source = ensureFileByExt(args[0], '.aab', 'usageExtractApk');
+        const output = options.output ||
+            path_1.default.join(path_1.default.dirname(source), `${path_1.default.basename(source, path_1.default.extname(source))}.apk`);
+        const includeAllSplits = parseBooleanOption(options.includeAllSplits);
+        const splits = parseCsvOption(options.splits);
+        const parser = createAabParser(source);
+        await parser.extractApk(output, {
+            includeAllSplits,
+            splits,
+        });
+        console.log((0, i18n_1.t)('apkExtracted', { output }));
+    },
+    packages: async ({ options, }) => {
+        await listPackage(await (0, app_1.resolveAppId)(options));
+    },
+    deletePackage: async ({ options }) => {
+        const appId = await (0, app_1.resolveAppId)(options);
+        let packageIds = (0, options_1.getStringListOption)(options, 'packageIds') ??
+            (0, options_1.getStringListOption)(options, 'packageId');
+        if (!packageIds) {
+            const packageVersions = (0, options_1.getStringListOption)(options, 'packageVersion');
+            if (!packageVersions) {
+                throw new Error((0, i18n_1.t)('usageDeletePackage'));
+            }
+            const allPkgs = await (0, api_1.getAllPackages)(appId);
+            if (!allPkgs) {
+                throw new Error((0, i18n_1.t)('noPackagesFound', { appId }));
+            }
+            const allPkgsMap = new Map(allPkgs.map((pkg) => [pkg.name, pkg]));
+            packageIds = packageVersions.map((packageVersion) => {
+                const selectedPackage = allPkgsMap.get(packageVersion);
+                if (!selectedPackage) {
+                    throw new Error((0, i18n_1.t)('packageNotFound', { packageVersion }));
+                }
+                return String(selectedPackage.id);
+            });
+        }
+        // Confirm deletion
+        // const confirmDelete = await question(
+        //   t('confirmDeletePackage', { packageId }),
+        // );
+        // if (
+        //   confirmDelete.toLowerCase() !== 'y' &&
+        //   confirmDelete.toLowerCase() !== 'yes'
+        // ) {
+        //   console.log(t('cancelled'));
+        //   return;
+        // }
+        try {
+            if ((0, http_helper_1.isStandaloneService)()) {
+                for (const packageId of packageIds) {
+                    await (0, api_1.doDelete)((0, api_1.servicePath)(`/versions/${encodeURIComponent(packageId)}`));
+                }
+                console.log((0, i18n_1.t)('deletePackagesSuccess', {
+                    count: packageIds.length,
+                    packageIds: packageIds.join(', '),
+                }));
+                return;
+            }
+            if (packageIds.length === 1) {
+                const [packageId] = packageIds;
+                await (0, api_1.doDelete)(`/app/${appId}/package/${packageId}`);
+                console.log((0, i18n_1.t)('deletePackageSuccess', { packageId }));
+            }
+            else {
+                await (0, api_1.doDelete)(`/app/${appId}/package`, {
+                    packageIds: toNumericIds(packageIds),
+                });
+                console.log((0, i18n_1.t)('deletePackagesSuccess', {
+                    count: packageIds.length,
+                    packageIds: packageIds.join(', '),
+                }));
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error((0, i18n_1.t)('deletePackageError', {
+                packageId: packageIds.join(', '),
+                error: message,
+            }));
+        }
+    },
+};

package/lib/provider.d.ts

@@ -0,0 +1,24 @@
+import type { BundleOptions, CLIProvider, CommandResult, Platform, PublishOptions, Session, SymbolicateOptions, UpdateVersionOptions, UploadOptions } from './types';
+export declare class CLIProviderImpl implements CLIProvider {
+    private session?;
+    private sessionInitPromise?;
+    private createContext;
+    private ensureInitialized;
+    private runMessageCommand;
+    private runDataCommand;
+    bundle(options: BundleOptions): Promise<CommandResult>;
+    publish(options: PublishOptions): Promise<CommandResult>;
+    symbolicate(options: SymbolicateOptions): Promise<CommandResult>;
+    upload(options: UploadOptions): Promise<CommandResult>;
+    getSelectedApp(platform?: Platform, config?: string): Promise<{
+        appId: string;
+        platform: Platform;
+    }>;
+    listApps(platform?: Platform): Promise<CommandResult>;
+    createApp(name: string, platform: Platform): Promise<CommandResult>;
+    listVersions(appId: string): Promise<CommandResult>;
+    updateVersion(appId: string, versionId: string, updates: UpdateVersionOptions): Promise<CommandResult>;
+    getPlatform(platform?: Platform): Promise<Platform>;
+    loadSession(): Promise<Session>;
+    listPackages(appId: string): Promise<CommandResult>;
+}