react-native-update-cli 2.8.4 → 2.9.0

package/lib/provider.d.ts

@@ -0,0 +1,26 @@
+import type { BundleOptions, CLIProvider, CommandContext, CommandResult, CustomWorkflow, Platform, PublishOptions, Session, UploadOptions, Version } from './types';
+export declare class CLIProviderImpl implements CLIProvider {
+    private workflows;
+    private session?;
+    private sessionInitPromise?;
+    private createContext;
+    private ensureInitialized;
+    private runMessageCommand;
+    private runDataCommand;
+    bundle(options: BundleOptions): Promise<CommandResult>;
+    publish(options: PublishOptions): Promise<CommandResult>;
+    upload(options: UploadOptions): Promise<CommandResult>;
+    getSelectedApp(platform?: Platform): Promise<{
+        appId: string;
+        platform: Platform;
+    }>;
+    listApps(platform?: Platform): Promise<CommandResult>;
+    createApp(name: string, platform: Platform): Promise<CommandResult>;
+    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>;
+    listPackages(appId?: string): Promise<CommandResult>;
+}

package/lib/provider.js

@@ -10,6 +10,8 @@ Object.defineProperty(exports, "CLIProviderImpl", {
 });
 const _api = require("./api");
 const _app = require("./app");
+const _commandresult = require("./utils/command-result");
+const _workflowrunner = require("./workflow-runner");
 function _getRequireWildcardCache(nodeInterop) {
     if (typeof WeakMap !== "function") return null;
     var cacheBabelInterop = new WeakMap();
@@ -52,129 +54,114 @@ function _interop_require_wildcard(obj, nodeInterop) {
     return newObj;
 }
 class CLIProviderImpl {
-    async init() {
-        try {
-            await (0, _api.loadSession)();
-            this.session = (0, _api.getSession)();
-        } catch (error) {}
+    createContext(options, args = []) {
+        return {
+            args,
+            options
+        };
+    }
+    async ensureInitialized() {
+        if (this.session) {
+            return;
+        }
+        if (!this.sessionInitPromise) {
+            this.sessionInitPromise = (async ()=>{
+                await (0, _api.loadSession)();
+                this.session = (0, _api.getSession)();
+            })().finally(()=>{
+                this.sessionInitPromise = undefined;
+            });
+        }
+        await this.sessionInitPromise;
+    }
+    runMessageCommand(task, fallbackError, successMessage, requireSession = true) {
+        return (0, _commandresult.runAsCommandResult)(async ()=>{
+            if (requireSession) {
+                await this.ensureInitialized();
+            }
+            await task();
+        }, fallbackError, ()=>({
+                message: successMessage
+            }));
+    }
+    runDataCommand(task, fallbackError, requireSession = true) {
+        return (0, _commandresult.runAsCommandResult)(async ()=>{
+            if (requireSession) {
+                await this.ensureInitialized();
+            }
+            return task();
+        }, fallbackError);
     }
     async bundle(options) {
-        try {
-            const context = {
-                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,
-                    hermes: options.hermes || false
-                }
-            };
+        return this.runMessageCommand(async ()=>{
+            const context = this.createContext({
+                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,
+                hermes: options.hermes || false
+            });
             const { bundleCommands } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("./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'
-            };
-        }
+        }, 'Unknown error during bundling', 'Bundle created successfully', false);
     }
     async publish(options) {
-        try {
-            const context = {
-                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
-                }
-            };
+        return this.runMessageCommand(async ()=>{
+            const context = this.createContext({
+                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 Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("./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'
-            };
-        }
+        }, 'Unknown error during publishing', 'Version published successfully');
     }
     async upload(options) {
-        try {
+        return this.runMessageCommand(async ()=>{
             var _filePath_split_pop;
             const platform = await this.getPlatform(options.platform);
             const { appId } = await this.getSelectedApp(platform);
             const filePath = options.filePath;
             const fileType = (_filePath_split_pop = filePath.split('.').pop()) == null ? void 0 : _filePath_split_pop.toLowerCase();
-            const context = {
-                args: [
-                    filePath
-                ],
-                options: {
-                    platform,
-                    appId,
-                    version: options.version
-                }
-            };
+            const context = this.createContext({
+                platform,
+                appId,
+                version: options.version
+            }, [
+                filePath
+            ]);
             const { packageCommands } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("./package")));
-            switch(fileType){
-                case 'ipa':
-                    await packageCommands.uploadIpa(context);
-                    break;
-                case 'apk':
-                    await packageCommands.uploadApk(context);
-                    break;
-                case 'aab':
-                    await packageCommands.uploadAab(context);
-                    break;
-                case 'app':
-                    await packageCommands.uploadApp(context);
-                    break;
-                default:
-                    throw new Error(`Unsupported file type: ${fileType}`);
+            const uploadHandlerMap = {
+                ipa: packageCommands.uploadIpa,
+                apk: packageCommands.uploadApk,
+                aab: packageCommands.uploadAab,
+                app: packageCommands.uploadApp
+            };
+            const uploadHandler = fileType && fileType in uploadHandlerMap ? uploadHandlerMap[fileType] : undefined;
+            if (!uploadHandler) {
+                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'
-            };
-        }
+            await uploadHandler(context);
+        }, 'Unknown error during upload', 'File uploaded successfully');
     }
     async getSelectedApp(platform) {
         const resolvedPlatform = await this.getPlatform(platform);
         return (0, _app.getSelectedApp)(resolvedPlatform);
     }
     async listApps(platform) {
-        try {
+        return this.runMessageCommand(async ()=>{
             const resolvedPlatform = await this.getPlatform(platform);
             const { appCommands } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("./app")));
             await appCommands.apps({
@@ -182,21 +169,10 @@ class CLIProviderImpl {
                     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'
-            };
-        }
+        }, 'Unknown error listing apps', 'Apps listed successfully');
     }
     async createApp(name, platform) {
-        try {
+        return this.runMessageCommand(async ()=>{
             const { appCommands } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("./app")));
             await appCommands.createApp({
                 options: {
@@ -205,74 +181,34 @@ class CLIProviderImpl {
                     downloadUrl: ''
                 }
             });
-            return {
-                success: true,
-                data: {
-                    message: 'App created successfully'
-                }
-            };
-        } catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Unknown error creating app'
-            };
-        }
+        }, 'Unknown error creating app', 'App created successfully');
     }
     async listVersions(appId) {
-        try {
-            const context = {
-                args: [],
-                options: {
-                    appId
-                }
-            };
+        return this.runMessageCommand(async ()=>{
+            const context = this.createContext({
+                appId
+            });
             const { versionCommands } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("./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'
-            };
-        }
+        }, 'Unknown error listing versions', 'Versions listed successfully');
     }
     async updateVersion(appId, versionId, updates) {
-        try {
-            const context = {
-                args: [
-                    versionId
-                ],
-                options: {
-                    appId,
-                    ...updates
-                }
-            };
+        return this.runMessageCommand(async ()=>{
+            const context = this.createContext({
+                appId,
+                ...updates
+            }, [
+                versionId
+            ]);
             const { versionCommands } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("./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'
-            };
-        }
+        }, 'Unknown error updating version', 'Version updated successfully');
     }
     async getPlatform(platform) {
         return (0, _app.getPlatform)(platform);
     }
     async loadSession() {
-        await (0, _api.loadSession)();
-        this.session = (0, _api.getSession)();
+        await this.ensureInitialized();
         if (!this.session) {
             throw new Error('Failed to load session');
         }
@@ -282,63 +218,25 @@ class CLIProviderImpl {
         this.workflows.set(workflow.name, workflow);
     }
     async executeWorkflow(workflowName, context) {
-        const workflow = this.workflows.get(workflowName);
-        if (!workflow) {
-            return {
-                success: false,
-                error: `Workflow '${workflowName}' not found`
-            };
-        }
-        try {
-            let previousResult = 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 this.runDataCommand(async ()=>{
+            const workflow = this.workflows.get(workflowName);
+            if (!workflow) {
+                throw new Error(`Workflow '${workflowName}' not found`);
             }
+            const result = await (0, _workflowrunner.runWorkflow)(workflowName, workflow, context);
             return {
-                success: true,
-                data: {
-                    message: `Workflow '${workflowName}' completed successfully`,
-                    result: previousResult
-                }
+                message: `Workflow '${workflowName}' completed successfully`,
+                result
             };
-        } catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : `Workflow '${workflowName}' failed`
-            };
-        }
-    }
-    getRegisteredWorkflows() {
-        return Array.from(this.workflows.keys());
+        }, `Workflow '${workflowName}' failed`);
     }
     async listPackages(appId) {
-        try {
-            const context = {
-                args: [],
-                options: appId ? {
-                    appId
-                } : {}
-            };
+        return this.runDataCommand(async ()=>{
             const { listPackage } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("./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'
-            };
-        }
+            return listPackage(appId || '');
+        }, 'Unknown error listing packages');
     }
     constructor(){
         this.workflows = new Map();
-        this.init();
     }
 }

package/lib/types.d.ts

@@ -0,0 +1,120 @@
+declare global {
+    var NO_INTERACTIVE: boolean;
+    var USE_ACC_OSS: boolean;
+}
+export interface Session {
+    token: string;
+}
+export type Platform = 'ios' | 'android' | 'harmony';
+export interface Package {
+    id: string;
+    name: string;
+    version?: string;
+    status?: string;
+    appId?: string;
+    appKey?: string;
+    versionName?: string | number | null;
+    buildTime?: string | number | null;
+    deps?: Record<string, string> | string | null;
+}
+export interface Version {
+    id: string;
+    hash: string;
+    name: string;
+    packages?: Package[];
+    deps?: Record<string, string> | string | null;
+}
+export interface CommandContext<TOptions extends Record<string, unknown> = Record<string, unknown>> {
+    args: string[];
+    options: TOptions;
+    platform?: Platform;
+    appId?: string;
+    session?: Session;
+}
+export interface CommandResult {
+    success: boolean;
+    data?: unknown;
+    error?: string;
+}
+export interface CommandDefinition {
+    name: string;
+    description?: string;
+    handler: (context: CommandContext) => Promise<CommandResult>;
+    options?: Record<string, {
+        hasValue?: boolean;
+        default?: unknown;
+        description?: string;
+    }>;
+}
+export interface BundleOptions {
+    dev?: boolean;
+    platform?: Platform;
+    bundleName?: string;
+    entryFile?: string;
+    output?: string;
+    sourcemap?: boolean;
+    taro?: boolean;
+    expo?: boolean;
+    rncli?: boolean;
+    hermes?: 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;
+    version?: string;
+}
+export interface WorkflowStep {
+    name: string;
+    description?: string;
+    execute: (context: CommandContext, previousResult?: unknown) => Promise<unknown>;
+    condition?: (context: CommandContext) => boolean;
+}
+export interface CustomWorkflow {
+    name: string;
+    description?: string;
+    steps: WorkflowStep[];
+    validate?: (context: CommandContext) => boolean;
+    options?: Record<string, {
+        hasValue?: boolean;
+        default?: unknown;
+        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/lib/user.d.ts

@@ -0,0 +1,8 @@
+import type { CommandContext } from 'types';
+export declare const userCommands: {
+    login: ({ args }: {
+        args: string[];
+    }) => Promise<void>;
+    logout: (context: CommandContext) => Promise<void>;
+    me: () => Promise<void>;
+};

package/lib/utils/add-gitignore.d.ts

@@ -0,0 +1 @@
+export declare function addGitIgnore(): void;

package/lib/utils/app-info-parser/aab.d.ts

@@ -0,0 +1,22 @@
+import { Zip } from './zip';
+export declare class AabParser extends Zip {
+    extractApk(outputPath: string, { includeAllSplits, splits, }: {
+        includeAllSplits?: boolean;
+        splits?: string[] | null;
+    }): Promise<void>;
+    /**
+     * 解析 AAB 文件信息（类似 APK parser 的 parse 方法）
+     * 注意：AAB 中的 AndroidManifest.xml 在 base/manifest/AndroidManifest.xml
+     */
+    parse(): Promise<Record<string, any>>;
+    /**
+     * Parse manifest
+     * @param {Buffer} buffer // manifest file's buffer
+     */
+    private _parseManifest;
+    /**
+     * Parse resourceMap
+     * @param {Buffer} buffer // resourceMap file's buffer
+     */
+    private _parseResourceMap;
+}

package/lib/utils/app-info-parser/aab.js

@@ -222,9 +222,5 @@ class AabParser extends _zip.Zip {
             }));
         }
     }
-    constructor(file){
-        super(file);
-        this.file = file;
-    }
 }
 const escapeRegExp = (value)=>value.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&');

package/lib/utils/app-info-parser/apk.d.ts

@@ -0,0 +1,14 @@
+import { Zip } from './zip';
+export declare class ApkParser extends Zip {
+    parse(): Promise<any>;
+    /**
+     * Parse manifest
+     * @param {Buffer} buffer // manifest file's buffer
+     */
+    private _parseManifest;
+    /**
+     * Parse resourceMap
+     * @param {Buffer} buffer // resourceMap file's buffer
+     */
+    private _parseResourceMap;
+}

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

@@ -16,27 +16,29 @@ const ManifestName = /^androidmanifest\.xml$/;
 const ResourceName = /^resources\.arsc$/;
 class ApkParser extends _zip.Zip {
     parse() {
+        const manifestKey = ManifestName.toString();
+        const resourceKey = ResourceName.toString();
         return new Promise((resolve, reject)=>{
             this.getEntries([
                 ManifestName,
                 ResourceName
             ]).then((buffers)=>{
-                const manifestBuffer = buffers[ManifestName];
+                const manifestBuffer = buffers[manifestKey];
                 if (!manifestBuffer) {
                     throw new Error("AndroidManifest.xml can't be found.");
                 }
                 let apkInfo;
                 let resourceMap;
                 apkInfo = this._parseManifest(manifestBuffer);
-                if (!buffers[ResourceName]) {
+                if (!buffers[resourceKey]) {
                     resolve(apkInfo);
                 } else {
-                    resourceMap = this._parseResourceMap(buffers[ResourceName]);
+                    resourceMap = this._parseResourceMap(buffers[resourceKey]);
                     apkInfo = (0, _utils.mapInfoResource)(apkInfo, resourceMap);
                     const iconPath = (0, _utils.findApkIconPath)(apkInfo);
                     if (iconPath) {
                         this.getEntry(iconPath).then((iconBuffer)=>{
-                            apkInfo.icon = iconBuffer ? (0, _utils.getBase64FromBuffer)(iconBuffer) : null;
+                            apkInfo.icon = Buffer.isBuffer(iconBuffer) ? (0, _utils.getBase64FromBuffer)(iconBuffer) : null;
                             resolve(apkInfo);
                         }).catch((e)=>{
                             apkInfo.icon = null;

package/lib/utils/app-info-parser/app.d.ts

@@ -0,0 +1,4 @@
+import { Zip } from './zip';
+export declare class AppParser extends Zip {
+    parse(): Promise<Record<string, never>>;
+}

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

@@ -10,4 +10,7 @@ Object.defineProperty(exports, "AppParser", {
 });
 const _zip = require("./zip");
 class AppParser extends _zip.Zip {
+    async parse() {
+        return {};
+    }
 }