rn-update-cli 1.0.0

package/lib/utils/zip-raw-writer.js

@@ -0,0 +1,209 @@
+"use strict";
+/**
+ * [INPUT]: 依赖源 ZIP 中央目录、可读流、CRC/尺寸元数据与文件系统
+ * [OUTPUT]: 对外提供 RawZipEntry、fitsRawZip、crc32Update 与 RawZipWriter
+ * [POS]: CLI 归档快速重打包底座，原样复制已压缩条目，避免资源二次压缩
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RawZipWriter = void 0;
+exports.fitsRawZip = fitsRawZip;
+exports.crc32Update = crc32Update;
+// A minimal zip writer that copies entries *as stored* — their compressed
+// bytes, CRC, sizes and timestamps straight from the source archive's central
+// directory — so repacking a subset of an apk / ipa / hap costs disk I/O, not
+// a second deflate of every asset (yazl can only add uncompressed data and
+// re-deflates it). Plain zip only: no zip64, no data descriptors, no extra
+// fields; callers must check `fitsRawZip` before choosing this writer.
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const LOCAL_HEADER_SIGNATURE = 0x04034b50;
+const CENTRAL_HEADER_SIGNATURE = 0x02014b50;
+const EOCD_SIGNATURE = 0x06054b50;
+const VERSION_NEEDED_DEFAULT = 20;
+/** "made by" for entries this writer creates itself: unix, spec 2.0 */
+const VERSION_MADE_BY_UNIX = (3 << 8) | 20;
+const FLAG_UTF8_NAMES = 0x800;
+const FLAG_DATA_DESCRIPTOR = 0x8;
+/** general-purpose bits carried over from a copied entry: encryption, deflate strength */
+const FLAG_KEEP_MASK = 0x0007;
+const MAX_UINT32 = 0xffffffff;
+const MAX_UINT16 = 0xffff;
+/** external attributes of a plain `-rw-r--r--` file */
+const UNIX_REGULAR_FILE_ATTRIBUTES = 0o100644 << 16;
+/**
+ * Whether an archive of `sourceSize` bytes with `entryCount` entries can be
+ * (partially) copied without zip64 structures: an output that only keeps a
+ * subset of the entries is never larger than its source.
+ */
+function fitsRawZip(sourceSize, entryCount) {
+    return sourceSize < MAX_UINT32 && entryCount < MAX_UINT16;
+}
+let crcTable;
+function getCrcTable() {
+    if (!crcTable) {
+        crcTable = new Int32Array(256);
+        for (let n = 0; n < 256; n++) {
+            let c = n;
+            for (let k = 0; k < 8; k++)
+                c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+            crcTable[n] = c;
+        }
+    }
+    return crcTable;
+}
+/** CRC-32 (IEEE) continued from `seed` (the running value, not inverted) */
+function crc32Update(seed, chunk) {
+    const table = getCrcTable();
+    let crc = ~seed;
+    for (let i = 0; i < chunk.length; i++) {
+        crc = table[(crc ^ chunk[i]) & 0xff] ^ (crc >>> 8);
+    }
+    return ~crc >>> 0;
+}
+class RawZipWriter {
+    output;
+    out;
+    central = [];
+    offset = 0;
+    count = 0;
+    failure = null;
+    closed;
+    constructor(output) {
+        this.output = output;
+        this.out = fs_extra_1.default.createWriteStream(output);
+        this.closed = new Promise((resolve, reject) => {
+            this.out.once('close', resolve);
+            this.out.once('error', (error) => {
+                this.failure = error;
+                reject(error);
+            });
+        });
+        // surfaced by the next write / end(), never as an unhandled rejection
+        this.closed.catch(() => { });
+    }
+    /** Copy one entry with its file data exactly as stored in the source. */
+    async addRawEntry(meta, data) {
+        if (meta.compressedSize > MAX_UINT32 ||
+            meta.uncompressedSize > MAX_UINT32 ||
+            this.offset > MAX_UINT32 ||
+            this.count >= MAX_UINT16) {
+            throw new Error(`zip64 required for ${meta.fileName}`);
+        }
+        const name = Buffer.from(meta.fileName, 'utf8');
+        if (name.length > MAX_UINT16) {
+            throw new Error(`file name too long: ${meta.fileName}`);
+        }
+        const flags = ((meta.generalPurposeBitFlag ?? 0) &
+            FLAG_KEEP_MASK &
+            ~FLAG_DATA_DESCRIPTOR) |
+            FLAG_UTF8_NAMES;
+        const versionNeeded = Math.max(VERSION_NEEDED_DEFAULT, meta.versionNeededToExtract ?? 0);
+        const localOffset = this.offset;
+        const local = Buffer.alloc(30 + name.length);
+        local.writeUInt32LE(LOCAL_HEADER_SIGNATURE, 0);
+        local.writeUInt16LE(versionNeeded, 4);
+        local.writeUInt16LE(flags, 6);
+        local.writeUInt16LE(meta.compressionMethod, 8);
+        local.writeUInt16LE(meta.lastModFileTime, 10);
+        local.writeUInt16LE(meta.lastModFileDate, 12);
+        local.writeUInt32LE(meta.crc32 >>> 0, 14);
+        local.writeUInt32LE(meta.compressedSize, 18);
+        local.writeUInt32LE(meta.uncompressedSize, 22);
+        local.writeUInt16LE(name.length, 26);
+        local.writeUInt16LE(0, 28);
+        name.copy(local, 30);
+        await this.write(local);
+        let copied = 0;
+        for await (const chunk of data) {
+            copied += chunk.length;
+            await this.write(chunk);
+        }
+        if (copied !== meta.compressedSize) {
+            throw new Error(`${meta.fileName}: read ${copied} bytes, expected ${meta.compressedSize}`);
+        }
+        const header = Buffer.alloc(46 + name.length);
+        header.writeUInt32LE(CENTRAL_HEADER_SIGNATURE, 0);
+        header.writeUInt16LE(meta.versionMadeBy ?? VERSION_MADE_BY_UNIX, 4);
+        header.writeUInt16LE(versionNeeded, 6);
+        header.writeUInt16LE(flags, 8);
+        header.writeUInt16LE(meta.compressionMethod, 10);
+        header.writeUInt16LE(meta.lastModFileTime, 12);
+        header.writeUInt16LE(meta.lastModFileDate, 14);
+        header.writeUInt32LE(meta.crc32 >>> 0, 16);
+        header.writeUInt32LE(meta.compressedSize, 20);
+        header.writeUInt32LE(meta.uncompressedSize, 24);
+        header.writeUInt16LE(name.length, 28);
+        header.writeUInt16LE(0, 30); // extra
+        header.writeUInt16LE(0, 32); // comment
+        header.writeUInt16LE(0, 34); // disk number start
+        header.writeUInt16LE(meta.internalFileAttributes ?? 0, 36);
+        header.writeUInt32LE((meta.externalFileAttributes ?? UNIX_REGULAR_FILE_ATTRIBUTES) >>> 0, 38);
+        header.writeUInt32LE(localOffset, 42);
+        name.copy(header, 46);
+        this.central.push(header);
+        this.count += 1;
+    }
+    /**
+     * Add a local file uncompressed (its CRC is computed in a first pass).
+     * `like` lends its timestamp and attributes, e.g. the archive entry this
+     * file replaces.
+     */
+    async addStoredFile(filePath, fileName, like) {
+        let crc = 0;
+        let size = 0;
+        for await (const chunk of fs_extra_1.default.createReadStream(filePath)) {
+            crc = crc32Update(crc, chunk);
+            size += chunk.length;
+        }
+        await this.addRawEntry({
+            fileName,
+            compressionMethod: 0,
+            crc32: crc,
+            compressedSize: size,
+            uncompressedSize: size,
+            lastModFileTime: like?.lastModFileTime ?? 0,
+            lastModFileDate: like?.lastModFileDate ?? 0x21, // 1980-01-01
+            externalFileAttributes: like?.externalFileAttributes,
+            versionMadeBy: like?.versionMadeBy,
+        }, fs_extra_1.default.createReadStream(filePath));
+    }
+    /** Write the central directory and close the file. */
+    async end() {
+        const cdOffset = this.offset;
+        for (const header of this.central)
+            await this.write(header);
+        const cdSize = this.offset - cdOffset;
+        if (cdOffset > MAX_UINT32 || cdSize > MAX_UINT32) {
+            throw new Error('zip64 required for the central directory');
+        }
+        const eocd = Buffer.alloc(22);
+        eocd.writeUInt32LE(EOCD_SIGNATURE, 0);
+        eocd.writeUInt16LE(0, 4);
+        eocd.writeUInt16LE(0, 6);
+        eocd.writeUInt16LE(this.count, 8);
+        eocd.writeUInt16LE(this.count, 10);
+        eocd.writeUInt32LE(cdSize, 12);
+        eocd.writeUInt32LE(cdOffset, 16);
+        eocd.writeUInt16LE(0, 20);
+        await this.write(eocd);
+        this.out.end();
+        await this.closed;
+    }
+    /** Stop writing and remove the partial output. */
+    async abort() {
+        this.out.destroy();
+        await this.closed.catch(() => { });
+        await fs_extra_1.default.remove(this.output).catch(() => { });
+    }
+    write(chunk) {
+        if (this.failure)
+            return Promise.reject(this.failure);
+        this.offset += chunk.length;
+        return new Promise((resolve, reject) => {
+            this.out.write(chunk, (error) => (error ? reject(error) : resolve()));
+        });
+    }
+}
+exports.RawZipWriter = RawZipWriter;

package/lib/version-operations.d.ts

@@ -0,0 +1,21 @@
+import type { Package, Version } from './types';
+type Deps = Record<string, string>;
+export declare function normalizeDeps(input: unknown): Deps | undefined;
+export declare function toNumericIds(ids: string[]): number[];
+export declare function printDepsChangesForPublish({ appId, versionId, pkgs, providedVersionDeps, }: {
+    appId: string;
+    versionId?: string;
+    pkgs: Package[];
+    providedVersionDeps?: Deps;
+}): Promise<void>;
+export declare function fetchVersions(appId: string, offset?: number, limit?: number): Promise<Version[]>;
+export declare function listVersions(appId: string, interactive?: boolean): Promise<Version[]>;
+export declare function chooseVersion(appId: string): Promise<Version>;
+export declare const bindVersionToPackages: ({ appId, versionId, pkgs, rollout, dryRun, }: {
+    appId: string;
+    versionId: string | null;
+    pkgs: Package[];
+    rollout?: number;
+    dryRun?: boolean;
+}) => Promise<void>;
+export {};

package/lib/version-operations.js

@@ -0,0 +1,320 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bindVersionToPackages = void 0;
+exports.normalizeDeps = normalizeDeps;
+exports.toNumericIds = toNumericIds;
+exports.printDepsChangesForPublish = printDepsChangesForPublish;
+exports.fetchVersions = fetchVersions;
+exports.listVersions = listVersions;
+exports.chooseVersion = chooseVersion;
+/**
+ * [INPUT]: 依赖旧版版本查询/绑定 API、渠道版本模型和终端交互工具
+ * [OUTPUT]: 对外提供版本查询、依赖变更提示、原生包绑定及版本选择操作
+ * [POS]: CLI 兼容发布操作层；独立服务的 UpdatePackage/Deployment 编排位于 standalone-publish.ts
+ */
+const chalk_1 = __importDefault(require("chalk"));
+const api_1 = require("./api");
+const utils_1 = require("./utils");
+const i18n_1 = require("./utils/i18n");
+function normalizeDeps(input) {
+    if (!input) {
+        return undefined;
+    }
+    let raw = input;
+    if (typeof input === 'string') {
+        try {
+            raw = JSON.parse(input);
+        }
+        catch (_e) {
+            return undefined;
+        }
+    }
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        return undefined;
+    }
+    const deps = {};
+    for (const [name, version] of Object.entries(raw)) {
+        if (typeof version === 'string' && version) {
+            deps[name] = version;
+        }
+    }
+    return Object.keys(deps).length > 0 ? deps : undefined;
+}
+function getDepsChanges(oldDeps, newDeps) {
+    if (!oldDeps || !newDeps) {
+        return [];
+    }
+    const rows = [];
+    const keys = Object.keys({ ...oldDeps, ...newDeps }).sort((a, b) => a.localeCompare(b));
+    for (const key of keys) {
+        const oldVersion = oldDeps[key];
+        const newVersion = newDeps[key];
+        if (oldVersion === undefined && newVersion !== undefined) {
+            rows.push({
+                dependency: key,
+                oldVersion: '-',
+                newVersion,
+                type: 'added',
+            });
+            continue;
+        }
+        if (oldVersion !== undefined && newVersion === undefined) {
+            rows.push({
+                dependency: key,
+                oldVersion,
+                newVersion: '-',
+                type: 'removed',
+            });
+            continue;
+        }
+        if (oldVersion !== undefined &&
+            newVersion !== undefined &&
+            oldVersion !== newVersion) {
+            rows.push({
+                dependency: key,
+                oldVersion,
+                newVersion,
+                type: 'changed',
+            });
+        }
+    }
+    return rows;
+}
+function toNumericIds(ids) {
+    return ids.map((id) => {
+        const numericId = Number(id);
+        if (!Number.isInteger(numericId) || numericId <= 0) {
+            throw new Error((0, i18n_1.t)('invalidId', { id }));
+        }
+        return numericId;
+    });
+}
+function getDepsChangeSummary(changes) {
+    return changes.reduce((acc, item) => {
+        if (item.type === 'added') {
+            acc.added += 1;
+        }
+        else if (item.type === 'removed') {
+            acc.removed += 1;
+        }
+        else {
+            acc.changed += 1;
+        }
+        return acc;
+    }, { added: 0, removed: 0, changed: 0 });
+}
+function renderVersionChange(change) {
+    const arrow = chalk_1.default.gray(` ${(0, i18n_1.t)('depsChangeArrow')} `);
+    if (change.type === 'added') {
+        return `${chalk_1.default.red((0, i18n_1.t)('depsChangeAddedLabel'))} | ${chalk_1.default.gray(change.oldVersion)}${arrow}${chalk_1.default.red(change.newVersion)}`;
+    }
+    if (change.type === 'removed') {
+        return `${chalk_1.default.green((0, i18n_1.t)('depsChangeRemovedLabel'))} | ${chalk_1.default.green(change.oldVersion)}${arrow}${chalk_1.default.gray(change.newVersion)}`;
+    }
+    return `${chalk_1.default.yellow((0, i18n_1.t)('depsChangeChangedLabel'))} | ${chalk_1.default.yellow(change.oldVersion)}${arrow}${chalk_1.default.yellow(change.newVersion)}`;
+}
+function printDepsChangesForPackage({ pkg, versionDeps, }) {
+    const pkgDeps = normalizeDeps(pkg.deps);
+    if (!pkgDeps) {
+        return false;
+    }
+    const changes = getDepsChanges(pkgDeps, versionDeps);
+    if (changes.length === 0) {
+        return false;
+    }
+    const summary = getDepsChangeSummary(changes);
+    const summaryText = (0, i18n_1.t)('depsChangeSummary', {
+        added: chalk_1.default.red(String(summary.added)),
+        removed: chalk_1.default.green(String(summary.removed)),
+        changed: chalk_1.default.yellow(String(summary.changed)),
+    });
+    const header = [
+        { value: (0, i18n_1.t)('depsChangeDependencyHeader') },
+        { value: (0, i18n_1.t)('depsChangeVersionHeader') },
+    ];
+    const rows = changes.map((change) => [
+        change.dependency,
+        renderVersionChange(change),
+    ]);
+    console.log('');
+    console.log(chalk_1.default.bgYellow.black.bold(` ${(0, i18n_1.t)('depsChangeWarningTitle')} `));
+    console.log(chalk_1.default.yellow((0, i18n_1.t)('depsChangeTargetPackage', {
+        packageName: pkg.name,
+        packageId: pkg.id,
+    })));
+    console.log(summaryText);
+    // tty-table is ~25 ms to load; only pay for it when a table is rendered
+    const Table = (0, utils_1.loadTtyTable)();
+    console.log(Table(header, rows).render());
+    console.log(chalk_1.default.yellow((0, i18n_1.t)('depsChangeRiskWarning')));
+    return true;
+}
+async function findVersionDeps(appId, versionId) {
+    const targetId = String(versionId);
+    const limit = 100;
+    let offset = 0;
+    while (true) {
+        const { data, count } = await (0, api_1.get)(`/app/${appId}/version/list?offset=${offset}&limit=${limit}`);
+        const versions = Array.isArray(data) ? data : [];
+        const version = versions.find((item) => String(item.id) === targetId);
+        if (version) {
+            return normalizeDeps(version.deps);
+        }
+        offset += versions.length;
+        if (versions.length === 0 || offset >= Number(count || 0)) {
+            break;
+        }
+    }
+    return undefined;
+}
+async function printDepsChangesForPublish({ appId, versionId, pkgs, providedVersionDeps, }) {
+    if (!versionId || pkgs.length !== 1) {
+        return;
+    }
+    let versionDeps = normalizeDeps(providedVersionDeps);
+    if (!versionDeps) {
+        try {
+            versionDeps = await findVersionDeps(appId, versionId);
+        }
+        catch (error) {
+            console.warn(chalk_1.default.yellow((0, i18n_1.t)('depsChangeFetchFailed', {
+                error: error?.message || String(error),
+            })));
+            return;
+        }
+    }
+    if (!versionDeps) {
+        return;
+    }
+    let hasChanges = false;
+    for (const pkg of pkgs) {
+        const printed = printDepsChangesForPackage({ pkg, versionDeps });
+        hasChanges = hasChanges || printed;
+    }
+    if (hasChanges) {
+        console.log(chalk_1.default.yellow((0, i18n_1.t)('depsChangeNonBlockingHint')));
+    }
+}
+const versionPageLimit = 10;
+async function fetchVersions(appId, offset = 0, limit = versionPageLimit) {
+    const { data } = await (0, api_1.get)(`/app/${appId}/version/list?offset=${offset}&limit=${limit}`);
+    return Array.isArray(data) ? data : [];
+}
+async function showVersion(appId, offset) {
+    const data = await fetchVersions(appId, offset, versionPageLimit);
+    console.log((0, i18n_1.t)('offset', { offset }));
+    for (const version of data) {
+        const pkgCount = version.packages?.length || 0;
+        let packageInfo = '';
+        if (pkgCount === 0) {
+            packageInfo = 'no package';
+        }
+        else {
+            packageInfo = (version.packages ?? [])
+                .slice(0, 3)
+                .map((pkg) => pkg.name)
+                .join(', ');
+            if (pkgCount > 3) {
+                packageInfo += `...and ${pkgCount - 3} more`;
+            }
+            else {
+                packageInfo = `[${packageInfo}]`;
+            }
+        }
+        console.log(`${version.id}) ${version.hash.slice(0, 8)} ${version.name} ${packageInfo}`);
+    }
+    return data;
+}
+async function listVersions(appId, interactive = true) {
+    let offset = 0;
+    while (true) {
+        const data = await showVersion(appId, offset);
+        if (!interactive) {
+            return data;
+        }
+        const cmd = await (0, utils_1.question)('page Up/page Down/Begin/Quit(U/D/B/Q)');
+        switch (cmd.toLowerCase()) {
+            case 'u':
+                offset = Math.max(0, offset - 10);
+                break;
+            case 'd':
+                offset += 10;
+                break;
+            case 'b':
+                offset = 0;
+                break;
+            case 'q':
+                return data;
+            case '':
+                return data;
+        }
+    }
+}
+async function chooseVersion(appId) {
+    let offset = 0;
+    while (true) {
+        const data = await showVersion(appId, offset);
+        if ((0, utils_1.isNonInteractive)()) {
+            throw new Error((0, i18n_1.t)('versionIdRequired'));
+        }
+        const cmd = await (0, utils_1.question)('Enter versionId or page Up/page Down/Begin(U/D/B)');
+        switch (cmd.toUpperCase()) {
+            case 'U':
+                offset = Math.max(0, offset - 10);
+                break;
+            case 'D':
+                offset += 10;
+                break;
+            case 'B':
+                offset = 0;
+                break;
+            default: {
+                const versionId = Number.parseInt(cmd, 10);
+                const v = data.find((version) => String(version.id) === String(versionId));
+                if (v) {
+                    return v;
+                }
+            }
+        }
+    }
+}
+const bindVersionToPackages = async ({ appId, versionId, pkgs, rollout, dryRun, }) => {
+    if (dryRun) {
+        console.log(chalk_1.default.yellow((0, i18n_1.t)('dryRun')));
+    }
+    if (rollout !== undefined) {
+        console.log(`${(0, i18n_1.t)('rolloutConfigSet', {
+            version: versionId,
+            versions: pkgs.map((pkg) => pkg.name).join(', '),
+            rollout: rollout,
+        })}`);
+    }
+    if (!dryRun) {
+        if (pkgs.length === 1) {
+            await (0, api_1.post)(`/app/${appId}/binding`, {
+                versionId,
+                rollout,
+                packageId: pkgs[0].id,
+            });
+        }
+        else {
+            await (0, api_1.post)(`/app/${appId}/binding`, {
+                versionId,
+                rollout,
+                packageIds: toNumericIds(pkgs.map((pkg) => String(pkg.id))),
+            });
+        }
+    }
+    for (const pkg of pkgs) {
+        console.log(`${(0, i18n_1.t)('versionBind', {
+            version: versionId,
+            nativeVersion: pkg.name,
+            id: pkg.id,
+        })}`);
+    }
+    console.log((0, i18n_1.t)('operationComplete', { count: pkgs.length }));
+};
+exports.bindVersionToPackages = bindVersionToPackages;

package/lib/versions.d.ts

@@ -0,0 +1,66 @@
+import type { Platform } from './types';
+import { type HermesBaseMeta } from './utils/hermes-base';
+export interface VersionCommandOptions {
+    [key: string]: unknown;
+    config?: string;
+    appKey?: string;
+    appId?: string;
+    name?: string;
+    description?: string;
+    metaInfo?: string;
+    diffFromHash?: string;
+    platform?: Platform;
+    versionId?: string;
+    versionIds?: string;
+    packageId?: string;
+    packageVersion?: string;
+    channel?: string;
+    targets?: string;
+    deploymentIds?: string;
+    releaseIds?: string;
+    releaseId?: string;
+    deploymentId?: string;
+    nativeVersionId?: string;
+    minPackageVersion?: string;
+    maxPackageVersion?: string;
+    packageVersionRange?: string;
+    rollout?: number | string;
+    dryRun?: boolean;
+    sourcemap?: string;
+    versionDeps?: Record<string, string>;
+    warnDepsChanges?: boolean;
+    /** internal: chain metadata from the bundle step (not a CLI flag) */
+    hermesBase?: HermesBaseMeta;
+    'no-interactive'?: boolean | string;
+}
+export { bindVersionToPackages, fetchVersions, normalizeDeps, } from './version-operations';
+/**
+ * Content identity of the ppk's bundle for the server (bundleHash, HBC version)
+ * plus the base used to compile it, and a copy of the bundle in the local
+ * cache so it can serve as a future base without a download.
+ */
+declare function describePpkBundle(ppkPath: string, base?: HermesBaseMeta): Promise<Record<string, unknown>>;
+/** Exported for tests: the version/create fields derived from a ppk + base. */
+export declare const describePpkBundleForTests: typeof describePpkBundle;
+export declare const versionCommands: {
+    registerPdiff: ({ args, options }: {
+        args: string[];
+        options: VersionCommandOptions;
+    }) => Promise<string>;
+    publish: ({ args, options, }: {
+        args: string[];
+        options: VersionCommandOptions;
+    }) => Promise<string>;
+    versions: ({ options }: {
+        options: VersionCommandOptions;
+    }) => Promise<void>;
+    update: ({ options }: {
+        options: VersionCommandOptions;
+    }) => Promise<void>;
+    updateVersionInfo: ({ options, }: {
+        options: VersionCommandOptions;
+    }) => Promise<void>;
+    deleteVersion: ({ options }: {
+        options: VersionCommandOptions;
+    }) => Promise<void>;
+};