react-native-update-cli 1.46.1 → 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 : {
@@ -288,7 +288,19 @@ async function copyHarmonyBundle(outputFolder) {
         await _fsextra.remove(_path.default.join(harmonyRawPath, 'update.json'));
         await _fsextra.copy('update.json', _path.default.join(harmonyRawPath, 'update.json'));
         await _fsextra.ensureDir(outputFolder);
-        await _fsextra.copy(harmonyRawPath, outputFolder);
+        const files = await _fsextra.readdir(harmonyRawPath);
+        for (const file of files){
+            if (file !== 'update.json' && file !== 'meta.json') {
+                const sourcePath = _path.default.join(harmonyRawPath, file);
+                const destPath = _path.default.join(outputFolder, file);
+                const stat = await _fsextra.stat(sourcePath);
+                if (stat.isFile()) {
+                    await _fsextra.copy(sourcePath, destPath);
+                } else if (stat.isDirectory()) {
+                    await _fsextra.copy(sourcePath, destPath);
+                }
+            }
+        }
     } catch (error) {
         console.error((0, _i18n.t)('copyHarmonyBundleError', {
             error
@@ -484,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();
     });
@@ -496,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);
             });
         });
     });
@@ -541,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 = {};
@@ -604,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);
                     });
                 });
             });
@@ -658,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)=>{
@@ -698,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);
                     });
                 });
             });
@@ -732,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);
                             });
                         });
@@ -810,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);
@@ -879,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();