react-native-update-cli 2.7.1 → 2.7.2

package/lib/esm/modules/user-module..mjs

@@ -0,0 +1,351 @@
+import { getSession, loadSession } from "../api";
+import { userCommands } from "../user";
+export 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 loadSession();
+                            const session = 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 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 import("../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 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 loadSession();
+                            const session = getSession();
+                            if (session && session.token) {
+                                try {
+                                    await 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 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 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/esm/modules/version-module..mjs

@@ -0,0 +1,6 @@
+export const versionModule = {
+    name: 'version',
+    version: '1.0.0',
+    commands: [],
+    workflows: []
+};

package/lib/esm/package..mjs

@@ -0,0 +1,316 @@
+import os from "os";
+import path from "path";
+import fs from "fs-extra";
+import Table from "tty-table";
+import { doDelete, getAllPackages, post, uploadFile } from "./api";
+import { getPlatform, getSelectedApp } from "./app";
+import { getAabInfo, getApkInfo, getAppInfo, getIpaInfo, question, saveToLocal } from "./utils";
+import { AabParser } from "./utils/app-info-parser/aab";
+import { depVersions } from "./utils/dep-versions";
+import { getCommitInfo } from "./utils/git";
+import { t } from "./utils/i18n";
+export async function listPackage(appId) {
+    const allPkgs = await getAllPackages(appId) || [];
+    const header = [
+        {
+            value: t('nativePackageId')
+        },
+        {
+            value: t('nativeVersion')
+        }
+    ];
+    const rows = [];
+    for (const pkg of allPkgs){
+        const { version } = pkg;
+        let versionInfo = '';
+        if (version) {
+            const versionObj = version;
+            versionInfo = t('boundTo', {
+                name: versionObj.name || version,
+                id: versionObj.id || version
+            });
+        }
+        let output = pkg.name;
+        if (pkg.status === 'paused') {
+            output += t('pausedStatus');
+        }
+        if (pkg.status === 'expired') {
+            output += t('expiredStatus');
+        }
+        output += versionInfo;
+        rows.push([
+            pkg.id,
+            output
+        ]);
+    }
+    console.log(Table(header, rows).render());
+    console.log(t('totalPackages', {
+        count: allPkgs.length
+    }));
+    return allPkgs;
+}
+export async function choosePackage(appId) {
+    const list = await listPackage(appId);
+    while(true){
+        const id = await question(t('enterNativePackageId'));
+        const app = list == null ? void 0 : list.find((v)=>v.id.toString() === id);
+        if (app) {
+            return app;
+        }
+    }
+}
+export const packageCommands = {
+    uploadIpa: async ({ args, options })=>{
+        const fn = args[0];
+        if (!fn || !fn.endsWith('.ipa')) {
+            throw new Error(t('usageUploadIpa'));
+        }
+        const ipaInfo = await getIpaInfo(fn);
+        const { versionName: extractedVersionName, buildTime } = ipaInfo;
+        const appIdInPkg = ipaInfo.appId;
+        const appKeyInPkg = ipaInfo.appKey;
+        const { appId, appKey } = await getSelectedApp('ios');
+        if (appIdInPkg && appIdInPkg != appId) {
+            throw new Error(t('appIdMismatchIpa', {
+                appIdInPkg,
+                appId
+            }));
+        }
+        if (appKeyInPkg && appKeyInPkg !== appKey) {
+            throw new Error(t('appKeyMismatchIpa', {
+                appKeyInPkg,
+                appKey
+            }));
+        }
+        // Use custom version if provided, otherwise use extracted version
+        const versionName = options.version || extractedVersionName;
+        if (options.version) {
+            console.log(t('usingCustomVersion', {
+                version: versionName
+            }));
+        }
+        const { hash } = await uploadFile(fn);
+        const { id } = await post(`/app/${appId}/package/create`, {
+            name: versionName,
+            hash,
+            buildTime,
+            deps: depVersions,
+            commit: await getCommitInfo()
+        });
+        saveToLocal(fn, `${appId}/package/${id}.ipa`);
+        console.log(t('ipaUploadSuccess', {
+            id,
+            version: versionName,
+            buildTime
+        }));
+    },
+    uploadApk: async ({ args, options })=>{
+        const fn = args[0];
+        if (!fn || !fn.endsWith('.apk')) {
+            throw new Error(t('usageUploadApk'));
+        }
+        const apkInfo = await getApkInfo(fn);
+        const { versionName: extractedVersionName, buildTime } = apkInfo;
+        const appIdInPkg = apkInfo.appId;
+        const appKeyInPkg = apkInfo.appKey;
+        const { appId, appKey } = await getSelectedApp('android');
+        if (appIdInPkg && appIdInPkg != appId) {
+            throw new Error(t('appIdMismatchApk', {
+                appIdInPkg,
+                appId
+            }));
+        }
+        if (appKeyInPkg && appKeyInPkg !== appKey) {
+            throw new Error(t('appKeyMismatchApk', {
+                appKeyInPkg,
+                appKey
+            }));
+        }
+        // Use custom version if provided, otherwise use extracted version
+        const versionName = options.version || extractedVersionName;
+        if (options.version) {
+            console.log(t('usingCustomVersion', {
+                version: versionName
+            }));
+        }
+        const { hash } = await uploadFile(fn);
+        const { id } = await post(`/app/${appId}/package/create`, {
+            name: versionName,
+            hash,
+            buildTime,
+            deps: depVersions,
+            commit: await getCommitInfo()
+        });
+        saveToLocal(fn, `${appId}/package/${id}.apk`);
+        console.log(t('apkUploadSuccess', {
+            id,
+            version: versionName,
+            buildTime
+        }));
+    },
+    uploadAab: async ({ args, options })=>{
+        const source = args[0];
+        if (!source || !source.endsWith('.aab')) {
+            throw new Error(t('usageUploadAab'));
+        }
+        const output = path.join(os.tmpdir(), `${path.basename(source, path.extname(source))}-${Date.now()}.apk`);
+        const includeAllSplits = options.includeAllSplits === true || options.includeAllSplits === 'true';
+        const splits = options.splits ? String(options.splits).split(',').map((item)=>item.trim()).filter(Boolean) : null;
+        const parser = new AabParser(source);
+        try {
+            await parser.extractApk(output, {
+                includeAllSplits,
+                splits
+            });
+            await packageCommands.uploadApk({
+                args: [
+                    output
+                ],
+                options
+            });
+        } finally{
+            if (await fs.pathExists(output)) {
+                await fs.remove(output);
+            }
+        }
+    },
+    uploadApp: async ({ args, options })=>{
+        const fn = args[0];
+        if (!fn || !fn.endsWith('.app')) {
+            throw new Error(t('usageUploadApp'));
+        }
+        const appInfo = await getAppInfo(fn);
+        const { versionName: extractedVersionName, buildTime } = appInfo;
+        const appIdInPkg = appInfo.appId;
+        const appKeyInPkg = appInfo.appKey;
+        const { appId, appKey } = await getSelectedApp('harmony');
+        if (appIdInPkg && appIdInPkg != appId) {
+            throw new Error(t('appIdMismatchApp', {
+                appIdInPkg,
+                appId
+            }));
+        }
+        if (appKeyInPkg && appKeyInPkg !== appKey) {
+            throw new Error(t('appKeyMismatchApp', {
+                appKeyInPkg,
+                appKey
+            }));
+        }
+        // Use custom version if provided, otherwise use extracted version
+        const versionName = options.version || extractedVersionName;
+        if (options.version) {
+            console.log(t('usingCustomVersion', {
+                version: versionName
+            }));
+        }
+        const { hash } = await uploadFile(fn);
+        const { id } = await post(`/app/${appId}/package/create`, {
+            name: versionName,
+            hash,
+            buildTime: String(buildTime),
+            deps: depVersions,
+            commit: await getCommitInfo()
+        });
+        saveToLocal(fn, `${appId}/package/${id}.app`);
+        console.log(t('appUploadSuccess', {
+            id,
+            version: versionName,
+            buildTime
+        }));
+    },
+    parseApp: async ({ args })=>{
+        const fn = args[0];
+        if (!fn || !fn.endsWith('.app')) {
+            throw new Error(t('usageParseApp'));
+        }
+        console.log(await getAppInfo(fn));
+    },
+    parseIpa: async ({ args })=>{
+        const fn = args[0];
+        if (!fn || !fn.endsWith('.ipa')) {
+            throw new Error(t('usageParseIpa'));
+        }
+        console.log(await getIpaInfo(fn));
+    },
+    parseApk: async ({ args })=>{
+        const fn = args[0];
+        if (!fn || !fn.endsWith('.apk')) {
+            throw new Error(t('usageParseApk'));
+        }
+        console.log(await getApkInfo(fn));
+    },
+    parseAab: async ({ args })=>{
+        const fn = args[0];
+        if (!fn || !fn.endsWith('.aab')) {
+            throw new Error(t('usageParseAab'));
+        }
+        console.log(await getAabInfo(fn));
+    },
+    extractApk: async ({ args, options })=>{
+        const source = args[0];
+        if (!source || !source.endsWith('.aab')) {
+            throw new Error(t('usageExtractApk'));
+        }
+        const output = options.output || path.join(path.dirname(source), `${path.basename(source, path.extname(source))}.apk`);
+        const includeAllSplits = options.includeAllSplits === true || options.includeAllSplits === 'true';
+        const splits = options.splits ? String(options.splits).split(',').map((item)=>item.trim()).filter(Boolean) : null;
+        const parser = new AabParser(source);
+        await parser.extractApk(output, {
+            includeAllSplits,
+            splits
+        });
+        console.log(t('apkExtracted', {
+            output
+        }));
+    },
+    packages: async ({ options })=>{
+        const platform = await getPlatform(options.platform);
+        const { appId } = await getSelectedApp(platform);
+        await listPackage(appId);
+    },
+    deletePackage: async ({ args, options })=>{
+        let { appId, packageId, packageVersion } = options;
+        if (!appId) {
+            const platform = await getPlatform(options.platform);
+            appId = (await getSelectedApp(platform)).appId;
+        }
+        // If no packageId provided as argument, let user choose from list
+        if (!packageId) {
+            const allPkgs = await getAllPackages(appId);
+            if (!allPkgs) {
+                throw new Error(t('noPackagesFound', {
+                    appId
+                }));
+            }
+            const selectedPackage = allPkgs.find((pkg)=>pkg.name === packageVersion);
+            if (!selectedPackage) {
+                throw new Error(t('packageNotFound', {
+                    packageVersion
+                }));
+            }
+            packageId = selectedPackage.id;
+        }
+        // Confirm deletion
+        // const confirmDelete = await question(
+        //   t('confirmDeletePackage', { packageId }),
+        // );
+        // if (
+        //   confirmDelete.toLowerCase() !== 'y' &&
+        //   confirmDelete.toLowerCase() !== 'yes'
+        // ) {
+        //   console.log(t('cancelled'));
+        //   return;
+        // }
+        try {
+            await doDelete(`/app/${appId}/package/${packageId}`);
+            console.log(t('deletePackageSuccess', {
+                packageId
+            }));
+        } catch (error) {
+            throw new Error(t('deletePackageError', {
+                packageId,
+                error: error.message
+            }));
+        }
+    }
+};