@nocobase/cli 2.1.0-alpha.46 → 2.1.0-alpha.47

package/dist/commands/env/proxy/index.js

@@ -0,0 +1,353 @@
+/**
+ * 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 { mkdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { Args, Command, Flags, loadHelpClass } from '@oclif/core';
+import { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime, } from '../../../lib/app-runtime.js';
+import { resolveDefaultConfigScope } from '../../../lib/cli-home.js';
+import { translateCli } from '../../../lib/cli-locale.js';
+import { applyEnvProxyAppEntryOptions, appConfigIncludesGeneratedConfig, appConfigHasManagedGeneratedConfigBlock, appConfigHasManagedNginxBlock, buildManagedAppEntryGeneratedConfigBlock, buildEnvProxyCaddyBundle, buildEnvProxyNginxBundle, extractManagedNginxConfigBlock, installEnvProxyProvider, reloadEnvProxyProvider, replaceManagedAppEntryGeneratedConfigBlock, replaceManagedNginxConfigBlock, syncEnvProxyNginxSnippets, } from '../../../lib/env-proxy.js';
+import { announceTargetEnv, failTask, startTask, succeedTask } from '../../../lib/ui.js';
+async function readOptionalTextFile(filePath) {
+    try {
+        return await readFile(filePath, 'utf8');
+    }
+    catch (error) {
+        const code = error && typeof error === 'object' && 'code' in error ? error.code : undefined;
+        if (code === 'ENOENT') {
+            return undefined;
+        }
+        throw error;
+    }
+}
+function buildEditableAppEntryReferenceLine(provider, generatedConfigPath) {
+    if (provider === 'caddy') {
+        return `import ./${path.basename(generatedConfigPath)}`;
+    }
+    return `include ${generatedConfigPath};`;
+}
+function replaceEditableAppEntryReferenceWithManagedBlock(content, provider, currentGeneratedConfigPath, nextGeneratedConfigPath) {
+    const currentReferenceLine = buildEditableAppEntryReferenceLine(provider, currentGeneratedConfigPath);
+    const nextBlock = buildManagedAppEntryGeneratedConfigBlock(provider, nextGeneratedConfigPath);
+    const escapedComment = provider === 'caddy'
+        ? '# Keep this import so `nb env proxy` can refresh managed routes.'
+        : '# Keep this include so `nb env proxy` can refresh managed routes.';
+    const escapedCommentPattern = escapedComment.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const escapedLinePattern = currentReferenceLine.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const legacyBlockPattern = new RegExp(`[ \\t]*${escapedCommentPattern}\\n[ \\t]*${escapedLinePattern.replace(/;$/, ';?')}`, 'm');
+    if (legacyBlockPattern.test(content)) {
+        return content.replace(legacyBlockPattern, nextBlock);
+    }
+    return content.replace(currentReferenceLine, nextBlock);
+}
+function normalizeProxyListenPort(value) {
+    const normalized = value?.trim() || undefined;
+    if (!normalized || !/^\d+$/.test(normalized)) {
+        return undefined;
+    }
+    const port = Number(normalized);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+        return undefined;
+    }
+    return normalized;
+}
+function buildNginxManagedBlockMissingMessage(appConfigPath) {
+    return translateCli('commands.envProxy.errors.nginxAppEntryMissingManagedBlock', {
+        appConfigPath,
+    }, {
+        fallback: `The editable nginx app entry config at ${appConfigPath} does not contain the NocoBase managed block. ` +
+            'Restore the managed block or delete the file and rerun `nb env proxy`.',
+    });
+}
+async function writeNginxProxyBundle(runtime, appEntryOptions, options) {
+    const bundle = await buildEnvProxyNginxBundle(runtime, { scope: options?.scope });
+    const managedConfigBlock = extractManagedNginxConfigBlock(bundle.appConfigContent);
+    if (!managedConfigBlock) {
+        throw new Error('Failed to render the managed nginx config block.');
+    }
+    const currentAppConfigContent = await readOptionalTextFile(bundle.appConfigPath);
+    let nextAppConfigContent = applyEnvProxyAppEntryOptions(bundle.appConfigContent, 'nginx', appEntryOptions);
+    let status = 'created';
+    if (currentAppConfigContent) {
+        if (!appConfigHasManagedNginxBlock(currentAppConfigContent)) {
+            throw new Error(buildNginxManagedBlockMissingMessage(bundle.appConfigPath));
+        }
+        nextAppConfigContent = applyEnvProxyAppEntryOptions(replaceManagedNginxConfigBlock(currentAppConfigContent, managedConfigBlock), 'nginx', appEntryOptions);
+        status = 'updated';
+    }
+    await Promise.all([mkdir(bundle.entryDir, { recursive: true }), mkdir(bundle.publicDir, { recursive: true })]);
+    await Promise.all([
+        writeFile(bundle.appConfigPath, nextAppConfigContent, 'utf8'),
+        writeFile(bundle.indexV1Path, bundle.indexV1Content, 'utf8'),
+        writeFile(bundle.indexV2Path, bundle.indexV2Content, 'utf8'),
+        writeFile(bundle.mainConfigPath, bundle.mainConfigContent, 'utf8'),
+        syncEnvProxyNginxSnippets({ scope: options?.scope }),
+    ]);
+    return {
+        bundle,
+        status,
+    };
+}
+async function writeCaddyProxyBundle(runtime, appEntryOptions, options) {
+    const bundle = await buildEnvProxyCaddyBundle(runtime, { scope: options?.scope });
+    const currentAppConfigContent = await readOptionalTextFile(bundle.appConfigPath);
+    let nextAppConfigContent = applyEnvProxyAppEntryOptions(bundle.appConfigContent, 'caddy', appEntryOptions);
+    let status = 'created';
+    if (currentAppConfigContent) {
+        if (appConfigHasManagedGeneratedConfigBlock(currentAppConfigContent)) {
+            nextAppConfigContent = applyEnvProxyAppEntryOptions(replaceManagedAppEntryGeneratedConfigBlock(currentAppConfigContent, 'caddy', bundle.generatedConfigPath), 'caddy', appEntryOptions);
+            status = 'updated';
+        }
+        else if (appConfigIncludesGeneratedConfig(currentAppConfigContent, bundle.generatedConfigPath, 'caddy')) {
+            nextAppConfigContent = applyEnvProxyAppEntryOptions(replaceEditableAppEntryReferenceWithManagedBlock(currentAppConfigContent, 'caddy', bundle.generatedConfigPath, bundle.generatedConfigPath), 'caddy', appEntryOptions);
+            status = 'migrated';
+        }
+        else {
+            throw new Error(translateCli('commands.envProxy.errors.appEntryMissingInclude', {
+                envName: runtime.envName,
+                appConfigPath: bundle.appConfigPath,
+                generatedConfigPath: bundle.generatedConfigPath,
+            }, {
+                fallback: `The editable app entry config at ${bundle.appConfigPath} does not reference ${bundle.generatedConfigPath}. ` +
+                    'Add the managed generated-config reference back into the editable app entry and rerun the command.',
+            }));
+        }
+    }
+    await Promise.all([mkdir(bundle.entryDir, { recursive: true }), mkdir(bundle.publicDir, { recursive: true })]);
+    await Promise.all([
+        writeFile(bundle.appConfigPath, nextAppConfigContent, 'utf8'),
+        writeFile(bundle.generatedConfigPath, bundle.generatedConfigContent, 'utf8'),
+        writeFile(bundle.indexV1Path, bundle.indexV1Content, 'utf8'),
+        writeFile(bundle.indexV2Path, bundle.indexV2Content, 'utf8'),
+        writeFile(bundle.mainConfigPath, bundle.mainConfigContent, 'utf8'),
+    ]);
+    return {
+        bundle,
+        status,
+    };
+}
+export const ENV_PROXY_NAME_ARG = Args.string({
+    description: 'Configured environment name to generate a proxy config for. Defaults to the current env when omitted',
+    required: false,
+});
+function createEnvProxySharedFlags() {
+    return {
+        env: Flags.string({
+            char: 'e',
+            description: 'Configured environment name to generate a proxy config for. Defaults to the current env when omitted',
+        }),
+        host: Flags.string({
+            description: 'Host exposed by the proxy entry config, such as example.com or localhost',
+        }),
+        port: Flags.string({
+            description: 'Port exposed by the proxy entry config, not the upstream NocoBase app port',
+        }),
+        install: Flags.boolean({
+            description: 'Install the rendered provider config into the provider main config when supported',
+            default: false,
+        }),
+        reload: Flags.boolean({
+            description: 'Validate and reload the provider after writing the proxy config',
+            default: false,
+        }),
+        print: Flags.boolean({
+            description: 'Print the rendered config to stdout instead of writing files',
+            default: false,
+        }),
+    };
+}
+export function createEnvProxyNginxFlags() {
+    return {
+        ...createEnvProxySharedFlags(),
+    };
+}
+export function createEnvProxyCaddyFlags() {
+    return {
+        ...createEnvProxySharedFlags(),
+        output: Flags.string({
+            char: 'o',
+            description: 'Output file path for providers that emit a single generated config file',
+        }),
+    };
+}
+function resolveRequestedEnv(command, args, flags) {
+    const envNameArg = args.name?.trim() || undefined;
+    const envNameFlag = flags.env?.trim() || undefined;
+    if (envNameArg && envNameFlag && envNameArg !== envNameFlag) {
+        command.error(`Environment name was provided both as the argument ("${envNameArg}") and as --env ("${envNameFlag}"). Please use only one.`);
+    }
+    return envNameArg || envNameFlag;
+}
+function resolveAppEntryOptions(command, flags) {
+    const requestedHost = flags.host?.trim() || undefined;
+    const requestedPort = flags.port?.trim() || undefined;
+    if (requestedPort && !normalizeProxyListenPort(requestedPort)) {
+        command.error(translateCli('commands.envProxy.errors.invalidProxyPort', { port: requestedPort }, {
+            fallback: `Invalid proxy entry port "${requestedPort}". Use an integer between 1 and 65535.`,
+        }));
+    }
+    return {
+        host: requestedHost,
+        port: normalizeProxyListenPort(requestedPort),
+    };
+}
+export async function runEnvProxyCommand(command, args, flags, provider) {
+    const scope = resolveDefaultConfigScope();
+    const requestedEnv = resolveRequestedEnv(command, args, flags);
+    if (flags.print && (flags.install || flags.reload)) {
+        command.error('`--print` cannot be combined with `--install` or `--reload`.');
+    }
+    if (flags.output && (flags.install || flags.reload)) {
+        command.error('`--output` cannot be combined with `--install` or `--reload` in the current implementation.');
+    }
+    const appEntryOptions = resolveAppEntryOptions(command, flags);
+    const runtime = await resolveManagedAppRuntime(requestedEnv);
+    if (!runtime) {
+        command.error(formatMissingManagedAppEnvMessage(requestedEnv));
+    }
+    if (runtime.kind === 'http') {
+        command.error(translateCli('commands.envProxy.errors.httpEnvUnsupported', { envName: runtime.envName }, {
+            fallback: `Can't generate a proxy config for "${runtime.envName}" from this machine because the env only has an API connection.`,
+        }));
+    }
+    if (runtime.kind === 'ssh') {
+        command.error(translateCli('commands.envProxy.errors.sshEnvUnsupported', { envName: runtime.envName }, {
+            fallback: `Can't generate a proxy config for "${runtime.envName}" yet because SSH envs are not implemented.`,
+        }));
+    }
+    announceTargetEnv(runtime.envName);
+    if (flags.output) {
+        command.error(translateCli(provider === 'nginx'
+            ? 'commands.envProxy.errors.nginxOutputUnsupported'
+            : 'commands.envProxy.errors.caddyOutputUnsupported', {
+            envName: runtime.envName,
+        }, {
+            fallback: provider === 'nginx'
+                ? 'The nginx provider does not support `--output`. It writes `app.conf`, `public/index-v1.html`, `public/index-v2.html`, and `nocobase.conf` into `~/.nocobase/proxy/nginx/<env>/`.'
+                : 'The caddy provider does not support `--output`. It writes `app.caddy`, `generated.caddy`, `public/index-v1.html`, `public/index-v2.html`, and `nocobase.caddy` into `~/.nocobase/proxy/caddy/<env>/`.',
+        }));
+    }
+    startTask(translateCli('commands.envProxy.messages.generating', { envName: runtime.envName }, {
+        fallback: `Generating proxy config for env "${runtime.envName}"...`,
+    }));
+    const generationFailureMessage = translateCli('commands.envProxy.messages.failed', { envName: runtime.envName }, {
+        fallback: `Failed to generate proxy config for env "${runtime.envName}".`,
+    });
+    const installStartMessage = translateCli('commands.envProxy.messages.installingProvider', { provider }, {
+        fallback: `Installing the shared proxy config into ${provider}...`,
+    });
+    const installFailureMessage = translateCli('commands.envProxy.messages.installProviderFailed', { provider }, {
+        fallback: `Failed to install the shared proxy config into ${provider}.`,
+    });
+    const reloadStartMessage = translateCli('commands.envProxy.messages.reloadingProvider', { provider }, {
+        fallback: `Validating and reloading ${provider}...`,
+    });
+    const reloadFailureMessage = translateCli('commands.envProxy.messages.reloadProviderFailed', { provider }, {
+        fallback: `Failed to validate and reload ${provider}.`,
+    });
+    try {
+        if (flags.print) {
+            if (provider === 'nginx') {
+                const bundle = await buildEnvProxyNginxBundle(runtime, { scope });
+                process.stdout.write(applyEnvProxyAppEntryOptions(bundle.appConfigContent, provider, appEntryOptions));
+            }
+            else {
+                const bundle = await buildEnvProxyCaddyBundle(runtime, { scope });
+                process.stdout.write(applyEnvProxyAppEntryOptions(bundle.appConfigContent, provider, appEntryOptions));
+            }
+            succeedTask(translateCli('commands.envProxy.messages.printed', { envName: runtime.envName }, {
+                fallback: `Printed proxy config for env "${runtime.envName}".`,
+            }));
+            return;
+        }
+        if (provider === 'nginx') {
+            const { bundle, status } = await writeNginxProxyBundle(runtime, appEntryOptions, { scope });
+            succeedTask(translateCli(status === 'created'
+                ? 'commands.envProxy.messages.savedNginxBundleCreated'
+                : 'commands.envProxy.messages.savedNginxBundleUpdated', {
+                envName: runtime.envName,
+                appConfigPath: bundle.appConfigPath,
+                entryDir: bundle.entryDir,
+            }, {
+                fallback: status === 'created'
+                    ? `Saved nginx proxy files for env "${runtime.envName}" under ${bundle.entryDir}, and created editable app entry config at ${bundle.appConfigPath}.`
+                    : `Saved nginx proxy files for env "${runtime.envName}" under ${bundle.entryDir}, and refreshed editable app entry config at ${bundle.appConfigPath}.`,
+            }));
+        }
+        else {
+            const { bundle, status } = await writeCaddyProxyBundle(runtime, appEntryOptions, { scope });
+            succeedTask(translateCli(status === 'created'
+                ? 'commands.envProxy.messages.savedCaddyBundleCreated'
+                : status === 'migrated'
+                    ? 'commands.envProxy.messages.savedCaddyBundleMigrated'
+                    : 'commands.envProxy.messages.savedCaddyBundleUpdated', { envName: runtime.envName, entryDir: bundle.entryDir, appConfigPath: bundle.appConfigPath }, {
+                fallback: status === 'created'
+                    ? `Saved caddy proxy files for env "${runtime.envName}" under ${bundle.entryDir}, and created editable app entry config at ${bundle.appConfigPath}.`
+                    : status === 'migrated'
+                        ? `Saved caddy proxy files for env "${runtime.envName}" under ${bundle.entryDir}, and migrated the app entry config at ${bundle.appConfigPath}.`
+                        : `Saved caddy proxy files for env "${runtime.envName}" under ${bundle.entryDir}, and refreshed editable app entry config at ${bundle.appConfigPath}.`,
+            }));
+        }
+    }
+    catch (error) {
+        failTask(generationFailureMessage);
+        command.error(error instanceof Error ? error.message : String(error));
+    }
+    if (flags.install) {
+        startTask(installStartMessage);
+        try {
+            const installResult = await installEnvProxyProvider(provider, { scope });
+            succeedTask(installResult.status === 'already-installed'
+                ? translateCli('commands.envProxy.messages.providerAlreadyInstalled', { provider, configPath: installResult.configPath }, {
+                    fallback: `The shared proxy config is already installed in the ${provider} main config at ${installResult.configPath}.`,
+                })
+                : translateCli('commands.envProxy.messages.providerInstalled', { provider, configPath: installResult.configPath }, {
+                    fallback: `Installed the shared proxy config into the ${provider} main config at ${installResult.configPath}.`,
+                }));
+        }
+        catch (error) {
+            failTask(installFailureMessage);
+            command.error(error instanceof Error ? error.message : String(error));
+        }
+    }
+    if (flags.reload) {
+        startTask(reloadStartMessage);
+        try {
+            await reloadEnvProxyProvider(provider, { scope });
+            succeedTask(translateCli('commands.envProxy.messages.providerReloaded', { provider }, {
+                fallback: `Validated and reloaded ${provider}.`,
+            }));
+        }
+        catch (error) {
+            failTask(reloadFailureMessage);
+            command.error(error instanceof Error ? error.message : String(error));
+        }
+    }
+}
+export default class EnvProxy extends Command {
+    static summary = 'Generate proxy configs for one managed env through provider subcommands';
+    static description = 'Use `nb env proxy nginx` or `nb env proxy caddy` to generate provider-specific proxy files.';
+    static examples = [
+        '<%= config.bin %> env proxy nginx',
+        '<%= config.bin %> env proxy nginx --env app1',
+        '<%= config.bin %> env proxy nginx --env app1 --install --reload',
+        '<%= config.bin %> env proxy caddy',
+        '<%= config.bin %> env proxy caddy --env app1',
+        '<%= config.bin %> env proxy caddy --env app1 --install --reload',
+        '<%= config.bin %> env proxy caddy --env app1 --print',
+    ];
+    async run() {
+        await this.parse(EnvProxy);
+        const Help = await loadHelpClass(this.config);
+        await new Help(this.config, this.config.pjson.oclif.helpOptions ?? this.config.pjson.helpOptions).showHelp([
+            this.id ?? 'env proxy',
+            ...this.argv,
+        ]);
+    }
+}

package/dist/commands/env/proxy/nginx.js

@@ -0,0 +1,28 @@
+/**
+ * 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 { createEnvProxyNginxFlags, ENV_PROXY_NAME_ARG, runEnvProxyCommand } from './index.js';
+export default class EnvProxyNginx extends Command {
+    static summary = 'Generate nginx proxy files for one managed env';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --env app1',
+        '<%= config.bin %> <%= command.id %> --env app1 --host a.local.nocobase.com --port 8080',
+        '<%= config.bin %> <%= command.id %> --env app1 --install --reload',
+        '<%= config.bin %> <%= command.id %> --env app1 --print',
+    ];
+    static args = {
+        name: ENV_PROXY_NAME_ARG,
+    };
+    static flags = createEnvProxyNginxFlags();
+    async run() {
+        const { args, flags } = await this.parse(EnvProxyNginx);
+        await runEnvProxyCommand(this, args, flags, 'nginx');
+    }
+}

package/dist/commands/env/remove.js

@@ -7,26 +7,104 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import { Args, Command, Flags } from '@oclif/core';
+import { resolveManagedAppRuntime } from '../../lib/app-runtime.js';
 import { getCurrentEnvName, loadAuthConfig, removeEnv } from '../../lib/auth-store.js';
 import { resolveDefaultConfigScope } from '../../lib/cli-home.js';
-import { confirm } from "../../lib/inquirer.js";
-import { isInteractiveTerminal, printVerbose, setVerboseMode } from '../../lib/ui.js';
+import { confirm, input } from "../../lib/inquirer.js";
+import { isInteractiveTerminal, printInfo, printVerbose, setVerboseMode } from '../../lib/ui.js';
+function formatRemoveForceRequiredMessage(envName, purge) {
+    if (purge) {
+        return [
+            `Refusing to purge env "${envName}" without confirmation in non-interactive mode.`,
+            'Re-run with `--purge --force` to continue.',
+        ].join('\n');
+    }
+    return [
+        `Refusing to remove env "${envName}" without confirmation in non-interactive mode.`,
+        'Re-run with `--force` to continue.',
+    ].join('\n');
+}
+function buildRemovePrompt(runtime, options) {
+    const subject = options.isCurrent ? `current env "${runtime.envName}"` : `env "${runtime.envName}"`;
+    if (options.purge) {
+        const lines = [`Purge ${subject}?`];
+        if (runtime.kind === 'local' || runtime.kind === 'docker') {
+            lines.push('This removes CLI-managed local runtime resources for this env on this machine.');
+            lines.push('Storage data will be removed, and downloaded local app files will be removed when applicable.');
+            lines.push('External database services are not managed by the CLI and will be left untouched.');
+        }
+        else {
+            lines.push('This env has no CLI-managed local runtime resources on this machine.');
+            lines.push('Only the saved CLI env config will be removed. External services are not touched.');
+        }
+        lines.push(`Type "${runtime.envName}" to confirm:`);
+        return lines.join('\n');
+    }
+    const lines = [`Remove ${subject}?`];
+    if (runtime.kind === 'local' || runtime.kind === 'docker') {
+        lines.push('NocoBase and any CLI-managed built-in database for this env will be stopped on this machine.');
+        lines.push('The saved CLI env config will then be removed. Storage data and local app files will be kept.');
+    }
+    else {
+        lines.push('Only the saved CLI env config will be removed.');
+    }
+    return lines.join('\n');
+}
+async function confirmEnvRemoval(runtime, options) {
+    if (!isInteractiveTerminal()) {
+        if (options.force) {
+            return true;
+        }
+        throw new Error(formatRemoveForceRequiredMessage(runtime.envName, options.purge));
+    }
+    if (options.force) {
+        return true;
+    }
+    if (options.purge) {
+        try {
+            await input({
+                message: buildRemovePrompt(runtime, options),
+                required: true,
+                validate: (value) => (value.trim() === runtime.envName ? true : `Type "${runtime.envName}" to confirm.`),
+                placeholder: runtime.envName,
+            });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    try {
+        return await confirm({
+            message: buildRemovePrompt(runtime, options),
+            default: false,
+        });
+    }
+    catch {
+        return false;
+    }
+}
 export default class EnvRemove extends Command {
     static summary = 'Remove a configured environment';
-    static description = 'Remove the saved CLI env config for an environment. This command does not clean local app files, containers, or storage data.';
+    static description = 'Remove a configured env. Local and Docker envs stop CLI-managed runtime resources on this machine first; pass `--purge` to also delete managed local resources, storage data, and downloaded app files when applicable.';
     static examples = [
         '<%= config.bin %> <%= command.id %> staging',
-        '<%= config.bin %> <%= command.id %> staging --yes',
+        '<%= config.bin %> <%= command.id %> staging --force',
+        '<%= config.bin %> <%= command.id %> staging --purge --force',
     ];
     static flags = {
         yes: Flags.boolean({
             char: 'y',
-            description: 'Skip confirmation and remove the saved CLI env config',
+            hidden: true,
             default: false,
         }),
         force: Flags.boolean({
             char: 'f',
-            hidden: true,
+            description: 'Skip confirmation for the selected remove mode',
+            default: false,
+        }),
+        purge: Flags.boolean({
+            description: 'Also remove CLI-managed local runtime resources, storage data, and downloaded app files when applicable. For remote API envs, only the saved CLI env config will be removed.',
             default: false,
         }),
         verbose: Flags.boolean({
@@ -49,25 +127,37 @@ export default class EnvRemove extends Command {
             this.error(`Env "${args.name}" is not configured`);
         }
         const currentEnv = await getCurrentEnvName({ scope });
+        const runtime = await resolveManagedAppRuntime(args.name);
+        if (!runtime) {
+            this.error(`Env "${args.name}" is not configured`);
+        }
         const skipConfirmation = flags.yes || flags.force;
-        if (!skipConfirmation) {
-            if (!isInteractiveTerminal()) {
-                this.error(`Refusing to remove env "${args.name}" without confirmation in non-interactive mode. Re-run with \`--yes\` to remove only the saved CLI env config.`);
-            }
-            const subject = args.name === currentEnv ? `current env "${args.name}"` : `env "${args.name}"`;
-            let confirmed = false;
-            try {
-                confirmed = await confirm({
-                    message: `Remove ${subject}? Only the saved CLI env config will be removed.`,
-                    default: false,
-                });
-            }
-            catch {
-                return;
-            }
-            if (!confirmed) {
+        let confirmed = false;
+        try {
+            confirmed = await confirmEnvRemoval(runtime, {
+                force: skipConfirmation,
+                isCurrent: args.name === currentEnv,
+                purge: flags.purge,
+            });
+        }
+        catch (error) {
+            this.error(error instanceof Error ? error.message : String(error));
+        }
+        if (!confirmed) {
+            return;
+        }
+        const runCommand = this.config.runCommand.bind(this.config);
+        const verboseArgv = flags.verbose ? ['--verbose'] : [];
+        if (flags.purge) {
+            if (runtime.kind === 'local' || runtime.kind === 'docker') {
+                await runCommand('app:destroy', ['--env', runtime.envName, '--force', ...verboseArgv]);
                 return;
             }
+            printInfo(`No local CLI-managed resources were found for "${runtime.envName}". Removing the saved CLI env config only.`);
+        }
+        else if (runtime.kind === 'local' || runtime.kind === 'docker') {
+            printVerbose(`Stopping CLI-managed runtime resources for "${runtime.envName}" before removing the env config.`);
+            await runCommand('app:stop', ['--env', runtime.envName, '--with-db', '--yes', ...verboseArgv]);
         }
         printVerbose(`Removing env "${args.name}"`);
         const result = await removeEnv(args.name, { scope });

package/dist/commands/env/shared.js

@@ -8,6 +8,7 @@
  */
 import { buildDockerDbContainerName, dockerContainerExists, dockerContainerIsRunning, } from '../../lib/app-runtime.js';
 import { executeRawApiRequest } from '../../lib/api-client.js';
+import { buildLocalAppUrl } from '../../lib/app-public-path.js';
 export function resolveApiBaseUrl(config) {
     return String(config.apiBaseUrl ?? config.baseUrl ?? config.apibaseUrl ?? '').trim();
 }
@@ -53,16 +54,23 @@ export function appUrl(runtime) {
     }
     const port = String(runtime.env.config.appPort ?? '').trim();
     if (port) {
-        return `http://127.0.0.1:${port}/`;
+        return buildLocalAppUrl(port, runtime.env.config?.appPublicPath) ?? '';
     }
     return '';
 }
-export function appRootPath(runtime) {
+export function appPath(runtime) {
+    if (runtime.kind === 'http') {
+        return '-';
+    }
+    const value = String(runtime.env.appPath ?? runtime.env.config.appPath ?? '').trim();
+    return value || '-';
+}
+export function sourcePath(runtime) {
     if (runtime.kind === 'http' || runtime.kind === 'docker') {
         return '-';
     }
     if (runtime.kind === 'local') {
-        return String(runtime.projectRoot ?? runtime.env.appRootPath ?? '').trim() || '-';
+        return String(runtime.projectRoot ?? runtime.env.sourcePath ?? runtime.env.appRootPath ?? '').trim() || '-';
     }
     return String(runtime.env.config.appRootPath ?? '').trim() || '-';
 }
@@ -98,15 +106,15 @@ function isNetworkFailure(error) {
     if (!(error instanceof Error)) {
         return false;
     }
-    return (error.name === 'AbortError'
-        || /fetch failed|network|timeout|timed out|abort|ECONNREFUSED|ECONNRESET|ENOTFOUND|ETIMEDOUT|EAI_AGAIN|ENETUNREACH/i.test(error.message));
+    return (error.name === 'AbortError' ||
+        /fetch failed|network|timeout|timed out|abort|ECONNREFUSED|ECONNRESET|ENOTFOUND|ETIMEDOUT|EAI_AGAIN|ENETUNREACH/i.test(error.message));
 }
 function isUnconfiguredFailure(error) {
     return error instanceof Error && /missing (a )?base url|missing base URL/i.test(error.message);
 }
 function isAuthFailure(error) {
-    return (error instanceof Error
-        && /EMPTY_TOKEN|INVALID_TOKEN|EXPIRED_TOKEN|BLOCKED_TOKEN|EXPIRED_SESSION|NOT_EXIST_USER|invalid_grant|sign in|signin|authentication failed/i.test(error.message));
+    return (error instanceof Error &&
+        /EMPTY_TOKEN|INVALID_TOKEN|EXPIRED_TOKEN|BLOCKED_TOKEN|EXPIRED_SESSION|NOT_EXIST_USER|invalid_grant|sign in|signin|authentication failed/i.test(error.message));
 }
 export async function apiStatus(envName, config, options = {}) {
     if (!resolveApiBaseUrl(config)) {
@@ -166,7 +174,7 @@ async function dockerStatus(containerName) {
     if (!(await dockerContainerExists(containerName))) {
         return 'missing';
     }
-    return await dockerContainerIsRunning(containerName) ? 'running' : 'stopped';
+    return (await dockerContainerIsRunning(containerName)) ? 'running' : 'stopped';
 }
 export async function dbStatus(runtime) {
     if (!runtime.env.config.builtinDb) {
@@ -192,5 +200,5 @@ export async function runtimeStatus(runtime) {
     if (runtime.kind === 'docker') {
         return await dockerStatus(runtime.containerName);
     }
-    return await isLocalAppHealthy(runtime) ? 'running' : 'stopped';
+    return (await isLocalAppHealthy(runtime)) ? 'running' : 'stopped';
 }