@nocobase/cli 2.1.0-alpha.2 → 2.1.0-alpha.20

package/dist/commands/download.js

@@ -0,0 +1,293 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import fsp from 'node:fs/promises';
+import { Command, Flags } from '@oclif/core';
+import * as p from '@clack/prompts';
+import path from 'node:path';
+import { stdin as stdinStream, stdout as stdoutStream } from 'node:process';
+import { run } from "../lib/run-npm.js";
+export default class Download extends Command {
+    static description = 'Scaffold or fetch NocoBase: npm (create-nocobase-app), docker (image pull), or git (shallow clone).';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> -y --source npm --version latest',
+        '<%= config.bin %> <%= command.id %> --source npm --version latest',
+        '<%= config.bin %> <%= command.id %> --source npm --version latest --output-dir=./app',
+        '<%= config.bin %> <%= command.id %> --source docker --version latest --docker-registry=nocobase/nocobase',
+        '<%= config.bin %> <%= command.id %> --source git --version latest --git-url=https://github.com/nocobase/nocobase.git',
+    ];
+    static flags = {
+        yes: Flags.boolean({
+            char: 'y',
+            description: 'Skip interactive prompts; use flags only (non-TTY implies -y)',
+            default: false,
+        }),
+        source: Flags.string({
+            char: 's',
+            description: 'Distribution: npm runs create-nocobase-app, docker runs docker pull, git clones the repository',
+            options: ['docker', 'npm', 'git'],
+            required: false,
+        }),
+        version: Flags.string({
+            char: 'v',
+            description: 'npm: dist-tag or version for create-nocobase-app; docker: image tag; git: branch or tag (latest→main, beta→next, alpha→develop); default: latest',
+        }),
+        replace: Flags.boolean({
+            char: 'r',
+            description: 'npm/git: delete the target project directory if it exists, then scaffold or clone again; docker: ignored',
+            default: false,
+        }),
+        'dev': Flags.boolean({
+            description: 'npm: install devDependencies in create-nocobase-app and run a non-production yarn install; git/docker: ignored',
+            default: false,
+        }),
+        'output-dir': Flags.string({
+            char: 'o',
+            description: 'npm/git: output directory (relative to cwd); default ./nocobase-<version> using the same value as --version; docker: ignored',
+        }),
+        'git-url': Flags.string({
+            description: 'git: remote URL to clone (default: https://github.com/nocobase/nocobase.git)',
+        }),
+        'docker-registry': Flags.string({
+            description: 'docker: image reference without tag (default: nocobase/nocobase); use -v for the tag, e.g. ghcr.io/nocobase/nocobase',
+        }),
+    };
+    resolveOutputDir(flags) {
+        const explicit = flags['output-dir'];
+        if (explicit) {
+            return explicit;
+        }
+        const tag = flags.version || 'latest';
+        const safe = tag.replace(/[/\\]/g, '-');
+        return `./nocobase-${safe}`;
+    }
+    defaultOutputDir(versionTag) {
+        const safe = versionTag.replace(/[/\\]/g, '-');
+        return `./nocobase-${safe}`;
+    }
+    /**
+     * When stdin/stdout are TTY and not `-y`, prompt for any missing download options.
+     */
+    async resolveDownloadFlags(flags) {
+        const interactive = Boolean(stdinStream.isTTY && stdoutStream.isTTY && !flags.yes);
+        let source = flags.source?.trim();
+        if (source === '') {
+            source = undefined;
+        }
+        let version = flags.version?.trim() || undefined;
+        let replace = flags.replace;
+        let dev = flags['dev'];
+        let outputDir = flags['output-dir']?.trim() || undefined;
+        if (outputDir === '') {
+            outputDir = undefined;
+        }
+        let gitUrl = flags['git-url']?.trim() || undefined;
+        if (gitUrl === '') {
+            gitUrl = undefined;
+        }
+        let dockerRegistry = flags['docker-registry']?.trim() || undefined;
+        if (dockerRegistry === '') {
+            dockerRegistry = undefined;
+        }
+        if (!interactive) {
+            if (!source) {
+                this.error('Distribution is required (--source npm|git|docker). Use a terminal for interactive setup, or pass -s/--source.');
+            }
+            const v = version || 'latest';
+            return {
+                source,
+                version: v,
+                replace,
+                'dev': dev,
+                'output-dir': outputDir,
+                'git-url': gitUrl,
+                'docker-registry': dockerRegistry,
+            };
+        }
+        p.intro('nb download');
+        if (!source) {
+            const src = await p.select({
+                message: 'How do you want to get NocoBase?',
+                options: [
+                    { value: 'npm', label: 'npm — create-nocobase-app' },
+                    { value: 'git', label: 'git — shallow clone' },
+                    { value: 'docker', label: 'docker — pull image' },
+                ],
+                initialValue: 'npm',
+            });
+            if (p.isCancel(src)) {
+                p.cancel('Download cancelled.');
+                this.exit(0);
+            }
+            source = src;
+        }
+        if (version === undefined) {
+            const verAns = await p.text({
+                message: 'Version / dist-tag / image tag / branch alias (-v)',
+                placeholder: 'latest',
+                initialValue: 'latest',
+            });
+            if (p.isCancel(verAns)) {
+                p.cancel('Download cancelled.');
+                this.exit(0);
+            }
+            version = verAns.trim() || 'latest';
+        }
+        const versionResolved = version || 'latest';
+        if (source === 'docker') {
+            if (dockerRegistry === undefined) {
+                const reg = await p.text({
+                    message: 'Docker image without tag (--docker-registry)',
+                    placeholder: 'nocobase/nocobase',
+                    initialValue: 'nocobase/nocobase',
+                });
+                if (p.isCancel(reg)) {
+                    p.cancel('Download cancelled.');
+                    this.exit(0);
+                }
+                dockerRegistry = reg.trim() || 'nocobase/nocobase';
+            }
+        }
+        if (source === 'git') {
+            if (gitUrl === undefined) {
+                const urlAns = await p.text({
+                    message: 'Git remote URL (--git-url)',
+                    placeholder: 'https://github.com/nocobase/nocobase.git',
+                    initialValue: 'https://github.com/nocobase/nocobase.git',
+                });
+                if (p.isCancel(urlAns)) {
+                    p.cancel('Download cancelled.');
+                    this.exit(0);
+                }
+                gitUrl = urlAns.trim() || 'https://github.com/nocobase/nocobase.git';
+            }
+        }
+        if (source === 'npm' || source === 'git') {
+            if (outputDir === undefined) {
+                const initialOut = this.defaultOutputDir(versionResolved);
+                const outAns = await p.text({
+                    message: 'Output directory relative to cwd (-o)',
+                    placeholder: initialOut,
+                    initialValue: initialOut,
+                });
+                if (p.isCancel(outAns)) {
+                    p.cancel('Download cancelled.');
+                    this.exit(0);
+                }
+                outputDir = outAns.trim() || initialOut;
+            }
+            const replaceAns = await p.confirm({
+                message: 'Delete existing output directory if present, then retry? (--replace)',
+                initialValue: replace,
+            });
+            if (p.isCancel(replaceAns)) {
+                p.cancel('Download cancelled.');
+                this.exit(0);
+            }
+            replace = replaceAns;
+        }
+        if (source === 'npm') {
+            const devAns = await p.confirm({
+                message: 'Install devDependencies and run a non-production yarn install? (--dev)',
+                initialValue: dev,
+            });
+            if (p.isCancel(devAns)) {
+                p.cancel('Download cancelled.');
+                this.exit(0);
+            }
+            dev = devAns;
+        }
+        return {
+            source,
+            version: versionResolved,
+            replace,
+            'dev': dev,
+            'output-dir': outputDir,
+            'git-url': gitUrl,
+            'docker-registry': dockerRegistry,
+        };
+    }
+    async downloadFromDocker(flags) {
+        const image = flags['docker-registry'] ?? 'nocobase/nocobase';
+        const tag = flags.version ?? 'latest';
+        await run('docker', ['pull', `${image}:${tag}`]);
+    }
+    async downloadFromNpm(flags) {
+        const versionSpec = flags.version || 'latest';
+        const outputDir = this.resolveOutputDir(flags);
+        const projectRoot = path.resolve(process.cwd(), outputDir);
+        const npxArgs = ['-y', `create-nocobase-app@${versionSpec}`, outputDir];
+        if (!flags['dev']) {
+            npxArgs.push('--skip-dev-dependencies');
+        }
+        if (flags.replace) {
+            await fsp.rm(projectRoot, { recursive: true, force: true });
+        }
+        await run('npx', npxArgs);
+        const installArgs = ['install'];
+        if (!flags['dev']) {
+            installArgs.push('--production');
+        }
+        await run('yarn', installArgs, { cwd: projectRoot });
+        return projectRoot;
+    }
+    async downloadFromGit(flags) {
+        const repoUrl = flags['git-url'] ?? 'https://github.com/nocobase/nocobase.git';
+        const versionSpec = flags.version || 'latest';
+        const outputDir = this.resolveOutputDir(flags);
+        const versionToRef = {
+            'latest': 'main',
+            'beta': 'next',
+            'alpha': 'develop',
+        };
+        if (flags.replace) {
+            await fsp.rm(path.resolve(process.cwd(), outputDir), { recursive: true, force: true });
+        }
+        const branch = versionToRef[versionSpec] || versionSpec;
+        const gitArgs = ['clone'];
+        gitArgs.push('--branch', branch);
+        gitArgs.push('--depth', '1', repoUrl, outputDir);
+        await run('git', gitArgs);
+        const projectRoot = path.resolve(process.cwd(), outputDir);
+        await run('yarn', ['install'], { cwd: projectRoot });
+        return projectRoot;
+    }
+    /**
+     * @returns Final resolved flags and, for npm/git, the absolute project directory.
+     */
+    async download() {
+        const { flags } = await this.parse(Download);
+        const resolved = await this.resolveDownloadFlags(flags);
+        switch (resolved.source) {
+            case 'npm': {
+                const projectRoot = await this.downloadFromNpm(resolved);
+                return { resolved, projectRoot };
+            }
+            case 'docker': {
+                await this.downloadFromDocker(resolved);
+                return { resolved, projectRoot: undefined };
+            }
+            case 'git': {
+                const projectRoot = await this.downloadFromGit(resolved);
+                return { resolved, projectRoot };
+            }
+            default:
+                this.error(`Invalid --source: ${resolved.source}`);
+        }
+    }
+    async run() {
+        try {
+            return await this.download();
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.error(message);
+        }
+    }
+}

package/dist/commands/env/add.js

@@ -0,0 +1,198 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { Args, Command, Flags } from '@oclif/core';
+import * as p from '@clack/prompts';
+import { upsertEnv } from '../../lib/auth-store.js';
+import { formatCliHomeScope } from '../../lib/cli-home.js';
+import { isInteractiveTerminal, printVerbose, setVerboseMode } from '../../lib/ui.js';
+export default class EnvAdd extends Command {
+    static summary = 'Save a named NocoBase API endpoint (token or OAuth), then switch the CLI to use it';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> local',
+        '<%= config.bin %> <%= command.id %> local --scope project --api-base-url http://localhost:13000/api --auth-type oauth',
+    ];
+    static args = {
+        name: Args.string({
+            description: 'Label for this environment (optional first argument; in a TTY, prompted when omitted; required when not using a TTY)',
+            required: false,
+        }),
+    };
+    static flags = {
+        env: Flags.string({
+            char: 'e',
+            hidden: true,
+            deprecated: true,
+            description: 'Environment name (same as the optional positional argument; for compatibility with -e/--env on other commands)',
+        }),
+        verbose: Flags.boolean({
+            description: 'Print detailed progress while writing config',
+            default: false,
+        }),
+        scope: Flags.string({
+            char: 's',
+            description: 'Where to store env config: project (.nocobase in the repo) or global (user-level); prompted in a TTY when omitted',
+            options: ['project', 'global'],
+        }),
+        'api-base-url': Flags.string({
+            char: 'u',
+            aliases: ['base-url'],
+            description: 'Root URL for HTTP API calls, including the /api prefix (e.g. http://localhost:13000/api); prompted in a TTY when omitted',
+        }),
+        'auth-type': Flags.string({
+            char: 'a',
+            description: 'Authentication: token (API key) or oauth (browser login via `nb env auth`); prompted in a TTY when omitted',
+            options: ['token', 'oauth'],
+        }),
+        'access-token': Flags.string({
+            char: 't',
+            aliases: ['token'],
+            description: 'API key or access token when using --auth-type token (prompted in a TTY when omitted)',
+        }),
+    };
+    exitCancelled() {
+        p.cancel('Cancelled.');
+        this.exit(0);
+    }
+    async run() {
+        const { args, flags } = await this.parse(EnvAdd);
+        setVerboseMode(flags.verbose);
+        const nameArg = args.name?.trim();
+        const nameFlag = flags.env?.trim() || undefined;
+        if (nameArg && nameFlag && nameArg !== nameFlag) {
+            this.error(`Environment name was given both as the argument ("${nameArg}") and as --env ("${nameFlag}"); use only one.`);
+        }
+        let name = nameArg || nameFlag || undefined;
+        let scope = flags.scope;
+        let baseUrl = flags['api-base-url'] ?? flags['base-url'];
+        let authType = flags['auth-type'];
+        const interactive = isInteractiveTerminal();
+        if (!interactive) {
+            const missing = [];
+            if (!name?.trim()) {
+                missing.push('<name> (first argument or --env)');
+            }
+            if (!scope) {
+                missing.push('--scope');
+            }
+            if (!baseUrl) {
+                missing.push('--api-base-url');
+            }
+            if (!authType) {
+                missing.push('--auth-type');
+            }
+            if (missing.length > 0) {
+                this.error(`Non-interactive mode requires: ${missing.join(', ')}. Example: nb env add -e local --scope project --api-base-url http://localhost:13000/api --auth-type oauth`);
+            }
+        }
+        else {
+            if (!name?.trim()) {
+                const answer = await p.text({
+                    message: 'Environment name',
+                    placeholder: 'default',
+                    defaultValue: 'default',
+                });
+                if (p.isCancel(answer)) {
+                    this.exitCancelled();
+                }
+                name = answer;
+            }
+            if (!scope) {
+                const answer = await p.select({
+                    message: 'Where should this env be stored?',
+                    options: [
+                        { value: 'project', label: 'Project', hint: '.nocobase in this repo' },
+                        { value: 'global', label: 'Global', hint: 'user-level config' },
+                    ],
+                    initialValue: 'project',
+                });
+                if (p.isCancel(answer)) {
+                    this.exitCancelled();
+                }
+                scope = answer;
+            }
+            if (!baseUrl) {
+                const answer = await p.text({
+                    message: 'API base URL',
+                    placeholder: 'http://localhost:13000/api',
+                    defaultValue: 'http://localhost:13000/api',
+                });
+                if (p.isCancel(answer)) {
+                    this.exitCancelled();
+                }
+                baseUrl = answer;
+            }
+            if (!authType) {
+                const answer = await p.select({
+                    message: 'How do you want to authenticate?',
+                    options: [
+                        { value: 'oauth', label: 'OAuth (browser login)', hint: 'runs nb env auth after save' },
+                        { value: 'token', label: 'API token / API key' },
+                    ],
+                    initialValue: 'oauth',
+                });
+                if (p.isCancel(answer)) {
+                    this.exitCancelled();
+                }
+                authType = answer;
+            }
+        }
+        const accessTokenKeys = ['access-token', 'token'];
+        const accessTokenFlagPresent = accessTokenKeys.some((key) => Object.prototype.hasOwnProperty.call(flags, key));
+        if (accessTokenFlagPresent && !flags['access-token'] && !flags['token']) {
+            if (!interactive) {
+                this.error('When passing --access-token (or --token) without a value, run in a TTY or provide the token as the flag value.');
+            }
+            const prompted = await p.password({
+                message: 'Access token / API key',
+                validate: (value) => (value.trim() ? undefined : 'Token cannot be empty'),
+            });
+            if (p.isCancel(prompted)) {
+                this.exitCancelled();
+            }
+            flags['access-token'] = prompted;
+        }
+        let token = flags['access-token'] ?? flags['token'];
+        if (!name?.trim()) {
+            this.error('Environment name cannot be empty.');
+        }
+        if (!baseUrl?.trim()) {
+            this.error('API base URL cannot be empty.');
+        }
+        name = name.trim();
+        baseUrl = baseUrl.trim();
+        if (authType === 'token') {
+            if (!token && interactive) {
+                const answer = await p.password({
+                    message: 'Access token / API key',
+                    validate: (value) => (value.trim() ? undefined : 'Token cannot be empty'),
+                });
+                if (p.isCancel(answer)) {
+                    this.exitCancelled();
+                }
+                token = answer;
+            }
+            if (!token?.trim()) {
+                this.error('Auth type token requires an access token. Pass `--access-token`, or run in a TTY to enter it.');
+            }
+            printVerbose(`Saving env "${name}" with API base URL ${baseUrl} (token auth)`);
+            await upsertEnv(name, { baseUrl, accessToken: token }, { scope });
+            this.log(`Saved env "${name}" and set it as current${scope ? ` in ${formatCliHomeScope(scope)} scope` : ''}.`);
+            return;
+        }
+        printVerbose(`Saving env "${name}" with API base URL ${baseUrl} (OAuth next)`);
+        await upsertEnv(name, { baseUrl }, { scope });
+        this.log(`Saved env "${name}"${scope ? ` in ${formatCliHomeScope(scope)} scope` : ''}. Starting OAuth login (\`nb env auth ${name}\`).`);
+        const authArgv = [name];
+        if (scope) {
+            authArgv.push('-s', scope);
+        }
+        await this.config.runCommand('env:auth', authArgv);
+    }
+}

package/dist/commands/env/auth.js

@@ -0,0 +1,61 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { Args, Command, Flags } from '@oclif/core';
+import { getCurrentEnvName } from '../../lib/auth-store.js';
+import { formatCliHomeScope } from '../../lib/cli-home.js';
+import { authenticateEnvWithOauth } from '../../lib/env-auth.js';
+import { failTask, startTask, succeedTask } from '../../lib/ui.js';
+export default class EnvAuth extends Command {
+    static summary = 'Authenticate an environment with OAuth';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> prod',
+    ];
+    static args = {
+        name: Args.string({
+            description: 'Environment name (omit to use the current env)',
+            required: true,
+        }),
+    };
+    static flags = {
+        env: Flags.string({
+            char: 'e',
+            hidden: true,
+            deprecated: true,
+            description: 'Environment name (same as the optional positional argument; for compatibility with -e/--env on other commands)',
+        }),
+        scope: Flags.string({
+            char: 's',
+            description: 'Config scope',
+            options: ['project', 'global'],
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(EnvAuth);
+        const scope = flags.scope;
+        const nameArg = args.name?.trim();
+        const nameFlag = flags.env?.trim() || undefined;
+        if (nameArg && nameFlag && nameArg !== nameFlag) {
+            this.error(`Environment name was given both as the argument ("${nameArg}") and as --env ("${nameFlag}"); use only one.`);
+        }
+        const envName = nameArg || nameFlag || undefined;
+        const envLabel = envName ?? (await getCurrentEnvName({ scope }));
+        startTask(`Authenticating env: ${envLabel}${scope ? ` (${formatCliHomeScope(scope)})` : ''}`);
+        try {
+            await authenticateEnvWithOauth({
+                envName,
+                scope,
+            });
+            succeedTask(`Authenticated env "${envLabel}" with OAuth${scope ? ` in ${formatCliHomeScope(scope)} scope` : ''}.`);
+        }
+        catch (error) {
+            failTask(`Failed to authenticate env "${envLabel}".`);
+            throw error;
+        }
+    }
+}

package/dist/commands/env/list.js

@@ -0,0 +1,41 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { Command, Flags } from '@oclif/core';
+import { listEnvs } from '../../lib/auth-store.js';
+import { formatCliHomeScope } from '../../lib/cli-home.js';
+import { renderTable } from '../../lib/ui.js';
+export default class EnvList extends Command {
+    static summary = 'List configured environments';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    static flags = {
+        scope: Flags.string({
+            char: 's',
+            description: 'Config scope',
+            options: ['project', 'global'],
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(EnvList);
+        const scope = flags.scope;
+        const { currentEnv, envs } = await listEnvs({ scope });
+        const names = Object.keys(envs).sort();
+        if (!names.length) {
+            this.log(`No envs configured${scope ? ` in ${formatCliHomeScope(scope)} scope` : ''}.`);
+            this.log('Run `nb env add <name> --base-url <url>` to add one.');
+            return;
+        }
+        const rows = names.map((name) => {
+            const env = envs[name];
+            return [name === currentEnv ? '*' : '', name, env.baseUrl ?? '', env.auth?.type ?? '', env.runtime?.version ?? ''];
+        });
+        this.log(renderTable(['Current', 'Name', 'Base URL', 'Auth', 'Runtime'], rows));
+    }
+}

package/dist/commands/env/remove.js

@@ -0,0 +1,65 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { Args, Command, Flags } from '@oclif/core';
+import { getCurrentEnvName, removeEnv } from '../../lib/auth-store.js';
+import { formatCliHomeScope } from '../../lib/cli-home.js';
+import { confirmAction, isInteractiveTerminal, printVerbose, setVerboseMode } from '../../lib/ui.js';
+export default class EnvRemove extends Command {
+    static summary = 'Remove a configured environment';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> staging',
+        '<%= config.bin %> <%= command.id %> staging -f',
+    ];
+    static flags = {
+        force: Flags.boolean({
+            char: 'f',
+            description: 'Remove without confirmation',
+            default: false,
+        }),
+        verbose: Flags.boolean({
+            description: 'Show detailed progress output',
+            default: false,
+        }),
+        scope: Flags.string({
+            char: 's',
+            description: 'Config scope',
+            options: ['project', 'global'],
+        }),
+    };
+    static args = {
+        name: Args.string({
+            description: 'Configured environment name',
+            required: true,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(EnvRemove);
+        setVerboseMode(flags.verbose);
+        const scope = flags.scope;
+        const currentEnv = await getCurrentEnvName({ scope });
+        if (args.name === currentEnv && !flags.force) {
+            if (!isInteractiveTerminal()) {
+                this.error('Refusing to remove the current env without confirmation. Re-run with `--force`.');
+            }
+            const confirmed = await confirmAction(`Remove current env "${args.name}"?`, { defaultValue: false });
+            if (!confirmed) {
+                this.log('Canceled.');
+                return;
+            }
+        }
+        printVerbose(`Removing env "${args.name}"`);
+        const result = await removeEnv(args.name, { scope });
+        this.log(`Removed env "${result.removed}"${scope ? ` from ${formatCliHomeScope(scope)} scope` : ''}.`);
+        if (result.hasEnvs) {
+            this.log(`Current env: ${result.currentEnv}`);
+            return;
+        }
+        this.log('No envs configured.');
+    }
+}