@nocobase/cli 2.1.0-beta.27 → 2.1.0-beta.30

package/dist/commands/plugin/enable.js

@@ -8,6 +8,7 @@
  */
 import { Args, Command, Flags } from '@oclif/core';
 import { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime, runDockerNocoBaseCommand, runLocalNocoBaseCommand, } from '../../lib/app-runtime.js';
+import { ensureCrossEnvConfirmed, hasExplicitEnvSelection } from '../../lib/env-guard.js';
 import { announceTargetEnv } from '../../lib/ui.js';
 export default class PluginEnable extends Command {
     static hidden = false;
@@ -27,18 +28,36 @@ export default class PluginEnable extends Command {
     static flags = {
         env: Flags.string({
             char: 'e',
-            description: 'CLI env name (from `nb env` / `nb init`). Defaults to the current env when omitted',
+            description: 'CLI env name to enable plugins for. Defaults to the current env when omitted',
+        }),
+        yes: Flags.boolean({
+            char: 'y',
+            description: 'Confirm using --env when it targets a different env than the current env',
+            default: false,
         }),
     };
     async run() {
         const { args, flags } = await this.parse(PluginEnable);
+        const requestedEnv = flags.env?.trim() || undefined;
+        const explicitEnvSelection = Boolean(requestedEnv && hasExplicitEnvSelection(this.argv));
+        if (explicitEnvSelection) {
+            const confirmed = await ensureCrossEnvConfirmed({
+                command: this,
+                requestedEnv,
+                yes: flags.yes,
+            });
+            if (!confirmed) {
+                this.log('Canceled.');
+                return;
+            }
+        }
         const packages = args.packages;
         if (!Array.isArray(packages) || packages.length === 0) {
             this.error('Pass at least one plugin package name.');
         }
-        const runtime = await resolveManagedAppRuntime(flags.env);
+        const runtime = await resolveManagedAppRuntime(requestedEnv);
         if (!runtime) {
-            this.error(formatMissingManagedAppEnvMessage(flags.env));
+            this.error(formatMissingManagedAppEnvMessage(requestedEnv));
         }
         announceTargetEnv(runtime.envName);
         if (runtime.kind === 'local') {
@@ -61,6 +80,8 @@ export default class PluginEnable extends Command {
             }
             return;
         }
-        await this.config.runCommand('api:pm:enable', ['--await-response', '--filter-by-tk', packages.join(',')]);
+        await this.config.runCommand('api:pm:enable', explicitEnvSelection
+            ? ['--await-response', '--filter-by-tk', packages.join(','), '--env', runtime.envName, '--yes']
+            : ['--await-response', '--filter-by-tk', packages.join(',')]);
     }
 }

package/dist/commands/plugin/list.js

@@ -8,6 +8,7 @@
  */
 import { Command, Flags } from '@oclif/core';
 import { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime, runDockerNocoBaseCommand, runLocalNocoBaseCommand, } from '../../lib/app-runtime.js';
+import { ensureCrossEnvConfirmed, hasExplicitEnvSelection } from '../../lib/env-guard.js';
 export default class PluginList extends Command {
     static hidden = false;
     static args = {};
@@ -21,14 +22,32 @@ export default class PluginList extends Command {
     static flags = {
         env: Flags.string({
             char: 'e',
-            description: 'CLI env name (from `nb env` / `nb init`). Defaults to the current env when omitted',
+            description: 'CLI env name to inspect plugins for. Defaults to the current env when omitted',
+        }),
+        yes: Flags.boolean({
+            char: 'y',
+            description: 'Confirm using --env when it targets a different env than the current env',
+            default: false,
         }),
     };
     async run() {
         const { flags } = await this.parse(PluginList);
-        const runtime = await resolveManagedAppRuntime(flags.env);
+        const requestedEnv = flags.env?.trim() || undefined;
+        const explicitEnvSelection = Boolean(requestedEnv && hasExplicitEnvSelection(this.argv));
+        if (explicitEnvSelection) {
+            const confirmed = await ensureCrossEnvConfirmed({
+                command: this,
+                requestedEnv,
+                yes: flags.yes,
+            });
+            if (!confirmed) {
+                this.log('Canceled.');
+                return;
+            }
+        }
+        const runtime = await resolveManagedAppRuntime(requestedEnv);
         if (!runtime) {
-            this.error(formatMissingManagedAppEnvMessage(flags.env));
+            this.error(formatMissingManagedAppEnvMessage(requestedEnv));
         }
         if (runtime.kind === 'local') {
             try {
@@ -57,6 +76,8 @@ export default class PluginList extends Command {
                 'Use a local, Docker, or HTTP env for plugin inspection right now.',
             ].join('\n'));
         }
-        await this.config.runCommand('api:pm:list', ['--mode=summary']);
+        await this.config.runCommand('api:pm:list', explicitEnvSelection
+            ? ['--mode=summary', '--env', runtime.envName, '--yes']
+            : ['--mode=summary']);
     }
 }

package/dist/commands/session/id.js

@@ -0,0 +1,24 @@
+/**
+ * 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 { resolveSessionIdentity } from '../../lib/session-id.js';
+export default class SessionId extends Command {
+    static summary = 'Show the current effective session id';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    async run() {
+        await this.parse(SessionId);
+        const identity = resolveSessionIdentity();
+        if (!identity) {
+            this.error('No effective session id is available. Run `nb session setup`, then open a new shell session or runtime.');
+        }
+        this.log(identity.id);
+    }
+}

package/dist/commands/session/remove.js

@@ -0,0 +1,57 @@
+/**
+ * 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.
+ */
+/**
+ * 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 { detectSessionShell, removeSessionIntegration } from '../../lib/session-integration.js';
+export default class SessionRemove extends Command {
+    static summary = 'Remove shell session integration for NB_SESSION_ID';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --shell zsh',
+    ];
+    static flags = {
+        shell: Flags.string({
+            description: 'Target shell to remove configuration from',
+            options: ['bash', 'zsh', 'fish', 'powershell', 'cmd'],
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(SessionRemove);
+        const shell = flags.shell ?? detectSessionShell();
+        if (!shell) {
+            this.error('Could not detect the current shell. Re-run with `--shell bash|zsh|fish|powershell|cmd`.');
+        }
+        const result = await removeSessionIntegration(shell);
+        this.log(`Session integration removed for ${result.shell}.`);
+        if (result.profileUpdated) {
+            for (const profileFile of result.profileFiles) {
+                this.log(`Profile updated: ${profileFile}`);
+            }
+        }
+        if (result.managedFileRemoved) {
+            this.log(`Managed file removed: ${result.managedFile}`);
+        }
+        if (result.cmdAutoRunRemoved) {
+            this.log(`cmd AutoRun updated: ${result.cmdAutoRunLocation}`);
+        }
+        if (result.agentConfigUpdated) {
+            this.log(`Opencode config updated: ${result.agentConfigFile}`);
+        }
+        if (result.agentPluginRemoved) {
+            this.log(`Opencode agent plugin removed: ${result.agentPluginFile}`);
+        }
+    }
+}

package/dist/commands/session/setup.js

@@ -0,0 +1,62 @@
+/**
+ * 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.
+ */
+/**
+ * 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 { detectSessionShell, setupSessionIntegration } from '../../lib/session-integration.js';
+export default class SessionSetup extends Command {
+    static summary = 'Set up shell session integration for NB_SESSION_ID';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --shell zsh',
+        '<%= config.bin %> <%= command.id %> --shell powershell',
+    ];
+    static flags = {
+        shell: Flags.string({
+            description: 'Target shell to configure',
+            options: ['bash', 'zsh', 'fish', 'powershell', 'cmd'],
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(SessionSetup);
+        const shell = flags.shell ?? detectSessionShell();
+        if (!shell) {
+            this.error('Could not detect the current shell. Re-run with `--shell bash|zsh|fish|powershell|cmd`.');
+        }
+        const result = await setupSessionIntegration(shell);
+        this.log(`Session integration configured for ${result.shell}.`);
+        this.log(`Managed file: ${result.managedFile}`);
+        if (result.cmdAutoRunConfigured) {
+            this.log(`cmd AutoRun updated: ${result.cmdAutoRunLocation}`);
+            this.log('Open a new cmd session to initialize NB_SESSION_ID automatically.');
+        }
+        if (result.agentConfigured) {
+            this.log(`Opencode agent plugin installed: ${result.agentPluginFile}`);
+            this.log(`Opencode config updated: ${result.agentConfigFile}`);
+        }
+        else if (result.agentSkippedReason === 'opencode_dir_not_found') {
+            this.log('Opencode config directory not found. Skipped agent session integration.');
+        }
+        if (result.profileFiles.length > 0) {
+            for (const profileFile of result.profileFiles) {
+                this.log(`Profile updated: ${profileFile}`);
+            }
+            this.log('Open a new shell session or reload your profile to initialize NB_SESSION_ID automatically.');
+        }
+        if (result.manualStep) {
+            this.log(result.manualStep);
+        }
+    }
+}

package/dist/commands/source/dev.js

@@ -7,6 +7,7 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import { Command, Flags } from '@oclif/core';
+import { ensureCrossEnvConfirmed, hasExplicitEnvSelection } from '../../lib/env-guard.js';
 import { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime, runLocalNocoBaseCommand, } from '../../lib/app-runtime.js';
 import { announceTargetEnv, printInfo } from '../../lib/ui.js';
 function formatUnsupportedRuntimeMessage(kind, envName) {
@@ -72,7 +73,13 @@ export default class SourceDev extends Command {
     static flags = {
         env: Flags.string({
             char: 'e',
-            description: 'CLI env name for dev mode. Defaults to the current env when omitted',
+            description: 'CLI env name to run dev mode for. Defaults to the current env when omitted',
+            required: false,
+        }),
+        yes: Flags.boolean({
+            char: 'y',
+            description: 'Confirm using --env when it targets a different env than the current env',
+            default: false,
             required: false,
         }),
         'db-sync': Flags.boolean({
@@ -103,6 +110,17 @@ export default class SourceDev extends Command {
     async run() {
         const { flags } = await this.parse(SourceDev);
         const requestedEnv = flags.env?.trim() || undefined;
+        if (requestedEnv && hasExplicitEnvSelection(this.argv)) {
+            const confirmed = await ensureCrossEnvConfirmed({
+                command: this,
+                requestedEnv,
+                yes: flags.yes,
+            });
+            if (!confirmed) {
+                this.log('Canceled.');
+                return;
+            }
+        }
         const runtime = await resolveManagedAppRuntime(requestedEnv);
         if (!runtime) {
             this.error(formatMissingManagedAppEnvMessage(requestedEnv));

package/dist/commands/source/download.js

@@ -13,10 +13,9 @@ import path from 'node:path';
 import { stdin as stdinStream, stdout as stdoutStream } from 'node:process';
 import { runPromptCatalog, } from "../../lib/prompt-catalog.js";
 import { applyCliLocale, CLI_LOCALE_FLAG_DESCRIPTION, CLI_LOCALE_FLAG_OPTIONS, localeText, resolveCliLocale, translateCli, } from "../../lib/cli-locale.js";
+import { DEFAULT_DOCKER_REGISTRY, DEFAULT_DOCKER_REGISTRY_ZH_CN, resolveDockerImageRef, } from "../../lib/docker-image.js";
 import { run } from "../../lib/run-npm.js";
 import { printVerbose, setVerboseMode, startTask, stopTask, updateTask } from '../../lib/ui.js';
-const DEFAULT_DOCKER_REGISTRY = 'nocobase/nocobase';
-const DEFAULT_DOCKER_REGISTRY_ZH_CN = 'registry.cn-shanghai.aliyuncs.com/nocobase/nocobase';
 const DEFAULT_DOCKER_PLATFORM = 'auto';
 const DEFAULT_DOWNLOAD_VERSION = 'beta';
 const downloadText = (key, values) => localeText(`commands.download.${key}`, values);
@@ -422,9 +421,11 @@ export default class SourceDownload extends Command {
         return outputAbs;
     }
     dockerTarPath(flags, outputAbs) {
-        const image = String(flags['docker-registry'] ?? '').trim() || defaultDockerRegistryForLang(process.env.NB_LOCALE);
-        const tag = flags.version ?? 'latest';
-        const safeBase = `${image.replace(/[/:]/g, '-')}-${tag.replace(/[/\\]/g, '-')}`;
+        const imageRef = resolveDockerImageRef(flags['docker-registry'], flags.version, {
+            defaultRegistry: defaultDockerRegistryForLang(process.env.NB_LOCALE),
+            defaultVersion: 'latest',
+        });
+        const safeBase = imageRef.replace(/[\\/:]/g, '-');
         return path.join(outputAbs, `${safeBase}.tar`);
     }
     /**
@@ -709,9 +710,10 @@ export default class SourceDownload extends Command {
         return argv;
     }
     async downloadFromDocker(flags) {
-        const image = String(flags['docker-registry'] ?? '').trim() || defaultDockerRegistryForLang(process.env.NB_LOCALE);
-        const tag = flags.version ?? 'latest';
-        const imageRef = `${image}:${tag}`;
+        const imageRef = resolveDockerImageRef(flags['docker-registry'], flags.version, {
+            defaultRegistry: defaultDockerRegistryForLang(process.env.NB_LOCALE),
+            defaultVersion: 'latest',
+        });
         const platform = dockerPlatformArg(flags['docker-platform']);
         const pullArgs = ['pull'];
         if (platform) {

package/dist/lib/app-managed-resources.js

@@ -10,10 +10,9 @@ import { mkdir, readdir } from 'node:fs/promises';
 import { dockerContainerExists, startDockerContainer } from './app-runtime.js';
 import { deriveBuiltinDbConnection, resolveBuiltinDbConnection } from './builtin-db.js';
 import { resolveConfiguredEnvPath } from './cli-home.js';
+import { DEFAULT_DOCKER_REGISTRY, DEFAULT_DOCKER_VERSION, resolveDockerImageRef, } from "./docker-image.js";
 import { commandSucceeds, run } from './run-npm.js';
 import Install from '../commands/install.js';
-const DEFAULT_DOCKER_REGISTRY = 'nocobase/nocobase';
-const DEFAULT_DOCKER_VERSION = 'alpha';
 const DOCKER_APP_STORAGE_DESTINATION = '/app/nocobase/storage';
 function commandStdio(verbose) {
     return verbose ? 'inherit' : 'ignore';
@@ -102,7 +101,10 @@ export function buildSavedDockerRunArgs(runtime) {
     const dbPassword = trimValue(config.dbPassword);
     const dockerRegistry = trimValue(config.dockerRegistry) || DEFAULT_DOCKER_REGISTRY;
     const version = trimValue(config.downloadVersion) || DEFAULT_DOCKER_VERSION;
-    const imageRef = `${dockerRegistry}:${version}`;
+    const imageRef = resolveDockerImageRef(dockerRegistry, version, {
+        defaultRegistry: DEFAULT_DOCKER_REGISTRY,
+        defaultVersion: DEFAULT_DOCKER_VERSION,
+    });
     const missing = [];
     if (!storagePath) {
         missing.push('storagePath');

package/dist/lib/app-runtime.js

@@ -61,7 +61,7 @@ export async function resolveManagedAppRuntime(envName) {
     if (!env) {
         return undefined;
     }
-    const resolvedName = env.name || envName?.trim() || config.currentEnv || 'default';
+    const resolvedName = env.name || envName?.trim() || config.lastEnv || 'default';
     const source = normalizeEnvSource(env);
     const dockerNetworkName = sanitizeDockerResourceName(getEffectiveCliConfigValue(config, 'docker.network') || defaultDockerNetworkName());
     const dockerContainerPrefix = sanitizeDockerResourceName(getEffectiveCliConfigValue(config, 'docker.container-prefix') || defaultDockerContainerPrefix());

package/dist/lib/auth-store.js

@@ -9,6 +9,7 @@
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
 import { resolveCliHomeDir, resolveConfiguredEnvPath, resolveEnvRelativePath, } from './cli-home.js';
+import { cleanupCurrentSessionAfterEnvRemoval, resolveEffectiveCurrentEnv, setSessionCurrentEnv, } from './session-store.js';
 function normalizeStoredEnvKind(value) {
     const kind = String(value ?? '').trim();
     if (kind === 'remote') {
@@ -84,7 +85,7 @@ function normalizeAuthConfig(config) {
                 }
                 : {}),
         },
-        currentEnv: config.currentEnv || 'default',
+        lastEnv: config.lastEnv || config.currentEnv || 'default',
         envs: Object.fromEntries(Object.entries(config.envs || {}).map(([envName, entry]) => [envName, normalizeEnvConfigEntry(entry) ?? {}])),
     };
 }
@@ -93,7 +94,7 @@ function getConfigFile(options = {}) {
 }
 function createDefaultConfig() {
     return {
-        currentEnv: 'default',
+        lastEnv: 'default',
         envs: {},
     };
 }
@@ -121,20 +122,24 @@ export async function saveAuthConfig(config, options = {}) {
 export async function listEnvs(options = {}) {
     const config = await loadAuthConfig(options);
     return {
-        currentEnv: config.currentEnv || 'default',
+        lastEnv: config.lastEnv || 'default',
         envs: config.envs,
     };
 }
 export async function getCurrentEnvName(options = {}) {
     const config = await loadAuthConfig(options);
-    return config.currentEnv || 'default';
+    return await resolveEffectiveCurrentEnv(Object.keys(config.envs).sort(), {
+        scope: options.scope,
+        lastEnv: config.lastEnv,
+    });
 }
 export async function setCurrentEnv(envName, options = {}) {
     const config = await loadExactAuthConfig(options);
     if (!config.envs[envName]) {
         throw new Error(`Env "${envName}" is not configured`);
     }
-    config.currentEnv = envName;
+    config.lastEnv = envName;
+    await setSessionCurrentEnv(envName, options.scope);
     await saveAuthConfig(config, options);
 }
 export class Env {
@@ -211,7 +216,10 @@ export class Env {
 export async function getEnv(envName, options = {}) {
     const { config: snapshot, ...loadOptions } = options;
     const config = snapshot ?? (await loadAuthConfig(loadOptions));
-    const resolved = envName?.trim() || config.currentEnv || 'default';
+    const resolved = envName?.trim() || (await resolveEffectiveCurrentEnv(Object.keys(config.envs).sort(), {
+        scope: loadOptions.scope,
+        lastEnv: config.lastEnv,
+    }));
     const envConfig = config.envs[resolved];
     if (!envConfig) {
         return undefined;
@@ -243,7 +251,6 @@ async function writeEnv(envName, updater, options = {}) {
     const config = await loadExactAuthConfig(options);
     const previous = config.envs[envName];
     config.envs[envName] = updater(previous);
-    config.currentEnv = envName;
     await saveAuthConfig(config, options);
 }
 export async function upsertEnv(envName, config, options = {}) {
@@ -306,7 +313,6 @@ export async function setEnvRuntime(envName, runtime, options = {}) {
         ...current,
         runtime,
     };
-    config.currentEnv = envName;
     await saveAuthConfig(config, options);
 }
 export async function removeEnv(envName, options = {}) {
@@ -315,14 +321,25 @@ export async function removeEnv(envName, options = {}) {
         throw new Error(`Env "${envName}" is not configured`);
     }
     delete config.envs[envName];
-    if (config.currentEnv === envName) {
+    if (config.lastEnv === envName) {
         const nextEnv = Object.keys(config.envs).sort()[0];
-        config.currentEnv = nextEnv ?? 'default';
+        config.lastEnv = nextEnv ?? 'default';
     }
     await saveAuthConfig(config, options);
+    const remainingEnvNames = Object.keys(config.envs).sort();
+    const fallbackEnv = remainingEnvNames.length
+        ? await resolveEffectiveCurrentEnv(remainingEnvNames, {
+            scope: options.scope,
+            lastEnv: config.lastEnv,
+        })
+        : undefined;
+    await cleanupCurrentSessionAfterEnvRemoval(envName, {
+        scope: options.scope,
+        fallbackEnv,
+    });
     return {
         removed: envName,
-        currentEnv: config.currentEnv || 'default',
+        lastEnv: config.lastEnv || 'default',
         hasEnvs: Object.keys(config.envs).length > 0,
     };
 }

package/dist/lib/docker-image.js

@@ -0,0 +1,37 @@
+/**
+ * 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.
+ */
+export const DEFAULT_DOCKER_REGISTRY = 'nocobase/nocobase';
+export const DEFAULT_DOCKER_REGISTRY_ZH_CN = 'registry.cn-shanghai.aliyuncs.com/nocobase/nocobase';
+export const DEFAULT_DOCKER_VERSION = 'alpha';
+export const DOCKER_IMAGE_FULL_SUFFIX = '-full';
+const OFFICIAL_FULL_IMAGE_REGISTRIES = new Set([
+    DEFAULT_DOCKER_REGISTRY,
+    DEFAULT_DOCKER_REGISTRY_ZH_CN,
+]);
+function trimValue(value) {
+    return String(value ?? '').trim();
+}
+export function shouldUseFullDockerImageTag(registry) {
+    return OFFICIAL_FULL_IMAGE_REGISTRIES.has(trimValue(registry));
+}
+export function normalizeDockerImageTag(registry, version) {
+    const tag = trimValue(version) || DEFAULT_DOCKER_VERSION;
+    if (!shouldUseFullDockerImageTag(registry)) {
+        return tag;
+    }
+    return tag.endsWith(DOCKER_IMAGE_FULL_SUFFIX)
+        ? tag
+        : `${tag}${DOCKER_IMAGE_FULL_SUFFIX}`;
+}
+export function resolveDockerImageRef(registry, version, options) {
+    const resolvedRegistry = trimValue(registry) || options?.defaultRegistry || DEFAULT_DOCKER_REGISTRY;
+    const rawVersion = trimValue(version) || options?.defaultVersion || DEFAULT_DOCKER_VERSION;
+    const normalizedTag = normalizeDockerImageTag(resolvedRegistry, rawVersion);
+    return `${resolvedRegistry}:${normalizedTag}`;
+}

package/dist/lib/env-guard.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 * as p from '@clack/prompts';
+import { stdin as input, stdout as output } from 'node:process';
+import { getCurrentEnvName } from './auth-store.js';
+function normalizeEnvName(value) {
+    const text = String(value ?? '').trim();
+    return text || undefined;
+}
+export function hasExplicitEnvSelection(argv) {
+    return argv.some((token, index) => (token === '--env'
+        || token === '-e'
+        || token.startsWith('--env=')
+        || (token.startsWith('-e') && token.length > 2 && index >= 0)));
+}
+function isInteractiveTerminal() {
+    return Boolean(input.isTTY && output.isTTY);
+}
+function formatCrossEnvPromptMessage(currentEnv, requestedEnv) {
+    return `Current env is "${currentEnv}", but this command targets "${requestedEnv}" via --env. Continue without switching the current env?`;
+}
+export function formatCrossEnvRefusalMessage(currentEnv, requestedEnv) {
+    return [
+        `Refusing to run against env "${requestedEnv}" because the current env is "${currentEnv}" and interactive confirmation is unavailable in the current agent session.`,
+        '',
+        'For safety, the agent will not switch envs automatically and will not add --yes on your behalf.',
+        '',
+        'To continue:',
+        `- run \`nb env use ${requestedEnv}\` yourself and then re-run the command, or`,
+        `- re-run the same command with \`--env ${requestedEnv} --yes\` to confirm this one-off cross-env operation.`,
+    ].join('\n');
+}
+export async function ensureCrossEnvConfirmed(options) {
+    const requestedEnv = normalizeEnvName(options.requestedEnv);
+    if (!requestedEnv) {
+        return true;
+    }
+    const currentEnv = normalizeEnvName(await getCurrentEnvName());
+    const interactiveTerminal = isInteractiveTerminal();
+    const bypassInteractivePrompt = interactiveTerminal && Boolean(options.yes);
+    if (!currentEnv || currentEnv === requestedEnv || bypassInteractivePrompt) {
+        return true;
+    }
+    if (!interactiveTerminal) {
+        options.command.error(formatCrossEnvRefusalMessage(currentEnv, requestedEnv));
+    }
+    const answer = await p.confirm({
+        message: formatCrossEnvPromptMessage(currentEnv, requestedEnv),
+        initialValue: false,
+    });
+    if (p.isCancel(answer)) {
+        return false;
+    }
+    return Boolean(answer);
+}

package/dist/lib/generated-command.js

@@ -16,6 +16,7 @@
  */
 import { Command, Flags } from '@oclif/core';
 import { executeApiRequest } from './api-client.js';
+import { ensureCrossEnvConfirmed } from './env-guard.js';
 import { applyPostProcessor } from './post-processors.js';
 import { registerPostProcessors } from '../post-processors/index.js';
 function buildParameterFlag(parameter, options) {
@@ -110,6 +111,12 @@ export function createGeneratedFlags(operation) {
         default: false,
         helpGroup: 'Global',
     });
+    flags.yes = Flags.boolean({
+        char: 'y',
+        description: 'Confirm using --env when it targets a different env than the current env',
+        default: false,
+        helpGroup: 'Global',
+    });
     flags.env = Flags.string({
         char: 'e',
         description: 'Environment name',
@@ -139,6 +146,15 @@ export class GeneratedApiCommand extends Command {
         registerPostProcessors();
         const ctor = this.constructor;
         const { flags } = await this.parse(ctor);
+        const confirmed = await ensureCrossEnvConfirmed({
+            command: this,
+            requestedEnv: flags.env,
+            yes: flags.yes,
+        });
+        if (!confirmed) {
+            this.log('Canceled.');
+            return;
+        }
         const response = await executeApiRequest({
             envName: flags.env,
             baseUrl: flags['api-base-url'],