react-native-update-cli 1.46.2 → 2.0.1

package/src/modules/user-module.ts

@@ -0,0 +1,406 @@
+import { getSession, loadSession } from '../api';
+import type { CLIModule, CommandContext } from '../types';
+import { userCommands } from '../user';
+
+export const userModule: CLIModule = {
+  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: CommandContext) => {
+            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: CommandContext, previousResult: any) => {
+            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: CommandContext, previousResult: any) => {
+            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: CommandContext, previousResult: any) => {
+            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: CommandContext) => {
+            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: CommandContext, previousResult: any) => {
+            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: CommandContext, previousResult: any) => {
+            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: CommandContext, previousResult: any) => {
+            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/src/modules/version-module.ts

@@ -0,0 +1,8 @@
+import type { CLIModule} from '../types';
+
+export const versionModule: CLIModule = {
+  name: 'version',
+  version: '1.0.0',
+  commands: [],
+  workflows: [],
+};

package/src/package.ts

@@ -4,11 +4,11 @@ import { t } from './utils/i18n';
 
 import { getPlatform, getSelectedApp } from './app';
 
-import { getApkInfo, getIpaInfo, getAppInfo } from './utils';
 import Table from 'tty-table';
+import type { Platform } from './types';
+import { getApkInfo, getAppInfo, getIpaInfo } from './utils';
 import { depVersions } from './utils/dep-versions';
 import { getCommitInfo } from './utils/git';
-import type { Platform } from 'types';
 
 export async function listPackage(appId: string) {
   const allPkgs = await getAllPackages(appId);
@@ -22,7 +22,11 @@ export async function listPackage(appId: string) {
     const { version } = pkg;
     let versionInfo = '';
     if (version) {
-      versionInfo = t('boundTo', { name: version.name, id: version.id });
+      const versionObj = version as any;
+      versionInfo = t('boundTo', {
+        name: versionObj.name || version,
+        id: versionObj.id || version,
+      });
     }
     let output = pkg.name;
     if (pkg.status === 'paused') {
@@ -45,7 +49,7 @@ export async function choosePackage(appId: string) {
 
   while (true) {
     const id = await question(t('enterNativePackageId'));
-    const app = list.find((v) => v.id === Number(id));
+    const app = list.find((v) => v.id.toString() === id);
     if (app) {
       return app;
     }
@@ -53,17 +57,21 @@ export async function choosePackage(appId: string) {
 }
 
 export const packageCommands = {
-  uploadIpa: async ({ args }: { args: string[] }) => {
+  uploadIpa: async ({
+    args,
+    options,
+  }: {
+    args: string[];
+    options: Record<string, any>;
+  }) => {
     const fn = args[0];
     if (!fn || !fn.endsWith('.ipa')) {
       throw new Error(t('usageUploadIpa'));
     }
-    const {
-      versionName,
-      buildTime,
-      appId: appIdInPkg,
-      appKey: appKeyInPkg,
-    } = await getIpaInfo(fn);
+    const ipaInfo = await getIpaInfo(fn);
+    const { versionName: extractedVersionName, buildTime } = ipaInfo;
+    const appIdInPkg = (ipaInfo as any).appId;
+    const appKeyInPkg = (ipaInfo as any).appKey;
     const { appId, appKey } = await getSelectedApp('ios');
 
     if (appIdInPkg && appIdInPkg != appId) {
@@ -74,6 +82,12 @@ export const packageCommands = {
       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`, {
@@ -86,17 +100,21 @@ export const packageCommands = {
     saveToLocal(fn, `${appId}/package/${id}.ipa`);
     console.log(t('ipaUploadSuccess', { id, version: versionName, buildTime }));
   },
-  uploadApk: async ({ args }: { args: string[] }) => {
+  uploadApk: async ({
+    args,
+    options,
+  }: {
+    args: string[];
+    options: Record<string, any>;
+  }) => {
     const fn = args[0];
     if (!fn || !fn.endsWith('.apk')) {
       throw new Error(t('usageUploadApk'));
     }
-    const {
-      versionName,
-      buildTime,
-      appId: appIdInPkg,
-      appKey: appKeyInPkg,
-    } = await getApkInfo(fn);
+    const apkInfo = await getApkInfo(fn);
+    const { versionName: extractedVersionName, buildTime } = apkInfo;
+    const appIdInPkg = (apkInfo as any).appId;
+    const appKeyInPkg = (apkInfo as any).appKey;
     const { appId, appKey } = await getSelectedApp('android');
 
     if (appIdInPkg && appIdInPkg != appId) {
@@ -107,6 +125,12 @@ export const packageCommands = {
       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`, {
@@ -119,17 +143,21 @@ export const packageCommands = {
     saveToLocal(fn, `${appId}/package/${id}.apk`);
     console.log(t('apkUploadSuccess', { id, version: versionName, buildTime }));
   },
-  uploadApp: async ({ args }: { args: string[] }) => {
+  uploadApp: async ({
+    args,
+    options,
+  }: {
+    args: string[];
+    options: Record<string, any>;
+  }) => {
     const fn = args[0];
     if (!fn || !fn.endsWith('.app')) {
       throw new Error(t('usageUploadApp'));
     }
-    const {
-      versionName,
-      buildTime,
-      appId: appIdInPkg,
-      appKey: appKeyInPkg,
-    } = await getAppInfo(fn);
+    const appInfo = await getAppInfo(fn);
+    const { versionName: extractedVersionName, buildTime } = appInfo;
+    const appIdInPkg = (appInfo as any).appId;
+    const appKeyInPkg = (appInfo as any).appKey;
     const { appId, appKey } = await getSelectedApp('harmony');
 
     if (appIdInPkg && appIdInPkg != appId) {
@@ -140,6 +168,12 @@ export const packageCommands = {
       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`, {