react-native-update-cli 2.8.5 → 2.9.1

package/lib/locales/zh.d.ts

@@ -0,0 +1,136 @@
+declare const _default: {
+    addedToGitignore: string;
+    androidCrunchPngsWarning: string;
+    aabOpenApksFailed: string;
+    aabReadUniversalApkFailed: string;
+    aabUniversalApkNotFound: string;
+    aabBundletoolDownloadHint: string;
+    aabManifestNotFound: string;
+    aabParseResourcesWarning: string;
+    aabParseFailed: string;
+    aabParseManifestError: string;
+    aabParseResourcesError: string;
+    appId: string;
+    appIdMismatchApk: string;
+    appIdMismatchApp: string;
+    appIdMismatchIpa: string;
+    appKeyMismatchApk: string;
+    appKeyMismatchApp: string;
+    appKeyMismatchIpa: string;
+    appName: string;
+    appNameQuestion: string;
+    appNotSelected: string;
+    appUploadSuccess: string;
+    apkUploadSuccess: string;
+    boundTo: string;
+    buildTimeNotFound: string;
+    bundleCommandError: string;
+    bundleNotFound: string;
+    bundlingWithRN: string;
+    cancelled: string;
+    composingSourceMap: string;
+    copyFileFailed: string;
+    copyHarmonyBundleError: string;
+    copyingDebugId: string;
+    createAppSuccess: string;
+    deleteFile: string;
+    deletingFile: string;
+    enterAppIdQuestion: string;
+    enterNativePackageId: string;
+    errorInHarmonyApp: string;
+    expiredStatus: string;
+    failedToParseIcon: string;
+    failedToParseUpdateJson: string;
+    fileGenerated: string;
+    fileSizeExceeded: string;
+    forceHermes: string;
+    hermesEnabledCompiling: string;
+    ipaUploadSuccess: string;
+    keyStrings: string;
+    latestVersionTag: string;
+    lockBestPractice: string;
+    lockNotFound: string;
+    loggedOut: string;
+    loginExpired: string;
+    loginFirst: string;
+    multipleLocksFound: string;
+    nativePackageId: string;
+    nativeVersion: string;
+    nativeVersionNotFoundGte: string;
+    nativeVersionNotFoundLte: string;
+    nativeVersionNotFoundMatch: string;
+    nativePackageIdNotFound: string;
+    noPackagesFound: string;
+    offset: string;
+    operationComplete: string;
+    operationSuccess: string;
+    packageIdRequired: string;
+    packageUploadSuccess: string;
+    depsChangeSummary: string;
+    depsChangeTargetPackage: string;
+    depsChangeDependencyHeader: string;
+    depsChangeVersionHeader: string;
+    depsChangeAddedLabel: string;
+    depsChangeRemovedLabel: string;
+    depsChangeChangedLabel: string;
+    depsChangeArrow: string;
+    depsChangeRiskWarning: string;
+    depsChangeFetchFailed: string;
+    depsChangeNonBlockingHint: string;
+    packing: string;
+    pausedStatus: string;
+    platform: string;
+    platformPrompt: string;
+    platformQuestion: string;
+    platformRequired: string;
+    pluginDetectionError: string;
+    pluginDetected: string;
+    ppkPackageGenerated: string;
+    processingError: string;
+    processingPackage: string;
+    processingStringPool: string;
+    publishUsage: string;
+    rnuVersionNotFound: string;
+    rolloutConfigSet: string;
+    rolloutRangeError: string;
+    runningHermesc: string;
+    sentryCliNotFound: string;
+    sentryReleaseCreated: string;
+    totalApps: string;
+    totalPackages: string;
+    typeStrings: string;
+    unsupportedPlatform: string;
+    uploadBundlePrompt: string;
+    uploadingSourcemap: string;
+    usageDiff: string;
+    usageParseApk: string;
+    usageParseAab: string;
+    usageExtractApk: string;
+    usageParseApp: string;
+    usageParseIpa: string;
+    usageUploadApk: string;
+    usageUploadAab: string;
+    usageUploadApp: string;
+    usageUploadIpa: string;
+    versionBind: string;
+    welcomeMessage: string;
+    versionNameQuestion: string;
+    versionDescriptionQuestion: string;
+    versionMetaInfoQuestion: string;
+    updateNativePackageQuestion: string;
+    unnamed: string;
+    dryRun: string;
+    usingCustomVersion: string;
+    confirmDeletePackage: string;
+    deletePackageSuccess: string;
+    deletePackageError: string;
+    usageDeletePackage: string;
+    deleteVersionSuccess: string;
+    deleteVersionError: string;
+    bundleFileNotFound: string;
+    diffPackageGenerated: string;
+    nodeBsdiffRequired: string;
+    nodeHdiffpatchRequired: string;
+    apkExtracted: string;
+};
+export default _default;

package/lib/module-manager.d.ts

@@ -0,0 +1,20 @@
+import type { CLIModule, CLIProvider, CommandContext, CommandDefinition, CommandResult, CustomWorkflow } from './types';
+export declare class ModuleManager {
+    private modules;
+    private provider;
+    private commands;
+    private workflows;
+    constructor();
+    registerModule(module: CLIModule): void;
+    unregisterModule(moduleName: string): void;
+    registerCommand(command: CommandDefinition): void;
+    registerWorkflow(workflow: CustomWorkflow): void;
+    executeCommand(commandName: string, context: CommandContext): Promise<CommandResult>;
+    executeWorkflow(workflowName: string, context: CommandContext): Promise<CommandResult>;
+    getProvider(): CLIProvider;
+    listCommands(): CommandDefinition[];
+    listWorkflows(): CustomWorkflow[];
+    listModules(): CLIModule[];
+    listAll(): void;
+}
+export declare const moduleManager: ModuleManager;

package/lib/module-manager.js

@@ -74,15 +74,6 @@ class ModuleManager {
         this.workflows.set(workflow.name, workflow);
         this.provider.registerWorkflow(workflow);
     }
-    getRegisteredCommands() {
-        return Array.from(this.commands.values());
-    }
-    getRegisteredWorkflows() {
-        return Array.from(this.workflows.values());
-    }
-    getRegisteredModules() {
-        return Array.from(this.modules.values());
-    }
     async executeCommand(commandName, context) {
         const command = this.commands.get(commandName);
         if (!command) {
@@ -102,6 +93,9 @@ class ModuleManager {
     listWorkflows() {
         return Array.from(this.workflows.values());
     }
+    listModules() {
+        return Array.from(this.modules.values());
+    }
     listAll() {
         console.log('\n=== Registered Commands ===');
         for (const command of this.commands.values()){

package/lib/modules/app-module.d.ts

@@ -0,0 +1,2 @@
+import type { CLIModule } from '../types';
+export declare const appModule: CLIModule;

package/lib/modules/app-module.js

@@ -9,6 +9,23 @@ Object.defineProperty(exports, "appModule", {
     }
 });
 const _app = require("../app");
+const _options = require("../utils/options");
+const allPlatforms = [
+    'ios',
+    'android',
+    'harmony'
+];
+const emptyAppsData = {
+    ios: [],
+    android: [],
+    harmony: []
+};
+function isPlatform(value) {
+    return value === 'ios' || value === 'android' || value === 'harmony';
+}
+function normalizePlatformOption(value) {
+    return isPlatform(value) ? value : '';
+}
 const appModule = {
     name: 'app',
     version: '1.0.0',
@@ -23,12 +40,14 @@ const appModule = {
                     description: 'Create the app',
                     execute: async (context)=>{
                         console.log('Creating app in workflow');
-                        const { name, downloadUrl, platform } = context.options;
+                        const name = (0, _options.getStringOption)(context.options, 'name');
+                        const downloadUrl = (0, _options.getStringOption)(context.options, 'downloadUrl');
+                        const platform = normalizePlatformOption(context.options.platform);
                         await _app.appCommands.createApp({
                             options: {
-                                name: name || '',
-                                downloadUrl: downloadUrl || '',
-                                platform: platform || ''
+                                name,
+                                downloadUrl,
+                                platform
                             }
                         });
                         return {
@@ -41,15 +60,16 @@ const appModule = {
                     description: 'Select the created app',
                     execute: async (context, previousResult)=>{
                         console.log('Selecting app in workflow');
-                        const { platform } = context.options;
+                        const state = (0, _options.toObjectState)(previousResult, {});
+                        const platform = normalizePlatformOption(context.options.platform);
                         await _app.appCommands.selectApp({
                             args: [],
                             options: {
-                                platform: platform || ''
+                                platform
                             }
                         });
                         return {
-                            ...previousResult,
+                            ...state,
                             appSelected: true
                         };
                     }
@@ -65,10 +85,10 @@ const appModule = {
                     description: 'List all apps',
                     execute: async (context)=>{
                         console.log('Listing all apps');
-                        const { platform } = context.options;
+                        const platform = normalizePlatformOption(context.options.platform);
                         await _app.appCommands.apps({
                             options: {
-                                platform: platform || ''
+                                platform
                             }
                         });
                         return {
@@ -81,15 +101,16 @@ const appModule = {
                     description: 'Select target app for operations',
                     execute: async (context, previousResult)=>{
                         console.log('Selecting target app');
-                        const { platform } = context.options;
+                        const state = (0, _options.toObjectState)(previousResult, {});
+                        const platform = normalizePlatformOption(context.options.platform);
                         await _app.appCommands.selectApp({
                             args: [],
                             options: {
-                                platform: platform || ''
+                                platform
                             }
                         });
                         return {
-                            ...previousResult,
+                            ...state,
                             targetAppSelected: true
                         };
                     }
@@ -105,32 +126,35 @@ const appModule = {
                     description: 'Scan apps on all platforms',
                     execute: async (context)=>{
                         console.log('🔍 Scanning apps on all platforms...');
-                        const platforms = [
-                            'ios',
-                            'android',
-                            'harmony'
-                        ];
-                        const appsData = {};
-                        for (const platform of platforms){
+                        const appsData = {
+                            ios: [],
+                            android: [],
+                            harmony: []
+                        };
+                        for (const platform of allPlatforms){
                             console.log(`  Scanning ${platform} platform...`);
-                            // Simulate getting app list
-                            await new Promise((resolve)=>setTimeout(resolve, 500));
-                            const appCount = Math.floor(Math.random() * 5) + 1;
-                            const apps = Array.from({
-                                length: appCount
-                            }, (_, i)=>({
-                                    id: `${platform}_app_${i + 1}`,
-                                    name: `App ${i + 1}`,
-                                    platform,
-                                    version: `1.${i}.0`,
-                                    status: Math.random() > 0.2 ? 'active' : 'inactive'
-                                }));
-                            appsData[platform] = apps;
-                            console.log(`    ✅ Found ${appCount} apps`);
+                            try {
+                                const rawApps = await (0, _app.listApp)(platform);
+                                const apps = rawApps.map((app, index)=>{
+                                    var _app_id, _app_name, _app_platform, _app_version;
+                                    return {
+                                        id: String((_app_id = app.id) != null ? _app_id : `${platform}-app-${index + 1}`),
+                                        name: (_app_name = app.name) != null ? _app_name : `App ${index + 1}`,
+                                        platform: (_app_platform = app.platform) != null ? _app_platform : platform,
+                                        version: typeof app.version === 'string' ? (_app_version = app.version) != null ? _app_version : 'unknown' : 'unknown',
+                                        status: app.status === 'inactive' ? 'inactive' : 'active'
+                                    };
+                                });
+                                appsData[platform] = apps;
+                                console.log(`    ✅ Found ${apps.length} apps`);
+                            } catch (error) {
+                                appsData[platform] = [];
+                                console.warn(`    ⚠️ Failed to scan ${platform}:`, error);
+                            }
                         }
                         console.log('✅ Platform scanning completed');
                         return {
-                            platforms,
+                            platforms: allPlatforms,
                             appsData,
                             scanned: true
                         };
@@ -141,16 +165,23 @@ const appModule = {
                     description: 'Analyze app status',
                     execute: async (context, previousResult)=>{
                         console.log('📊 Analyzing app status...');
-                        const { appsData } = previousResult;
+                        const state = (0, _options.toObjectState)(previousResult, {});
+                        var _state_appsData;
+                        const appsData = (_state_appsData = state.appsData) != null ? _state_appsData : emptyAppsData;
                         const analysis = {
                             totalApps: 0,
                             activeApps: 0,
                             inactiveApps: 0,
-                            platformDistribution: {},
+                            platformDistribution: {
+                                ios: 0,
+                                android: 0,
+                                harmony: 0
+                            },
                             issues: []
                         };
-                        for (const [platform, apps] of Object.entries(appsData)){
-                            const platformApps = apps;
+                        for (const platform of allPlatforms){
+                            var _appsData_platform;
+                            const platformApps = (_appsData_platform = appsData[platform]) != null ? _appsData_platform : [];
                             analysis.totalApps += platformApps.length;
                             analysis.platformDistribution[platform] = platformApps.length;
                             for (const app of platformApps){
@@ -168,10 +199,12 @@ const appModule = {
                         console.log(`  Inactive apps: ${analysis.inactiveApps}`);
                         if (analysis.issues.length > 0) {
                             console.log('⚠️ Issues found:');
-                            analysis.issues.forEach((issue)=>console.log(`    - ${issue}`));
+                            for (const issue of analysis.issues){
+                                console.log(`    - ${issue}`);
+                            }
                         }
                         return {
-                            ...previousResult,
+                            ...state,
                             analysis
                         };
                     }
@@ -181,7 +214,16 @@ const appModule = {
                     description: 'Optimize app configuration',
                     execute: async (context, previousResult)=>{
                         console.log('⚡ Optimizing app configuration...');
-                        const { analysis } = previousResult;
+                        const state = (0, _options.toObjectState)(previousResult, {});
+                        const analysis = state.analysis;
+                        if (!analysis) {
+                            console.log('  No analysis data, skip optimization');
+                            return {
+                                ...state,
+                                optimizations: [],
+                                optimized: false
+                            };
+                        }
                         const optimizations = [];
                         if (analysis.inactiveApps > 0) {
                             console.log('  Handling inactive apps...');
@@ -191,15 +233,13 @@ const appModule = {
                             console.log('  Many apps detected, suggest grouping...');
                             optimizations.push('Create app groups');
                         }
-                        // Simulate optimization process
                         for (const optimization of optimizations){
                             console.log(`    Executing: ${optimization}...`);
-                            await new Promise((resolve)=>setTimeout(resolve, 800));
                             console.log(`    ✅ ${optimization} completed`);
                         }
                         console.log('✅ App optimization completed');
                         return {
-                            ...previousResult,
+                            ...state,
                             optimizations,
                             optimized: true
                         };

package/lib/modules/bundle-module.d.ts

@@ -0,0 +1,2 @@
+import type { CLIModule } from '../types';
+export declare const bundleModule: CLIModule;

package/lib/modules/bundle-module.js

@@ -23,7 +23,7 @@ const bundleModule = {
                     description: 'Detect base version',
                     execute: async (context)=>{
                         console.log('🔍 Detecting base version...');
-                        const { baseVersion, platform } = context.options;
+                        const { baseVersion } = context.options;
                         if (baseVersion) {
                             console.log(`✅ Using specified base version: ${baseVersion}`);
                             return {
@@ -31,9 +31,7 @@ const bundleModule = {
                                 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)}`;
+                        const autoDetectedVersion = 'latest';
                         console.log(`✅ Auto detected base version: ${autoDetectedVersion}`);
                         return {
                             baseVersion: autoDetectedVersion,
@@ -46,6 +44,7 @@ const bundleModule = {
                     description: 'Build current version',
                     execute: async (context, previousResult)=>{
                         console.log('🏗️ Building current version...');
+                        const state = previousResult && typeof previousResult === 'object' ? previousResult : {};
                         const { platform, dev = false, sourcemap = false, bundleName = 'index.bundlejs', entryFile = 'index.js', intermediaDir, taro = false, expo = false, rncli = false, hermes = false, output } = context.options;
                         console.log(`Building ${platform} platform...`);
                         console.log(`  Entry file: ${entryFile}`);
@@ -73,16 +72,16 @@ const bundleModule = {
                                 args: [],
                                 options: buildOptions
                             });
+                            const bundlePath = typeof output === 'string' ? output : '${tempDir}/output/${platform}.${time}.ppk';
                             const currentBuild = {
-                                version: `v${Math.floor(Math.random() * 3) + 2}.0.0`,
+                                version: typeof state.baseVersion === 'string' ? state.baseVersion : 'current',
                                 platform,
-                                bundlePath: `./build/current_${platform}.ppk`,
-                                size: Math.floor(Math.random() * 15) + 10,
+                                bundlePath,
                                 buildTime: Date.now()
                             };
                             console.log(`✅ Current version build completed: ${currentBuild.version}`);
                             return {
-                                ...previousResult,
+                                ...state,
                                 currentBuild
                             };
                         } catch (error) {

package/lib/modules/index.d.ts

@@ -0,0 +1,6 @@
+export { bundleModule } from './bundle-module';
+export { versionModule } from './version-module';
+export { appModule } from './app-module';
+export { userModule } from './user-module';
+export { packageModule } from './package-module';
+export declare const builtinModules: import("..").CLIModule[];

package/lib/modules/package-module.d.ts

@@ -0,0 +1,2 @@
+import type { CLIModule } from '../types';
+export declare const packageModule: CLIModule;

package/lib/modules/user-module.d.ts

@@ -0,0 +1,2 @@
+import type { CLIModule } from '../types';
+export declare const userModule: CLIModule;