rn-update-cli 1.0.0

package/lib/provider.js

@@ -0,0 +1,244 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLIProviderImpl = void 0;
+/**
+ * [INPUT]: 依赖 CLI 命令编排器、会话初始化与公共 PublishOptions
+ * [OUTPUT]: 对外提供 CLIProviderImpl 的 bundle/publish/upload 等程序化命令入口，并完整传递独立投放参数
+ * [POS]: CLI 公共 SDK 边界；把调用方参数转换为命令上下文，不直接承担 HTTP 或发布事务
+ */
+const api_1 = require("./api");
+const app_1 = require("./app");
+const command_result_1 = require("./utils/command-result");
+const i18n_1 = require("./utils/i18n");
+const DEFAULT_BUNDLE_OUTPUT = '$' + '{tempDir}/output/$' + '{platform}.$' + '{time}.ppk';
+class CLIProviderImpl {
+    session;
+    sessionInitPromise;
+    createContext(options, args = []) {
+        return { args, options };
+    }
+    async ensureInitialized() {
+        if (this.session) {
+            return;
+        }
+        if (!this.sessionInitPromise) {
+            this.sessionInitPromise = (async () => {
+                await (0, api_1.loadSession)();
+                this.session = (0, api_1.getSession)();
+            })().finally(() => {
+                this.sessionInitPromise = undefined;
+            });
+        }
+        await this.sessionInitPromise;
+    }
+    runMessageCommand(task, fallbackError, successMessage, requireSession = true) {
+        return (0, command_result_1.runAsCommandResult)(async () => {
+            if (requireSession) {
+                await this.ensureInitialized();
+            }
+            await task();
+        }, fallbackError, () => ({ message: successMessage }));
+    }
+    runDataCommand(task, fallbackError, requireSession = true) {
+        return (0, command_result_1.runAsCommandResult)(async () => {
+            if (requireSession) {
+                await this.ensureInitialized();
+            }
+            return task();
+        }, fallbackError);
+    }
+    async bundle(options) {
+        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 || DEFAULT_BUNDLE_OUTPUT,
+                'no-interactive': true,
+                // on by default like the CLI: archived with the version for symbolicate
+                sourcemap: options.sourcemap ?? true,
+                taro: options.taro || false,
+                expo: options.expo || false,
+                rncli: options.rncli || false,
+                hermes: options.hermes || false,
+                hermesBase: options.hermesBase || 'auto',
+                verifyHermesBase: options.verifyHermesBase ?? true,
+                resetCache: options.resetCache ?? true,
+                sentryRelease: options.sentryRelease,
+                sentryDist: options.sentryDist,
+                appId: options.appId,
+                config: options.config,
+            });
+            const { bundleCommands } = await Promise.resolve().then(() => __importStar(require('./bundle')));
+            await bundleCommands.bundle(context);
+        }, 'Unknown error during bundling', 'Bundle created successfully', false);
+    }
+    async publish(options) {
+        return this.runMessageCommand(async () => {
+            const context = this.createContext({
+                name: options.name,
+                description: options.description,
+                metaInfo: options.metaInfo,
+                packageId: options.packageId,
+                packageVersion: options.packageVersion,
+                diffFromHash: options.diffFromHash,
+                channel: options.channel,
+                targets: options.targets,
+                deploymentIds: options.deploymentIds,
+                releaseIds: options.releaseIds,
+                minPackageVersion: options.minPackageVersion,
+                maxPackageVersion: options.maxPackageVersion,
+                packageVersionRange: options.packageVersionRange,
+                platform: options.platform,
+                appId: options.appId,
+                config: options.config,
+                'no-interactive': true,
+                rollout: options.rollout === undefined
+                    ? undefined
+                    : String(options.rollout),
+                dryRun: options.dryRun || false,
+                sourcemap: options.sourcemap,
+            }, options.filePath ? [options.filePath] : []);
+            const { versionCommands } = await Promise.resolve().then(() => __importStar(require('./versions')));
+            await versionCommands.publish(context);
+        }, 'Unknown error during publishing', 'Version published successfully');
+    }
+    async symbolicate(options) {
+        return this.runMessageCommand(async () => {
+            const context = this.createContext({
+                hash: options.hash,
+                versionId: options.versionId,
+                platform: options.platform,
+                appId: options.appId,
+                config: options.config,
+                output: options.output,
+            }, options.stackFile ? [options.stackFile] : []);
+            const { symbolicateCommands } = await Promise.resolve().then(() => __importStar(require('./symbolicate')));
+            await symbolicateCommands.symbolicate(context);
+        }, 'Unknown error during symbolication', 'Stack symbolicated');
+    }
+    async upload(options) {
+        return this.runMessageCommand(async () => {
+            const filePath = options.filePath;
+            const fileType = filePath.split('.').pop()?.toLowerCase();
+            const context = this.createContext({
+                platform: options.platform,
+                appId: options.appId,
+                appKey: options.appKey,
+                version: options.version,
+                config: options.config,
+            }, [filePath]);
+            const { packageCommands } = await Promise.resolve().then(() => __importStar(require('./package')));
+            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((0, i18n_1.t)('unsupportedFileType', { fileType }));
+            }
+            await uploadHandler(context);
+        }, 'Unknown error during upload', 'File uploaded successfully');
+    }
+    async getSelectedApp(platform, config) {
+        const resolvedPlatform = await this.getPlatform(platform);
+        return (0, app_1.getSelectedApp)(resolvedPlatform, config);
+    }
+    async listApps(platform) {
+        return this.runDataCommand(async () => {
+            const { getAppCommands } = await Promise.resolve().then(() => __importStar(require('./app')));
+            return getAppCommands().apps({
+                options: { platform: platform ?? '' },
+            });
+        }, 'Unknown error listing apps');
+    }
+    async createApp(name, platform) {
+        return this.runMessageCommand(async () => {
+            const { getAppCommands } = await Promise.resolve().then(() => __importStar(require('./app')));
+            await getAppCommands().createApp({
+                options: {
+                    name,
+                    platform,
+                    downloadUrl: '',
+                },
+            });
+        }, 'Unknown error creating app', 'App created successfully');
+    }
+    async listVersions(appId) {
+        return this.runDataCommand(async () => {
+            const { fetchVersions } = await Promise.resolve().then(() => __importStar(require('./versions')));
+            return fetchVersions(appId);
+        }, 'Unknown error listing versions');
+    }
+    async updateVersion(appId, versionId, updates) {
+        return this.runMessageCommand(async () => {
+            const context = this.createContext({
+                appId,
+                versionId,
+                ...updates,
+                'no-interactive': true,
+                rollout: updates.rollout === undefined ? undefined : String(updates.rollout),
+            });
+            const { versionCommands } = await Promise.resolve().then(() => __importStar(require('./versions')));
+            await versionCommands.update(context);
+        }, 'Unknown error updating version', 'Version updated successfully');
+    }
+    async getPlatform(platform) {
+        return (0, app_1.getPlatform)(platform);
+    }
+    async loadSession() {
+        await this.ensureInitialized();
+        if (!this.session) {
+            throw new Error((0, i18n_1.t)('failedToLoadSession'));
+        }
+        return this.session;
+    }
+    async listPackages(appId) {
+        return this.runDataCommand(async () => {
+            if (!appId) {
+                throw new Error((0, i18n_1.t)('appIdRequired'));
+            }
+            const { listPackage } = await Promise.resolve().then(() => __importStar(require('./package')));
+            return listPackage(appId);
+        }, 'Unknown error listing packages');
+    }
+}
+exports.CLIProviderImpl = CLIProviderImpl;

package/lib/standalone-publish.d.ts

@@ -0,0 +1,17 @@
+import type { VersionCommandOptions } from './versions';
+export declare function publishStandalone(fn: string, appId: string, options: VersionCommandOptions): Promise<string>;
+/** Retry publishing deployments returned by a failed standalone publish.
+ *
+ * Retry uses exact deployment ids and revisions; no artifact upload or new
+ * package is created.
+ */
+export declare function retryStandalonePublish(appId: string, releaseIdsInput: string, dryRun?: boolean): Promise<string>;
+/**
+ * Upload and register one native-package patch for one exact build.
+ *
+ * The server deliberately does not expose a group-wide pdiff field for this
+ * command: a patch is only valid against the nativeVersionId it was built
+ * from. A dry-run resolves local arguments but never uploads or mutates a
+ * release mapping.
+ */
+export declare function registerStandalonePdiff(filePath: string, options: VersionCommandOptions): Promise<string>;