react-native-update-cli 2.7.0 → 2.7.2

package/lib/esm/provider..mjs

@@ -0,0 +1,293 @@
+import { getSession, loadSession } from "./api";
+import { getPlatform, getSelectedApp } from "./app";
+export class CLIProviderImpl {
+    async init() {
+        try {
+            await loadSession();
+            this.session = getSession();
+        } catch (error) {}
+    }
+    async bundle(options) {
+        try {
+            const context = {
+                args: [],
+                options: {
+                    dev: options.dev || false,
+                    platform: options.platform,
+                    bundleName: options.bundleName || 'index.bundlejs',
+                    entryFile: options.entryFile || 'index.js',
+                    output: options.output || '${tempDir}/output/${platform}.${time}.ppk',
+                    sourcemap: options.sourcemap || false,
+                    taro: options.taro || false,
+                    expo: options.expo || false,
+                    rncli: options.rncli || false,
+                    hermes: options.hermes || false
+                }
+            };
+            const { bundleCommands } = await import("./bundle");
+            await bundleCommands.bundle(context);
+            return {
+                success: true,
+                data: {
+                    message: 'Bundle created successfully'
+                }
+            };
+        } catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error during bundling'
+            };
+        }
+    }
+    async publish(options) {
+        try {
+            const context = {
+                args: [],
+                options: {
+                    name: options.name,
+                    description: options.description,
+                    metaInfo: options.metaInfo,
+                    packageId: options.packageId,
+                    packageVersion: options.packageVersion,
+                    minPackageVersion: options.minPackageVersion,
+                    maxPackageVersion: options.maxPackageVersion,
+                    packageVersionRange: options.packageVersionRange,
+                    rollout: options.rollout,
+                    dryRun: options.dryRun || false
+                }
+            };
+            const { versionCommands } = await import("./versions");
+            await versionCommands.publish(context);
+            return {
+                success: true,
+                data: {
+                    message: 'Version published successfully'
+                }
+            };
+        } catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error during publishing'
+            };
+        }
+    }
+    async upload(options) {
+        try {
+            var _filePath_split_pop;
+            const platform = await this.getPlatform(options.platform);
+            const { appId } = await this.getSelectedApp(platform);
+            const filePath = options.filePath;
+            const fileType = (_filePath_split_pop = filePath.split('.').pop()) == null ? void 0 : _filePath_split_pop.toLowerCase();
+            const context = {
+                args: [
+                    filePath
+                ],
+                options: {
+                    platform,
+                    appId,
+                    version: options.version
+                }
+            };
+            const { packageCommands } = await import("./package");
+            switch(fileType){
+                case 'ipa':
+                    await packageCommands.uploadIpa(context);
+                    break;
+                case 'apk':
+                    await packageCommands.uploadApk(context);
+                    break;
+                case 'aab':
+                    await packageCommands.uploadAab(context);
+                    break;
+                case 'app':
+                    await packageCommands.uploadApp(context);
+                    break;
+                default:
+                    throw new Error(`Unsupported file type: ${fileType}`);
+            }
+            return {
+                success: true,
+                data: {
+                    message: 'File uploaded successfully'
+                }
+            };
+        } catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error during upload'
+            };
+        }
+    }
+    async getSelectedApp(platform) {
+        const resolvedPlatform = await this.getPlatform(platform);
+        return getSelectedApp(resolvedPlatform);
+    }
+    async listApps(platform) {
+        try {
+            const resolvedPlatform = await this.getPlatform(platform);
+            const { appCommands } = await import("./app");
+            await appCommands.apps({
+                options: {
+                    platform: resolvedPlatform
+                }
+            });
+            return {
+                success: true,
+                data: {
+                    message: 'Apps listed successfully'
+                }
+            };
+        } catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error listing apps'
+            };
+        }
+    }
+    async createApp(name, platform) {
+        try {
+            const { appCommands } = await import("./app");
+            await appCommands.createApp({
+                options: {
+                    name,
+                    platform,
+                    downloadUrl: ''
+                }
+            });
+            return {
+                success: true,
+                data: {
+                    message: 'App created successfully'
+                }
+            };
+        } catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error creating app'
+            };
+        }
+    }
+    async listVersions(appId) {
+        try {
+            const context = {
+                args: [],
+                options: {
+                    appId
+                }
+            };
+            const { versionCommands } = await import("./versions");
+            await versionCommands.versions(context);
+            return {
+                success: true,
+                data: {
+                    message: 'Versions listed successfully'
+                }
+            };
+        } catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error listing versions'
+            };
+        }
+    }
+    async updateVersion(appId, versionId, updates) {
+        try {
+            const context = {
+                args: [
+                    versionId
+                ],
+                options: {
+                    appId,
+                    ...updates
+                }
+            };
+            const { versionCommands } = await import("./versions");
+            await versionCommands.update(context);
+            return {
+                success: true,
+                data: {
+                    message: 'Version updated successfully'
+                }
+            };
+        } catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error updating version'
+            };
+        }
+    }
+    async getPlatform(platform) {
+        return getPlatform(platform);
+    }
+    async loadSession() {
+        await loadSession();
+        this.session = getSession();
+        if (!this.session) {
+            throw new Error('Failed to load session');
+        }
+        return this.session;
+    }
+    registerWorkflow(workflow) {
+        this.workflows.set(workflow.name, workflow);
+    }
+    async executeWorkflow(workflowName, context) {
+        const workflow = this.workflows.get(workflowName);
+        if (!workflow) {
+            return {
+                success: false,
+                error: `Workflow '${workflowName}' not found`
+            };
+        }
+        try {
+            let previousResult = null;
+            for (const step of workflow.steps){
+                if (step.condition && !step.condition(context)) {
+                    console.log(`Skipping step '${step.name}' due to condition`);
+                    continue;
+                }
+                console.log(`Executing step '${step.name}'`);
+                previousResult = await step.execute(context, previousResult);
+            }
+            return {
+                success: true,
+                data: {
+                    message: `Workflow '${workflowName}' completed successfully`,
+                    result: previousResult
+                }
+            };
+        } catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : `Workflow '${workflowName}' failed`
+            };
+        }
+    }
+    getRegisteredWorkflows() {
+        return Array.from(this.workflows.keys());
+    }
+    async listPackages(appId) {
+        try {
+            const context = {
+                args: [],
+                options: appId ? {
+                    appId
+                } : {}
+            };
+            const { listPackage } = await import("./package");
+            const result = await listPackage(appId || '');
+            return {
+                success: true,
+                data: result
+            };
+        } catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error listing packages'
+            };
+        }
+    }
+    constructor(){
+        this.workflows = new Map();
+        this.init();
+    }
+}

package/lib/esm/types..mjs

@@ -0,0 +1 @@
+export { };

package/lib/esm/user..mjs

@@ -0,0 +1,36 @@
+import crypto from "crypto";
+import { closeSession, get, post, replaceSession, saveSession } from "./api";
+import { question } from "./utils";
+import { t } from "./utils/i18n";
+function md5(str) {
+    return crypto.createHash('md5').update(str).digest('hex');
+}
+export const userCommands = {
+    login: async ({ args })=>{
+        const email = args[0] || await question('email:');
+        const pwd = args[1] || await question('password:', true);
+        const { token, info } = await post('/user/login', {
+            email,
+            pwd: md5(pwd)
+        });
+        replaceSession({
+            token
+        });
+        await saveSession();
+        console.log(t('welcomeMessage', {
+            name: info.name
+        }));
+    },
+    logout: async (context)=>{
+        await closeSession();
+        console.log(t('loggedOut'));
+    },
+    me: async ()=>{
+        const me = await get('/user/me');
+        for(const k in me){
+            if (k !== 'ok') {
+                console.log(`${k}: ${me[k]}`);
+            }
+        }
+    }
+};

package/lib/esm/utils/add-gitignore..mjs

@@ -0,0 +1,32 @@
+import fs from "fs";
+// import path from 'path';
+import { credentialFile, tempDir } from "./constants";
+import { t } from "./i18n";
+export function addGitIgnore() {
+    const shouldIgnore = [
+        credentialFile,
+        tempDir
+    ];
+    const gitignorePath = '.gitignore';
+    if (!fs.existsSync(gitignorePath)) {
+        return;
+    }
+    const gitignoreContent = fs.readFileSync(gitignorePath, 'utf-8');
+    const gitignoreLines = gitignoreContent.split('\n');
+    for (const line of gitignoreLines){
+        const index = shouldIgnore.indexOf(line.trim());
+        if (index !== -1) {
+            shouldIgnore.splice(index, 1);
+        }
+    }
+    if (shouldIgnore.length > 0) {
+        gitignoreLines.push('# react-native-update');
+        for (const line of shouldIgnore){
+            gitignoreLines.push(line);
+            console.log(t('addedToGitignore', {
+                line
+            }));
+        }
+        fs.writeFileSync(gitignorePath, gitignoreLines.join('\n'));
+    }
+}

package/lib/esm/utils/app-info-parser/aab..mjs

@@ -0,0 +1,215 @@
+import { spawn } from "child_process";
+import os from "os";
+import path from "path";
+import fs from "fs-extra";
+import { open as openZipFile } from "yauzl";
+import { t } from "../i18n";
+import { ResourceFinder } from "./resource-finder";
+import { mapInfoResource } from "./utils";
+import { ManifestParser } from "./xml-parser/manifest";
+import { Zip } from "./zip";
+export class AabParser extends Zip {
+    async extractApk(outputPath, { includeAllSplits, splits }) {
+        const normalizedSplits = Array.isArray(splits) ? splits.map((item)=>item.trim()).filter(Boolean) : [];
+        const modules = includeAllSplits ? null : Array.from(new Set([
+            'base',
+            ...normalizedSplits
+        ]));
+        const modulesArgs = modules ? [
+            `--modules=${modules.join(',')}`
+        ] : [];
+        const runCommand = (command, args, options = {})=>new Promise((resolve, reject)=>{
+                const inheritStdio = options.stdio === 'inherit';
+                const child = spawn(command, args, {
+                    stdio: inheritStdio ? 'inherit' : [
+                        'ignore',
+                        'pipe',
+                        'pipe'
+                    ],
+                    env: options.env
+                });
+                let stderr = '';
+                if (!inheritStdio) {
+                    var _child_stderr;
+                    (_child_stderr = child.stderr) == null ? void 0 : _child_stderr.on('data', (chunk)=>{
+                        stderr += chunk.toString();
+                    });
+                }
+                child.on('error', reject);
+                child.on('close', (code)=>{
+                    if (code === 0) {
+                        resolve();
+                        return;
+                    }
+                    reject(new Error(stderr.trim() || `Command failed: ${command} (code ${code})`));
+                });
+            });
+        // Create a temp file for the .apks output
+        const tempDir = os.tmpdir();
+        const tempApksPath = path.join(tempDir, `temp-${Date.now()}.apks`);
+        const needsNpxDownload = async ()=>{
+            try {
+                await runCommand('npx', [
+                    '--no-install',
+                    'node-bundletool',
+                    '--version'
+                ]);
+                return false;
+            } catch (e) {
+                return true;
+            }
+        };
+        try {
+            // 1. Build APKS (universal mode)
+            // We assume bundletool is in the path.
+            // User might need keystore to sign it properly but for simple extraction we stick to default debug key if possible or unsigned?
+            // actually bundletool build-apks signs with debug key by default if no keystore provided.
+            try {
+                await runCommand('bundletool', [
+                    'build-apks',
+                    '--mode=universal',
+                    `--bundle=${this.file}`,
+                    `--output=${tempApksPath}`,
+                    '--overwrite',
+                    ...modulesArgs
+                ]);
+            } catch (e) {
+                // Fallback to npx node-bundletool if bundletool is not in PATH
+                // We use -y to avoid interactive prompt for installation
+                if (await needsNpxDownload()) {
+                    console.log(t('aabBundletoolDownloadHint'));
+                }
+                await runCommand('npx', [
+                    '-y',
+                    'node-bundletool',
+                    'build-apks',
+                    '--mode=universal',
+                    `--bundle=${this.file}`,
+                    `--output=${tempApksPath}`,
+                    '--overwrite',
+                    ...modulesArgs
+                ], {
+                    stdio: 'inherit',
+                    env: {
+                        ...process.env,
+                        npm_config_progress: 'true'
+                    }
+                });
+            }
+            // 2. Extract universal.apk from the .apks (zip) file
+            await new Promise((resolve, reject)=>{
+                openZipFile(tempApksPath, {
+                    lazyEntries: true
+                }, (err, zipfile)=>{
+                    if (err || !zipfile) {
+                        reject(err || new Error(t('aabOpenApksFailed')));
+                        return;
+                    }
+                    let found = false;
+                    zipfile.readEntry();
+                    zipfile.on('entry', (entry)=>{
+                        if (entry.fileName === 'universal.apk') {
+                            found = true;
+                            zipfile.openReadStream(entry, (err, readStream)=>{
+                                if (err || !readStream) {
+                                    reject(err || new Error(t('aabReadUniversalApkFailed')));
+                                    return;
+                                }
+                                const writeStream = fs.createWriteStream(outputPath);
+                                readStream.pipe(writeStream);
+                                writeStream.on('close', ()=>{
+                                    zipfile.close();
+                                    resolve();
+                                });
+                                writeStream.on('error', reject);
+                            });
+                        } else {
+                            zipfile.readEntry();
+                        }
+                    });
+                    zipfile.on('end', ()=>{
+                        if (!found) reject(new Error(t('aabUniversalApkNotFound')));
+                    });
+                    zipfile.on('error', reject);
+                });
+            });
+        } finally{
+            // Cleanup
+            if (await fs.pathExists(tempApksPath)) {
+                await fs.remove(tempApksPath);
+            }
+        }
+    }
+    /**
+   * 解析 AAB 文件信息（类似 APK parser 的 parse 方法）
+   * 注意：AAB 中的 AndroidManifest.xml 在 base/manifest/AndroidManifest.xml
+   */ async parse() {
+        const manifestPath = 'base/manifest/AndroidManifest.xml';
+        const ResourceName = /^base\/resources\.arsc$/;
+        try {
+            const manifestBuffer = await this.getEntry(new RegExp(`^${escapeRegExp(manifestPath)}$`));
+            if (!manifestBuffer) {
+                throw new Error(t('aabManifestNotFound'));
+            }
+            let apkInfo = this._parseManifest(manifestBuffer);
+            try {
+                const resourceBuffer = await this.getEntry(ResourceName);
+                if (resourceBuffer) {
+                    const resourceMap = this._parseResourceMap(resourceBuffer);
+                    apkInfo = mapInfoResource(apkInfo, resourceMap);
+                }
+            } catch (e) {
+                var _e_message;
+                console.warn(t('aabParseResourcesWarning', {
+                    error: (_e_message = e == null ? void 0 : e.message) != null ? _e_message : e
+                }));
+            }
+            return apkInfo;
+        } catch (error) {
+            var _error_message;
+            throw new Error(t('aabParseFailed', {
+                error: (_error_message = error.message) != null ? _error_message : error
+            }));
+        }
+    }
+    /**
+   * Parse manifest
+   * @param {Buffer} buffer // manifest file's buffer
+   */ _parseManifest(buffer) {
+        try {
+            const parser = new ManifestParser(buffer, {
+                ignore: [
+                    'application.activity',
+                    'application.service',
+                    'application.receiver',
+                    'application.provider',
+                    'permission-group'
+                ]
+            });
+            return parser.parse();
+        } catch (e) {
+            var _e_message;
+            throw new Error(t('aabParseManifestError', {
+                error: (_e_message = e == null ? void 0 : e.message) != null ? _e_message : e
+            }));
+        }
+    }
+    /**
+   * Parse resourceMap
+   * @param {Buffer} buffer // resourceMap file's buffer
+   */ _parseResourceMap(buffer) {
+        try {
+            return new ResourceFinder().processResourceTable(buffer);
+        } catch (e) {
+            var _e_message;
+            throw new Error(t('aabParseResourcesError', {
+                error: (_e_message = e == null ? void 0 : e.message) != null ? _e_message : e
+            }));
+        }
+    }
+    constructor(file){
+        super(file);
+        this.file = file;
+    }
+}
+const escapeRegExp = (value)=>value.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&');

package/lib/esm/utils/app-info-parser/apk..mjs

@@ -0,0 +1,75 @@
+import { ResourceFinder } from "./resource-finder";
+import { findApkIconPath, getBase64FromBuffer, mapInfoResource } from "./utils";
+import { ManifestParser } from "./xml-parser/manifest";
+import { Zip } from "./zip";
+const ManifestName = /^androidmanifest\.xml$/;
+const ResourceName = /^resources\.arsc$/;
+export class ApkParser extends Zip {
+    parse() {
+        return new Promise((resolve, reject)=>{
+            this.getEntries([
+                ManifestName,
+                ResourceName
+            ]).then((buffers)=>{
+                const manifestBuffer = buffers[ManifestName];
+                if (!manifestBuffer) {
+                    throw new Error("AndroidManifest.xml can't be found.");
+                }
+                let apkInfo;
+                let resourceMap;
+                apkInfo = this._parseManifest(manifestBuffer);
+                if (!buffers[ResourceName]) {
+                    resolve(apkInfo);
+                } else {
+                    resourceMap = this._parseResourceMap(buffers[ResourceName]);
+                    apkInfo = mapInfoResource(apkInfo, resourceMap);
+                    const iconPath = findApkIconPath(apkInfo);
+                    if (iconPath) {
+                        this.getEntry(iconPath).then((iconBuffer)=>{
+                            apkInfo.icon = iconBuffer ? getBase64FromBuffer(iconBuffer) : null;
+                            resolve(apkInfo);
+                        }).catch((e)=>{
+                            apkInfo.icon = null;
+                            resolve(apkInfo);
+                            console.warn('[Warning] failed to parse icon: ', e);
+                        });
+                    } else {
+                        apkInfo.icon = null;
+                        resolve(apkInfo);
+                    }
+                }
+            }).catch((e)=>{
+                reject(e);
+            });
+        });
+    }
+    /**
+   * Parse manifest
+   * @param {Buffer} buffer // manifest file's buffer
+   */ _parseManifest(buffer) {
+        try {
+            const parser = new ManifestParser(buffer, {
+                ignore: [
+                    'application.activity',
+                    'application.service',
+                    'application.receiver',
+                    'application.provider',
+                    'permission-group'
+                ]
+            });
+            return parser.parse();
+        } catch (e) {
+            throw new Error(`Parse AndroidManifest.xml error: ${e.message || e}`);
+        }
+    }
+    /**
+   * Parse resourceMap
+   * @param {Buffer} buffer // resourceMap file's buffer
+   */ _parseResourceMap(buffer) {
+        try {
+            return new ResourceFinder().processResourceTable(buffer);
+        } catch (e) {
+            throw new Error(`Parser resources.arsc error: ${e}`);
+        }
+    }
+}

package/lib/esm/utils/app-info-parser/app..mjs

@@ -0,0 +1,3 @@
+import { Zip } from "./zip";
+export class AppParser extends Zip {
+}