rn-update-cli 1.0.0

package/lib/utils/app-info-parser/xml-parser/manifest.js

@@ -0,0 +1,207 @@
+"use strict";
+/**
+ * [INPUT]: 依赖 BinaryXmlParser 与 Android manifest 的 intent/category 常量
+ * [OUTPUT]: 对外提供 ManifestParser，将二进制清单压平为应用包所需元数据
+ * [POS]: Android manifest 解析适配层，被 APK/AAB 解析器调用，不读取归档本身
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManifestParser = void 0;
+// From https://github.com/openstf/adbkit-apkreader
+const binary_1 = require("./binary");
+const INTENT_MAIN = 'android.intent.action.MAIN';
+const CATEGORY_LAUNCHER = 'android.intent.category.LAUNCHER';
+class ManifestParser {
+    buffer;
+    xmlParser;
+    constructor(buffer, options = {}) {
+        this.buffer = buffer;
+        this.xmlParser = new binary_1.BinaryXmlParser(this.buffer, options);
+    }
+    collapseAttributes(element) {
+        const collapsed = Object.create(null);
+        const attributes = element.attributes;
+        for (let i = 0, len = attributes.length; i < len; i++) {
+            const attr = attributes[i];
+            collapsed[attr.name] = attr.typedValue.value;
+        }
+        return collapsed;
+    }
+    parseIntents(element, target) {
+        target.intentFilters = [];
+        target.metaData = [];
+        for (const child of element.childNodes) {
+            switch (child.nodeName) {
+                case 'intent-filter': {
+                    const intentFilter = this.collapseAttributes(child);
+                    intentFilter.actions = [];
+                    intentFilter.categories = [];
+                    intentFilter.data = [];
+                    for (const item of child.childNodes) {
+                        switch (item.nodeName) {
+                            case 'action':
+                                intentFilter.actions.push(this.collapseAttributes(item));
+                                break;
+                            case 'category':
+                                intentFilter.categories.push(this.collapseAttributes(item));
+                                break;
+                            case 'data':
+                                intentFilter.data.push(this.collapseAttributes(item));
+                                break;
+                        }
+                    }
+                    target.intentFilters.push(intentFilter);
+                    break;
+                }
+                case 'meta-data':
+                    target.metaData.push(this.collapseAttributes(child));
+                    break;
+            }
+        }
+    }
+    parseApplication(element) {
+        const app = this.collapseAttributes(element);
+        app.activities = [];
+        app.activityAliases = [];
+        app.launcherActivities = [];
+        app.services = [];
+        app.receivers = [];
+        app.providers = [];
+        app.usesLibraries = [];
+        app.metaData = [];
+        for (const child of element.childNodes) {
+            switch (child.nodeName) {
+                case 'activity': {
+                    const activity = this.collapseAttributes(child);
+                    this.parseIntents(child, activity);
+                    app.activities.push(activity);
+                    if (this.isLauncherActivity(activity)) {
+                        app.launcherActivities.push(activity);
+                    }
+                    break;
+                }
+                case 'activity-alias': {
+                    const activityAlias = this.collapseAttributes(child);
+                    this.parseIntents(child, activityAlias);
+                    app.activityAliases.push(activityAlias);
+                    if (this.isLauncherActivity(activityAlias)) {
+                        app.launcherActivities.push(activityAlias);
+                    }
+                    break;
+                }
+                case 'service': {
+                    const service = this.collapseAttributes(child);
+                    this.parseIntents(child, service);
+                    app.services.push(service);
+                    break;
+                }
+                case 'receiver': {
+                    const receiver = this.collapseAttributes(child);
+                    this.parseIntents(child, receiver);
+                    app.receivers.push(receiver);
+                    break;
+                }
+                case 'provider': {
+                    const provider = this.collapseAttributes(child);
+                    provider.grantUriPermissions = [];
+                    provider.metaData = [];
+                    provider.pathPermissions = [];
+                    for (const item of child.childNodes) {
+                        switch (item.nodeName) {
+                            case 'grant-uri-permission':
+                                provider.grantUriPermissions.push(this.collapseAttributes(item));
+                                break;
+                            case 'meta-data':
+                                provider.metaData.push(this.collapseAttributes(item));
+                                break;
+                            case 'path-permission':
+                                provider.pathPermissions.push(this.collapseAttributes(item));
+                                break;
+                        }
+                    }
+                    app.providers.push(provider);
+                    break;
+                }
+                case 'uses-library':
+                    app.usesLibraries.push(this.collapseAttributes(child));
+                    break;
+                case 'meta-data':
+                    app.metaData.push(this.collapseAttributes(child));
+                    break;
+            }
+        }
+        return app;
+    }
+    isLauncherActivity(activity) {
+        return activity.intentFilters.some((filter) => {
+            const hasMain = filter.actions.some((action) => action.name === INTENT_MAIN);
+            if (!hasMain) {
+                return false;
+            }
+            return filter.categories.some((category) => category.name === CATEGORY_LAUNCHER);
+        });
+    }
+    parse() {
+        const document = this.xmlParser.parse();
+        const manifest = this.collapseAttributes(document);
+        manifest.usesPermissions = [];
+        manifest.usesPermissionsSDK23 = [];
+        manifest.permissions = [];
+        manifest.permissionTrees = [];
+        manifest.permissionGroups = [];
+        manifest.instrumentation = null;
+        manifest.usesSdk = null;
+        manifest.usesConfiguration = null;
+        manifest.usesFeatures = [];
+        manifest.supportsScreens = null;
+        manifest.compatibleScreens = [];
+        manifest.supportsGlTextures = [];
+        manifest.application = Object.create(null);
+        for (const element of document.childNodes) {
+            switch (element.nodeName) {
+                case 'uses-permission':
+                    manifest.usesPermissions.push(this.collapseAttributes(element));
+                    break;
+                case 'uses-permission-sdk-23':
+                    manifest.usesPermissionsSDK23.push(this.collapseAttributes(element));
+                    break;
+                case 'permission':
+                    manifest.permissions.push(this.collapseAttributes(element));
+                    break;
+                case 'permission-tree':
+                    manifest.permissionTrees.push(this.collapseAttributes(element));
+                    break;
+                case 'permission-group':
+                    manifest.permissionGroups.push(this.collapseAttributes(element));
+                    break;
+                case 'instrumentation':
+                    manifest.instrumentation = this.collapseAttributes(element);
+                    break;
+                case 'uses-sdk':
+                    manifest.usesSdk = this.collapseAttributes(element);
+                    break;
+                case 'uses-configuration':
+                    manifest.usesConfiguration = this.collapseAttributes(element);
+                    break;
+                case 'uses-feature':
+                    manifest.usesFeatures.push(this.collapseAttributes(element));
+                    break;
+                case 'supports-screens':
+                    manifest.supportsScreens = this.collapseAttributes(element);
+                    break;
+                case 'compatible-screens':
+                    for (const screen of element.childNodes) {
+                        manifest.compatibleScreens.push(this.collapseAttributes(screen));
+                    }
+                    break;
+                case 'supports-gl-texture':
+                    manifest.supportsGlTextures.push(this.collapseAttributes(element));
+                    break;
+                case 'application':
+                    manifest.application = this.parseApplication(element);
+                    break;
+            }
+        }
+        return manifest;
+    }
+}
+exports.ManifestParser = ManifestParser;

package/lib/utils/app-info-parser/zip.d.ts

@@ -0,0 +1,29 @@
+/**
+ * [INPUT]: 依赖文件路径、ZIP 条目枚举/读取与归档元数据辅助函数
+ * [OUTPUT]: 对外提供 Zip 基类，统一平台应用包的条目访问和路径解析
+ * [POS]: 应用包解析子域的共享归档边界，隐藏文件路径与 ZIP 流细节
+ */
+export declare class Zip {
+    file: string | File;
+    constructor(file: string | File);
+    /**
+     * get entries by regexps, the return format is: { <filename>: <Buffer|Blob> }
+     * @param {Array} regexps // regexps for matching files
+     * @param {String} type // return type, can be buffer or blob, default buffer
+     */
+    getEntries(regexps: Array<RegExp | string>, type?: 'buffer' | 'blob'): Promise<Record<string, Blob | Buffer<ArrayBufferLike>>>;
+    /**
+     * get entry by regex, return an instance of Buffer or Blob
+     * @param {Regex} regex // regex for matching file
+     * @param {String} type // return type, can be buffer or blob, default buffer
+     */
+    getEntry(regex: RegExp | string, type?: 'buffer' | 'blob'): Promise<Blob | Buffer<ArrayBufferLike>>;
+    getEntryFromHarmonyApp(regex: RegExp): Promise<Buffer | Blob | undefined>;
+    /**
+     * Read multiple entries in a single pass over the archive (including
+     * nested .hap extraction), instead of one full scan per entry.
+     * Returns buffers in the same order as the given regexps.
+     */
+    getEntriesFromHarmonyApp(regexps: RegExp[]): Promise<(Buffer | undefined)[]>;
+    private readEntries;
+}

package/lib/utils/app-info-parser/zip.js

@@ -0,0 +1,97 @@
+"use strict";
+/**
+ * [INPUT]: 依赖文件路径、ZIP 条目枚举/读取与归档元数据辅助函数
+ * [OUTPUT]: 对外提供 Zip 基类，统一平台应用包的条目访问和路径解析
+ * [POS]: 应用包解析子域的共享归档边界，隐藏文件路径与 ZIP 流细节
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Zip = void 0;
+const path_1 = __importDefault(require("path"));
+const zip_entries_1 = require("../zip-entries");
+const utils_1 = require("./utils");
+class Zip {
+    file;
+    constructor(file) {
+        this.file = typeof file === 'string' ? path_1.default.resolve(file) : file;
+    }
+    /**
+     * get entries by regexps, the return format is: { <filename>: <Buffer|Blob> }
+     * @param {Array} regexps // regexps for matching files
+     * @param {String} type // return type, can be buffer or blob, default buffer
+     */
+    getEntries(regexps, type = 'buffer') {
+        const decoded = regexps.map((regex) => (0, utils_1.decodeNullUnicode)(regex));
+        return this.readEntries(decoded, type);
+    }
+    /**
+     * get entry by regex, return an instance of Buffer or Blob
+     * @param {Regex} regex // regex for matching file
+     * @param {String} type // return type, can be buffer or blob, default buffer
+     */
+    getEntry(regex, type = 'buffer') {
+        const decoded = (0, utils_1.decodeNullUnicode)(regex);
+        return this.readEntries([decoded], type).then((buffers) => buffers[decoded]);
+    }
+    async getEntryFromHarmonyApp(regex) {
+        return (await this.getEntriesFromHarmonyApp([regex]))[0];
+    }
+    /**
+     * Read multiple entries in a single pass over the archive (including
+     * nested .hap extraction), instead of one full scan per entry.
+     * Returns buffers in the same order as the given regexps.
+     */
+    async getEntriesFromHarmonyApp(regexps) {
+        const results = new Array(regexps.length);
+        try {
+            if (typeof this.file !== 'string') {
+                throw new Error('Param error: [file] must be file path in Node.');
+            }
+            await (0, zip_entries_1.enumZipEntries)(this.file, async (entry, zipFile) => {
+                for (let i = 0; i < regexps.length; i++) {
+                    if (regexps[i].test(entry.fileName)) {
+                        results[i] = await (0, zip_entries_1.readEntry)(entry, zipFile);
+                    }
+                }
+            });
+        }
+        catch (error) {
+            console.error('Error in getEntriesFromHarmonyApp:', error);
+        }
+        return results;
+    }
+    async readEntries(decoded, type) {
+        if (typeof this.file !== 'string') {
+            throw new Error('Param error: [file] must be file path in Node.');
+        }
+        const buffers = {};
+        await (0, zip_entries_1.enumZipEntries)(this.file, async (entry, zipFile) => {
+            if (entry.fileName.endsWith('/')) {
+                return;
+            }
+            const entryName = (0, utils_1.decodeNullUnicode)(entry.fileName).toString();
+            const lowerEntryName = entryName.toLowerCase();
+            const matched = decoded.find((pattern) => {
+                if (typeof pattern === 'string') {
+                    return pattern === entryName || pattern === lowerEntryName;
+                }
+                pattern.lastIndex = 0;
+                if (pattern.test(entryName)) {
+                    return true;
+                }
+                pattern.lastIndex = 0;
+                return pattern.test(lowerEntryName);
+            });
+            if (!matched) {
+                return;
+            }
+            const buffer = await (0, zip_entries_1.readEntry)(entry, zipFile);
+            buffers[matched] =
+                type === 'blob' ? new Blob([buffer]) : buffer;
+        });
+        return buffers;
+    }
+}
+exports.Zip = Zip;

package/lib/utils/check-lockfile.d.ts

@@ -0,0 +1,6 @@
+/**
+ * [INPUT]: 依赖文件系统、项目路径、workspace 结构与本地化文案
+ * [OUTPUT]: 对外提供 checkLockFiles，检查项目包管理器锁文件并给出一致性提示
+ * [POS]: CLI 构建前环境检查层，只报告锁文件状态，不修改依赖解析结果
+ */
+export declare function checkLockFiles(): void;

package/lib/utils/check-lockfile.js

@@ -0,0 +1,93 @@
+"use strict";
+/**
+ * [INPUT]: 依赖文件系统、项目路径、workspace 结构与本地化文案
+ * [OUTPUT]: 对外提供 checkLockFiles，检查项目包管理器锁文件并给出一致性提示
+ * [POS]: CLI 构建前环境检查层，只报告锁文件状态，不修改依赖解析结果
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkLockFiles = checkLockFiles;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const i18n_1 = require("./i18n");
+const lockFiles = [
+    'package-lock.json',
+    'yarn.lock',
+    'pnpm-lock.yaml',
+    'bun.lockb',
+    'bun.lock',
+];
+// Function to check if a directory is a monorepo root
+// (package.json workspaces field, or pnpm-workspace.yaml)
+function hasWorkspaces(dir) {
+    if (fs_1.default.existsSync(path_1.default.join(dir, 'pnpm-workspace.yaml'))) {
+        return true;
+    }
+    const pkgPath = path_1.default.join(dir, 'package.json');
+    if (fs_1.default.existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(fs_1.default.readFileSync(pkgPath, 'utf-8'));
+            return !!pkg.workspaces;
+        }
+        catch (_e) {
+            // Ignore parsing errors
+        }
+    }
+    return false;
+}
+// Helper function to find lock files in a specific directory
+function findLockFilesInDir(directory) {
+    const found = [];
+    for (const file of lockFiles) {
+        const filePath = path_1.default.join(directory, file);
+        if (fs_1.default.existsSync(filePath)) {
+            found.push(filePath);
+        }
+    }
+    return found;
+}
+function checkLockFiles() {
+    const cwd = process.cwd();
+    let searchDir = cwd;
+    let foundLockFiles = findLockFilesInDir(searchDir);
+    // If no lock file in cwd, try to find monorepo root and check there
+    if (foundLockFiles.length === 0) {
+        // Search upwards for package.json with workspaces
+        let currentDir = path_1.default.dirname(cwd); // Start searching from parent
+        let projectRootDir = null;
+        while (true) {
+            if (hasWorkspaces(currentDir)) {
+                projectRootDir = currentDir;
+                break;
+            }
+            const parentDir = path_1.default.dirname(currentDir);
+            if (parentDir === currentDir) {
+                // Reached the filesystem root
+                break;
+            }
+            currentDir = parentDir;
+        }
+        // If a potential root was found, switch search directory and re-check
+        if (projectRootDir) {
+            searchDir = projectRootDir;
+            foundLockFiles = findLockFilesInDir(searchDir);
+        }
+        // If no projectRootDir found, foundLockFiles remains empty and searchDir remains cwd
+    }
+    // Handle results based on findings in the final searchDir
+    if (foundLockFiles.length === 1) {
+        // Successfully found one lock file in the determined searchDir
+        return;
+    }
+    if (foundLockFiles.length > 1) {
+        // Found multiple lock files in the determined searchDir
+        console.warn((0, i18n_1.t)('lockBestPractice'));
+        throw new Error((0, i18n_1.t)('multipleLocksFound', { lockFiles: foundLockFiles.join(', ') }));
+    }
+    // If we reach here, foundLockFiles.length === 0
+    console.warn((0, i18n_1.t)('lockBestPractice'));
+    // Warn instead of throwing an error if no lock file is found
+    console.warn((0, i18n_1.t)('lockNotFound'));
+}

package/lib/utils/check-plugin.d.ts

@@ -0,0 +1,12 @@
+/**
+ * [INPUT]: 依赖本地化文案与已登记的 CLI 插件配置
+ * [OUTPUT]: 对外提供 checkPlugins，校验插件组合并返回 bundle 参数
+ * [POS]: CLI 插件兼容性检查边界，连接配置声明与 bundle 编排，不执行插件安装
+ */
+interface BundleParams {
+    sentry: boolean;
+    sourcemap: boolean;
+    [key: string]: any;
+}
+export declare function checkPlugins(): Promise<BundleParams>;
+export {};

package/lib/utils/check-plugin.js

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * [INPUT]: 依赖本地化文案与已登记的 CLI 插件配置
+ * [OUTPUT]: 对外提供 checkPlugins，校验插件组合并返回 bundle 参数
+ * [POS]: CLI 插件兼容性检查边界，连接配置声明与 bundle 编排，不执行插件安装
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkPlugins = checkPlugins;
+const i18n_1 = require("./i18n");
+const plugin_config_1 = require("./plugin-config");
+async function checkPlugins() {
+    const params = {
+        sentry: false,
+        sourcemap: false,
+    };
+    const results = await Promise.all(plugin_config_1.plugins.map(async (plugin) => {
+        try {
+            const isEnabled = await plugin.detect();
+            return { isEnabled, error: null };
+        }
+        catch (error) {
+            return { isEnabled: false, error };
+        }
+    }));
+    results.forEach(({ isEnabled, error }, index) => {
+        const plugin = plugin_config_1.plugins[index];
+        if (error) {
+            console.warn((0, i18n_1.t)('pluginDetectionError', { name: plugin.name, error }));
+        }
+        else if (isEnabled && plugin.bundleParams) {
+            Object.assign(params, plugin.bundleParams);
+            console.log((0, i18n_1.t)('pluginDetected', { name: plugin.name }));
+        }
+    });
+    return params;
+}

package/lib/utils/command-result.d.ts

@@ -0,0 +1,8 @@
+/**
+ * [INPUT]: 依赖 CLI CommandResult 公共类型与未知错误值
+ * [OUTPUT]: 对外提供错误归一化与 runAsCommandResult，统一命令层结果形状
+ * [POS]: CLI 命令边界的错误适配器，隔离异常来源与顶层输出协议
+ */
+import type { CommandResult } from '../types';
+export declare function toErrorMessage(error: unknown, fallback: string): string;
+export declare function runAsCommandResult<T>(task: () => Promise<T>, fallbackError: string, mapSuccess?: (result: T) => unknown): Promise<CommandResult>;

package/lib/utils/command-result.js

@@ -0,0 +1,27 @@
+"use strict";
+/**
+ * [INPUT]: 依赖 CLI CommandResult 公共类型与未知错误值
+ * [OUTPUT]: 对外提供错误归一化与 runAsCommandResult，统一命令层结果形状
+ * [POS]: CLI 命令边界的错误适配器，隔离异常来源与顶层输出协议
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toErrorMessage = toErrorMessage;
+exports.runAsCommandResult = runAsCommandResult;
+function toErrorMessage(error, fallback) {
+    return error instanceof Error ? error.message : fallback;
+}
+async function runAsCommandResult(task, fallbackError, mapSuccess) {
+    try {
+        const result = await task();
+        return {
+            success: true,
+            data: mapSuccess ? mapSuccess(result) : result,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: toErrorMessage(error, fallbackError),
+        };
+    }
+}

package/lib/utils/constants.d.ts

@@ -0,0 +1,10 @@
+export declare const scriptName = "pakta";
+export declare const ppkBundleFileNames: string[];
+export declare const isPPKBundleFileName: (fileName: string) => boolean;
+export declare const credentialFile = ".pakta.token";
+/** Standalone service credentials never share a token across service URLs. */
+export declare function credentialFileForService(serviceUrl?: string): string;
+export declare const updateJson = "update.json";
+export declare const tempDir = ".pakta";
+export declare const pricingPageUrl = "https://pakta.dev/pricing";
+export declare const defaultEndpoints: string[];

package/lib/utils/constants.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultEndpoints = exports.pricingPageUrl = exports.tempDir = exports.updateJson = exports.credentialFile = exports.isPPKBundleFileName = exports.ppkBundleFileNames = exports.scriptName = void 0;
+exports.credentialFileForService = credentialFileForService;
+/**
+ * [INPUT]: 依赖进程环境与操作系统用户目录
+ * [OUTPUT]: 对外提供品牌、默认端点、凭据文件和临时目录常量
+ * [POS]: CLI 全局常量层，确保不同独立服务地址的凭据不互相覆盖
+ */
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const crypto_1 = require("crypto");
+exports.scriptName = 'pakta';
+exports.ppkBundleFileNames = ['index.bundlejs', 'bundle.harmony.js'];
+const isPPKBundleFileName = (fileName) => exports.ppkBundleFileNames.includes(fileName);
+exports.isPPKBundleFileName = isPPKBundleFileName;
+exports.credentialFile = '.pakta.token';
+/** Standalone service credentials never share a token across service URLs. */
+function credentialFileForService(serviceUrl) {
+    const normalized = serviceUrl?.trim().replace(/\/+$/, '');
+    if (!normalized) {
+        return exports.credentialFile;
+    }
+    const suffix = (0, crypto_1.createHash)('sha256').update(normalized).digest('hex').slice(0, 16);
+    return path_1.default.join(os_1.default.homedir(), `.${exports.scriptName}-${suffix}.token`);
+}
+// update.json 是 CLI 与客户端 SDK 共同读取的应用配置入口。
+exports.updateJson = 'update.json';
+exports.tempDir = '.pakta';
+exports.pricingPageUrl = 'https://pakta.dev/pricing';
+exports.defaultEndpoints = [
+    'https://api.pakta.dev',
+    'https://api.pakta.app',
+    'https://update.react-native.cn/api',
+    'https://update.reactnative.cn/api',
+];

package/lib/utils/dep-versions.d.ts

@@ -0,0 +1,20 @@
+/**
+ * [INPUT]: 依赖项目 package.json、已安装依赖目录、文件系统与路径解析
+ * [OUTPUT]: 对外提供 getDepVersions、getDepVersion 与惰性 depVersions 代理
+ * [POS]: CLI 运行时版本信息边界，按需读取依赖版本并缓存，供诊断和命令编排消费
+ */
+/** Installed versions of the cwd project's dependencies, keys sorted. */
+export declare function getDepVersions(): Record<string, string>;
+/**
+ * Installed version of one direct (dev)dependency of the cwd project, or
+ * undefined when the project does not declare it or it is not installed.
+ * Two file reads instead of one per dependency: the version banner printed
+ * before every command must not scale with the size of the project.
+ */
+export declare function getDepVersion(name: string, cwd?: string): string | undefined;
+/**
+ * Same data as `getDepVersions()` but as a lazily populated object, for the
+ * remaining property-access call sites (`depVersions['react-native']`).
+ * Nothing is resolved until the first property access.
+ */
+export declare const depVersions: Record<string, string>;