react-native-update-cli 2.8.5 → 2.9.1

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

@@ -13,47 +13,6 @@ function _interop_require_default(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 colorizeDiff = (from, to)=>{
     const toParts = to.split('.');
     const diffIndex = from.split('.').findIndex((part, i)=>part !== toParts[i]);
@@ -105,11 +64,11 @@ const columnHeaderRenderer = (column)=>{
 const drawBox = (lines, color = _safe.yellow, horizontalPadding = 3)=>{
     const maxLineWidth = lines.reduce((max, row)=>Math.max(max, (0, _safe.strip)(row).length), 0);
     console.log(color(`┌${'─'.repeat(maxLineWidth + horizontalPadding * 2)}┐`));
-    lines.forEach((row)=>{
+    for (const row of lines){
         const padding = ' '.repeat(horizontalPadding);
         const fullRow = `${row}${' '.repeat(maxLineWidth - (0, _safe.strip)(row).length)}`;
         console.log(`${color('│')}${padding}${(0, _safe.reset)(fullRow)}${padding}${color('│')}`);
-    });
+    }
     console.log(color(`└${'─'.repeat(maxLineWidth + horizontalPadding * 2)}┘`));
 };
 const getTableColumns = (rows)=>{
@@ -171,11 +130,11 @@ const getTableColumns = (rows)=>{
             items: []
         }
     ];
-    rows.forEach((row)=>{
-        columns.forEach((column)=>{
+    for (const row of rows){
+        for (const column of columns){
             column.maxLength = Math.max(column.label.length, column.maxLength, row[column.attrName].length || 0);
-        });
-    });
+        }
+    }
     return columns;
 };
 const getTableRows = (updates)=>{
@@ -184,7 +143,8 @@ const getTableRows = (updates)=>{
         const getGroup = (a, b)=>{
             if (b && (0, _major.default)(b) === 0) {
                 return 'majorVersionZero';
-            } else if (a && b) {
+            }
+            if (a && b) {
                 var _semverDiff;
                 const releaseType = (_semverDiff = (0, _diff.default)(a, b)) != null ? _semverDiff : '';
                 if ([
@@ -193,12 +153,14 @@ const getTableRows = (updates)=>{
                     'prerelease'
                 ].includes(releaseType)) {
                     return 'major';
-                } else if ([
+                }
+                if ([
                     'minor',
                     'preminor'
                 ].includes(releaseType)) {
                     return 'minor';
-                } else if ([
+                }
+                if ([
                     'patch',
                     'prepatch'
                 ].includes(releaseType)) {
@@ -208,7 +170,7 @@ const getTableRows = (updates)=>{
             return 'unknown';
         };
         const add = (group, location, installed, wanted)=>all.push({
-                name: ' ' + name,
+                name: ` ${name}`,
                 location,
                 installed: installed != null ? installed : 'unknown',
                 latest: latest != null ? latest : 'unknown',
@@ -279,21 +241,23 @@ const displayTable = (latestVersionPackages)=>{
 const checkVersions = async (packages, skipMissing, options = {
     useCache: true
 })=>{
-    const ora = (await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("ora")))).default;
-    const spinner = ora({
-        text: (0, _safe.cyan)('Checking versions...')
-    });
-    spinner.start();
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore
-    let latestVersionPackages = await (0, _.default)(packages, options);
+    console.log((0, _safe.cyan)('Checking versions...'));
+    let latestVersionPackages;
+    if (typeof packages === 'string') {
+        latestVersionPackages = [
+            await (0, _.default)(packages, options)
+        ];
+    } else if (Array.isArray(packages)) {
+        latestVersionPackages = await (0, _.default)(packages, options);
+    } else {
+        latestVersionPackages = await (0, _.default)(packages, options);
+    }
     if (skipMissing) {
         latestVersionPackages = latestVersionPackages.filter((pkg)=>{
             var _pkg_local, _ref;
             return (_ref = (_pkg_local = pkg.local) != null ? _pkg_local : pkg.globalNpm) != null ? _ref : pkg.globalYarn;
         });
     }
-    spinner.stop();
     displayTable(latestVersionPackages);
 };
 void (async ()=>{

package/lib/utils/latest-version/index.d.ts

@@ -0,0 +1,146 @@
+import type { Agent } from 'http';
+interface RegistryVersions {
+    /**
+     * The latest version of the package found on the registry (if found).
+     */
+    latest?: string;
+    /**
+     * The next version of the package found on the registry (if found).
+     */
+    next?: string;
+    /**
+     * The latest version of the package found on the registry and satisfied by the wanted tag or version range.
+     */
+    wanted?: string;
+}
+interface InstalledVersions {
+    /**
+     * The current local installed version of the package (if installed).
+     */
+    local?: string;
+    /**
+     * The current npm global installed version of the package (if installed).
+     */
+    globalNpm?: string;
+    /**
+     * The current yarn global installed version of the package (if installed).
+     */
+    globalYarn?: string;
+}
+interface LatestVersionPackage extends InstalledVersions, RegistryVersions {
+    /**
+     * The name of the package.
+     */
+    name: string;
+    /**
+     * The tag or version range that was provided (if provided).
+     * @default "latest"
+     */
+    wantedTagOrRange?: string;
+    /**
+     * Whether the local or global installed versions (if any) could be upgraded or not, based on the wanted version.
+     */
+    updatesAvailable: {
+        local: string | false;
+        globalNpm: string | false;
+        globalYarn: string | false;
+    } | false;
+    /**
+     * Any error that might have occurred during the process.
+     */
+    error?: Error;
+}
+interface RequestOptions {
+    readonly ca?: string | Buffer | Array<string | Buffer>;
+    readonly rejectUnauthorized?: boolean;
+    readonly agent?: Agent | boolean;
+    readonly timeout?: number;
+}
+interface LatestVersionOptions {
+    /**
+     * Awaiting the api to return might take time, depending on the network, and might impact your package loading performance.
+     * You can use the cache mechanism to improve load performance and reduce unnecessary network requests.
+     * If `useCache` is not supplied, the api will always check for updates and wait for every requests to return before returning itself.
+     * If `useCache` is used, the api will always returned immediately, with either (for each provided packages):
+     * 1) a latest/next version available if a cache was found
+     * 2) no latest/next version available if no cache was found - in such case updates will be fetched in the background and a cache will
+     * be created for each provided packages and made available for the next call to the api.
+     * @default false
+     */
+    readonly useCache?: boolean;
+    /**
+     * How long the cache for the provided packages should be used before being refreshed (in milliseconds).
+     * If `useCache` is not supplied, this option has no effect.
+     * If `0` is used, this will force the cache to refresh immediately:
+     * 1) The api will returned immediately (without any latest nor next version available for the provided packages)
+     * 2) New updates will be fetched in the background
+     * 3) The cache for each provided packages will be refreshed and made available for the next call to the api
+     * @default ONE_DAY
+     */
+    readonly cacheMaxAge?: number;
+    /**
+     * A JavaScript package registry url that implements the CommonJS Package Registry specification.
+     * @default "Looks at any registry urls in the .npmrc file or fallback to the default npm registry instead"
+     * @example <caption>.npmrc</caption>
+     * registry = 'https://custom-registry.com/'
+     * @pkgscope:registry = 'https://custom-registry.com/'
+     */
+    readonly registryUrl?: string;
+    /**
+     * Set of options to be passed down to Node.js http/https request.
+     * @example <caption>Behind a proxy with self-signed certificate</caption>
+     * { ca: [ fs.readFileSync('proxy-cert.pem') ] }
+     * @example <caption>Bypassing certificate validation</caption>
+     * { rejectUnauthorized: false }
+     */
+    readonly requestOptions?: RequestOptions;
+}
+interface LatestVersion {
+    /**
+     * Get latest versions of packages from of a package json like object.
+     * @param {PackageJson} item - A package json like object (with dependencies, devDependencies and peerDependencies attributes).
+     * @example { dependencies: { 'npm': 'latest' }, devDependencies: { 'npm': '1.3.2' }, peerDependencies: { '@scope/name': '^5.0.2' } }
+     * @param {LatestVersionOptions} [options] - An object optionally specifying the use of the cache, the max age of the cache, the registry url and the http or https options.
+     * If `useCache` is not supplied, the default of `false` is used.
+     * If `cacheMaxAge` is not supplied, the default of `one day` is used.
+     * If `registryUrl` is not supplied, the default from `.npmrc` is used or a fallback to the `npm registry url` instead.
+     * @returns {Promise<LatestVersionPackage[]>}
+     */
+    (item: PackageJson, options?: LatestVersionOptions): Promise<LatestVersionPackage[]>;
+    /**
+     * Get latest version of a single package.
+     * @param {Package} item - A single package object (represented by a string that should match the following format: `${'@' | ''}${string}@${string}`)
+     * @example 'npm', 'npm@1.3.2', '@scope/name@^5.0.2'
+     * @param {LatestVersionOptions} [options] - An object optionally specifying the use of the cache, the max age of the cache, the registry url and the http or https options.
+     * If `useCache` is not supplied, the default of `false` is used.
+     * If `cacheMaxAge` is not supplied, the default of `one day` is used.
+     * If `registryUrl` is not supplied, the default from `.npmrc` is used or a fallback to the npm registry url instead.
+     * @returns {Promise<LatestVersionPackage>}
+     */
+    (item: Package, options?: LatestVersionOptions): Promise<LatestVersionPackage>;
+    /**
+     * Get latest versions of a collection of packages.
+     * @param {Package[]} items - A collection of package object (represented by a string that should match the following format: `${'@' | ''}${string}@${string}`)
+     * @example ['npm', 'npm@1.3.2', '@scope/name@^5.0.2']
+     * @param {LatestVersionOptions} [options] - An object optionally specifying the use of the cache, the max age of the cache, the registry url and the http or https options.
+     * If `useCache` is not supplied, the default of `false` is used.
+     * If `cacheMaxAge` is not supplied, the default of `one day` is used.
+     * If `registryUrl` is not supplied, the default from `.npmrc` is used or a fallback to the npm registry url instead.
+     * @returns {Promise<LatestVersionPackage[]>}
+     */
+    (items: Package[], options?: LatestVersionOptions): Promise<LatestVersionPackage[]>;
+}
+type PackageRange = `${'@' | ''}${string}@${string}`;
+type Package = PackageRange | string;
+type PackageJsonDependencies = Record<string, string>;
+type PackageJson = Record<string, any> & ({
+    dependencies: PackageJsonDependencies;
+} | {
+    devDependencies: PackageJsonDependencies;
+} | {
+    peerDependencies: PackageJsonDependencies;
+});
+export declare const ONE_DAY: number;
+declare const latestVersion: LatestVersion;
+export type { LatestVersion, Package, PackageRange, PackageJson, PackageJsonDependencies, RegistryVersions, LatestVersionPackage, RequestOptions, LatestVersionOptions, };
+export default latestVersion;

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

@@ -173,7 +173,8 @@ const getInstalledVersion = (pkgName, location = 'local')=>{
         if (location === 'globalNpm') {
             var _require;
             return (_require = require((0, _path.join)(_globaldirs.npm.packages, pkgName, 'package.json'))) == null ? void 0 : _require.version;
-        } else if (location === 'globalYarn') {
+        }
+        if (location === 'globalYarn') {
             var _yarnGlobalPkg_dependencies, _require1;
             // Make sure package is globally installed by Yarn
             const yarnGlobalPkg = require((0, _path.resolve)(_globaldirs.yarn.packages, '..', 'package.json'));
@@ -181,27 +182,26 @@ const getInstalledVersion = (pkgName, location = 'local')=>{
                 return undefined;
             }
             return (_require1 = require((0, _path.join)(_globaldirs.yarn.packages, pkgName, 'package.json'))) == null ? void 0 : _require1.version;
-        } else {
-            /**
-       * Compute the local paths manually as require.resolve() and require.resolve.paths()
-       * cannot be trusted anymore.
-       * @see https://github.com/nodejs/node/issues/33460
-       * @see https://github.com/nodejs/loaders/issues/26
-       */ const { root } = (0, _path.parse)(process.cwd());
-            let path = process.cwd();
-            const localPaths = [
-                (0, _path.join)(path, 'node_modules')
-            ];
-            while(path !== root){
-                path = (0, _path.dirname)(path);
-                localPaths.push((0, _path.join)(path, 'node_modules'));
-            }
-            for (const localPath of localPaths){
-                const pkgPath = (0, _path.join)(localPath, pkgName, 'package.json');
-                if ((0, _fs.existsSync)(pkgPath)) {
-                    var _require2;
-                    return (_require2 = require(pkgPath)) == null ? void 0 : _require2.version;
-                }
+        }
+        /**
+     * Compute the local paths manually as require.resolve() and require.resolve.paths()
+     * cannot be trusted anymore.
+     * @see https://github.com/nodejs/node/issues/33460
+     * @see https://github.com/nodejs/loaders/issues/26
+     */ const { root } = (0, _path.parse)(process.cwd());
+        let path = process.cwd();
+        const localPaths = [
+            (0, _path.join)(path, 'node_modules')
+        ];
+        while(path !== root){
+            path = (0, _path.dirname)(path);
+            localPaths.push((0, _path.join)(path, 'node_modules'));
+        }
+        for (const localPath of localPaths){
+            const pkgPath = (0, _path.join)(localPath, pkgName, 'package.json');
+            if ((0, _fs.existsSync)(pkgPath)) {
+                var _require2;
+                return (_require2 = require(pkgPath)) == null ? void 0 : _require2.version;
             }
         }
         return undefined;

package/lib/utils/options.d.ts

@@ -0,0 +1,4 @@
+export declare function getBooleanOption(options: Record<string, unknown>, key: string, fallback?: boolean): boolean;
+export declare function getStringOption(options: Record<string, unknown>, key: string, fallback?: string): string;
+export declare function getOptionalStringOption(options: Record<string, unknown>, key: string): string | undefined;
+export declare function toObjectState<T extends Record<string, unknown>>(value: unknown, fallback: T): T;

package/lib/utils/options.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getBooleanOption: function() {
+        return getBooleanOption;
+    },
+    getOptionalStringOption: function() {
+        return getOptionalStringOption;
+    },
+    getStringOption: function() {
+        return getStringOption;
+    },
+    toObjectState: function() {
+        return toObjectState;
+    }
+});
+function getBooleanOption(options, key, fallback = false) {
+    const value = options[key];
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'string') {
+        return value.toLowerCase() === 'true';
+    }
+    if (typeof value === 'number') {
+        return value !== 0;
+    }
+    return fallback;
+}
+function getStringOption(options, key, fallback = '') {
+    const value = options[key];
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (typeof value === 'number' || typeof value === 'boolean') {
+        return String(value);
+    }
+    return fallback;
+}
+function getOptionalStringOption(options, key) {
+    const value = options[key];
+    if (typeof value === 'string') {
+        return value || undefined;
+    }
+    if (typeof value === 'number' || typeof value === 'boolean') {
+        return String(value);
+    }
+    return undefined;
+}
+function toObjectState(value, fallback) {
+    if (value && typeof value === 'object') {
+        return value;
+    }
+    return fallback;
+}

package/lib/utils/plugin-config.d.ts

@@ -0,0 +1,9 @@
+interface PluginConfig {
+    name: string;
+    bundleParams?: {
+        [key: string]: any;
+    };
+    detect: () => Promise<boolean>;
+}
+export declare const plugins: PluginConfig[];
+export {};

package/lib/utils/zip-entries.d.ts

@@ -0,0 +1,3 @@
+import { type Entry, type ZipFile as YauzlZipFile } from 'yauzl';
+export declare function readEntry(entry: Entry, zipFile: YauzlZipFile): Promise<Buffer>;
+export declare function enumZipEntries(zipFn: string, callback: (entry: Entry, zipFile: YauzlZipFile, nestedPath?: string) => Promise<any> | undefined, nestedPath?: string): Promise<unknown>;

package/lib/versions.d.ts

@@ -0,0 +1,43 @@
+import type { Package, Platform } from './types';
+interface VersionCommandOptions {
+    appId?: string;
+    name?: string;
+    description?: string;
+    metaInfo?: string;
+    platform?: Platform;
+    versionId?: string;
+    packageId?: string;
+    packageVersion?: string;
+    minPackageVersion?: string;
+    maxPackageVersion?: string;
+    packageVersionRange?: string;
+    rollout?: string;
+    dryRun?: boolean;
+    versionDeps?: Record<string, string>;
+}
+export declare const bindVersionToPackages: ({ appId, versionId, pkgs, rollout, dryRun, }: {
+    appId: string;
+    versionId: string;
+    pkgs: Package[];
+    rollout?: number;
+    dryRun?: boolean;
+}) => Promise<void>;
+export declare const versionCommands: {
+    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>;
+};
+export {};

package/lib/workflow-runner.d.ts

@@ -0,0 +1,2 @@
+import type { CommandContext, CustomWorkflow } from './types';
+export declare function runWorkflow(workflowName: string, workflow: CustomWorkflow, context: CommandContext): Promise<unknown>;

package/lib/workflow-runner.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "runWorkflow", {
+    enumerable: true,
+    get: function() {
+        return runWorkflow;
+    }
+});
+async function runWorkflow(workflowName, workflow, context) {
+    if (workflow.validate && !workflow.validate(context)) {
+        throw new Error(`Workflow '${workflowName}' validation failed`);
+    }
+    let previousResult;
+    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 previousResult;
+}

package/package.json

@@ -1,12 +1,25 @@
 {
   "name": "react-native-update-cli",
-  "version": "2.8.5",
+  "version": "2.9.1",
   "description": "command line tool for react-native-update (remote updates for react native)",
-  "main": "index.js",
+  "main": "lib/exports.js",
+  "types": "lib/exports.d.ts",
   "bin": {
     "pushy": "lib/index.js",
     "cresc": "lib/index.js"
   },
+  "exports": {
+    ".": {
+      "types": "./lib/exports.d.ts",
+      "require": "./lib/exports.js",
+      "default": "./lib/exports.js"
+    },
+    "./cli": {
+      "types": "./lib/index.d.ts",
+      "require": "./lib/index.js",
+      "default": "./lib/index.js"
+    }
+  },
   "files": [
     "lib",
     "src",
@@ -14,9 +27,11 @@
     "cli.json"
   ],
   "scripts": {
-    "build": "swc src -d lib --strip-leading-paths",
-    "prepublishOnly": "bun scripts/prepublish.js && bun run build && chmod +x lib/index.js",
-    "lint": "tsc --noEmit & biome check --write ."
+    "build": "rm -rf lib && swc src -d lib --strip-leading-paths && tsc -p tsconfig.build.json",
+    "prepublishOnly": "bun scripts/prepublish.ts && bun run build && chmod +x lib/index.js",
+    "lint": "tsc --noEmit && biome check --write .",
+    "test": "bun test",
+    "test:coverage": "bun test --coverage --coverage-reporter=text --coverage-reporter=lcov"
   },
   "repository": {
     "type": "git",

package/src/api.ts

@@ -9,7 +9,7 @@ import tcpp from 'tcp-ping';
 import { getBaseUrl } from 'utils/http-helper';
 import packageJson from '../package.json';
 import type { Package, Session } from './types';
-import { credentialFile, pricingPageUrl, IS_CRESC } from './utils/constants';
+import { IS_CRESC, credentialFile, pricingPageUrl } from './utils/constants';
 import { t } from './utils/i18n';
 
 const tcpPing = util.promisify(tcpp.ping);

package/src/app.ts

@@ -6,7 +6,13 @@ import { doDelete, get, post } from './api';
 import type { Platform } from './types';
 import { t } from './utils/i18n';
 
-const validPlatforms = ['ios', 'android', 'harmony'];
+interface AppSummary {
+  id: number;
+  name: string;
+  platform: Platform;
+}
+
+const validPlatforms = ['ios', 'android', 'harmony'] as const;
 
 export async function getPlatform(platform?: string) {
   return assertPlatform(
@@ -14,11 +20,11 @@ export async function getPlatform(platform?: string) {
   ) as Platform;
 }
 
-export function assertPlatform(platform: string) {
-  if (!validPlatforms.includes(platform)) {
+export function assertPlatform(platform: string): Platform {
+  if (!validPlatforms.includes(platform as Platform)) {
     throw new Error(t('unsupportedPlatform', { platform }));
   }
-  return platform;
+  return platform as Platform;
 }
 
 export function getSelectedApp(platform: Platform) {
@@ -36,7 +42,10 @@ export function getSelectedApp(platform: Platform) {
 
 export async function listApp(platform: Platform | '' = '') {
   const { data } = await get('/app/list');
-  const list = platform ? data.filter((v) => v.platform === platform) : data;
+  const allApps = data as AppSummary[];
+  const list = platform
+    ? allApps.filter((app: AppSummary) => app.platform === platform)
+    : allApps;
 
   const header = [
     { value: t('appId') },
@@ -59,7 +68,7 @@ export async function chooseApp(platform: Platform) {
 
   while (true) {
     const id = await question(t('enterAppIdQuestion'));
-    const app = list.find((v) => v.id === Number(id));
+    const app = list.find((item: AppSummary) => item.id === Number(id));
     if (app) {
       return app;
     }
@@ -70,7 +79,7 @@ export const appCommands = {
   createApp: async function ({
     options,
   }: {
-    options: { name: string; downloadUrl: string; platform: Platform };
+    options: { name: string; downloadUrl: string; platform?: Platform | '' };
   }) {
     const name = options.name || (await question(t('appNameQuestion')));
     const { downloadUrl } = options;
@@ -97,16 +106,16 @@ export const appCommands = {
     await doDelete(`/app/${id}`);
     console.log(t('operationSuccess'));
   },
-  apps: async ({ options }: { options: { platform: Platform } }) => {
-    const { platform } = options;
-    listApp(platform);
+  apps: async ({ options }: { options: { platform?: Platform | '' } }) => {
+    const { platform = '' } = options;
+    await listApp(platform);
   },
   selectApp: async ({
     args,
     options,
   }: {
     args: string[];
-    options: { platform: Platform };
+    options: { platform?: Platform | '' };
   }) => {
     const platform = await getPlatform(options.platform);
     const id = args[0]