react-native-update-cli 1.46.2 → 2.0.0

package/lib/modules/bundle-module.js

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "bundleModule", {
+    enumerable: true,
+    get: function() {
+        return bundleModule;
+    }
+});
+const _bundle = require("../bundle");
+const bundleModule = {
+    name: 'bundle',
+    version: '1.0.0',
+    commands: [],
+    workflows: [
+        {
+            name: 'incremental-build',
+            description: 'Incremental build workflow - generate diff packages',
+            steps: [
+                {
+                    name: 'detect-base-version',
+                    description: 'Detect base version',
+                    execute: async (context)=>{
+                        console.log('🔍 Detecting base version...');
+                        const { baseVersion, platform } = context.options;
+                        if (baseVersion) {
+                            console.log(`✅ Using specified base version: ${baseVersion}`);
+                            return {
+                                baseVersion,
+                                specified: true
+                            };
+                        }
+                        console.log('Auto detecting latest version...');
+                        await new Promise((resolve)=>setTimeout(resolve, 800));
+                        const autoDetectedVersion = `v${Math.floor(Math.random() * 3) + 1}.${Math.floor(Math.random() * 10)}.${Math.floor(Math.random() * 10)}`;
+                        console.log(`✅ Auto detected base version: ${autoDetectedVersion}`);
+                        return {
+                            baseVersion: autoDetectedVersion,
+                            specified: false
+                        };
+                    }
+                },
+                {
+                    name: 'build-current-version',
+                    description: 'Build current version',
+                    execute: async (context, previousResult)=>{
+                        console.log('🏗️ Building current version...');
+                        const { platform, dev = false, sourcemap = false, bundleName = 'index.bundlejs', entryFile = 'index.js', intermediaDir, taro = false, expo = false, rncli = false, disableHermes = false, output } = context.options;
+                        console.log(`Building ${platform} platform...`);
+                        console.log(`  Entry file: ${entryFile}`);
+                        console.log(`  Bundle name: ${bundleName}`);
+                        console.log(`  Development mode: ${dev}`);
+                        console.log(`  Source maps: ${sourcemap}`);
+                        try {
+                            const buildOptions = {
+                                platform,
+                                dev,
+                                sourcemap,
+                                bundleName,
+                                entryFile,
+                                taro,
+                                expo,
+                                rncli,
+                                disableHermes,
+                                intermediaDir: '${tempDir}/intermedia/${platform}',
+                                output: '${tempDir}/output/${platform}.${time}.ppk'
+                            };
+                            if (intermediaDir) {
+                                buildOptions.intermediaDir = intermediaDir;
+                            }
+                            await _bundle.bundleCommands.bundle({
+                                args: [],
+                                options: buildOptions
+                            });
+                            const currentBuild = {
+                                version: `v${Math.floor(Math.random() * 3) + 2}.0.0`,
+                                platform,
+                                bundlePath: `./build/current_${platform}.ppk`,
+                                size: Math.floor(Math.random() * 15) + 10,
+                                buildTime: Date.now()
+                            };
+                            console.log(`✅ Current version build completed: ${currentBuild.version}`);
+                            return {
+                                ...previousResult,
+                                currentBuild
+                            };
+                        } catch (error) {
+                            console.error('❌ Current version build failed:', error);
+                            throw error;
+                        }
+                    }
+                }
+            ],
+            validate: (context)=>{
+                if (!context.options.platform) {
+                    console.error('❌ Incremental build requires platform specification');
+                    return false;
+                }
+                return true;
+            },
+            options: {
+                platform: {
+                    hasValue: true,
+                    description: 'Target platform (required)'
+                },
+                baseVersion: {
+                    hasValue: true,
+                    description: 'Base version (auto detect if not specified)'
+                },
+                skipValidation: {
+                    hasValue: false,
+                    default: false,
+                    description: 'Skip diff package validation'
+                },
+                dev: {
+                    hasValue: false,
+                    default: false,
+                    description: 'Development mode build'
+                },
+                bundleName: {
+                    hasValue: true,
+                    default: 'index.bundlejs',
+                    description: 'Bundle file name'
+                },
+                entryFile: {
+                    hasValue: true,
+                    default: 'index.js',
+                    description: 'Entry file'
+                },
+                sourcemap: {
+                    hasValue: false,
+                    default: false,
+                    description: 'Generate source maps'
+                },
+                output: {
+                    hasValue: true,
+                    description: 'Custom output path for diff package'
+                },
+                intermediaDir: {
+                    hasValue: true,
+                    description: 'Intermediate directory'
+                },
+                taro: {
+                    hasValue: false,
+                    default: false,
+                    description: 'Use Taro CLI'
+                },
+                expo: {
+                    hasValue: false,
+                    default: false,
+                    description: 'Use Expo CLI'
+                },
+                rncli: {
+                    hasValue: false,
+                    default: false,
+                    description: 'Use React Native CLI'
+                },
+                disableHermes: {
+                    hasValue: false,
+                    default: false,
+                    description: 'Disable Hermes'
+                },
+                name: {
+                    hasValue: true,
+                    description: 'Version name for publishing'
+                },
+                description: {
+                    hasValue: true,
+                    description: 'Version description for publishing'
+                },
+                metaInfo: {
+                    hasValue: true,
+                    description: 'Meta information for publishing'
+                },
+                rollout: {
+                    hasValue: true,
+                    description: 'Rollout percentage'
+                },
+                dryRun: {
+                    hasValue: false,
+                    default: false,
+                    description: 'Dry run mode'
+                }
+            }
+        }
+    ]
+};

package/lib/modules/index.js

@@ -0,0 +1,42 @@
+"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, {
+    appModule: function() {
+        return _appmodule.appModule;
+    },
+    builtinModules: function() {
+        return builtinModules;
+    },
+    bundleModule: function() {
+        return _bundlemodule.bundleModule;
+    },
+    packageModule: function() {
+        return _packagemodule.packageModule;
+    },
+    userModule: function() {
+        return _usermodule.userModule;
+    },
+    versionModule: function() {
+        return _versionmodule.versionModule;
+    }
+});
+const _appmodule = require("./app-module");
+const _bundlemodule = require("./bundle-module");
+const _packagemodule = require("./package-module");
+const _usermodule = require("./user-module");
+const _versionmodule = require("./version-module");
+const builtinModules = [
+    _bundlemodule.bundleModule,
+    _versionmodule.versionModule,
+    _appmodule.appModule,
+    _usermodule.userModule,
+    _packagemodule.packageModule
+];

package/lib/modules/package-module.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "packageModule", {
+    enumerable: true,
+    get: function() {
+        return packageModule;
+    }
+});
+const packageModule = {
+    name: 'package',
+    version: '1.0.0',
+    commands: [],
+    workflows: []
+};

package/lib/modules/user-module.js

@@ -0,0 +1,402 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "userModule", {
+    enumerable: true,
+    get: function() {
+        return userModule;
+    }
+});
+const _api = require("../api");
+const _user = require("../user");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const userModule = {
+    name: 'user',
+    version: '1.0.0',
+    commands: [],
+    workflows: [
+        {
+            name: 'auth-check',
+            description: 'Check authentication status and user information',
+            options: {
+                autoLogin: {
+                    default: false,
+                    description: 'Automatically login if not authenticated'
+                },
+                showDetails: {
+                    default: true,
+                    description: 'Show detailed user information'
+                }
+            },
+            steps: [
+                {
+                    name: 'load-session',
+                    description: 'Load existing session from local storage',
+                    execute: async (context)=>{
+                        console.log('Loading session from local storage...');
+                        try {
+                            await (0, _api.loadSession)();
+                            const session = (0, _api.getSession)();
+                            if (session && session.token) {
+                                console.log('✓ Session found in local storage');
+                                return {
+                                    sessionLoaded: true,
+                                    hasToken: true,
+                                    session
+                                };
+                            } else {
+                                console.log('✗ No valid session found in local storage');
+                                return {
+                                    sessionLoaded: true,
+                                    hasToken: false,
+                                    session: null
+                                };
+                            }
+                        } catch (error) {
+                            console.log('✗ Failed to load session:', error instanceof Error ? error.message : 'Unknown error');
+                            return {
+                                sessionLoaded: false,
+                                hasToken: false,
+                                session: null,
+                                error: error instanceof Error ? error.message : 'Unknown error'
+                            };
+                        }
+                    }
+                },
+                {
+                    name: 'validate-session',
+                    description: 'Validate session by calling API',
+                    execute: async (context, previousResult)=>{
+                        if (!previousResult.hasToken) {
+                            console.log('No token available, skipping validation');
+                            return {
+                                ...previousResult,
+                                validated: false,
+                                reason: 'No token available'
+                            };
+                        }
+                        console.log('Validating session with server...');
+                        try {
+                            await _user.userCommands.me();
+                            console.log('✓ Session is valid');
+                            return {
+                                ...previousResult,
+                                validated: true,
+                                reason: 'Session validated successfully'
+                            };
+                        } catch (error) {
+                            console.log('✗ Session validation failed:', error instanceof Error ? error.message : 'Unknown error');
+                            return {
+                                ...previousResult,
+                                validated: false,
+                                reason: error instanceof Error ? error.message : 'Unknown error'
+                            };
+                        }
+                    }
+                },
+                {
+                    name: 'get-user-info',
+                    description: 'Get current user information',
+                    execute: async (context, previousResult)=>{
+                        if (!previousResult.validated) {
+                            console.log('Session not valid, cannot get user info');
+                            return {
+                                ...previousResult,
+                                userInfo: null,
+                                reason: 'Session not valid'
+                            };
+                        }
+                        console.log('Getting user information...');
+                        try {
+                            const { get } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("../api")));
+                            const userInfo = await get('/user/me');
+                            console.log('✓ User information retrieved successfully');
+                            if (context.options.showDetails !== false) {
+                                console.log('\n=== User Information ===');
+                                for (const [key, value] of Object.entries(userInfo)){
+                                    if (key !== 'ok') {
+                                        console.log(`${key}: ${value}`);
+                                    }
+                                }
+                                console.log('========================\n');
+                            }
+                            return {
+                                ...previousResult,
+                                userInfo,
+                                reason: 'User info retrieved successfully'
+                            };
+                        } catch (error) {
+                            console.log('✗ Failed to get user info:', error instanceof Error ? error.message : 'Unknown error');
+                            return {
+                                ...previousResult,
+                                userInfo: null,
+                                reason: error instanceof Error ? error.message : 'Unknown error'
+                            };
+                        }
+                    }
+                },
+                {
+                    name: 'handle-auth-failure',
+                    description: 'Handle authentication failure',
+                    execute: async (context, previousResult)=>{
+                        if (previousResult.validated) {
+                            console.log('✓ Authentication check completed successfully');
+                            return {
+                                ...previousResult,
+                                authCheckComplete: true,
+                                status: 'authenticated'
+                            };
+                        }
+                        console.log('✗ Authentication check failed');
+                        if (context.options.autoLogin) {
+                            console.log('Attempting automatic login...');
+                            try {
+                                await _user.userCommands.login({
+                                    args: []
+                                });
+                                console.log('✓ Automatic login successful');
+                                return {
+                                    ...previousResult,
+                                    authCheckComplete: true,
+                                    status: 'auto-logged-in',
+                                    autoLoginSuccess: true
+                                };
+                            } catch (error) {
+                                console.log('✗ Automatic login failed:', error instanceof Error ? error.message : 'Unknown error');
+                                return {
+                                    ...previousResult,
+                                    authCheckComplete: true,
+                                    status: 'failed',
+                                    autoLoginSuccess: false,
+                                    autoLoginError: error instanceof Error ? error.message : 'Unknown error'
+                                };
+                            }
+                        } else {
+                            console.log('Please run login command to authenticate');
+                            return {
+                                ...previousResult,
+                                authCheckComplete: true,
+                                status: 'unauthenticated',
+                                suggestion: 'Run login command to authenticate'
+                            };
+                        }
+                    }
+                }
+            ]
+        },
+        {
+            name: 'login-flow',
+            description: 'Complete login flow with validation',
+            options: {
+                email: {
+                    hasValue: true,
+                    description: 'User email'
+                },
+                password: {
+                    hasValue: true,
+                    description: 'User password'
+                },
+                validateAfterLogin: {
+                    default: true,
+                    description: 'Validate session after login'
+                }
+            },
+            steps: [
+                {
+                    name: 'check-existing-session',
+                    description: 'Check if user is already logged in',
+                    execute: async (context)=>{
+                        console.log('Checking existing session...');
+                        try {
+                            await (0, _api.loadSession)();
+                            const session = (0, _api.getSession)();
+                            if (session && session.token) {
+                                try {
+                                    await _user.userCommands.me();
+                                    console.log('✓ User is already logged in');
+                                    return {
+                                        alreadyLoggedIn: true,
+                                        session: session,
+                                        status: 'authenticated'
+                                    };
+                                } catch (error) {
+                                    console.log('✗ Existing session is invalid, proceeding with login');
+                                    return {
+                                        alreadyLoggedIn: false,
+                                        session: null,
+                                        status: 'session-expired'
+                                    };
+                                }
+                            } else {
+                                console.log('No existing session found');
+                                return {
+                                    alreadyLoggedIn: false,
+                                    session: null,
+                                    status: 'no-session'
+                                };
+                            }
+                        } catch (error) {
+                            console.log('Error checking existing session:', error instanceof Error ? error.message : 'Unknown error');
+                            return {
+                                alreadyLoggedIn: false,
+                                session: null,
+                                status: 'error',
+                                error: error instanceof Error ? error.message : 'Unknown error'
+                            };
+                        }
+                    }
+                },
+                {
+                    name: 'perform-login',
+                    description: 'Perform user login',
+                    execute: async (context, previousResult)=>{
+                        if (previousResult.alreadyLoggedIn) {
+                            console.log('Skipping login - user already authenticated');
+                            return {
+                                ...previousResult,
+                                loginPerformed: false,
+                                loginSuccess: true
+                            };
+                        }
+                        console.log('Performing login...');
+                        try {
+                            const loginArgs = [];
+                            if (context.options.email) {
+                                loginArgs.push(context.options.email);
+                            }
+                            if (context.options.password) {
+                                loginArgs.push(context.options.password);
+                            }
+                            await _user.userCommands.login({
+                                args: loginArgs
+                            });
+                            console.log('✓ Login successful');
+                            return {
+                                ...previousResult,
+                                loginPerformed: true,
+                                loginSuccess: true
+                            };
+                        } catch (error) {
+                            console.log('✗ Login failed:', error instanceof Error ? error.message : 'Unknown error');
+                            return {
+                                ...previousResult,
+                                loginPerformed: true,
+                                loginSuccess: false,
+                                loginError: error instanceof Error ? error.message : 'Unknown error'
+                            };
+                        }
+                    }
+                },
+                {
+                    name: 'validate-login',
+                    description: 'Validate login by getting user info',
+                    execute: async (context, previousResult)=>{
+                        if (!previousResult.loginSuccess && !previousResult.alreadyLoggedIn) {
+                            console.log('Login failed, skipping validation');
+                            return {
+                                ...previousResult,
+                                validationPerformed: false,
+                                validationSuccess: false
+                            };
+                        }
+                        if (context.options.validateAfterLogin === false) {
+                            console.log('Skipping validation as requested');
+                            return {
+                                ...previousResult,
+                                validationPerformed: false,
+                                validationSuccess: true
+                            };
+                        }
+                        console.log('Validating login by getting user information...');
+                        try {
+                            const userInfo = await _user.userCommands.me();
+                            console.log('✓ Login validation successful');
+                            return {
+                                ...previousResult,
+                                validationPerformed: true,
+                                validationSuccess: true,
+                                userInfo
+                            };
+                        } catch (error) {
+                            console.log('✗ Login validation failed:', error instanceof Error ? error.message : 'Unknown error');
+                            return {
+                                ...previousResult,
+                                validationPerformed: true,
+                                validationSuccess: false,
+                                validationError: error instanceof Error ? error.message : 'Unknown error'
+                            };
+                        }
+                    }
+                },
+                {
+                    name: 'login-summary',
+                    description: 'Provide login flow summary',
+                    execute: async (context, previousResult)=>{
+                        console.log('\n=== Login Flow Summary ===');
+                        if (previousResult.alreadyLoggedIn) {
+                            console.log('Status: Already logged in');
+                            console.log('Session: Valid');
+                        } else if (previousResult.loginSuccess) {
+                            console.log('Status: Login successful');
+                            if (previousResult.validationSuccess) {
+                                console.log('Validation: Passed');
+                            } else {
+                                console.log('Validation: Failed');
+                            }
+                        } else {
+                            console.log('Status: Login failed');
+                            console.log('Error:', previousResult.loginError || 'Unknown error');
+                        }
+                        console.log('==========================\n');
+                        return {
+                            ...previousResult,
+                            flowComplete: true,
+                            finalStatus: previousResult.alreadyLoggedIn || previousResult.loginSuccess ? 'success' : 'failed'
+                        };
+                    }
+                }
+            ]
+        }
+    ]
+};

package/lib/modules/version-module.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "versionModule", {
+    enumerable: true,
+    get: function() {
+        return versionModule;
+    }
+});
+const versionModule = {
+    name: 'version',
+    version: '1.0.0',
+    commands: [],
+    workflows: []
+};