@nocobase/cli 2.1.0-alpha.30 → 2.1.0-alpha.32

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/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'],

package/dist/lib/resource-command.js

@@ -7,6 +7,7 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import { Flags } from '@oclif/core';
+import { ensureCrossEnvConfirmed } from './env-guard.js';
 import { executeResourceRequest } from './resource-request.js';
 import { setVerboseMode } from './ui.js';
 function parseJson(value, flagName) {
@@ -95,6 +96,11 @@ export const resourceBaseFlags = {
         description: 'Show detailed progress output',
         default: false,
     }),
+    yes: Flags.boolean({
+        char: 'y',
+        description: 'Confirm using --env when it targets a different env than the current env',
+        default: false,
+    }),
     env: Flags.string({
         char: 'e',
         description: 'Environment name',
@@ -331,6 +337,15 @@ export function buildQueryArgs(flags) {
 }
 export async function runResourceCommand(command, action, flags, args) {
     setVerboseMode(Boolean(flags.verbose));
+    const confirmed = await ensureCrossEnvConfirmed({
+        command,
+        requestedEnv: flags.env,
+        yes: flags.yes,
+    });
+    if (!confirmed) {
+        command.log('Canceled.');
+        return;
+    }
     const response = await executeResourceRequest({
         envName: flags.env,
         baseUrl: flags['api-base-url'],

package/dist/lib/runtime-generator.js

@@ -18,7 +18,7 @@ import { createHash } from 'node:crypto';
 import { loadBuildConfig } from './build-config.js';
 import { toKebabCase, toLogicalActionName, toLogicalResourceName, toResourceSegments } from './naming.js';
 import { collectOperations } from './openapi.js';
-const RESERVED_FLAG_NAMES = new Set(['api-base-url', 'base-url', 'env', 'token', 'json-output', 'body', 'body-file']);
+const RESERVED_FLAG_NAMES = new Set(['api-base-url', 'base-url', 'env', 'token', 'json-output', 'body', 'body-file', 'yes']);
 function matchesPattern(value, pattern) {
     if (!value) {
         return false;

package/dist/lib/session-id.js

@@ -0,0 +1,17 @@
+/**
+ * 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 function resolveSessionIdentity() {
+    const sessionId = String(process.env.NB_SESSION_ID ?? '').trim();
+    if (sessionId) {
+        return {
+            id: sessionId,
+        };
+    }
+    return undefined;
+}