react-native-update-cli 1.46.2 → 2.0.0

package/lib/bundle.js

@@ -19,20 +19,20 @@ _export(exports, {
         return readEntry;
     }
 });
+const _child_process = require("child_process");
 const _path = /*#__PURE__*/ _interop_require_default(require("path"));
-const _utils = require("./utils");
+const _compareversions = require("compare-versions");
 const _fsextra = /*#__PURE__*/ _interop_require_wildcard(require("fs-extra"));
-const _yazl = require("yazl");
 const _yauzl = require("yauzl");
+const _yazl = require("yazl");
 const _app = require("./app");
-const _child_process = require("child_process");
-const _compareversions = require("compare-versions");
+const _utils = require("./utils");
 const _os = /*#__PURE__*/ _interop_require_default(require("os"));
+const _addgitignore = require("./utils/add-gitignore");
+const _checklockfile = require("./utils/check-lockfile");
+const _constants = require("./utils/constants");
 const _depversions = require("./utils/dep-versions");
 const _i18n = require("./utils/i18n");
-const _constants = require("./utils/constants");
-const _checklockfile = require("./utils/check-lockfile");
-const _addgitignore = require("./utils/add-gitignore");
 const _versions = require("./versions");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
@@ -496,7 +496,7 @@ async function pack(dir, output) {
         addDirectory(dir, '');
         zipfile.outputStream.on('error', (err)=>reject(err));
         zipfile.outputStream.pipe(_fsextra.createWriteStream(output)).on('close', ()=>{
-            resolve();
+            resolve(void 0);
         });
         zipfile.end();
     });
@@ -508,17 +508,14 @@ function readEntry(entry, zipFile) {
     const buffers = [];
     return new Promise((resolve, reject)=>{
         zipFile.openReadStream(entry, (err, stream)=>{
-            stream.pipe({
-                write (chunk) {
-                    buffers.push(chunk);
-                },
-                end () {
-                    resolve(Buffer.concat(buffers));
-                },
-                prependListener () {},
-                on () {},
-                once () {},
-                emit () {}
+            stream.on('data', (chunk)=>{
+                buffers.push(chunk);
+            });
+            stream.on('end', ()=>{
+                resolve(Buffer.concat(buffers));
+            });
+            stream.on('error', (err)=>{
+                reject(err);
             });
         });
     });
@@ -553,7 +550,7 @@ async function diffFromPPK(origin, next, output) {
             throw err;
         });
         zipfile.outputStream.pipe(_fsextra.createWriteStream(output)).on('close', ()=>{
-            resolve();
+            resolve(void 0);
         });
     });
     const addedEntry = {};
@@ -616,7 +613,7 @@ async function diffFromPPK(origin, next, output) {
                     zipfile.addReadStream(readStream, entry.fileName);
                     readStream.on('end', ()=>{
                         //console.log('add finished');
-                        resolve();
+                        resolve(void 0);
                     });
                 });
             });
@@ -670,7 +667,7 @@ async function diffFromPackage(origin, next, output, originBundleName, transform
             throw err;
         });
         zipfile.outputStream.pipe(_fsextra.createWriteStream(output)).on('close', ()=>{
-            resolve();
+            resolve(void 0);
         });
     });
     await enumZipEntries(next, (entry, nextZipfile)=>{
@@ -710,7 +707,7 @@ async function diffFromPackage(origin, next, output, originBundleName, transform
                     zipfile.addReadStream(readStream, entry.fileName);
                     readStream.on('end', ()=>{
                         //console.log('add finished');
-                        resolve();
+                        resolve(void 0);
                     });
                 });
             });
@@ -744,7 +741,7 @@ async function enumZipEntries(zipFn, callback, nestedPath = '') {
                                 if (err) return rej(err);
                                 const writeStream = _fsextra.createWriteStream(tempZipPath);
                                 readStream.pipe(writeStream);
-                                writeStream.on('finish', res);
+                                writeStream.on('finish', ()=>res(void 0));
                                 writeStream.on('error', rej);
                             });
                         });
@@ -822,11 +819,11 @@ const bundleCommands = {
             outputFolder: intermediaDir,
             platform,
             sourcemapOutput: sourcemap || sourcemapPlugin ? sourcemapOutput : '',
-            disableHermes,
+            disableHermes: !!disableHermes,
             cli: {
-                taro,
-                expo,
-                rncli
+                taro: !!taro,
+                expo: !!expo,
+                rncli: !!rncli
             }
         });
         await pack(_path.default.resolve(intermediaDir), realOutput);
@@ -891,6 +888,11 @@ const bundleCommands = {
         await diffFromPackage(origin, next, realOutput, 'assets/index.android.bundle');
         console.log(`${realOutput} generated.`);
     },
+    async diffFromApp ({ args, options }) {
+        const { origin, next, realOutput } = diffArgsCheck(args, options, 'diffFromApp');
+        await diffFromPackage(origin, next, realOutput, 'resources/rawfile/bundle.harmony.js');
+        console.log(`${realOutput} generated.`);
+    },
     async hdiffFromApp ({ args, options }) {
         const { origin, next, realOutput } = diffArgsCheck(args, options, 'hdiffFromApp');
         await diffFromPackage(origin, next, realOutput, 'resources/rawfile/bundle.harmony.js');

package/lib/exports.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    CLIProviderImpl: function() {
+        return _provider.CLIProviderImpl;
+    },
+    appModule: function() {
+        return _appmodule.appModule;
+    },
+    builtinModules: function() {
+        return _modules.builtinModules;
+    },
+    bundleModule: function() {
+        return _bundlemodule.bundleModule;
+    },
+    getPlatform: function() {
+        return _app.getPlatform;
+    },
+    getSelectedApp: function() {
+        return _app.getSelectedApp;
+    },
+    getSession: function() {
+        return _api.getSession;
+    },
+    loadSession: function() {
+        return _api.loadSession;
+    },
+    moduleManager: function() {
+        return _modulemanager.moduleManager;
+    },
+    packageModule: function() {
+        return _packagemodule.packageModule;
+    },
+    question: function() {
+        return _utils.question;
+    },
+    saveToLocal: function() {
+        return _utils.saveToLocal;
+    },
+    userModule: function() {
+        return _usermodule.userModule;
+    },
+    versionModule: function() {
+        return _versionmodule.versionModule;
+    }
+});
+const _modulemanager = require("./module-manager");
+const _provider = require("./provider");
+const _modules = require("./modules");
+const _bundlemodule = require("./modules/bundle-module");
+const _versionmodule = require("./modules/version-module");
+const _appmodule = require("./modules/app-module");
+const _usermodule = require("./modules/user-module");
+const _packagemodule = require("./modules/package-module");
+const _api = require("./api");
+const _app = require("./app");
+const _utils = require("./utils");

package/lib/index.js

@@ -3,21 +3,76 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    CLIProviderImpl: function() {
+        return _provider.CLIProviderImpl;
+    },
+    moduleManager: function() {
+        return _modulemanager.moduleManager;
+    }
+});
 const _api = require("./api");
+const _app = require("./app");
+const _bundle = require("./bundle");
+const _modulemanager = require("./module-manager");
+const _modules = require("./modules");
+const _package = require("./package");
+const _user = require("./user");
 const _utils = require("./utils");
 const _i18n = require("./utils/i18n");
-const _bundle = require("./bundle");
 const _versions = require("./versions");
-const _user = require("./user");
-const _app = require("./app");
-const _package = require("./package");
+const _provider = require("./provider");
+function registerBuiltinModules() {
+    for (const module of _modules.builtinModules){
+        try {
+            _modulemanager.moduleManager.registerModule(module);
+        } catch (error) {
+            console.error(`Failed to register module ${module.name}:`, error);
+        }
+    }
+}
 function printUsage() {
-    // const commandName = args[0];
-    // TODO: print usage of commandName, or print global usage.
+    console.log('React Native Update CLI');
+    console.log('');
+    console.log('Traditional commands:');
+    const legacyCommands = {
+        ..._user.userCommands,
+        ..._bundle.bundleCommands,
+        ..._app.appCommands,
+        ..._package.packageCommands,
+        ..._versions.versionCommands
+    };
+    for (const [name, handler] of Object.entries(legacyCommands)){
+        console.log(`  ${name}: Legacy command`);
+    }
+    console.log('');
+    console.log('Modular commands:');
+    const commands = _modulemanager.moduleManager.getRegisteredCommands();
+    for (const command of commands){
+        console.log(`  ${command.name}: ${command.description || 'No description'}`);
+    }
+    console.log('');
+    console.log('Available workflows:');
+    const workflows = _modulemanager.moduleManager.getRegisteredWorkflows();
+    for (const workflow of workflows){
+        console.log(`  ${workflow.name}: ${workflow.description || 'No description'}`);
+    }
+    console.log('');
+    console.log('Special commands:');
+    console.log('  list: List all available commands and workflows');
+    console.log('  workflow <name>: Execute a specific workflow');
+    console.log('  help: Show this help message');
+    console.log('');
     console.log('Visit `https://github.com/reactnativecn/react-native-update` for document.');
     process.exit(1);
 }
-const commands = {
+const legacyCommands = {
     ..._user.userCommands,
     ..._bundle.bundleCommands,
     ..._app.appCommands,
@@ -30,16 +85,52 @@ async function run() {
     if (process.argv.indexOf('-v') >= 0 || process.argv[2] === 'version') {
         process.exit();
     }
+    // Register builtin modules for modular functionality
+    registerBuiltinModules();
     const argv = require('cli-arguments').parse(require('../cli.json'));
     global.NO_INTERACTIVE = argv.options['no-interactive'];
     global.USE_ACC_OSS = argv.options.acc;
-    (0, _api.loadSession)().then(()=>commands[argv.command](argv)).catch((err)=>{
+    const context = {
+        args: argv.args || [],
+        options: argv.options || {}
+    };
+    try {
+        await (0, _api.loadSession)();
+        context.session = require('./api').getSession();
+        // Handle special modular commands first
+        if (argv.command === 'help') {
+            printUsage();
+        } else if (argv.command === 'list') {
+            _modulemanager.moduleManager.listAll();
+        } else if (argv.command === 'workflow') {
+            const workflowName = argv.args[0];
+            if (!workflowName) {
+                console.error('Workflow name is required');
+                process.exit(1);
+            }
+            const result = await _modulemanager.moduleManager.executeWorkflow(workflowName, context);
+            if (!result.success) {
+                console.error('Workflow execution failed:', result.error);
+                process.exit(1);
+            }
+            console.log('Workflow completed successfully:', result.data);
+        } else if (legacyCommands[argv.command]) {
+            await legacyCommands[argv.command](argv);
+        } else {
+            const result = await _modulemanager.moduleManager.executeCommand(argv.command, context);
+            if (!result.success) {
+                console.error('Command execution failed:', result.error);
+                process.exit(1);
+            }
+            console.log('Command completed successfully:', result.data);
+        }
+    } catch (err) {
         if (err.status === 401) {
             console.log((0, _i18n.t)('loginFirst'));
             return;
         }
         console.error(err.stack);
         process.exit(-1);
-    });
+    }
 }
 run();

package/lib/module-manager.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ModuleManager: function() {
+        return ModuleManager;
+    },
+    moduleManager: function() {
+        return moduleManager;
+    }
+});
+const _provider = require("./provider");
+class ModuleManager {
+    registerModule(module) {
+        if (this.modules.has(module.name)) {
+            throw new Error(`Module '${module.name}' is already registered`);
+        }
+        this.modules.set(module.name, module);
+        if (module.commands) {
+            for (const command of module.commands){
+                this.registerCommand(command);
+            }
+        }
+        if (module.workflows) {
+            for (const workflow of module.workflows){
+                this.registerWorkflow(workflow);
+            }
+        }
+        if (module.init) {
+            module.init(this.provider);
+        }
+        console.log(`Module '${module.name}' (v${module.version}) registered successfully`);
+    }
+    unregisterModule(moduleName) {
+        const module = this.modules.get(moduleName);
+        if (!module) {
+            throw new Error(`Module '${moduleName}' is not registered`);
+        }
+        if (module.commands) {
+            for (const command of module.commands){
+                this.commands.delete(command.name);
+            }
+        }
+        if (module.workflows) {
+            for (const workflow of module.workflows){
+                this.workflows.delete(workflow.name);
+            }
+        }
+        if (module.cleanup) {
+            module.cleanup();
+        }
+        this.modules.delete(moduleName);
+        console.log(`Module '${moduleName}' unregistered successfully`);
+    }
+    registerCommand(command) {
+        if (this.commands.has(command.name)) {
+            throw new Error(`Command '${command.name}' is already registered`);
+        }
+        this.commands.set(command.name, command);
+    }
+    registerWorkflow(workflow) {
+        if (this.workflows.has(workflow.name)) {
+            throw new Error(`Workflow '${workflow.name}' is already registered`);
+        }
+        this.workflows.set(workflow.name, workflow);
+        this.provider.registerWorkflow(workflow);
+    }
+    getRegisteredCommands() {
+        return Array.from(this.commands.values());
+    }
+    getRegisteredWorkflows() {
+        return Array.from(this.workflows.values());
+    }
+    getRegisteredModules() {
+        return Array.from(this.modules.values());
+    }
+    async executeCommand(commandName, context) {
+        const command = this.commands.get(commandName);
+        if (!command) {
+            throw new Error(`Command '${commandName}' not found`);
+        }
+        return await command.handler(context);
+    }
+    async executeWorkflow(workflowName, context) {
+        return await this.provider.executeWorkflow(workflowName, context);
+    }
+    getProvider() {
+        return this.provider;
+    }
+    listCommands() {
+        return Array.from(this.commands.values());
+    }
+    listWorkflows() {
+        return Array.from(this.workflows.values());
+    }
+    listAll() {
+        console.log('\n=== Registered Commands ===');
+        for (const command of this.commands.values()){
+            console.log(`  ${command.name}: ${command.description || 'No description'}`);
+        }
+        console.log('\n=== Registered Workflows ===');
+        for (const workflow of this.workflows.values()){
+            console.log(`  ${workflow.name}: ${workflow.description || 'No description'}`);
+        }
+        console.log('\n=== Registered Modules ===');
+        for (const module of this.modules.values()){
+            var _module_commands, _module_workflows;
+            console.log(`  ${module.name} (v${module.version}): ${((_module_commands = module.commands) == null ? void 0 : _module_commands.length) || 0} commands, ${((_module_workflows = module.workflows) == null ? void 0 : _module_workflows.length) || 0} workflows`);
+        }
+    }
+    constructor(){
+        this.modules = new Map();
+        this.commands = new Map();
+        this.workflows = new Map();
+        this.provider = new _provider.CLIProviderImpl();
+    }
+}
+const moduleManager = new ModuleManager();

package/lib/modules/app-module.js

@@ -0,0 +1,223 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "appModule", {
+    enumerable: true,
+    get: function() {
+        return appModule;
+    }
+});
+const _app = require("../app");
+const appModule = {
+    name: 'app',
+    version: '1.0.0',
+    commands: [],
+    workflows: [
+        {
+            name: 'setup-app',
+            description: 'Setup a new app with initial configuration',
+            steps: [
+                {
+                    name: 'create',
+                    description: 'Create the app',
+                    execute: async (context)=>{
+                        console.log('Creating app in workflow');
+                        const { name, downloadUrl, platform } = context.options;
+                        await _app.appCommands.createApp({
+                            options: {
+                                name: name || '',
+                                downloadUrl: downloadUrl || '',
+                                platform: platform || ''
+                            }
+                        });
+                        return {
+                            appCreated: true
+                        };
+                    }
+                },
+                {
+                    name: 'select',
+                    description: 'Select the created app',
+                    execute: async (context, previousResult)=>{
+                        console.log('Selecting app in workflow');
+                        const { platform } = context.options;
+                        await _app.appCommands.selectApp({
+                            args: [],
+                            options: {
+                                platform: platform || ''
+                            }
+                        });
+                        return {
+                            ...previousResult,
+                            appSelected: true
+                        };
+                    }
+                }
+            ]
+        },
+        {
+            name: 'manage-apps',
+            description: 'Manage multiple apps',
+            steps: [
+                {
+                    name: 'list-apps',
+                    description: 'List all apps',
+                    execute: async (context)=>{
+                        console.log('Listing all apps');
+                        const { platform } = context.options;
+                        await _app.appCommands.apps({
+                            options: {
+                                platform: platform || ''
+                            }
+                        });
+                        return {
+                            appsListed: true
+                        };
+                    }
+                },
+                {
+                    name: 'select-target-app',
+                    description: 'Select target app for operations',
+                    execute: async (context, previousResult)=>{
+                        console.log('Selecting target app');
+                        const { platform } = context.options;
+                        await _app.appCommands.selectApp({
+                            args: [],
+                            options: {
+                                platform: platform || ''
+                            }
+                        });
+                        return {
+                            ...previousResult,
+                            targetAppSelected: true
+                        };
+                    }
+                }
+            ]
+        },
+        {
+            name: 'multi-platform-app-management',
+            description: 'Multi-platform app unified management workflow',
+            steps: [
+                {
+                    name: 'scan-platforms',
+                    description: 'Scan apps on all platforms',
+                    execute: async (context)=>{
+                        console.log('🔍 Scanning apps on all platforms...');
+                        const platforms = [
+                            'ios',
+                            'android',
+                            'harmony'
+                        ];
+                        const appsData = {};
+                        for (const platform of platforms){
+                            console.log(`  Scanning ${platform} platform...`);
+                            // Simulate getting app list
+                            await new Promise((resolve)=>setTimeout(resolve, 500));
+                            const appCount = Math.floor(Math.random() * 5) + 1;
+                            const apps = Array.from({
+                                length: appCount
+                            }, (_, i)=>({
+                                    id: `${platform}_app_${i + 1}`,
+                                    name: `App ${i + 1}`,
+                                    platform,
+                                    version: `1.${i}.0`,
+                                    status: Math.random() > 0.2 ? 'active' : 'inactive'
+                                }));
+                            appsData[platform] = apps;
+                            console.log(`    ✅ Found ${appCount} apps`);
+                        }
+                        console.log('✅ Platform scanning completed');
+                        return {
+                            platforms,
+                            appsData,
+                            scanned: true
+                        };
+                    }
+                },
+                {
+                    name: 'analyze-apps',
+                    description: 'Analyze app status',
+                    execute: async (context, previousResult)=>{
+                        console.log('📊 Analyzing app status...');
+                        const { appsData } = previousResult;
+                        const analysis = {
+                            totalApps: 0,
+                            activeApps: 0,
+                            inactiveApps: 0,
+                            platformDistribution: {},
+                            issues: []
+                        };
+                        for (const [platform, apps] of Object.entries(appsData)){
+                            const platformApps = apps;
+                            analysis.totalApps += platformApps.length;
+                            analysis.platformDistribution[platform] = platformApps.length;
+                            for (const app of platformApps){
+                                if (app.status === 'active') {
+                                    analysis.activeApps++;
+                                } else {
+                                    analysis.inactiveApps++;
+                                    analysis.issues.push(`${platform}/${app.name}: App is inactive`);
+                                }
+                            }
+                        }
+                        console.log('📈 Analysis results:');
+                        console.log(`  Total apps: ${analysis.totalApps}`);
+                        console.log(`  Active apps: ${analysis.activeApps}`);
+                        console.log(`  Inactive apps: ${analysis.inactiveApps}`);
+                        if (analysis.issues.length > 0) {
+                            console.log('⚠️ Issues found:');
+                            analysis.issues.forEach((issue)=>console.log(`    - ${issue}`));
+                        }
+                        return {
+                            ...previousResult,
+                            analysis
+                        };
+                    }
+                },
+                {
+                    name: 'optimize-apps',
+                    description: 'Optimize app configuration',
+                    execute: async (context, previousResult)=>{
+                        console.log('⚡ Optimizing app configuration...');
+                        const { analysis } = previousResult;
+                        const optimizations = [];
+                        if (analysis.inactiveApps > 0) {
+                            console.log('  Handling inactive apps...');
+                            optimizations.push('Reactivate inactive apps');
+                        }
+                        if (analysis.totalApps > 10) {
+                            console.log('  Many apps detected, suggest grouping...');
+                            optimizations.push('Create app groups');
+                        }
+                        // Simulate optimization process
+                        for (const optimization of optimizations){
+                            console.log(`    Executing: ${optimization}...`);
+                            await new Promise((resolve)=>setTimeout(resolve, 800));
+                            console.log(`    ✅ ${optimization} completed`);
+                        }
+                        console.log('✅ App optimization completed');
+                        return {
+                            ...previousResult,
+                            optimizations,
+                            optimized: true
+                        };
+                    }
+                }
+            ],
+            options: {
+                includeInactive: {
+                    hasValue: false,
+                    default: true,
+                    description: 'Include inactive apps'
+                },
+                autoOptimize: {
+                    hasValue: false,
+                    default: true,
+                    description: 'Auto optimize configuration'
+                }
+            }
+        }
+    ]
+};