@nocobase/cli 2.1.0-alpha.16 → 2.1.0-alpha.18

package/dist/commands/env/update.js

@@ -0,0 +1,58 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Command, Flags } from '@oclif/core';
+import { updateEnvRuntime } from '../../lib/bootstrap.js';
+import { formatCliHomeScope } from '../../lib/cli-home.js';
+import { failTask, startTask, succeedTask } from '../../lib/ui.js';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+export default class EnvUpdate extends Command {
+    static summary = 'Refresh an environment runtime from swagger:get and persist connection overrides';
+    static id = 'env update';
+    static flags = {
+        verbose: Flags.boolean({
+            description: 'Show detailed progress output',
+            default: false,
+        }),
+        env: Flags.string({
+            char: 'e',
+            description: 'Environment name',
+        }),
+        scope: Flags.string({
+            char: 's',
+            description: 'Config scope',
+            options: ['project', 'global'],
+        }),
+        'base-url': Flags.string({
+            description: 'NocoBase API base URL override. When provided, persist it to the target env before saving the refreshed runtime.',
+        }),
+        role: Flags.string({
+            description: 'Role override, sent as X-Role',
+        }),
+        token: Flags.string({
+            char: 't',
+            description: 'API key override. When provided, persist it to the target env before saving the refreshed runtime.',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(EnvUpdate);
+        const scope = flags.scope;
+        const envLabel = flags.env ?? 'current';
+        startTask(`Updating env runtime: ${envLabel}${scope ? ` (${formatCliHomeScope(scope)})` : ''}`);
+        try {
+            const runtime = await updateEnvRuntime({
+                envName: flags.env,
+                scope,
+                baseUrl: flags['base-url'],
+                role: flags.role,
+                token: flags.token,
+                configFile: path.join(path.dirname(path.dirname(path.dirname(__dirname))), 'nocobase-ctl.config.json'),
+                verbose: flags.verbose,
+            });
+            succeedTask(`Updated env "${envLabel}" to runtime "${runtime.version}"${scope ? ` in ${formatCliHomeScope(scope)} scope` : ''}.`);
+        }
+        catch (error) {
+            failTask(`Failed to update env "${envLabel}".`);
+            throw error;
+        }
+    }
+}

package/dist/commands/env/use.js

@@ -0,0 +1,26 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { setCurrentEnv } from '../../lib/auth-store.js';
+import { formatCliHomeScope } from '../../lib/cli-home.js';
+export default class EnvUse extends Command {
+    static summary = 'Switch the current environment';
+    static id = 'env use';
+    static flags = {
+        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(EnvUse);
+        const scope = flags.scope;
+        await setCurrentEnv(args.name, { scope });
+        this.log(`Current env: ${args.name}${scope ? ` (${formatCliHomeScope(scope)} scope)` : ''}`);
+    }
+}

package/dist/commands/resource/create.js

@@ -0,0 +1,15 @@
+import { Command } from '@oclif/core';
+import { buildCreateArgs, createFlags, runResourceCommand } from '../../lib/resource-command.js';
+export default class ResourceCreate extends Command {
+    static summary = 'Create a record in a resource';
+    static description = 'Create a record in a generic resource. Pass record content through --values as a JSON object.';
+    static examples = [
+        `<%= config.bin %> <%= command.id %> --resource users --values '{"nickname":"Ada"}'`,
+        `<%= config.bin %> <%= command.id %> --resource posts.comments --source-id 1 --values '{"content":"Hello"}'`,
+    ];
+    static flags = createFlags;
+    async run() {
+        const { flags } = await this.parse(ResourceCreate);
+        await runResourceCommand(this, 'create', flags, buildCreateArgs(flags));
+    }
+}

package/dist/commands/resource/destroy.js

@@ -0,0 +1,15 @@
+import { Command } from '@oclif/core';
+import { buildDestroyArgs, destroyFlags, runResourceCommand } from '../../lib/resource-command.js';
+export default class ResourceDestroy extends Command {
+    static summary = 'Delete records from a resource';
+    static description = 'Delete records from a generic resource. Target records with --filter-by-tk or --filter.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --resource users --filter-by-tk 1',
+        `<%= config.bin %> <%= command.id %> --resource posts --filter '{"status":"archived"}'`,
+    ];
+    static flags = destroyFlags;
+    async run() {
+        const { flags } = await this.parse(ResourceDestroy);
+        await runResourceCommand(this, 'destroy', flags, buildDestroyArgs(flags));
+    }
+}

package/dist/commands/resource/get.js

@@ -0,0 +1,15 @@
+import { Command } from '@oclif/core';
+import { buildGetArgs, getFlags, runResourceCommand } from '../../lib/resource-command.js';
+export default class ResourceGet extends Command {
+    static summary = 'Get a record from a resource';
+    static description = 'Get a record from a generic resource. Use --filter-by-tk for the primary key and association resource names with --source-id when needed.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --resource users --filter-by-tk 1',
+        '<%= config.bin %> <%= command.id %> --resource posts.comments --source-id 1 --filter-by-tk 2',
+    ];
+    static flags = getFlags;
+    async run() {
+        const { flags } = await this.parse(ResourceGet);
+        await runResourceCommand(this, 'get', flags, buildGetArgs(flags));
+    }
+}

package/dist/commands/resource/index.js

@@ -0,0 +1,7 @@
+import { Command } from '@oclif/core';
+export default class Resource extends Command {
+    static summary = 'Work with generic collection resources';
+    async run() {
+        this.log('Use `nb api resource --help` to view available subcommands.');
+    }
+}

package/dist/commands/resource/list.js

@@ -0,0 +1,16 @@
+import { Command } from '@oclif/core';
+import { buildListArgs, listFlags, runResourceCommand } from '../../lib/resource-command.js';
+export default class ResourceList extends Command {
+    static summary = 'List records from a resource';
+    static description = 'List records from a generic resource. Use association resource names like posts.comments with --source-id when needed.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --resource users',
+        '<%= config.bin %> <%= command.id %> --resource posts.comments --source-id 1 --fields id --fields content',
+        `<%= config.bin %> <%= command.id %> --resource users --filter '{"status":"active"}' --sort=-createdAt`,
+    ];
+    static flags = listFlags;
+    async run() {
+        const { flags } = await this.parse(ResourceList);
+        await runResourceCommand(this, 'list', flags, buildListArgs(flags));
+    }
+}

package/dist/commands/resource/query.js

@@ -0,0 +1,15 @@
+import { Command } from '@oclif/core';
+import { buildQueryArgs, queryFlags, runResourceCommand } from '../../lib/resource-command.js';
+export default class ResourceQuery extends Command {
+    static summary = 'Run an aggregate query on a resource';
+    static description = 'Run an aggregate query on a generic resource. Pass measures, dimensions, and orders as JSON arrays.';
+    static examples = [
+        `<%= config.bin %> <%= command.id %> --resource orders --measures '[{"field":["id"],"aggregation":"count","alias":"count"}]'`,
+        `<%= config.bin %> <%= command.id %> --resource orders --dimensions '[{"field":["status"],"alias":"status"}]' --orders '[{"field":["createdAt"],"order":"desc"}]'`,
+    ];
+    static flags = queryFlags;
+    async run() {
+        const { flags } = await this.parse(ResourceQuery);
+        await runResourceCommand(this, 'query', flags, buildQueryArgs(flags));
+    }
+}

package/dist/commands/resource/update.js

@@ -0,0 +1,15 @@
+import { Command } from '@oclif/core';
+import { buildUpdateArgs, runResourceCommand, updateFlags } from '../../lib/resource-command.js';
+export default class ResourceUpdate extends Command {
+    static summary = 'Update records in a resource';
+    static description = 'Update records in a generic resource. Target records with --filter-by-tk or --filter, and pass updated values through --values.';
+    static examples = [
+        `<%= config.bin %> <%= command.id %> --resource users --filter-by-tk 1 --values '{"nickname":"Grace"}'`,
+        `<%= config.bin %> <%= command.id %> --resource posts --filter '{"status":"draft"}' --values '{"status":"published"}'`,
+    ];
+    static flags = updateFlags;
+    async run() {
+        const { flags } = await this.parse(ResourceUpdate);
+        await runResourceCommand(this, 'update', flags, buildUpdateArgs(flags));
+    }
+}

package/dist/generated/command-registry.js

@@ -0,0 +1,88 @@
+/**
+ * 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 } from '@oclif/core';
+import EnvAdd from "../commands/env/add.js";
+import EnvAuth from "../commands/env/auth.js";
+import EnvList from "../commands/env/list.js";
+import EnvRemove from "../commands/env/remove.js";
+import EnvUpdate from "../commands/env/update.js";
+import EnvUse from "../commands/env/use.js";
+import ResourceCreate from "../commands/resource/create.js";
+import ResourceDestroy from "../commands/resource/destroy.js";
+import ResourceGet from "../commands/resource/get.js";
+import ResourceList from "../commands/resource/list.js";
+import ResourceQuery from "../commands/resource/query.js";
+import ResourceUpdate from "../commands/resource/update.js";
+import { getCurrentEnvName, getEnv } from "../lib/auth-store.js";
+import { createGeneratedFlags, GeneratedApiCommand } from "../lib/generated-command.js";
+import { loadRuntimeSync } from "../lib/runtime-store.js";
+function readEnvName(argv) {
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token === '--env') {
+            return argv[index + 1];
+        }
+        if (token === '-e') {
+            return argv[index + 1];
+        }
+        if (token.startsWith('--env=')) {
+            return token.slice('--env='.length);
+        }
+    }
+    return undefined;
+}
+function createRuntimeCommand(operation) {
+    return class RuntimeCommand extends GeneratedApiCommand {
+        static summary = operation.summary;
+        static description = operation.description;
+        static examples = operation.examples;
+        static flags = createGeneratedFlags(operation);
+        static operation = operation;
+    };
+}
+function createRuntimeIndexCommand(commandId, operation) {
+    return class RuntimeIndexCommand extends Command {
+        static summary = operation.resourceDescription || operation.resourceDisplayName || `Work with ${commandId}`;
+        static description = operation.resourceDescription;
+        async run() {
+            this.log(`Use \`nb ${commandId} --help\` to view available subcommands.`);
+        }
+    };
+}
+const registry = {
+    // env: Env,
+    'env:add': EnvAdd,
+    'env:auth': EnvAuth,
+    'env:list': EnvList,
+    'env:remove': EnvRemove,
+    'env:update': EnvUpdate,
+    'env:use': EnvUse,
+    // 'api:resource': Resource,
+    'api:resource:create': ResourceCreate,
+    'api:resource:destroy': ResourceDestroy,
+    'api:resource:get': ResourceGet,
+    'api:resource:list': ResourceList,
+    'api:resource:query': ResourceQuery,
+    'api:resource:update': ResourceUpdate,
+};
+const envName = readEnvName(process.argv.slice(2)) ?? (await getCurrentEnvName());
+const env = await getEnv(envName);
+const runtime = loadRuntimeSync(env?.runtime?.version);
+for (const operation of runtime?.commands ?? []) {
+    const commandSegments = operation.commandId.split(' ');
+    const commandKey = commandSegments.join(':');
+    registry[`api:${commandKey}`] = createRuntimeCommand(operation);
+    // const topLevelCommandId = commandSegments[0];
+    // const modulePrefix = toKebabCase(operation.moduleDisplayName || operation.moduleName || '');
+    // const isTopLevelResource = Boolean(topLevelCommandId && modulePrefix && topLevelCommandId !== modulePrefix);
+    // if (isTopLevelResource && !registry[`api:${topLevelCommandId}`]) {
+    //   registry[`api:${topLevelCommandId}`] = createRuntimeIndexCommand(`api ${topLevelCommandId}`, operation);
+    // }
+}
+export default registry;

package/dist/lib/api-client.js

@@ -0,0 +1,199 @@
+import { promises as fs } from 'node:fs';
+import { resolveServerRequestTarget } from './env-auth.js';
+function normalizeBaseUrl(baseUrl) {
+    return baseUrl.replace(/\/+$/, '');
+}
+async function parseResponse(response) {
+    const text = await response.text();
+    let data = text;
+    if (text) {
+        try {
+            data = JSON.parse(text);
+        }
+        catch (error) {
+            data = text;
+        }
+    }
+    return {
+        ok: response.ok,
+        status: response.status,
+        data,
+    };
+}
+function parseScalarValue(value, type) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (type === 'boolean') {
+        return value;
+    }
+    if (type === 'integer' || type === 'number') {
+        return Number(value);
+    }
+    if (typeof value !== 'string') {
+        return value;
+    }
+    const trimmed = value.trim();
+    if ((trimmed.startsWith('{') && trimmed.endsWith('}')) || (trimmed.startsWith('[') && trimmed.endsWith(']'))) {
+        try {
+            return JSON.parse(trimmed);
+        }
+        catch (error) {
+            return value;
+        }
+    }
+    return value;
+}
+function hasParameterValue(flags, parameter) {
+    const value = flags[parameter.flagName];
+    if (parameter.type === 'boolean') {
+        return value !== undefined;
+    }
+    if (Array.isArray(value)) {
+        return value.length > 0;
+    }
+    return value !== undefined && value !== '';
+}
+function listProvidedBodyFlags(flags, parameters) {
+    return parameters
+        .filter((parameter) => hasParameterValue(flags, parameter))
+        .map((parameter) => `--${parameter.flagName}`);
+}
+export async function parseBody(flags, operation) {
+    const inlineBody = flags.body;
+    const bodyFile = flags['body-file'];
+    const bodyParameters = operation.parameters.filter((parameter) => parameter.in === 'body');
+    const hasBodyFlags = bodyParameters.some((parameter) => hasParameterValue(flags, parameter));
+    if ((inlineBody || bodyFile) && hasBodyFlags) {
+        const providedBodyFlags = listProvidedBodyFlags(flags, bodyParameters);
+        const rawBodyInput = inlineBody ? '--body' : '--body-file';
+        throw new Error(`Conflicting request body inputs: received ${rawBodyInput} together with body field flags (${providedBodyFlags.join(', ')}). Use either body field flags or --body/--body-file.`);
+    }
+    if (inlineBody) {
+        return JSON.parse(inlineBody);
+    }
+    if (bodyFile) {
+        return fs.readFile(bodyFile, 'utf8').then((content) => JSON.parse(content));
+    }
+    if (!bodyParameters.length) {
+        return undefined;
+    }
+    const body = {};
+    for (const parameter of bodyParameters) {
+        const rawValue = flags[parameter.flagName];
+        const value = parameter.isArray && !parameter.jsonEncoded
+            ? (Array.isArray(rawValue) ? rawValue : rawValue ? [rawValue] : undefined)
+            : parseScalarValue(rawValue, parameter.type);
+        if (parameter.required && (value === undefined || value === '')) {
+            throw new Error(`Missing required body field --${parameter.flagName}`);
+        }
+        if (value === undefined) {
+            continue;
+        }
+        body[parameter.name] = value;
+    }
+    if (Object.keys(body).length > 0) {
+        return body;
+    }
+    if (operation.hasBody && operation.bodyRequired) {
+        throw new Error('Missing request body. Use body field flags or --body/--body-file.');
+    }
+    return undefined;
+}
+export async function executeApiRequest(options) {
+    const { baseUrl, token } = await resolveServerRequestTarget(options);
+    const headers = new Headers();
+    if (token) {
+        headers.set('authorization', `Bearer ${token}`);
+    }
+    if (options.role) {
+        headers.set('x-role', options.role);
+    }
+    const query = new URLSearchParams();
+    let requestPath = options.operation.pathTemplate;
+    for (const parameter of options.operation.parameters) {
+        if (parameter.in === 'body') {
+            continue;
+        }
+        const rawValue = options.flags[parameter.flagName];
+        const value = parameter.isArray
+            ? (Array.isArray(rawValue) ? rawValue : rawValue ? [rawValue] : undefined)
+            : parseScalarValue(rawValue, parameter.type);
+        if (parameter.required && (value === undefined || value === '')) {
+            throw new Error(`Missing required parameter --${parameter.flagName}`);
+        }
+        if (value === undefined) {
+            continue;
+        }
+        if (parameter.in === 'path') {
+            requestPath = requestPath.replace(`{${parameter.name}}`, encodeURIComponent(String(value)));
+            continue;
+        }
+        if (parameter.in === 'query') {
+            if (Array.isArray(value)) {
+                value.forEach((item) => query.append(parameter.name, String(parseScalarValue(item, parameter.type))));
+            }
+            else if (typeof value === 'object') {
+                query.set(parameter.name, JSON.stringify(value));
+            }
+            else {
+                query.set(parameter.name, String(value));
+            }
+            continue;
+        }
+        if (parameter.in === 'header') {
+            headers.set(parameter.name, typeof value === 'object' ? JSON.stringify(value) : String(value));
+            continue;
+        }
+    }
+    const body = await parseBody(options.flags, options.operation);
+    if (body !== undefined) {
+        headers.set('content-type', 'application/json');
+    }
+    const url = new URL(`${normalizeBaseUrl(baseUrl)}${requestPath}`);
+    query.forEach((value, key) => url.searchParams.append(key, value));
+    const response = await fetch(url, {
+        method: options.operation.method.toUpperCase(),
+        headers,
+        body: body === undefined ? undefined : JSON.stringify(body),
+    });
+    return parseResponse(response);
+}
+export async function executeRawApiRequest(options) {
+    const { baseUrl, token } = await resolveServerRequestTarget(options);
+    const headers = new Headers();
+    if (token) {
+        headers.set('authorization', `Bearer ${token}`);
+    }
+    if (options.role) {
+        headers.set('x-role', options.role);
+    }
+    for (const [name, value] of Object.entries(options.headers ?? {})) {
+        if (value === undefined || value === null || value === '') {
+            continue;
+        }
+        headers.set(name, typeof value === 'object' ? JSON.stringify(value) : String(value));
+    }
+    if (options.body !== undefined) {
+        headers.set('content-type', 'application/json');
+    }
+    const url = new URL(`${normalizeBaseUrl(baseUrl)}${options.path}`);
+    for (const [key, value] of Object.entries(options.query ?? {})) {
+        if (value === undefined) {
+            continue;
+        }
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                url.searchParams.append(key, typeof item === 'object' ? JSON.stringify(item) : String(item));
+            }
+            continue;
+        }
+        url.searchParams.set(key, typeof value === 'object' ? JSON.stringify(value) : String(value));
+    }
+    const response = await fetch(url, {
+        method: options.method.toUpperCase(),
+        headers,
+        body: options.body === undefined ? undefined : JSON.stringify(options.body),
+    });
+    return parseResponse(response);
+}

package/dist/lib/auth-store.js

@@ -0,0 +1,155 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { resolveCliHomeDir } from './cli-home.js';
+const DEFAULT_CONFIG = {
+    currentEnv: 'default',
+    envs: {},
+};
+function getConfigFile(options = {}) {
+    return path.join(resolveCliHomeDir(options.scope), 'config.json');
+}
+export async function loadAuthConfig(options = {}) {
+    try {
+        const content = await fs.readFile(getConfigFile(options), 'utf8');
+        const parsed = JSON.parse(content);
+        return {
+            currentEnv: parsed.currentEnv || 'default',
+            envs: parsed.envs || {},
+        };
+    }
+    catch (_error) {
+        return DEFAULT_CONFIG;
+    }
+}
+export async function saveAuthConfig(config, options = {}) {
+    const filePath = getConfigFile(options);
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, JSON.stringify(config, null, 2));
+}
+export async function listEnvs(options = {}) {
+    const config = await loadAuthConfig(options);
+    return {
+        currentEnv: config.currentEnv || 'default',
+        envs: config.envs,
+    };
+}
+export async function getCurrentEnvName(options = {}) {
+    const config = await loadAuthConfig(options);
+    return config.currentEnv || 'default';
+}
+export async function setCurrentEnv(envName, options = {}) {
+    const config = await loadAuthConfig(options);
+    if (!config.envs[envName]) {
+        throw new Error(`Env "${envName}" is not configured`);
+    }
+    config.currentEnv = envName;
+    await saveAuthConfig(config, options);
+}
+export async function getEnv(envName, options = {}) {
+    const config = await loadAuthConfig(options);
+    const resolved = envName || config.currentEnv || 'default';
+    return config.envs[resolved];
+}
+function areAuthConfigsEquivalent(left, right) {
+    if (!left && !right) {
+        return true;
+    }
+    if (!left || !right || left.type !== right.type) {
+        return false;
+    }
+    if (left.type === 'token' && right.type === 'token') {
+        return left.accessToken === right.accessToken;
+    }
+    if (left.type === 'oauth' && right.type === 'oauth') {
+        return (left.accessToken === right.accessToken &&
+            left.refreshToken === right.refreshToken &&
+            left.expiresAt === right.expiresAt &&
+            left.scope === right.scope &&
+            left.issuer === right.issuer &&
+            left.clientId === right.clientId &&
+            left.resource === right.resource);
+    }
+    return false;
+}
+async function writeEnv(envName, updater, options = {}) {
+    const config = await loadAuthConfig(options);
+    const previous = config.envs[envName];
+    config.envs[envName] = updater(previous);
+    config.currentEnv = envName;
+    await saveAuthConfig(config, options);
+}
+export async function upsertEnv(envName, baseUrl, accessToken, options = {}) {
+    await writeEnv(envName, (previous) => {
+        const baseUrlChanged = previous?.baseUrl !== baseUrl;
+        const nextAuth = accessToken
+            ? {
+                type: 'token',
+                accessToken,
+            }
+            : baseUrlChanged || previous?.auth?.type === 'token'
+                ? undefined
+                : previous?.auth;
+        const authChanged = !areAuthConfigsEquivalent(previous?.auth, nextAuth);
+        return {
+            ...previous,
+            baseUrl,
+            auth: nextAuth,
+            runtime: baseUrlChanged || authChanged ? undefined : previous?.runtime,
+        };
+    }, options);
+}
+export async function updateEnvConnection(envName, updates, options = {}) {
+    await writeEnv(envName, (previous) => {
+        const nextBaseUrl = updates.baseUrl ?? previous?.baseUrl;
+        const baseUrlChanged = previous?.baseUrl !== nextBaseUrl;
+        const nextAuth = updates.accessToken
+            ? {
+                type: 'token',
+                accessToken: updates.accessToken,
+            }
+            : baseUrlChanged || previous?.auth?.type === 'token'
+                ? undefined
+                : previous?.auth;
+        const authChanged = !areAuthConfigsEquivalent(previous?.auth, nextAuth);
+        return {
+            ...previous,
+            ...(nextBaseUrl !== undefined ? { baseUrl: nextBaseUrl } : {}),
+            auth: nextAuth,
+            runtime: baseUrlChanged || authChanged ? undefined : previous?.runtime,
+        };
+    }, options);
+}
+export async function setEnvOauthSession(envName, auth, options = {}) {
+    await writeEnv(envName, (previous) => ({
+        ...previous,
+        auth,
+        runtime: options.preserveRuntime ? previous?.runtime : undefined,
+    }), options);
+}
+export async function setEnvRuntime(envName, runtime, options = {}) {
+    const config = await loadAuthConfig(options);
+    const current = config.envs[envName] ?? {};
+    config.envs[envName] = {
+        ...current,
+        runtime,
+    };
+    config.currentEnv = envName;
+    await saveAuthConfig(config, options);
+}
+export async function removeEnv(envName, options = {}) {
+    const config = await loadAuthConfig(options);
+    if (!config.envs[envName]) {
+        throw new Error(`Env "${envName}" is not configured`);
+    }
+    delete config.envs[envName];
+    if (config.currentEnv === envName) {
+        const nextEnv = Object.keys(config.envs).sort()[0];
+        config.currentEnv = nextEnv ?? 'default';
+    }
+    await saveAuthConfig(config, options);
+    return {
+        removed: envName,
+        currentEnv: config.currentEnv || 'default',
+        hasEnvs: Object.keys(config.envs).length > 0,
+    };
+}