@swell/cli 1.0.2 → 2.0.1-alpha.2

package/dist/commands/app/install.js

@@ -0,0 +1,177 @@
+import { confirm } from '@inquirer/prompts';
+import { Flags } from '@oclif/core';
+import * as semver from 'semver';
+import ora from 'ora';
+import config from '../../lib/config.js';
+import style from '../../lib/style.js';
+import { selectLoggedInStoreId, selectEnvironmentId, } from '../../lib/stores.js';
+import { RemoteAppCommand } from '../../remote-app-command.js';
+export default class AppInstall extends RemoteAppCommand {
+    static description = `Without a version specified, install the latest version of the app.
+
+Without a store specified, install the app in the Live environment of the current store.`;
+    static examples = [
+        'swell install',
+        'swell install -v 3.2.7',
+        'swell install -v 1.0.0 -s my-store-id',
+    ];
+    static flags = {
+        env: Flags.string({
+            char: 'e',
+            description: 'target environment to install the app, defaults to live',
+        }),
+        store: Flags.string({
+            char: 's',
+            description: 'target store id to install the app, defaults to the current store',
+        }),
+        version: Flags.string({
+            char: 'v',
+            description: 'version of the app to install, defaults to latest',
+            async parse(input) {
+                if (!semver.valid(input)) {
+                    throw new Error(`Invalid version: ${input}`);
+                }
+                return input;
+            },
+        }),
+    };
+    static summary = 'Install an existing app in another store environment.';
+    async run() {
+        const { flags } = await this.parse(AppInstall);
+        const { env, store, version } = flags;
+        this.app = await this.getAppWithConfig();
+        const versions = await this.getVersions(version);
+        if (versions.length === 0) {
+            this.error(`${version ? `Version ${version} not found` : 'No versions found'} for ${style.appConfigValue(this.app.name)} app. ${version
+                ? ''
+                : `Create a version with the ${style.command('swell version')} command first.`}`);
+        }
+        const versionToInstall = version
+            ? versions.find((ver) => ver.version === version)?.version
+            : versions[0].version;
+        let storeToInstall = store;
+        if (!storeToInstall) {
+            const loggedInStores = config.get('stores') || [];
+            if (loggedInStores.length > 0) {
+                storeToInstall = await selectLoggedInStoreId('Which store do you want to install the app in?');
+            }
+            if (!storeToInstall) {
+                return;
+            }
+        }
+        let envToInstall = env;
+        if (!envToInstall) {
+            envToInstall = await selectEnvironmentId();
+        }
+        if (envToInstall === 'live') {
+            envToInstall = undefined;
+        }
+        if (envToInstall && envToInstall !== 'test') {
+            this.error(`${envToInstall} is not a valid environment.`);
+        }
+        if (envToInstall === 'test' && storeToInstall === this.app.client_id) {
+            this.error(`You cannot install an app in the test environment of the same store.`);
+        }
+        config.ensureLoggedIn(storeToInstall);
+        this.api.setStoreEnv(storeToInstall, envToInstall);
+        // check if app is already installed on store
+        const existingInstalledApp = await this.getInstalledApp();
+        const existingVersion = existingInstalledApp?.id
+            ? existingInstalledApp.version
+            : null;
+        // confirm install unless params were passed explicitly
+        let extraMessage = '';
+        if (!store || !env) {
+            const continueInstall = await confirm({
+                message: this.installConfirmationMessage(storeToInstall, envToInstall, versionToInstall, existingVersion),
+            });
+            if (!continueInstall) {
+                // we don't want to throw an error as it is a valid exit
+                return;
+            }
+        }
+        else {
+            extraMessage = ` ${style.appConfigValue(this.app.name)} v${versionToInstall} on ${style.storeId(storeToInstall)} [${envToInstall ? envToInstall : 'live'}]`;
+        }
+        const shouldContinue = await this.confirmRemoveDevelopmentApp(storeToInstall);
+        if (!shouldContinue) {
+            return;
+        }
+        const spinner = ora();
+        // install or update app depending on whether it's already installed
+        let request;
+        if (existingInstalledApp?.id) {
+            spinner.start(`Updating${extraMessage}...`);
+            request = async () => this.updateApp(versionToInstall, envToInstall);
+        }
+        else {
+            spinner.start(`Installing${extraMessage}...`);
+            request = async () => this.installApp(versionToInstall, envToInstall);
+        }
+        const response = await this.handleRequestErrors(request, () => spinner.fail('Something went wrong.'));
+        if (response?.errors) {
+            spinner.fail(`Error installing app: ${JSON.stringify(response.errors)}`);
+        }
+        spinner.succeed(`Install complete. Manage app settings in your dashboard at ${style.link(this.dashboardUrl({ flags: { env: envToInstall } }, storeToInstall))}.`);
+    }
+    async installApp(version, env) {
+        return this.api.post({ adminPath: `/client/apps` }, 
+        // eslint-disable-next-line camelcase
+        { body: { app_id: this.app.id, version } });
+    }
+    installConfirmationMessage(storeToInstall, envToInstall, versionToInstall, existingVersion) {
+        const message = [];
+        if (existingVersion && semver.gt(versionToInstall, existingVersion)) {
+            message.push('Updating');
+        }
+        else if (existingVersion &&
+            semver.lt(versionToInstall, existingVersion)) {
+            message.push('Rolling back');
+        }
+        else {
+            message.push('Install');
+        }
+        let versionToShow = versionToInstall;
+        versionToShow += versionToInstall === this.app.version ? ' (latest)' : '';
+        message.push(style.appConfigValue(this.app.name), `v${versionToShow}`, `on ${style.storeId(storeToInstall)} [${envToInstall ? envToInstall : 'live'}]?`);
+        return message.join(' ');
+    }
+    async updateApp(version, env) {
+        await this.api.put({ adminPath: `/client/apps/${this.app.id}` }, { body: { version } });
+    }
+    async getInstalledApp() {
+        // check if app is already installed on store
+        return await this.api.get({ adminPath: `/client/apps/${this.app.id}` }, {});
+    }
+    async confirmRemoveDevelopmentApp(storeToInstall) {
+        const existingSourcedApps = await this.api.get({ adminPath: `/client/apps` }, {
+            query: { source_id: this.app.id },
+        });
+        if (existingSourcedApps.results[0]?.id) {
+            const continueInstall = await confirm({
+                message: `${style.storeId(storeToInstall)} has a development version of ${style.appConfigValue(this.app.name)}. Do you want to replace it with an installed instance?`,
+                default: false,
+            });
+            if (!continueInstall) {
+                return false;
+            }
+            // uninstall the existing app
+            const spinner = ora();
+            spinner.start('Removing development app...');
+            try {
+                await this.api.put({
+                    adminPath: `/client/apps/${existingSourcedApps.results[0].app_id}`,
+                }, {
+                    body: { uninstalled: true },
+                });
+                spinner.succeed('Development app removed.');
+            }
+            catch (err) {
+                spinner.fail(`Error removing development app from ${style.storeId(storeToInstall)}.`);
+                this.logError(err.message);
+                return false;
+            }
+        }
+        return true;
+    }
+}

package/dist/commands/app/push.d.ts

@@ -0,0 +1,17 @@
+import { RemoteAppCommand } from '../../remote-app-command.js';
+export default class AppPush extends RemoteAppCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        file: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    static orientation: {
+        env: string;
+    };
+    static summary: string;
+    run(): Promise<void>;
+    private logDashboardUrl;
+    private pushConfigPath;
+    private pushFile;
+    private confirmRemoveInstalledApp;
+}

package/dist/commands/app/push.js

@@ -0,0 +1,158 @@
+import { confirm } from '@inquirer/prompts';
+import { Flags } from '@oclif/core';
+import * as path from 'node:path';
+import ora from 'ora';
+import { appConfigFileExists } from '../../lib/app-config.js';
+import { ConfigPaths, allConfigFilesPathsByType, appConfigFromFile, getConfigTypeFromPath, getConfigTypeKeyFromValue, } from '../../lib/apps/index.js';
+import style from '../../lib/style.js';
+import { RemoteAppCommand } from '../../remote-app-command.js';
+import { default as swellConfig } from '../../lib/config.js';
+export default class AppPush extends RemoteAppCommand {
+    static description = `Push all app configurations, a specific file, or a specific configuration
+type to an app in your store's test environment. If the app does not exist yet,
+it will be created and its global ID saved to a .swellrc file.
+
+- If no file is specified, all configuration files will be pushed to the store.
+  This includes the app icon (assets/icon.png) and swell.json.
+- If a file is specified, only that file will be pushed to the store.
+- If a directory is specified, only files in that directory will be pushed.
+
+App configuration directories:
+${Object.values(ConfigPaths)
+        .map((dir) => style.path(`${dir}/`))
+        .join('\n')}`;
+    static examples = [
+        'swell app push',
+        'swell app push -f content',
+        'swell app push -f models/products.json',
+    ];
+    static flags = {
+        file: Flags.string({
+            char: 'f',
+            description: 'relative path to a configuration file or directory to push',
+        }),
+    };
+    static orientation = {
+        env: 'test',
+    };
+    static summary = 'Push configuration files to your Swell app.';
+    async run() {
+        const { flags } = await this.parse(AppPush);
+        const { file } = flags;
+        const currentStore = swellConfig.getDefaultStore();
+        this.api.setStoreEnv(currentStore, 'test');
+        this.app = await this.getAppWithConfig(undefined, false);
+        const confirmExistingApp = await this.confirmRemoveInstalledApp(currentStore);
+        if (confirmExistingApp === false) {
+            return;
+        }
+        // If app exists but owned by another client, offer to create a new instance
+        if (this.app.client_id !== currentStore) {
+            if (!confirmExistingApp?.id) {
+                const confirmPushNew = await confirm({
+                    message: `${style.appConfigValue(this.app.name)} has a dev version in another store (${style.storeId(this.app.client_id)}). Do you want to create a new development instance in ${style.storeId(currentStore)}?`,
+                    default: false,
+                });
+                if (!confirmPushNew) {
+                    return;
+                }
+            }
+            // create a new app
+            this.app = await this.getCreateUpdateApp();
+            if (!this.app) {
+                return;
+            }
+        }
+        else if (!file) {
+            // update existing app if not targeting a file
+            this.app = await this.getCreateUpdateApp(this.app);
+        }
+        if (file) {
+            const filePath = path.join(this.appPath, file);
+            if (!appConfigFileExists(filePath)) {
+                this.error(`Path ${style.path(file)} does not exist`);
+            }
+            const filePathParsed = path.parse(file);
+            // if no directory is identified and no extension, it means the user
+            // passed in a config directory
+            if (!filePathParsed.dir && !filePathParsed.ext) {
+                await this.pushConfigPath(filePathParsed.base);
+                this.logDashboardUrl(flags, currentStore);
+                return;
+            }
+            await this.pushFile(filePath);
+            this.logDashboardUrl(flags, currentStore);
+            return;
+        }
+        const syncResult = await this.syncAppConfigs();
+        const { installed, removed } = syncResult;
+        this.log(`Pushed ${installed.length} ${installed.length === 1 ? 'configuration' : 'configurations'}${removed.length > 0 ? ` (removed ${removed.length}).` : '.'}`);
+        this.logDashboardUrl(flags, currentStore);
+    }
+    logDashboardUrl(flags, storeId) {
+        this.log(`View the ${style.appConfigValue(this.app.name)} app in your dashboard at ${style.link(this.dashboardUrl(flags, storeId))}.`);
+    }
+    async pushConfigPath(path) {
+        const configType = getConfigTypeFromPath(path);
+        const configTypeKey = getConfigTypeKeyFromValue(configType);
+        if (!configTypeKey) {
+            this.error(`Invalid config path: ${path}`);
+        }
+        let pushedFiles = 0;
+        for (const { configFile } of allConfigFilesPathsByType(this.appPath, configTypeKey)) {
+            const appConfig = appConfigFromFile(configFile, configType);
+            // eslint-disable-next-line no-await-in-loop
+            await this.pushConfigFile(appConfig);
+            pushedFiles += 1;
+        }
+        if (pushedFiles === 0) {
+            this.log(`No valid files to push found for ${style.path(path)}.`);
+        }
+        else {
+            this.log(`Pushed ${style.path(path)} to ${style.appConfigValue(this.app.name)}.`);
+        }
+    }
+    async pushFile(file) {
+        const configType = getConfigTypeFromPath(path.basename(path.dirname(file)));
+        if (!configType) {
+            this.error(`File ${file} is not a valid file to push.`);
+        }
+        const appConfig = appConfigFromFile(file, configType);
+        await this.pushConfigFile(appConfig);
+    }
+    async confirmRemoveInstalledApp(currentStore) {
+        if (!this.app.private_id) {
+            return true;
+        }
+        const existingInstalledApp = await this.api.get({
+            adminPath: `/client/apps/${this.app.private_id}`,
+        }, { query: { versioned: true } });
+        if (existingInstalledApp) {
+            const continuePush = await confirm({
+                message: `${style.storeId(currentStore)} has an installed version of ${style.appConfigValue(this.app.name)} v${existingInstalledApp.version}. Do you want to replace it with a development instance?`,
+                default: false,
+            });
+            if (!continuePush) {
+                return false;
+            }
+            // uninstall the existing app
+            const spinner = ora();
+            spinner.start('Removing installed app...');
+            try {
+                await this.api.put({
+                    adminPath: `/client/apps/${this.app.id}`,
+                }, {
+                    body: { uninstalled: true },
+                });
+                spinner.succeed('Installed app removed.');
+                this.log();
+            }
+            catch (err) {
+                spinner.fail(`Error removing installed app from ${style.storeId(currentStore)}.`);
+                this.logError(err.message);
+                return false;
+            }
+        }
+        return existingInstalledApp;
+    }
+}

package/dist/commands/app/version.d.ts

@@ -0,0 +1,18 @@
+import { RemoteAppCommand } from '../../remote-app-command.js';
+export default class AppVersion extends RemoteAppCommand {
+    static args: {
+        nextVersion: import("@oclif/core/lib/interfaces/parser.js").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        'git-tag': import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        message: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    static summary: string;
+    run(): Promise<void>;
+    private gitCommit;
+    private gitTag;
+    private updateRemote;
+    private validateAndComputeVersion;
+}

package/dist/commands/app/version.js

@@ -0,0 +1,156 @@
+import { confirm, input } from '@inquirer/prompts';
+import git from '@npmcli/git';
+import { Args, Flags } from '@oclif/core';
+import { CLIError } from '@oclif/errors';
+import * as semver from 'semver';
+import ora from 'ora';
+import style from '../../lib/style.js';
+import { RemoteAppCommand } from '../../remote-app-command.js';
+const RELEASE_TYPES = [
+    'major',
+    'premajor',
+    'minor',
+    'preminor',
+    'patch',
+    'prepatch',
+    'prerelease',
+];
+const TAG_VERSION_PREFIX = 'v';
+export default class AppVersion extends RemoteAppCommand {
+    static args = {
+        nextVersion: Args.string({
+            description: `semver version or release type: ${[
+                '<next.version>',
+                ...RELEASE_TYPES,
+            ].join('|')}`,
+            async parse(input) {
+                if (RELEASE_TYPES.includes(input)) {
+                    return input;
+                }
+                const parsedInput = semver.valid(input);
+                if (parsedInput) {
+                    return parsedInput;
+                }
+                throw new CLIError(`Invalid version: ${input}`);
+            },
+        }),
+    };
+    static description = `When executed without specifying NEXTVERSION, the command will display the current
+version of your app.
+
+If a NEXTVERSION is provided, the command will validate and compute the version
+according to Semver rules by only allowing incremental updates.
+
+The version change will be committed to the Git repository using the provided
+message or a default similar to the tag, e.g. "v1.0.1".
+
+By default, it creates a Git tag for the specified version. You can disable this
+behavior by using the --git-tag=false option.`;
+    static examples = [
+        'swell app version',
+        'swell app version minor',
+        'swell app version 1.0.0 -m "First release"',
+    ];
+    static flags = {
+        'git-tag': Flags.boolean({
+            default: true,
+            description: 'create a git tag for this version (default true)',
+        }),
+        message: Flags.string({
+            char: 'm',
+            description: 'description of the changes in this version',
+        }),
+    };
+    static summary = 'Increment the version of your Swell app.';
+    async run() {
+        const { args, flags } = await this.parse(AppVersion);
+        const { 'git-tag': gitTag } = flags;
+        let { message } = flags;
+        let { nextVersion } = args;
+        // load app from remote
+        this.app = await this.getAppWithConfig();
+        const remoteVersion = this.app.version;
+        const versions = await this.getVersions();
+        // if the user didn't set a version, show the current one
+        if (!nextVersion) {
+            if (versions.length > 0) {
+                const lastVersion = versions[0].version;
+                this.log(`${style.appConfigValue(this.app.name)} latest version is ${style.appConfigValue(lastVersion)}`);
+            }
+            else {
+                this.log(`${style.appConfigValue(this.app.name)} has not been versioned yet`);
+            }
+            return;
+        }
+        nextVersion = this.validateAndComputeVersion(nextVersion, remoteVersion);
+        if (!message) {
+            message = await input({
+                message: 'Describe the changes in this version',
+            });
+        }
+        const continueVersion = await confirm({
+            message: `Create ${style.appConfigValue(this.app.name)} version ${nextVersion}?`,
+        });
+        if (!continueVersion) {
+            return;
+        }
+        if (!message) {
+            message = `${TAG_VERSION_PREFIX}${nextVersion}`;
+        }
+        const spinner = ora();
+        spinner.start('Creating version...');
+        try {
+            await this.updateRemote(nextVersion, message, spinner);
+            await this.gitCommit(message);
+            if (gitTag)
+                await this.gitTag(nextVersion);
+        }
+        catch (err) {
+            spinner.fail(err.message);
+            return;
+        }
+        spinner.succeed(`${style.appConfigValue(this.app.name)} version ${nextVersion} created.`);
+    }
+    async gitCommit(message) {
+        // check if there are changes in the app config file
+        // if there are no changes, there is nothing to commit
+        const configStatus = await git.spawn(['status', this.appConfig.path], {
+            cwd: this.appConfig.cwd,
+        });
+        if (configStatus.stdout.includes('nothing to commit')) {
+            return;
+        }
+        // add the app config file to commit - this will contain the new version
+        await git.spawn(['add', this.appConfig.path]);
+        // commit the version change to git. It skips the git hooks with -n
+        await git.spawn(['commit', '-n', '-m', message]);
+    }
+    async gitTag(nextVersion) {
+        const tag = `${TAG_VERSION_PREFIX}${nextVersion}`;
+        // tag the version in git
+        await git.spawn(['tag', tag], { cwd: process.cwd() });
+    }
+    async updateRemote(nextVersion, message, spinner) {
+        // update the version on the remote
+        const versionResponse = await this.api.post({ adminPath: `/apps/${this.app.id}/versions` }, { body: { description: message, version: nextVersion } });
+        if (!versionResponse || !versionResponse.version) {
+            spinner.fail('Something went wrong.');
+        }
+        // update the local app config file since remote was successful
+        this.appConfig.set('version', nextVersion);
+    }
+    validateAndComputeVersion(nextVersion, remoteVersion) {
+        let version = nextVersion;
+        // compute the value of the next version and check if it's valid
+        if (RELEASE_TYPES.includes(nextVersion)) {
+            // increment the version
+            version = semver.inc(remoteVersion, version);
+        }
+        this.debug(`next version: ${version}`, `remote version: ${remoteVersion}`);
+        if (semver.eq(version, remoteVersion) ||
+            semver.lt(version, remoteVersion)) {
+            this.error(`The version you are trying to create ${version} needs to be greater than the current version ${remoteVersion}`);
+        }
+        return version;
+    }
+}

package/dist/commands/app/watch.d.ts

@@ -0,0 +1,15 @@
+import { RemoteAppCommand } from '../../remote-app-command.js';
+export default class AppWatch extends RemoteAppCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        'sync-all': import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    static orientation: {
+        env: string;
+    };
+    static summary: string;
+    private watchListener;
+    run(): Promise<void>;
+    private handleFileChange;
+}

package/dist/commands/app/watch.js

@@ -0,0 +1,110 @@
+import { Flags } from '@oclif/core';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { appConfigFileExists } from '../../lib/app-config.js';
+import { appConfigFromFile, findAppConfig, getConfigTypeFromPath, hasAllowedFileExtension, } from '../../lib/apps/index.js';
+import style from '../../lib/style.js';
+import { RemoteAppCommand } from '../../remote-app-command.js';
+export default class AppWatch extends RemoteAppCommand {
+    static description = `Watches configuration files including functions, and automatically pushes
+to the remote store.
+
+Optionally synchronize all configs on change.`;
+    static examples = [
+        'swell app watch',
+        'swell app watch -a',
+        'swell app watch --sync-all',
+    ];
+    static flags = {
+        'sync-all': Flags.boolean({
+            char: 'a',
+            default: false,
+            description: 'synchronize all app configurations on file change',
+        }),
+    };
+    static orientation = {
+        env: 'test',
+    };
+    static summary = 'Watch for changes and push app configurations.';
+    watchListener = async (eventType, filename) => {
+        const configFile = filename;
+        const pathParsed = path.parse(configFile);
+        const fileDirs = pathParsed.dir.split(path.sep);
+        // only the first directory is relevant for us
+        const configDir = fileDirs[0];
+        // we only want to watch files in the root of the app directory
+        // and with the allowed extensions
+        if (!configDir ||
+            fileDirs.length > 1 ||
+            !hasAllowedFileExtension(configFile)) {
+            return;
+        }
+        const configType = getConfigTypeFromPath(configDir);
+        if (!configType) {
+            this.debug(`watchListener: ${filename} is not a valid config type`);
+            return;
+        }
+        let watchFileEvent;
+        // per node docs:
+        //
+        //    On most platforms, 'rename' is emitted whenever a filename appears
+        //    or disappears in the directory.
+        //
+        // we want however to identify delete file events so we can send the
+        // correct API request
+        if (eventType === 'rename') {
+            watchFileEvent = 'new';
+            if (!appConfigFileExists(path.join(this.appPath, configFile))) {
+                watchFileEvent = 'deleted';
+            }
+        }
+        else {
+            watchFileEvent = 'change';
+        }
+        try {
+            await this.handleFileChange(configFile, configType, watchFileEvent);
+        }
+        catch (error) {
+            // we don't want to break the watcher if an error is thrown while
+            // handling a file change
+            this.debug(error);
+            // for tests though, we want to break the watcher
+            if (process.env.NODE_ENV === 'test') {
+                // throwing does not break the test so we need to hard exit and log
+                // the error
+                console.error(style.error(error));
+                // eslint-disable-next-line no-process-exit, unicorn/no-process-exit
+                process.exit(1);
+            }
+        }
+        // refetch app to get updated configs
+        this.app = await this.getAppWithConfig(this.app.id);
+    };
+    async run() {
+        const { flags } = await this.parse(AppWatch);
+        this.app = await this.getAppWithConfig();
+        this.log('Watching for changes...');
+        if (flags['sync-all']) {
+            await this.syncAppConfigs();
+            fs.watch(this.appPath, { recursive: true }, async (eventType, filename) => {
+                if (filename && hasAllowedFileExtension(filename)) {
+                    await this.syncAppConfigs();
+                }
+            });
+            return;
+        }
+        fs.watch(this.appPath, { recursive: true }, this.watchListener);
+    }
+    async handleFileChange(configFile, configType, event) {
+        if (event === 'deleted') {
+            const appConfig = findAppConfig(this.app, configFile, configType);
+            if (!appConfig) {
+                return;
+            }
+            return this.removeConfig(appConfig);
+        }
+        const appConfig = appConfigFromFile(path.join(this.appPath, configFile), configType);
+        const result = await this.pushConfigFile(appConfig);
+        this.debug(`handleFileChange: ${configFile} pushed`, result);
+    }
+}

package/dist/commands/create/app.d.ts

@@ -0,0 +1,21 @@
+import { SwellCommand } from '../../swell-command.js';
+export default class CreateApp extends SwellCommand {
+    static args: {
+        id: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        pkg: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        yes: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    static description: string;
+    static examples: {
+        command: string;
+        description: string;
+    }[];
+    run(): Promise<void>;
+    private tryPackageSetup;
+    private setupPackage;
+    private findPackageManager;
+    private doesPackageManagerExist;
+    private createAppConfigFolders;
+}