react-native-update-cli 1.46.1 → 2.0.0

package/lib/utils/git.js

@@ -8,9 +8,9 @@ Object.defineProperty(exports, "getCommitInfo", {
         return getCommitInfo;
     }
 });
-const _isomorphicgit = /*#__PURE__*/ _interop_require_default(require("isomorphic-git"));
 const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
 const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _isomorphicgit = /*#__PURE__*/ _interop_require_default(require("isomorphic-git"));
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj

package/lib/utils/i18n.js

@@ -33,4 +33,6 @@ _i18next.default.init({
         escapeValue: false
     }
 });
-const t = _i18next.default.t;
+function t(key, options) {
+    return _i18next.default.t(key, options);
+}

package/lib/utils/index.js

@@ -34,14 +34,14 @@ _export(exports, {
         return translateOptions;
     }
 });
-const _fsextra = /*#__PURE__*/ _interop_require_default(require("fs-extra"));
 const _os = /*#__PURE__*/ _interop_require_default(require("os"));
 const _path = /*#__PURE__*/ _interop_require_default(require("path"));
-const _packagejson = /*#__PURE__*/ _interop_require_default(require("../../package.json"));
-const _appinfoparser = /*#__PURE__*/ _interop_require_default(require("./app-info-parser"));
-const _compareversions = require("compare-versions");
 const _chalk = /*#__PURE__*/ _interop_require_default(require("chalk"));
+const _compareversions = require("compare-versions");
+const _fsextra = /*#__PURE__*/ _interop_require_default(require("fs-extra"));
+const _packagejson = /*#__PURE__*/ _interop_require_default(require("../../package.json"));
 const _latestversion = /*#__PURE__*/ _interop_require_default(require("../utils/latest-version"));
+const _appinfoparser = /*#__PURE__*/ _interop_require_default(require("./app-info-parser"));
 const _checkplugin = require("./check-plugin");
 const _read = require("read");
 const _constants = require("./constants");

package/lib/utils/latest-version/cli.js

@@ -2,12 +2,12 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-const _safe = require("@colors/colors/safe");
 const _fs = require("fs");
 const _path = require("path");
-const _ = /*#__PURE__*/ _interop_require_default(require("."));
-const _major = /*#__PURE__*/ _interop_require_default(require("semver/functions/major"));
+const _safe = require("@colors/colors/safe");
 const _diff = /*#__PURE__*/ _interop_require_default(require("semver/functions/diff"));
+const _major = /*#__PURE__*/ _interop_require_default(require("semver/functions/major"));
+const _ = /*#__PURE__*/ _interop_require_default(require("."));
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj

package/lib/utils/latest-version/index.js

@@ -17,14 +17,14 @@ _export(exports, {
     }
 });
 const _fs = require("fs");
-const _path = require("path");
-const _globaldirs = require("global-dirs");
 const _os = require("os");
+const _path = require("path");
 const _url = require("url");
-const _registryurl = /*#__PURE__*/ _interop_require_default(require("registry-auth-token/registry-url"));
+const _globaldirs = require("global-dirs");
 const _registryauthtoken = /*#__PURE__*/ _interop_require_default(require("registry-auth-token"));
-const _maxsatisfying = /*#__PURE__*/ _interop_require_default(require("semver/ranges/max-satisfying"));
+const _registryurl = /*#__PURE__*/ _interop_require_default(require("registry-auth-token/registry-url"));
 const _gt = /*#__PURE__*/ _interop_require_default(require("semver/functions/gt"));
+const _maxsatisfying = /*#__PURE__*/ _interop_require_default(require("semver/ranges/max-satisfying"));
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj

package/lib/versions.js

@@ -19,12 +19,12 @@ _export(exports, {
 const _api = require("./api");
 const _utils = require("./utils");
 const _i18n = require("./utils/i18n");
+const _chalk = /*#__PURE__*/ _interop_require_default(require("chalk"));
+const _compareversions = require("compare-versions");
 const _app = require("./app");
 const _package = require("./package");
 const _depversions = require("./utils/dep-versions");
 const _git = require("./utils/git");
-const _compareversions = require("compare-versions");
-const _chalk = /*#__PURE__*/ _interop_require_default(require("chalk"));
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-update-cli",
-  "version": "1.46.1",
+  "version": "2.0.0",
   "description": "command line tool for react-native-update (remote updates for react native)",
   "main": "index.js",
   "bin": {
@@ -19,7 +19,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/reactnativecn/react-native-pushy-cli.git"
+    "url": "git+https://github.com/reactnativecn/react-native-update-cli.git"
   },
   "keywords": [
     "react-native",
@@ -31,9 +31,9 @@
   "author": "reactnativecn",
   "license": "BSD-3-Clause",
   "bugs": {
-    "url": "https://github.com/reactnativecn/react-native-pushy/issues"
+    "url": "https://github.com/reactnativecn/react-native-update-cli/issues"
   },
-  "homepage": "https://github.com/reactnativecn/react-native-pushy/tree/master/react-native-pushy-cli",
+  "homepage": "https://github.com/reactnativecn/react-native-update-cli",
   "dependencies": {
     "@colors/colors": "^1.6.0",
     "bplist-parser": "^0.3.2",

package/src/api.ts

@@ -1,18 +1,18 @@
-import fetch from 'node-fetch';
 import fs from 'fs';
-import util from 'util';
 import path from 'path';
+import util from 'util';
+import filesizeParser from 'filesize-parser';
+import FormData from 'form-data';
+import fetch from 'node-fetch';
 import ProgressBar from 'progress';
-import packageJson from '../package.json';
 import tcpp from 'tcp-ping';
-import filesizeParser from 'filesize-parser';
+import packageJson from '../package.json';
+import type { Package, Session } from './types';
 import {
-  pricingPageUrl,
   credentialFile,
   defaultEndpoint,
+  pricingPageUrl,
 } from './utils/constants';
-import type { Session, Package } from 'types';
-import FormData from 'form-data';
 import { t } from './utils/i18n';
 
 const tcpPing = util.promisify(tcpp.ping);

package/src/app.ts

@@ -1,8 +1,8 @@
-import { question } from './utils';
 import fs from 'fs';
 import Table from 'tty-table';
+import { question } from './utils';
 
-import { post, get, doDelete } from './api';
+import { doDelete, get, post } from './api';
 import type { Platform } from './types';
 import { t } from './utils/i18n';
 

package/src/bundle.ts

@@ -1,24 +1,24 @@
+import { spawn, spawnSync } from 'child_process';
 import path from 'path';
-import { translateOptions } from './utils';
+import { satisfies } from 'compare-versions';
 import * as fs from 'fs-extra';
-import { ZipFile as YazlZipFile } from 'yazl';
 import {
   type Entry,
-  open as openZipFile,
   type ZipFile as YauzlZipFile,
+  open as openZipFile,
 } from 'yauzl';
-import { question, checkPlugins } from './utils';
+import { ZipFile as YazlZipFile } from 'yazl';
 import { getPlatform } from './app';
-import { spawn, spawnSync } from 'child_process';
-import { satisfies } from 'compare-versions';
+import { translateOptions } from './utils';
+import { checkPlugins, question } from './utils';
 const g2js = require('gradle-to-js/lib/parser');
 import os from 'os';
 const properties = require('properties');
+import { addGitIgnore } from './utils/add-gitignore';
+import { checkLockFiles } from './utils/check-lockfile';
+import { tempDir } from './utils/constants';
 import { depVersions } from './utils/dep-versions';
 import { t } from './utils/i18n';
-import { tempDir } from './utils/constants';
-import { checkLockFiles } from './utils/check-lockfile';
-import { addGitIgnore } from './utils/add-gitignore';
 import { versionCommands } from './versions';
 
 type Diff = (oldSource?: Buffer, newSource?: Buffer) => Buffer;
@@ -288,9 +288,22 @@ async function copyHarmonyBundle(outputFolder: string) {
     }
     await fs.remove(path.join(harmonyRawPath, 'update.json'));
     await fs.copy('update.json', path.join(harmonyRawPath, 'update.json'));
-
     await fs.ensureDir(outputFolder);
-    await fs.copy(harmonyRawPath, outputFolder);
+
+    const files = await fs.readdir(harmonyRawPath);
+    for (const file of files) {
+      if (file !== 'update.json' && file !== 'meta.json') {
+        const sourcePath = path.join(harmonyRawPath, file);
+        const destPath = path.join(outputFolder, file);
+        const stat = await fs.stat(sourcePath);
+
+        if (stat.isFile()) {
+          await fs.copy(sourcePath, destPath);
+        } else if (stat.isDirectory()) {
+          await fs.copy(sourcePath, destPath);
+        }
+      }
+    }
   } catch (error: any) {
     console.error(t('copyHarmonyBundleError', { error }));
     throw new Error(t('copyFileFailed', { error: error.message }));
@@ -521,7 +534,7 @@ async function pack(dir: string, output: string) {
 
     zipfile.outputStream.on('error', (err: any) => reject(err));
     zipfile.outputStream.pipe(fs.createWriteStream(output)).on('close', () => {
-      resolve();
+      resolve(void 0);
     });
     zipfile.end();
   });
@@ -535,17 +548,14 @@ export function readEntry(
   const buffers: Buffer[] = [];
   return new Promise((resolve, reject) => {
     zipFile.openReadStream(entry, (err, stream) => {
-      stream.pipe({
-        write(chunk: Buffer) {
-          buffers.push(chunk);
-        },
-        end() {
-          resolve(Buffer.concat(buffers));
-        },
-        prependListener() {},
-        on() {},
-        once() {},
-        emit() {},
+      stream.on('data', (chunk: Buffer) => {
+        buffers.push(chunk);
+      });
+      stream.on('end', () => {
+        resolve(Buffer.concat(buffers));
+      });
+      stream.on('error', (err) => {
+        reject(err);
       });
     });
   });
@@ -595,7 +605,7 @@ async function diffFromPPK(origin: string, next: string, output: string) {
       throw err;
     });
     zipfile.outputStream.pipe(fs.createWriteStream(output)).on('close', () => {
-      resolve();
+      resolve(void 0);
     });
   });
 
@@ -672,7 +682,7 @@ async function diffFromPPK(origin: string, next: string, output: string) {
           zipfile.addReadStream(readStream, entry.fileName);
           readStream.on('end', () => {
             //console.log('add finished');
-            resolve();
+            resolve(void 0);
           });
         });
       });
@@ -745,7 +755,7 @@ async function diffFromPackage(
       throw err;
     });
     zipfile.outputStream.pipe(fs.createWriteStream(output)).on('close', () => {
-      resolve();
+      resolve(void 0);
     });
   });
 
@@ -793,7 +803,7 @@ async function diffFromPackage(
           zipfile.addReadStream(readStream, entry.fileName);
           readStream.on('end', () => {
             //console.log('add finished');
-            resolve();
+            resolve(void 0);
           });
         });
       });
@@ -845,7 +855,7 @@ export async function enumZipEntries(
                   if (err) return rej(err);
                   const writeStream = fs.createWriteStream(tempZipPath);
                   readStream.pipe(writeStream);
-                  writeStream.on('finish', res);
+                  writeStream.on('finish', () => res(void 0));
                   writeStream.on('error', rej);
                 });
               });
@@ -963,11 +973,11 @@ export const bundleCommands = {
       outputFolder: intermediaDir,
       platform,
       sourcemapOutput: sourcemap || sourcemapPlugin ? sourcemapOutput : '',
-      disableHermes,
+      disableHermes: !!disableHermes,
       cli: {
-        taro,
-        expo,
-        rncli,
+        taro: !!taro,
+        expo: !!expo,
+        rncli: !!rncli,
       },
     });
 
@@ -1072,6 +1082,21 @@ export const bundleCommands = {
     console.log(`${realOutput} generated.`);
   },
 
+  async diffFromApp({ args, options }) {
+    const { origin, next, realOutput } = diffArgsCheck(
+      args,
+      options,
+      'diffFromApp',
+    );
+    await diffFromPackage(
+      origin,
+      next,
+      realOutput,
+      'resources/rawfile/bundle.harmony.js',
+    );
+    console.log(`${realOutput} generated.`);
+  },
+
   async hdiffFromApp({ args, options }) {
     const { origin, next, realOutput } = diffArgsCheck(
       args,

package/src/exports.ts

@@ -0,0 +1,30 @@
+export { moduleManager } from './module-manager';
+export { CLIProviderImpl } from './provider';
+
+export type {
+  CLIProvider,
+  CLIModule,
+  CommandDefinition,
+  CustomWorkflow,
+  WorkflowStep,
+  CommandContext,
+  CommandResult,
+  BundleOptions,
+  PublishOptions,
+  UploadOptions,
+  Platform,
+  Session,
+  Version,
+  Package,
+} from './types';
+
+export { builtinModules } from './modules';
+export { bundleModule } from './modules/bundle-module';
+export { versionModule } from './modules/version-module';
+export { appModule } from './modules/app-module';
+export { userModule } from './modules/user-module';
+export { packageModule } from './modules/package-module';
+
+export { loadSession, getSession } from './api';
+export { getPlatform, getSelectedApp } from './app';
+export { question, saveToLocal } from './utils';

package/src/index.ts

@@ -1,25 +1,76 @@
 #!/usr/bin/env node
 
 import { loadSession } from './api';
+import { appCommands } from './app';
+import { bundleCommands } from './bundle';
+import { moduleManager } from './module-manager';
+import { builtinModules } from './modules';
+import { packageCommands } from './package';
+import type { CommandContext } from './types';
+import { userCommands } from './user';
 import { printVersionCommand } from './utils';
 import { t } from './utils/i18n';
-import { bundleCommands } from './bundle';
 import { versionCommands } from './versions';
-import { userCommands } from './user';
-import { appCommands } from './app';
-import { packageCommands } from './package';
+
+function registerBuiltinModules() {
+  for (const module of builtinModules) {
+    try {
+      moduleManager.registerModule(module);
+    } catch (error) {
+      console.error(`Failed to register module ${module.name}:`, error);
+    }
+  }
+}
 
 function printUsage() {
-  // const commandName = args[0];
-  // TODO: print usage of commandName, or print global usage.
+  console.log('React Native Update CLI');
+  console.log('');
+  console.log('Traditional commands:');
+  
+  const legacyCommands = {
+    ...userCommands,
+    ...bundleCommands,
+    ...appCommands,
+    ...packageCommands,
+    ...versionCommands,
+  };
+  
+  for (const [name, handler] of Object.entries(legacyCommands)) {
+    console.log(`  ${name}: Legacy command`);
+  }
 
+  console.log('');
+  console.log('Modular commands:');
+  const commands = moduleManager.getRegisteredCommands();
+  for (const command of commands) {
+    console.log(
+      `  ${command.name}: ${command.description || 'No description'}`,
+    );
+  }
+
+  console.log('');
+  console.log('Available workflows:');
+  const workflows = moduleManager.getRegisteredWorkflows();
+  for (const workflow of workflows) {
+    console.log(
+      `  ${workflow.name}: ${workflow.description || 'No description'}`,
+    );
+  }
+
+  console.log('');
+  console.log('Special commands:');
+  console.log('  list: List all available commands and workflows');
+  console.log('  workflow <name>: Execute a specific workflow');
+  console.log('  help: Show this help message');
+  
+  console.log('');
   console.log(
     'Visit `https://github.com/reactnativecn/react-native-update` for document.',
   );
   process.exit(1);
 }
 
-const commands = {
+const legacyCommands = {
   ...userCommands,
   ...bundleCommands,
   ...appCommands,
@@ -34,20 +85,71 @@ async function run() {
     process.exit();
   }
 
+  // Register builtin modules for modular functionality
+  registerBuiltinModules();
+
   const argv = require('cli-arguments').parse(require('../cli.json'));
   global.NO_INTERACTIVE = argv.options['no-interactive'];
   global.USE_ACC_OSS = argv.options.acc;
 
-  loadSession()
-    .then(() => commands[argv.command](argv))
-    .catch((err) => {
-      if (err.status === 401) {
-        console.log(t('loginFirst'));
-        return;
+  const context: CommandContext = {
+    args: argv.args || [],
+    options: argv.options || {},
+  };
+
+  try {
+    await loadSession();
+    context.session = require('./api').getSession();
+
+    // Handle special modular commands first
+    if (argv.command === 'help') {
+      printUsage();
+    } else if (argv.command === 'list') {
+      moduleManager.listAll();
+    } else if (argv.command === 'workflow') {
+      const workflowName = argv.args[0];
+      if (!workflowName) {
+        console.error('Workflow name is required');
+        process.exit(1);
+      }
+      const result = await moduleManager.executeWorkflow(workflowName, context);
+      if (!result.success) {
+        console.error('Workflow execution failed:', result.error);
+        process.exit(1);
+      }
+      console.log('Workflow completed successfully:', result.data);
+    } 
+    // Try legacy commands first for backward compatibility
+    else if (legacyCommands[argv.command]) {
+      await legacyCommands[argv.command](argv);
+    }
+    // Fall back to modular commands
+    else {
+      const result = await moduleManager.executeCommand(argv.command, context);
+      if (!result.success) {
+        console.error('Command execution failed:', result.error);
+        process.exit(1);
       }
-      console.error(err.stack);
-      process.exit(-1);
-    });
+      console.log('Command completed successfully:', result.data);
+    }
+  } catch (err: any) {
+    if (err.status === 401) {
+      console.log(t('loginFirst'));
+      return;
+    }
+    console.error(err.stack);
+    process.exit(-1);
+  }
 }
 
+export { moduleManager };
+export { CLIProviderImpl } from './provider';
+export type {
+  CLIProvider,
+  CLIModule,
+  CommandDefinition,
+  CustomWorkflow,
+  WorkflowStep,
+} from './types';
+
 run();

package/src/module-manager.ts

@@ -0,0 +1,149 @@
+import { CLIProviderImpl } from './provider';
+import type {
+  CLIModule,
+  CLIProvider,
+  CommandDefinition,
+  CustomWorkflow,
+} from './types';
+
+export class ModuleManager {
+  private modules: Map<string, CLIModule> = new Map();
+  private provider: CLIProvider;
+  private commands: Map<string, CommandDefinition> = new Map();
+  private workflows: Map<string, CustomWorkflow> = new Map();
+
+  constructor() {
+    this.provider = new CLIProviderImpl();
+  }
+
+  registerModule(module: CLIModule): void {
+    if (this.modules.has(module.name)) {
+      throw new Error(`Module '${module.name}' is already registered`);
+    }
+
+    this.modules.set(module.name, module);
+
+    if (module.commands) {
+      for (const command of module.commands) {
+        this.registerCommand(command);
+      }
+    }
+
+    if (module.workflows) {
+      for (const workflow of module.workflows) {
+        this.registerWorkflow(workflow);
+      }
+    }
+
+    if (module.init) {
+      module.init(this.provider);
+    }
+
+    console.log(
+      `Module '${module.name}' (v${module.version}) registered successfully`,
+    );
+  }
+
+  unregisterModule(moduleName: string): void {
+    const module = this.modules.get(moduleName);
+    if (!module) {
+      throw new Error(`Module '${moduleName}' is not registered`);
+    }
+
+    if (module.commands) {
+      for (const command of module.commands) {
+        this.commands.delete(command.name);
+      }
+    }
+
+    if (module.workflows) {
+      for (const workflow of module.workflows) {
+        this.workflows.delete(workflow.name);
+      }
+    }
+
+    if (module.cleanup) {
+      module.cleanup();
+    }
+
+    this.modules.delete(moduleName);
+    console.log(`Module '${moduleName}' unregistered successfully`);
+  }
+
+  registerCommand(command: CommandDefinition): void {
+    if (this.commands.has(command.name)) {
+      throw new Error(`Command '${command.name}' is already registered`);
+    }
+    this.commands.set(command.name, command);
+  }
+
+  registerWorkflow(workflow: CustomWorkflow): void {
+    if (this.workflows.has(workflow.name)) {
+      throw new Error(`Workflow '${workflow.name}' is already registered`);
+    }
+    this.workflows.set(workflow.name, workflow);
+    this.provider.registerWorkflow(workflow);
+  }
+
+  getRegisteredCommands(): CommandDefinition[] {
+    return Array.from(this.commands.values());
+  }
+
+  getRegisteredWorkflows(): CustomWorkflow[] {
+    return Array.from(this.workflows.values());
+  }
+
+  getRegisteredModules(): CLIModule[] {
+    return Array.from(this.modules.values());
+  }
+
+  async executeCommand(commandName: string, context: any): Promise<any> {
+    const command = this.commands.get(commandName);
+    if (!command) {
+      throw new Error(`Command '${commandName}' not found`);
+    }
+
+    return await command.handler(context);
+  }
+
+  async executeWorkflow(workflowName: string, context: any): Promise<any> {
+    return await this.provider.executeWorkflow(workflowName, context);
+  }
+
+  getProvider(): CLIProvider {
+    return this.provider;
+  }
+
+  listCommands(): any[] {
+    return Array.from(this.commands.values());
+  }
+
+  listWorkflows(): CustomWorkflow[] {
+    return Array.from(this.workflows.values());
+  }
+
+  listAll(): void {
+    console.log('\n=== Registered Commands ===');
+    for (const command of this.commands.values()) {
+      console.log(
+        `  ${command.name}: ${command.description || 'No description'}`,
+      );
+    }
+
+    console.log('\n=== Registered Workflows ===');
+    for (const workflow of this.workflows.values()) {
+      console.log(
+        `  ${workflow.name}: ${workflow.description || 'No description'}`,
+      );
+    }
+
+    console.log('\n=== Registered Modules ===');
+    for (const module of this.modules.values()) {
+      console.log(
+        `  ${module.name} (v${module.version}): ${module.commands?.length || 0} commands, ${module.workflows?.length || 0} workflows`,
+      );
+    }
+  }
+}
+
+export const moduleManager = new ModuleManager();