react-native-update-cli 1.46.2 → 2.0.1

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: []
+};

package/lib/package.js

@@ -46,9 +46,10 @@ async function listPackage(appId) {
         const { version } = pkg;
         let versionInfo = '';
         if (version) {
+            const versionObj = version;
             versionInfo = (0, _i18n.t)('boundTo', {
-                name: version.name,
-                id: version.id
+                name: versionObj.name || version,
+                id: versionObj.id || version
             });
         }
         let output = pkg.name;
@@ -74,19 +75,22 @@ async function choosePackage(appId) {
     const list = await listPackage(appId);
     while(true){
         const id = await (0, _utils.question)((0, _i18n.t)('enterNativePackageId'));
-        const app = list.find((v)=>v.id === Number(id));
+        const app = list.find((v)=>v.id.toString() === id);
         if (app) {
             return app;
         }
     }
 }
 const packageCommands = {
-    uploadIpa: async ({ args })=>{
+    uploadIpa: async ({ args, options })=>{
         const fn = args[0];
         if (!fn || !fn.endsWith('.ipa')) {
             throw new Error((0, _i18n.t)('usageUploadIpa'));
         }
-        const { versionName, buildTime, appId: appIdInPkg, appKey: appKeyInPkg } = await (0, _utils.getIpaInfo)(fn);
+        const ipaInfo = await (0, _utils.getIpaInfo)(fn);
+        const { versionName: extractedVersionName, buildTime } = ipaInfo;
+        const appIdInPkg = ipaInfo.appId;
+        const appKeyInPkg = ipaInfo.appKey;
         const { appId, appKey } = await (0, _app.getSelectedApp)('ios');
         if (appIdInPkg && appIdInPkg != appId) {
             throw new Error((0, _i18n.t)('appIdMismatchIpa', {
@@ -100,6 +104,13 @@ const packageCommands = {
                 appKey
             }));
         }
+        // Use custom version if provided, otherwise use extracted version
+        const versionName = options.version || extractedVersionName;
+        if (options.version) {
+            console.log((0, _i18n.t)('usingCustomVersion', {
+                version: versionName
+            }));
+        }
         const { hash } = await (0, _api.uploadFile)(fn);
         const { id } = await (0, _api.post)(`/app/${appId}/package/create`, {
             name: versionName,
@@ -115,12 +126,15 @@ const packageCommands = {
             buildTime
         }));
     },
-    uploadApk: async ({ args })=>{
+    uploadApk: async ({ args, options })=>{
         const fn = args[0];
         if (!fn || !fn.endsWith('.apk')) {
             throw new Error((0, _i18n.t)('usageUploadApk'));
         }
-        const { versionName, buildTime, appId: appIdInPkg, appKey: appKeyInPkg } = await (0, _utils.getApkInfo)(fn);
+        const apkInfo = await (0, _utils.getApkInfo)(fn);
+        const { versionName: extractedVersionName, buildTime } = apkInfo;
+        const appIdInPkg = apkInfo.appId;
+        const appKeyInPkg = apkInfo.appKey;
         const { appId, appKey } = await (0, _app.getSelectedApp)('android');
         if (appIdInPkg && appIdInPkg != appId) {
             throw new Error((0, _i18n.t)('appIdMismatchApk', {
@@ -134,6 +148,13 @@ const packageCommands = {
                 appKey
             }));
         }
+        // Use custom version if provided, otherwise use extracted version
+        const versionName = options.version || extractedVersionName;
+        if (options.version) {
+            console.log((0, _i18n.t)('usingCustomVersion', {
+                version: versionName
+            }));
+        }
         const { hash } = await (0, _api.uploadFile)(fn);
         const { id } = await (0, _api.post)(`/app/${appId}/package/create`, {
             name: versionName,
@@ -149,12 +170,15 @@ const packageCommands = {
             buildTime
         }));
     },
-    uploadApp: async ({ args })=>{
+    uploadApp: async ({ args, options })=>{
         const fn = args[0];
         if (!fn || !fn.endsWith('.app')) {
             throw new Error((0, _i18n.t)('usageUploadApp'));
         }
-        const { versionName, buildTime, appId: appIdInPkg, appKey: appKeyInPkg } = await (0, _utils.getAppInfo)(fn);
+        const appInfo = await (0, _utils.getAppInfo)(fn);
+        const { versionName: extractedVersionName, buildTime } = appInfo;
+        const appIdInPkg = appInfo.appId;
+        const appKeyInPkg = appInfo.appKey;
         const { appId, appKey } = await (0, _app.getSelectedApp)('harmony');
         if (appIdInPkg && appIdInPkg != appId) {
             throw new Error((0, _i18n.t)('appIdMismatchApp', {
@@ -168,6 +192,13 @@ const packageCommands = {
                 appKey
             }));
         }
+        // Use custom version if provided, otherwise use extracted version
+        const versionName = options.version || extractedVersionName;
+        if (options.version) {
+            console.log((0, _i18n.t)('usingCustomVersion', {
+                version: versionName
+            }));
+        }
         const { hash } = await (0, _api.uploadFile)(fn);
         const { id } = await (0, _api.post)(`/app/${appId}/package/create`, {
             name: versionName,