react-native-update-cli 1.46.2 → 2.0.0

package/src/provider.ts

@@ -0,0 +1,341 @@
+import { getSession, loadSession } from './api';
+import { getPlatform, getSelectedApp } from './app';
+import type {
+  BundleOptions,
+  CLIProvider,
+  CommandContext,
+  CommandResult,
+  CustomWorkflow,
+  Platform,
+  PublishOptions,
+  Session,
+  UploadOptions,
+  Version,
+} from './types';
+
+export class CLIProviderImpl implements CLIProvider {
+  private workflows: Map<string, CustomWorkflow> = new Map();
+  private session?: Session;
+
+  constructor() {
+    this.init();
+  }
+
+  private async init() {
+    try {
+      await loadSession();
+      this.session = getSession();
+    } catch (error) {}
+  }
+
+  async bundle(options: BundleOptions): Promise<CommandResult> {
+    try {
+      const context: CommandContext = {
+        args: [],
+        options: {
+          dev: options.dev || false,
+          platform: options.platform,
+          bundleName: options.bundleName || 'index.bundlejs',
+          entryFile: options.entryFile || 'index.js',
+          output: options.output || '${tempDir}/output/${platform}.${time}.ppk',
+          sourcemap: options.sourcemap || false,
+          taro: options.taro || false,
+          expo: options.expo || false,
+          rncli: options.rncli || false,
+          disableHermes: options.disableHermes || false,
+        },
+      };
+
+      const { bundleCommands } = await import('./bundle');
+      await bundleCommands.bundle(context);
+
+      return {
+        success: true,
+        data: { message: 'Bundle created successfully' },
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error:
+          error instanceof Error
+            ? error.message
+            : 'Unknown error during bundling',
+      };
+    }
+  }
+
+  async publish(options: PublishOptions): Promise<CommandResult> {
+    try {
+      const context: CommandContext = {
+        args: [],
+        options: {
+          name: options.name,
+          description: options.description,
+          metaInfo: options.metaInfo,
+          packageId: options.packageId,
+          packageVersion: options.packageVersion,
+          minPackageVersion: options.minPackageVersion,
+          maxPackageVersion: options.maxPackageVersion,
+          packageVersionRange: options.packageVersionRange,
+          rollout: options.rollout,
+          dryRun: options.dryRun || false,
+        },
+      };
+
+      const { versionCommands } = await import('./versions');
+      await versionCommands.publish(context);
+
+      return {
+        success: true,
+        data: { message: 'Version published successfully' },
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error:
+          error instanceof Error
+            ? error.message
+            : 'Unknown error during publishing',
+      };
+    }
+  }
+
+  async upload(options: UploadOptions): Promise<CommandResult> {
+    try {
+      const platform = await this.getPlatform(options.platform);
+      const { appId } = await this.getSelectedApp(platform);
+
+      const filePath = options.filePath;
+      const fileType = filePath.split('.').pop()?.toLowerCase();
+
+      const context: CommandContext = {
+        args: [filePath],
+        options: { platform, appId },
+      };
+
+      const { packageCommands } = await import('./package');
+
+      switch (fileType) {
+        case 'ipa':
+          await packageCommands.uploadIpa(context);
+          break;
+        case 'apk':
+          await packageCommands.uploadApk(context);
+          break;
+        case 'app':
+          await packageCommands.uploadApp(context);
+          break;
+        default:
+          throw new Error(`Unsupported file type: ${fileType}`);
+      }
+
+      return {
+        success: true,
+        data: { message: 'File uploaded successfully' },
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error:
+          error instanceof Error
+            ? error.message
+            : 'Unknown error during upload',
+      };
+    }
+  }
+
+  async getSelectedApp(
+    platform?: Platform,
+  ): Promise<{ appId: string; platform: Platform }> {
+    const resolvedPlatform = await this.getPlatform(platform);
+    return getSelectedApp(resolvedPlatform);
+  }
+
+  async listApps(platform?: Platform): Promise<CommandResult> {
+    try {
+      const resolvedPlatform = await this.getPlatform(platform);
+      const { appCommands } = await import('./app');
+      await appCommands.apps({ options: { platform: resolvedPlatform } });
+
+      return {
+        success: true,
+        data: { message: 'Apps listed successfully' },
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error:
+          error instanceof Error ? error.message : 'Unknown error listing apps',
+      };
+    }
+  }
+
+  async createApp(name: string, platform: Platform): Promise<CommandResult> {
+    try {
+      const { appCommands } = await import('./app');
+      await appCommands.createApp({
+        options: {
+          name,
+          platform,
+          downloadUrl: '',
+        },
+      });
+
+      return {
+        success: true,
+        data: { message: 'App created successfully' },
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error:
+          error instanceof Error ? error.message : 'Unknown error creating app',
+      };
+    }
+  }
+
+  async listVersions(appId: string): Promise<CommandResult> {
+    try {
+      const context: CommandContext = {
+        args: [],
+        options: { appId },
+      };
+
+      const { versionCommands } = await import('./versions');
+      await versionCommands.versions(context);
+
+      return {
+        success: true,
+        data: { message: 'Versions listed successfully' },
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error:
+          error instanceof Error
+            ? error.message
+            : 'Unknown error listing versions',
+      };
+    }
+  }
+
+  async updateVersion(
+    appId: string,
+    versionId: string,
+    updates: Partial<Version>,
+  ): Promise<CommandResult> {
+    try {
+      const context: CommandContext = {
+        args: [versionId],
+        options: {
+          appId,
+          ...updates,
+        },
+      };
+
+      const { versionCommands } = await import('./versions');
+      await versionCommands.update(context);
+
+      return {
+        success: true,
+        data: { message: 'Version updated successfully' },
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error:
+          error instanceof Error
+            ? error.message
+            : 'Unknown error updating version',
+      };
+    }
+  }
+
+  async getPlatform(platform?: Platform): Promise<Platform> {
+    return getPlatform(platform);
+  }
+
+  async loadSession(): Promise<Session> {
+    await loadSession();
+    this.session = getSession();
+    if (!this.session) {
+      throw new Error('Failed to load session');
+    }
+    return this.session;
+  }
+
+  registerWorkflow(workflow: CustomWorkflow): void {
+    this.workflows.set(workflow.name, workflow);
+  }
+
+  async executeWorkflow(
+    workflowName: string,
+    context: CommandContext,
+  ): Promise<CommandResult> {
+    const workflow = this.workflows.get(workflowName);
+    if (!workflow) {
+      return {
+        success: false,
+        error: `Workflow '${workflowName}' not found`,
+      };
+    }
+
+    try {
+      let previousResult: any = null;
+      for (const step of workflow.steps) {
+        if (step.condition && !step.condition(context)) {
+          console.log(`Skipping step '${step.name}' due to condition`);
+          continue;
+        }
+
+        console.log(`Executing step '${step.name}'`);
+        previousResult = await step.execute(context, previousResult);
+      }
+
+      return {
+        success: true,
+        data: {
+          message: `Workflow '${workflowName}' completed successfully`,
+          result: previousResult,
+        },
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error:
+          error instanceof Error
+            ? error.message
+            : `Workflow '${workflowName}' failed`,
+      };
+    }
+  }
+
+  getRegisteredWorkflows(): string[] {
+    return Array.from(this.workflows.keys());
+  }
+
+  async listPackages(appId?: string): Promise<CommandResult> {
+    try {
+      const context: CommandContext = {
+        args: [],
+        options: appId ? { appId } : {},
+      };
+
+      const { listPackage } = await import('./package');
+      const result = await listPackage(appId || '');
+
+      return {
+        success: true,
+        data: result,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error:
+          error instanceof Error
+            ? error.message
+            : 'Unknown error listing packages',
+      };
+    }
+  }
+}

package/src/types.ts

@@ -12,6 +12,12 @@ export type Platform = 'ios' | 'android' | 'harmony';
 export interface Package {
   id: string;
   name: string;
+  version?: string;
+  status?: string;
+  appId?: string;
+  appKey?: string;
+  versionName?: any;
+  buildTime?: any;
 }
 
 export interface Version {
@@ -20,3 +26,122 @@ export interface Version {
   name: string;
   packages?: Package[];
 }
+
+export interface CommandContext {
+  args: string[];
+  options: Record<string, any>;
+  platform?: Platform;
+  appId?: string;
+  session?: Session;
+}
+
+export interface CommandResult {
+  success: boolean;
+  data?: any;
+  error?: string;
+}
+
+export interface CommandDefinition {
+  name: string;
+  description?: string;
+  handler: (context: CommandContext) => Promise<CommandResult>;
+  options?: Record<
+    string,
+    {
+      hasValue?: boolean;
+      default?: any;
+      description?: string;
+    }
+  >;
+}
+
+export interface BundleOptions {
+  dev?: boolean;
+  platform?: Platform;
+  bundleName?: string;
+  entryFile?: string;
+  output?: string;
+  sourcemap?: boolean;
+  taro?: boolean;
+  expo?: boolean;
+  rncli?: boolean;
+  disableHermes?: boolean;
+}
+
+export interface PublishOptions {
+  name?: string;
+  description?: string;
+  metaInfo?: string;
+  packageId?: string;
+  packageVersion?: string;
+  minPackageVersion?: string;
+  maxPackageVersion?: string;
+  packageVersionRange?: string;
+  rollout?: number;
+  dryRun?: boolean;
+}
+
+export interface UploadOptions {
+  platform?: Platform;
+  filePath: string;
+  appId?: string;
+}
+
+export interface WorkflowStep {
+  name: string;
+  description?: string;
+  execute: (context: CommandContext, previousResult?: any) => Promise<any>;
+  condition?: (context: CommandContext) => boolean;
+}
+
+export interface CustomWorkflow {
+  name: string;
+  description?: string;
+  steps: WorkflowStep[];
+  validate?: (context: CommandContext) => boolean;
+  options?: Record<
+    string,
+    {
+      hasValue?: boolean;
+      default?: any;
+      description?: string;
+    }
+  >;
+}
+
+export interface CLIProvider {
+  bundle: (options: BundleOptions) => Promise<CommandResult>;
+  publish: (options: PublishOptions) => Promise<CommandResult>;
+  upload: (options: UploadOptions) => Promise<CommandResult>;
+
+  createApp: (name: string, platform: Platform) => Promise<CommandResult>;
+  listApps: (platform?: Platform) => Promise<CommandResult>;
+  getSelectedApp: (
+    platform?: Platform,
+  ) => Promise<{ appId: string; platform: Platform }>;
+
+  listVersions: (appId: string) => Promise<CommandResult>;
+  updateVersion: (
+    appId: string,
+    versionId: string,
+    updates: Partial<Version>,
+  ) => Promise<CommandResult>;
+
+  getPlatform: (platform?: Platform) => Promise<Platform>;
+  loadSession: () => Promise<Session>;
+
+  registerWorkflow: (workflow: CustomWorkflow) => void;
+  executeWorkflow: (
+    workflowName: string,
+    context: CommandContext,
+  ) => Promise<CommandResult>;
+}
+
+export interface CLIModule {
+  name: string;
+  version: string;
+  commands?: CommandDefinition[];
+  workflows?: CustomWorkflow[];
+  init?: (provider: CLIProvider) => void;
+  cleanup?: () => void;
+}

package/src/user.ts

@@ -1,6 +1,7 @@
-import { question } from './utils';
-import { post, get, replaceSession, saveSession, closeSession } from './api';
 import crypto from 'crypto';
+import type { CommandContext } from 'types';
+import { closeSession, get, post, replaceSession, saveSession } from './api';
+import { question } from './utils';
 import { t } from './utils/i18n';
 
 function md5(str: string) {
@@ -19,7 +20,7 @@ export const userCommands = {
     await saveSession();
     console.log(t('welcomeMessage', { name: info.name }));
   },
-  logout: async () => {
+  logout: async (context: CommandContext) => {
     await closeSession();
     console.log(t('loggedOut'));
   },

package/src/utils/app-info-parser/apk.js

@@ -1,64 +1,74 @@
-const Zip = require('./zip')
-const { mapInfoResource, findApkIconPath, getBase64FromBuffer } = require('./utils')
-const ManifestName = /^androidmanifest\.xml$/
-const ResourceName = /^resources\.arsc$/
+const Zip = require('./zip');
+const {
+  mapInfoResource,
+  findApkIconPath,
+  getBase64FromBuffer,
+} = require('./utils');
+const ManifestName = /^androidmanifest\.xml$/;
+const ResourceName = /^resources\.arsc$/;
 
-const ManifestXmlParser = require('./xml-parser/manifest')
-const ResourceFinder = require('./resource-finder')
+const ManifestXmlParser = require('./xml-parser/manifest');
+const ResourceFinder = require('./resource-finder');
 
 class ApkParser extends Zip {
   /**
    * parser for parsing .apk file
    * @param {String | File | Blob} file // file's path in Node, instance of File or Blob in Browser
    */
-  constructor (file) {
-    super(file)
+  constructor(file) {
+    super(file);
     if (!(this instanceof ApkParser)) {
-      return new ApkParser(file)
+      return new ApkParser(file);
     }
   }
-  parse () {
+  parse() {
     return new Promise((resolve, reject) => {
-      this.getEntries([ManifestName, ResourceName]).then(buffers => {
-        if (!buffers[ManifestName]) {
-          throw new Error('AndroidManifest.xml can\'t be found.')
-        }
-        let apkInfo = this._parseManifest(buffers[ManifestName])
-        let resourceMap
-        if (!buffers[ResourceName]) {
-          resolve(apkInfo)
-        } else {
-          // parse resourceMap
-          resourceMap = this._parseResourceMap(buffers[ResourceName])
-          // update apkInfo with resourceMap
-          apkInfo = mapInfoResource(apkInfo, resourceMap)
-
-          // find icon path and parse icon
-          const iconPath = findApkIconPath(apkInfo)
-          if (iconPath) {
-            this.getEntry(iconPath).then(iconBuffer => {
-              apkInfo.icon = iconBuffer ? getBase64FromBuffer(iconBuffer) : null
-              resolve(apkInfo)
-            }).catch(e => {
-              apkInfo.icon = null
-              resolve(apkInfo)
-              console.warn('[Warning] failed to parse icon: ', e)
-            })
+      this.getEntries([ManifestName, ResourceName])
+        .then((buffers) => {
+          if (!buffers[ManifestName]) {
+            throw new Error("AndroidManifest.xml can't be found.");
+          }
+          let apkInfo = this._parseManifest(buffers[ManifestName]);
+          let resourceMap;
+          if (!buffers[ResourceName]) {
+            resolve(apkInfo);
           } else {
-            apkInfo.icon = null
-            resolve(apkInfo)
+            // parse resourceMap
+            resourceMap = this._parseResourceMap(buffers[ResourceName]);
+            // update apkInfo with resourceMap
+            apkInfo = mapInfoResource(apkInfo, resourceMap);
+
+            // find icon path and parse icon
+            const iconPath = findApkIconPath(apkInfo);
+            if (iconPath) {
+              this.getEntry(iconPath)
+                .then((iconBuffer) => {
+                  apkInfo.icon = iconBuffer
+                    ? getBase64FromBuffer(iconBuffer)
+                    : null;
+                  resolve(apkInfo);
+                })
+                .catch((e) => {
+                  apkInfo.icon = null;
+                  resolve(apkInfo);
+                  console.warn('[Warning] failed to parse icon: ', e);
+                });
+            } else {
+              apkInfo.icon = null;
+              resolve(apkInfo);
+            }
           }
-        }
-      }).catch(e => {
-        reject(e)
-      })
-    })
+        })
+        .catch((e) => {
+          reject(e);
+        });
+    });
   }
   /**
    * Parse manifest
    * @param {Buffer} buffer // manifest file's buffer
    */
-  _parseManifest (buffer) {
+  _parseManifest(buffer) {
     try {
       const parser = new ManifestXmlParser(buffer, {
         ignore: [
@@ -66,25 +76,25 @@ class ApkParser extends Zip {
           'application.service',
           'application.receiver',
           'application.provider',
-          'permission-group'
-        ]
-      })
-      return parser.parse()
+          'permission-group',
+        ],
+      });
+      return parser.parse();
     } catch (e) {
-      throw new Error('Parse AndroidManifest.xml error: ', e)
+      throw new Error('Parse AndroidManifest.xml error: ', e);
     }
   }
   /**
    * Parse resourceMap
    * @param {Buffer} buffer // resourceMap file's buffer
    */
-  _parseResourceMap (buffer) {
+  _parseResourceMap(buffer) {
     try {
-      return new ResourceFinder().processResourceTable(buffer)
+      return new ResourceFinder().processResourceTable(buffer);
     } catch (e) {
-      throw new Error('Parser resources.arsc error: ' + e)
+      throw new Error('Parser resources.arsc error: ' + e);
     }
   }
 }
 
-module.exports = ApkParser
+module.exports = ApkParser;

package/src/utils/app-info-parser/app.js

@@ -1,16 +1,16 @@
-const Zip = require('./zip')
+const Zip = require('./zip');
 
 class AppParser extends Zip {
   /**
    * parser for parsing .apk file
    * @param {String | File | Blob} file // file's path in Node, instance of File or Blob in Browser
    */
-  constructor (file) {
-    super(file)
+  constructor(file) {
+    super(file);
     if (!(this instanceof AppParser)) {
-      return new AppParser(file)
+      return new AppParser(file);
     }
   }
 }
 
-module.exports = AppParser
+module.exports = AppParser;