react-native-update-cli 2.8.5 → 2.9.1

package/lib/bundle.js

@@ -8,518 +8,120 @@ Object.defineProperty(exports, "bundleCommands", {
         return bundleCommands;
     }
 });
-const _child_process = require("child_process");
 const _path = /*#__PURE__*/ _interop_require_default(require("path"));
-const _compareversions = require("compare-versions");
-const _fsextra = /*#__PURE__*/ _interop_require_wildcard(require("fs-extra"));
-const _yazl = require("yazl");
 const _app = require("./app");
+const _bundlepack = require("./bundle-pack");
+const _bundlerunner = require("./bundle-runner");
 const _utils = require("./utils");
 const _addgitignore = require("./utils/add-gitignore");
 const _checklockfile = require("./utils/check-lockfile");
 const _constants = require("./utils/constants");
 const _depversions = require("./utils/dep-versions");
 const _i18n = require("./utils/i18n");
+const _options = require("./utils/options");
 const _versions = require("./versions");
-const _os = /*#__PURE__*/ _interop_require_default(require("os"));
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
-function _getRequireWildcardCache(nodeInterop) {
-    if (typeof WeakMap !== "function") return null;
-    var cacheBabelInterop = new WeakMap();
-    var cacheNodeInterop = new WeakMap();
-    return (_getRequireWildcardCache = function(nodeInterop) {
-        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
-    })(nodeInterop);
-}
-function _interop_require_wildcard(obj, nodeInterop) {
-    if (!nodeInterop && obj && obj.__esModule) {
-        return obj;
-    }
-    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
-        return {
-            default: obj
-        };
-    }
-    var cache = _getRequireWildcardCache(nodeInterop);
-    if (cache && cache.has(obj)) {
-        return cache.get(obj);
-    }
-    var newObj = {
-        __proto__: null
-    };
-    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
-    for(var key in obj){
-        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
-            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
-            if (desc && (desc.get || desc.set)) {
-                Object.defineProperty(newObj, key, desc);
-            } else {
-                newObj[key] = obj[key];
-            }
-        }
-    }
-    newObj.default = obj;
-    if (cache) {
-        cache.set(obj, newObj);
-    }
-    return newObj;
-}
-const g2js = require('gradle-to-js/lib/parser');
-const properties = require('properties');
-async function runReactNativeBundleCommand({ bundleName, dev, entryFile, outputFolder, platform, sourcemapOutput, config, forceHermes, cli }) {
-    let gradleConfig = {};
-    if (platform === 'android') {
-        gradleConfig = await checkGradleConfig();
-        if (gradleConfig.crunchPngs !== false) {
-            console.warn((0, _i18n.t)('androidCrunchPngsWarning'));
-        }
-    }
-    const reactNativeBundleArgs = [];
-    const envArgs = process.env.PUSHY_ENV_ARGS;
-    if (envArgs) {
-        reactNativeBundleArgs.push(...envArgs.trim().split(/\s+/));
-    }
-    _fsextra.emptyDirSync(outputFolder);
-    let cliPath = '';
-    let usingExpo = false;
-    const getExpoCli = ()=>{
-        try {
-            const searchPaths = [
-                process.cwd()
-            ];
-            // 尝试添加 expo 包的路径作为额外的搜索路径
-            try {
-                const expoPath = require.resolve('expo/package.json', {
-                    paths: [
-                        process.cwd()
-                    ]
-                });
-                // 获取 expo 包的目录路径
-                const expoDir = expoPath.replace(/\/package\.json$/, '');
-                searchPaths.push(expoDir);
-            } catch (e) {
-            // expo 包不存在，忽略
-            }
-            // 尝试从搜索路径中解析 @expo/cli
-            cliPath = require.resolve('@expo/cli', {
-                paths: searchPaths
-            });
-            const expoCliVersion = JSON.parse(_fsextra.readFileSync(require.resolve('@expo/cli/package.json', {
-                paths: searchPaths
-            })).toString()).version;
-            // expo cli 0.10.17 (expo 49) 开始支持 bundle:embed
-            if ((0, _compareversions.satisfies)(expoCliVersion, '>= 0.10.17')) {
-                usingExpo = true;
-            } else {
-                cliPath = '';
-            }
-        } catch (e) {}
-    };
-    const getRnCli = ()=>{
-        try {
-            // rn < 0.75
-            cliPath = require.resolve('react-native/local-cli/cli.js', {
-                paths: [
-                    process.cwd()
-                ]
-            });
-        } catch (e) {
-            // rn >= 0.75
-            cliPath = require.resolve('@react-native-community/cli/build/bin.js', {
-                paths: [
-                    process.cwd()
-                ]
-            });
-        }
-    };
-    const getTaroCli = ()=>{
-        try {
-            cliPath = require.resolve('@tarojs/cli/bin/taro', {
-                paths: [
-                    process.cwd()
-                ]
-            });
-        } catch (e) {}
-    };
-    if (cli.expo) {
-        getExpoCli();
-    } else if (cli.taro) {
-        getTaroCli();
-    } else if (cli.rncli) {
-        getRnCli();
-    }
-    if (!cliPath) {
-        getExpoCli();
-        if (!usingExpo) {
-            getRnCli();
-        }
-    }
-    const bundleParams = await (0, _utils.checkPlugins)();
-    const isSentry = bundleParams.sentry;
-    if (isSentry) {
-        if (platform === 'ios') {
-            process.env.SENTRY_PROPERTIES = 'ios/sentry.properties';
-        } else if (platform === 'android') {
-            process.env.SENTRY_PROPERTIES = 'android/sentry.properties';
-        }
-    }
-    let bundleCommand = 'bundle';
-    if (usingExpo) {
-        bundleCommand = 'export:embed';
-    } else if (platform === 'harmony') {
-        bundleCommand = 'bundle-harmony';
-    } else if (cli.taro) {
-        bundleCommand = 'build';
-    }
-    if (platform === 'harmony') {
-        bundleName = 'bundle.harmony.js';
-        if (forceHermes === undefined) {
-            // enable hermes by default for harmony
-            forceHermes = true;
-        }
-    }
-    reactNativeBundleArgs.push(cliPath, bundleCommand, '--assets-dest', outputFolder, '--bundle-output', _path.default.join(outputFolder, bundleName));
-    if (platform !== 'harmony') {
-        reactNativeBundleArgs.push('--platform', platform, '--reset-cache');
-    }
-    if (cli.taro) {
-        reactNativeBundleArgs.push('--type', 'rn');
-    } else {
-        reactNativeBundleArgs.push('--dev', dev, '--entry-file', entryFile);
-    }
-    if (sourcemapOutput) {
-        reactNativeBundleArgs.push('--sourcemap-output', sourcemapOutput);
-    }
-    if (config) {
-        reactNativeBundleArgs.push('--config', config);
-    }
-    const reactNativeBundleProcess = (0, _child_process.spawn)('node', reactNativeBundleArgs);
-    console.log(`Running bundle command: node ${reactNativeBundleArgs.join(' ')}`);
-    return new Promise((resolve, reject)=>{
-        reactNativeBundleProcess.stdout.on('data', (data)=>{
-            console.log(data.toString().trim());
-        });
-        reactNativeBundleProcess.stderr.on('data', (data)=>{
-            console.error(data.toString().trim());
-        });
-        reactNativeBundleProcess.on('close', async (exitCode)=>{
-            if (exitCode) {
-                reject(new Error((0, _i18n.t)('bundleCommandError', {
-                    code: exitCode
-                })));
-            } else {
-                let hermesEnabled = false;
-                if (forceHermes) {
-                    hermesEnabled = true;
-                    console.log((0, _i18n.t)('forceHermes'));
-                } else if (platform === 'android') {
-                    const gradlePropeties = await new Promise((resolve)=>{
-                        properties.parse('./android/gradle.properties', {
-                            path: true
-                        }, (error, props)=>{
-                            if (error) {
-                                console.error(error);
-                                resolve({});
-                            }
-                            resolve(props);
-                        });
-                    });
-                    hermesEnabled = gradlePropeties.hermesEnabled;
-                    if (typeof hermesEnabled !== 'boolean') hermesEnabled = gradleConfig.enableHermes;
-                } else if (platform === 'ios' && _fsextra.existsSync('ios/Pods/hermes-engine')) {
-                    hermesEnabled = true;
-                }
-                if (hermesEnabled) {
-                    await compileHermesByteCode(bundleName, outputFolder, sourcemapOutput, !isSentry);
-                }
-                if (platform === 'harmony') {
-                    const harmonyRawAssetsPath = 'harmony/entry/src/main/resources/rawfile/assets';
-                    // copy all files in outputFolder to harmonyRawPath
-                    // assets should be in rawfile/assets
-                    _fsextra.ensureDirSync(harmonyRawAssetsPath);
-                    _fsextra.copySync(outputFolder, harmonyRawAssetsPath, {
-                        overwrite: true
-                    });
-                    _fsextra.moveSync(`${harmonyRawAssetsPath}/bundle.harmony.js`, `${harmonyRawAssetsPath}/../bundle.harmony.js`, {
-                        overwrite: true
-                    });
-                }
-                resolve(null);
-            }
-        });
-    });
-}
-function getHermesOSBin() {
-    if (_os.default.platform() === 'win32') return 'win64-bin';
-    if (_os.default.platform() === 'darwin') return 'osx-bin';
-    if (_os.default.platform() === 'linux') return 'linux64-bin';
-}
-async function checkGradleConfig() {
-    let enableHermes = false;
-    let crunchPngs;
-    try {
-        const gradleConfig = await g2js.parseFile('android/app/build.gradle');
-        crunchPngs = gradleConfig.android.buildTypes.release.crunchPngs;
-        const projectConfig = gradleConfig['project.ext.react'];
-        if (projectConfig) {
-            for (const packagerConfig of projectConfig){
-                if (packagerConfig.includes('enableHermes') && packagerConfig.includes('true')) {
-                    enableHermes = true;
-                    break;
-                }
-            }
-        }
-    } catch (e) {}
+function normalizeBundleOptions(translatedOptions, platform) {
     return {
-        enableHermes,
-        crunchPngs
+        bundleName: (0, _options.getStringOption)(translatedOptions, 'bundleName', 'index.bundlejs'),
+        entryFile: (0, _options.getStringOption)(translatedOptions, 'entryFile', 'index.js'),
+        intermediaDir: (0, _options.getStringOption)(translatedOptions, 'intermediaDir', `${_constants.tempDir}/intermedia/${platform}`),
+        output: (0, _options.getStringOption)(translatedOptions, 'output', `${_constants.tempDir}/output/${platform}.\${time}.ppk`),
+        dev: (0, _options.getBooleanOption)(translatedOptions, 'dev', false) ? 'true' : 'false',
+        sourcemap: (0, _options.getBooleanOption)(translatedOptions, 'sourcemap', false),
+        taro: (0, _options.getBooleanOption)(translatedOptions, 'taro', false),
+        expo: (0, _options.getBooleanOption)(translatedOptions, 'expo', false),
+        rncli: (0, _options.getBooleanOption)(translatedOptions, 'rncli', false),
+        hermes: (0, _options.getBooleanOption)(translatedOptions, 'hermes', false),
+        name: (0, _options.getOptionalStringOption)(translatedOptions, 'name'),
+        description: (0, _options.getOptionalStringOption)(translatedOptions, 'description'),
+        metaInfo: (0, _options.getOptionalStringOption)(translatedOptions, 'metaInfo'),
+        packageId: (0, _options.getOptionalStringOption)(translatedOptions, 'packageId'),
+        packageVersion: (0, _options.getOptionalStringOption)(translatedOptions, 'packageVersion'),
+        minPackageVersion: (0, _options.getOptionalStringOption)(translatedOptions, 'minPackageVersion'),
+        maxPackageVersion: (0, _options.getOptionalStringOption)(translatedOptions, 'maxPackageVersion'),
+        packageVersionRange: (0, _options.getOptionalStringOption)(translatedOptions, 'packageVersionRange'),
+        rollout: (0, _options.getOptionalStringOption)(translatedOptions, 'rollout'),
+        dryRun: (0, _options.getBooleanOption)(translatedOptions, 'dryRun', false)
     };
 }
-async function compileHermesByteCode(bundleName, outputFolder, sourcemapOutput, shouldCleanSourcemap) {
-    console.log((0, _i18n.t)('hermesEnabledCompiling'));
-    // >= rn 0.69
-    const rnDir = _path.default.dirname(require.resolve('react-native', {
-        paths: [
-            process.cwd()
-        ]
-    }));
-    let hermesPath = _path.default.join(rnDir, `/sdks/hermesc/${getHermesOSBin()}`);
-    // < rn 0.69
-    if (!_fsextra.existsSync(hermesPath)) {
-        hermesPath = `node_modules/hermes-engine/${getHermesOSBin()}`;
-    }
-    const hermesCommand = `${hermesPath}/hermesc`;
-    const args = [
-        '-emit-binary',
-        '-out',
-        _path.default.join(outputFolder, bundleName),
-        _path.default.join(outputFolder, bundleName),
-        '-O'
-    ];
-    if (sourcemapOutput) {
-        _fsextra.copyFileSync(sourcemapOutput, _path.default.join(outputFolder, `${bundleName}.txt.map`));
-        args.push('-output-source-map');
-    }
-    console.log((0, _i18n.t)('runningHermesc', {
-        command: hermesCommand,
-        args: args.join(' ')
-    }));
-    (0, _child_process.spawnSync)(hermesCommand, args, {
-        stdio: 'ignore'
-    });
-    if (sourcemapOutput) {
-        const composerPath = 'node_modules/react-native/scripts/compose-source-maps.js';
-        if (!_fsextra.existsSync(composerPath)) {
-            return;
-        }
-        console.log((0, _i18n.t)('composingSourceMap'));
-        (0, _child_process.spawnSync)('node', [
-            composerPath,
-            _path.default.join(outputFolder, `${bundleName}.txt.map`),
-            _path.default.join(outputFolder, `${bundleName}.map`),
-            '-o',
-            sourcemapOutput
-        ], {
-            stdio: 'ignore'
-        });
-    }
-    if (shouldCleanSourcemap) {
-        _fsextra.removeSync(_path.default.join(outputFolder, `${bundleName}.txt.map`));
-    }
-}
-async function copyDebugidForSentry(bundleName, outputFolder, sourcemapOutput) {
-    if (sourcemapOutput) {
-        let copyDebugidPath;
-        try {
-            copyDebugidPath = require.resolve('@sentry/react-native/scripts/copy-debugid.js', {
-                paths: [
-                    process.cwd()
-                ]
-            });
-        } catch (error) {
-            console.error((0, _i18n.t)('sentryCliNotFound'));
-            return;
-        }
-        if (!_fsextra.existsSync(copyDebugidPath)) {
-            return;
-        }
-        console.log((0, _i18n.t)('copyingDebugId'));
-        (0, _child_process.spawnSync)('node', [
-            copyDebugidPath,
-            _path.default.join(outputFolder, `${bundleName}.txt.map`),
-            _path.default.join(outputFolder, `${bundleName}.map`)
-        ], {
-            stdio: 'ignore'
-        });
-    }
-    _fsextra.removeSync(_path.default.join(outputFolder, `${bundleName}.txt.map`));
-}
-async function uploadSourcemapForSentry(bundleName, outputFolder, sourcemapOutput, version) {
-    if (sourcemapOutput) {
-        let sentryCliPath;
-        try {
-            sentryCliPath = require.resolve('@sentry/cli/bin/sentry-cli', {
-                paths: [
-                    process.cwd()
-                ]
-            });
-        } catch (error) {
-            console.error((0, _i18n.t)('sentryCliNotFound'));
-            return;
-        }
-        if (!_fsextra.existsSync(sentryCliPath)) {
-            return;
-        }
-        (0, _child_process.spawnSync)('node', [
-            sentryCliPath,
-            'releases',
-            'set-commits',
-            version,
-            '--auto'
-        ], {
-            stdio: 'inherit'
-        });
-        console.log((0, _i18n.t)('sentryReleaseCreated', {
-            version
-        }));
-        console.log((0, _i18n.t)('uploadingSourcemap'));
-        (0, _child_process.spawnSync)('node', [
-            sentryCliPath,
-            'releases',
-            'files',
-            version,
-            'upload-sourcemaps',
-            '--strip-prefix',
-            _path.default.join(process.cwd(), outputFolder),
-            _path.default.join(outputFolder, bundleName),
-            _path.default.join(outputFolder, `${bundleName}.map`)
-        ], {
-            stdio: 'inherit'
-        });
+async function uploadSentryArtifactsIfNeeded(shouldUpload, bundleName, intermediaDir, sourcemapOutput, versionName) {
+    if (!shouldUpload) {
+        return;
     }
+    await (0, _bundlerunner.copyDebugidForSentry)(bundleName, intermediaDir, sourcemapOutput);
+    await (0, _bundlerunner.uploadSourcemapForSentry)(bundleName, intermediaDir, sourcemapOutput, versionName);
 }
-const ignorePackingFileNames = [
-    '.',
-    '..',
-    'index.bundlejs.map',
-    'bundle.harmony.js.map'
-];
-const ignorePackingExtensions = [
-    'DS_Store',
-    'txt.map'
-];
-async function pack(dir, output) {
-    console.log((0, _i18n.t)('packing'));
-    _fsextra.ensureDirSync(_path.default.dirname(output));
-    await new Promise((resolve, reject)=>{
-        const zipfile = new _yazl.ZipFile();
-        function addDirectory(root, rel) {
-            if (rel) {
-                zipfile.addEmptyDirectory(rel);
-            }
-            const childs = _fsextra.readdirSync(root);
-            for (const name of childs){
-                if (ignorePackingFileNames.includes(name) || ignorePackingExtensions.some((ext)=>name.endsWith(`.${ext}`))) {
-                    continue;
-                }
-                const fullPath = _path.default.join(root, name);
-                const stat = _fsextra.statSync(fullPath);
-                if (stat.isFile()) {
-                    //console.log('adding: ' + rel+name);
-                    zipfile.addFile(fullPath, rel + name);
-                } else if (stat.isDirectory()) {
-                    //console.log('adding: ' + rel+name+'/');
-                    addDirectory(fullPath, `${rel}${name}/`);
-                }
-            }
+async function publishBundleVersion(outputPath, platform, payload) {
+    return _versions.versionCommands.publish({
+        args: [
+            outputPath
+        ],
+        options: {
+            platform,
+            ...payload
         }
-        addDirectory(dir, '');
-        zipfile.outputStream.on('error', (err)=>reject(err));
-        zipfile.outputStream.pipe(_fsextra.createWriteStream(output)).on('close', ()=>{
-            resolve(void 0);
-        });
-        zipfile.end();
     });
-    console.log((0, _i18n.t)('fileGenerated', {
-        file: output
-    }));
 }
 const bundleCommands = {
     bundle: async ({ options })=>{
-        const platform = await (0, _app.getPlatform)(options.platform);
-        const { bundleName, entryFile, intermediaDir, output, dev, sourcemap, taro, expo, rncli, hermes, name, description, metaInfo, packageId, packageVersion, minPackageVersion, maxPackageVersion, packageVersionRange, rollout, dryRun } = (0, _utils.translateOptions)({
+        const platform = await (0, _app.getPlatform)(typeof options.platform === 'string' ? options.platform : undefined);
+        const translatedOptions = (0, _utils.translateOptions)({
             ...options,
             tempDir: _constants.tempDir,
             platform
         });
+        const normalized = normalizeBundleOptions(translatedOptions, platform);
         (0, _checklockfile.checkLockFiles)();
         (0, _addgitignore.addGitIgnore)();
         const bundleParams = await (0, _utils.checkPlugins)();
-        const sourcemapPlugin = bundleParams.sourcemap;
-        const isSentry = bundleParams.sentry;
-        const sourcemapOutput = _path.default.join(intermediaDir, `${bundleName}.map`);
-        const realOutput = output.replace(/\$\{time\}/g, `${Date.now()}`);
+        const sourcemapOutput = _path.default.join(normalized.intermediaDir, `${normalized.bundleName}.map`);
+        const realOutput = normalized.output.replace(/\$\{time\}/g, `${Date.now()}`);
         if (!platform) {
             throw new Error((0, _i18n.t)('platformRequired'));
         }
         console.log(`Bundling with react-native: ${_depversions.depVersions['react-native']}`);
-        await runReactNativeBundleCommand({
-            bundleName,
-            dev,
-            entryFile,
-            outputFolder: intermediaDir,
+        await (0, _bundlerunner.runReactNativeBundleCommand)({
+            bundleName: normalized.bundleName,
+            dev: normalized.dev,
+            entryFile: normalized.entryFile,
+            outputFolder: normalized.intermediaDir,
             platform,
-            sourcemapOutput: sourcemap || sourcemapPlugin ? sourcemapOutput : '',
-            forceHermes: hermes,
+            sourcemapOutput: normalized.sourcemap || bundleParams.sourcemap ? sourcemapOutput : '',
+            forceHermes: normalized.hermes,
             cli: {
-                taro: !!taro,
-                expo: !!expo,
-                rncli: !!rncli
-            }
+                taro: normalized.taro,
+                expo: normalized.expo,
+                rncli: normalized.rncli
+            },
+            isSentry: bundleParams.sentry
         });
-        await pack(_path.default.resolve(intermediaDir), realOutput);
-        if (name) {
-            const versionName = await _versions.versionCommands.publish({
-                args: [
-                    realOutput
-                ],
-                options: {
-                    platform,
-                    name,
-                    description,
-                    metaInfo,
-                    packageId,
-                    packageVersion,
-                    minPackageVersion,
-                    maxPackageVersion,
-                    packageVersionRange,
-                    rollout,
-                    dryRun: Boolean(dryRun)
-                }
+        await (0, _bundlepack.packBundle)(_path.default.resolve(normalized.intermediaDir), realOutput);
+        if (normalized.name) {
+            const versionName = await publishBundleVersion(realOutput, platform, {
+                name: normalized.name,
+                description: normalized.description,
+                metaInfo: normalized.metaInfo,
+                packageId: normalized.packageId,
+                packageVersion: normalized.packageVersion,
+                minPackageVersion: normalized.minPackageVersion,
+                maxPackageVersion: normalized.maxPackageVersion,
+                packageVersionRange: normalized.packageVersionRange,
+                rollout: normalized.rollout,
+                dryRun: normalized.dryRun
             });
-            if (isSentry) {
-                await copyDebugidForSentry(bundleName, intermediaDir, sourcemapOutput);
-                await uploadSourcemapForSentry(bundleName, intermediaDir, sourcemapOutput, versionName);
-            }
-        } else if (!options['no-interactive']) {
+            await uploadSentryArtifactsIfNeeded(bundleParams.sentry, normalized.bundleName, normalized.intermediaDir, sourcemapOutput, versionName);
+            return;
+        }
+        if (!(0, _options.getBooleanOption)(options, 'no-interactive', false)) {
             const v = await (0, _utils.question)((0, _i18n.t)('uploadBundlePrompt'));
             if (v.toLowerCase() === 'y') {
-                const versionName = await _versions.versionCommands.publish({
-                    args: [
-                        realOutput
-                    ],
-                    options: {
-                        platform
-                    }
-                });
-                if (isSentry) {
-                    await copyDebugidForSentry(bundleName, intermediaDir, sourcemapOutput);
-                    await uploadSourcemapForSentry(bundleName, intermediaDir, sourcemapOutput, versionName);
-                }
+                const versionName = await publishBundleVersion(realOutput, platform, {});
+                await uploadSentryArtifactsIfNeeded(bundleParams.sentry, normalized.bundleName, normalized.intermediaDir, sourcemapOutput, versionName);
             }
         }
     }

package/lib/diff.d.ts

@@ -0,0 +1,13 @@
+import type { CommandContext } from './types';
+import { enumZipEntries, readEntry } from './utils/zip-entries';
+export { enumZipEntries, readEntry };
+export declare const diffCommands: {
+    diff: ({ args, options }: CommandContext) => Promise<void>;
+    hdiff: ({ args, options }: CommandContext) => Promise<void>;
+    diffFromApk: ({ args, options }: CommandContext) => Promise<void>;
+    hdiffFromApk: ({ args, options }: CommandContext) => Promise<void>;
+    diffFromApp: ({ args, options }: CommandContext) => Promise<void>;
+    hdiffFromApp: ({ args, options }: CommandContext) => Promise<void>;
+    diffFromIpa: ({ args, options }: CommandContext) => Promise<void>;
+    hdiffFromIpa: ({ args, options }: CommandContext) => Promise<void>;
+};