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

package/dist/commands/env/add.js

@@ -7,10 +7,36 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import { Args, Command, Flags } from '@oclif/core';
-import * as p from '@clack/prompts';
 import { upsertEnv } from '../../lib/auth-store.js';
-import { formatCliHomeScope } from '../../lib/cli-home.js';
-import { isInteractiveTerminal, printVerbose, setVerboseMode } from '../../lib/ui.js';
+import { runPromptCatalog, } from '../../lib/prompt-catalog.js';
+import { validateApiBaseUrl } from '../../lib/prompt-validators.js';
+import { printVerbose, setVerboseMode } from '../../lib/ui.js';
+import * as p from '@clack/prompts';
+const ENV_RUNTIME_FLAG_MAP = {
+    source: 'source',
+    'download-version': 'downloadVersion',
+    'docker-registry': 'dockerRegistry',
+    'docker-platform': 'dockerPlatform',
+    'git-url': 'gitUrl',
+    'npm-registry': 'npmRegistry',
+    'app-root-path': 'appRootPath',
+    'storage-path': 'storagePath',
+    'app-port': 'appPort',
+    'app-key': 'appKey',
+    timezone: 'timezone',
+    'db-dialect': 'dbDialect',
+    'db-host': 'dbHost',
+    'db-port': 'dbPort',
+    'db-database': 'dbDatabase',
+    'db-user': 'dbUser',
+    'db-password': 'dbPassword',
+};
+const ENV_BOOLEAN_RUNTIME_FLAG_MAP = {
+    'builtin-db': 'builtinDb',
+    'dev-dependencies': 'devDependencies',
+    build: 'build',
+    'build-dts': 'buildDts',
+};
 export default class EnvAdd extends Command {
     static summary = 'Save a named NocoBase API endpoint (token or OAuth), then switch the CLI to use it';
     static examples = [
@@ -35,10 +61,21 @@ export default class EnvAdd extends Command {
             description: 'Print detailed progress while writing config',
             default: false,
         }),
+        'no-intro': Flags.boolean({
+            hidden: true,
+            description: 'Skip command intro when invoked by another CLI command',
+            default: false,
+        }),
         scope: Flags.string({
             char: 's',
             description: 'Where to store env config: project (.nocobase in the repo) or global (user-level); prompted in a TTY when omitted',
             options: ['project', 'global'],
+            default: 'project',
+        }),
+        'default-api-base-url': Flags.string({
+            char: 'd',
+            hidden: true,
+            description: 'Default API base URL for HTTP API calls, including the /api prefix (e.g. http://localhost:13000/api); prompted in a TTY when omitted',
         }),
         'api-base-url': Flags.string({
             char: 'u',
@@ -55,144 +92,209 @@ export default class EnvAdd extends Command {
             aliases: ['token'],
             description: 'API key or access token when using --auth-type token (prompted in a TTY when omitted)',
         }),
+        source: Flags.string({
+            hidden: true,
+            description: 'Application source saved with this env',
+        }),
+        'download-version': Flags.string({
+            hidden: true,
+            description: 'Downloaded app version saved with this env',
+        }),
+        'docker-registry': Flags.string({
+            hidden: true,
+            description: 'Docker registry saved with this env',
+        }),
+        'docker-platform': Flags.string({
+            hidden: true,
+            description: 'Docker image platform saved with this env',
+        }),
+        'git-url': Flags.string({
+            hidden: true,
+            description: 'Git repository URL saved with this env',
+        }),
+        'npm-registry': Flags.string({
+            hidden: true,
+            description: 'npm registry saved with this env',
+        }),
+        'dev-dependencies': Flags.boolean({
+            allowNo: true,
+            hidden: true,
+            description: 'Whether development dependencies were installed for this env',
+        }),
+        build: Flags.boolean({
+            allowNo: true,
+            hidden: true,
+            description: 'Whether the app was built after download for this env',
+        }),
+        'build-dts': Flags.boolean({
+            allowNo: true,
+            hidden: true,
+            description: 'Whether declaration files were emitted during build for this env',
+        }),
+        'app-root-path': Flags.string({
+            hidden: true,
+            description: 'Application root path saved with this env',
+        }),
+        'storage-path': Flags.string({
+            hidden: true,
+            description: 'Storage path saved with this env',
+        }),
+        'app-port': Flags.string({
+            hidden: true,
+            description: 'Application HTTP port saved with this env',
+        }),
+        'app-key': Flags.string({
+            hidden: true,
+            description: 'Application secret key saved with this env',
+        }),
+        timezone: Flags.string({
+            hidden: true,
+            description: 'Application timezone saved with this env',
+        }),
+        'builtin-db': Flags.boolean({
+            allowNo: true,
+            hidden: true,
+            description: 'Whether this env uses a CLI-managed built-in database',
+        }),
+        'db-dialect': Flags.string({
+            hidden: true,
+            description: 'Database dialect saved with this env',
+        }),
+        'db-host': Flags.string({
+            hidden: true,
+            description: 'Database host saved with this env',
+        }),
+        'db-port': Flags.string({
+            hidden: true,
+            description: 'Database port saved with this env',
+        }),
+        'db-database': Flags.string({
+            hidden: true,
+            description: 'Database name saved with this env',
+        }),
+        'db-user': Flags.string({
+            hidden: true,
+            description: 'Database user saved with this env',
+        }),
+        'db-password': Flags.string({
+            hidden: true,
+            description: 'Database password saved with this env',
+        }),
     };
-    exitCancelled() {
-        p.cancel('Cancelled.');
-        this.exit(0);
-    }
-    async run() {
-        const { args, flags } = await this.parse(EnvAdd);
-        setVerboseMode(flags.verbose);
-        const nameArg = args.name?.trim();
-        const nameFlag = flags.env?.trim() || undefined;
-        if (nameArg && nameFlag && nameArg !== nameFlag) {
-            this.error(`Environment name was given both as the argument ("${nameArg}") and as --env ("${nameFlag}"); use only one.`);
+    static prompts = {
+        name: {
+            type: 'text',
+            message: 'What would you like to call this environment?',
+            placeholder: 'default',
+            required: true,
+        },
+        scope: {
+            type: 'select',
+            message: 'Where should this connection be saved?',
+            options: [
+                { value: 'project', label: 'Project', hint: '.nocobase in this repo' },
+                { value: 'global', label: 'Global', hint: 'user-level config' },
+            ],
+            initialValue: 'project',
+            required: true,
+        },
+        apiBaseUrl: {
+            type: 'text',
+            message: 'What is the API base URL?',
+            placeholder: 'http://localhost:13000/api',
+            required: true,
+            validate: validateApiBaseUrl,
+        },
+        authType: {
+            type: 'select',
+            message: 'How would you like to sign in?',
+            options: [
+                { value: 'oauth', label: 'OAuth (browser login)', hint: 'runs nb env auth after save' },
+                { value: 'token', label: 'API token / API key' },
+            ],
+            initialValue: 'oauth',
+            required: true,
+        },
+        accessToken: {
+            type: 'text',
+            message: 'Enter an API token or API key',
+            placeholder: 'Enter your API token / API key',
+            required: true,
+            hidden: (values) => values.authType !== 'token',
+        },
+    };
+    buildPromptValues(nameArg, flags) {
+        const values = {};
+        const name = nameArg?.trim() || flags.env?.trim();
+        if (name) {
+            values.name = name;
         }
-        let name = nameArg || nameFlag || undefined;
-        let scope = flags.scope;
-        let baseUrl = flags['api-base-url'] ?? flags['base-url'];
-        let authType = flags['auth-type'];
-        const interactive = isInteractiveTerminal();
-        if (!interactive) {
-            const missing = [];
-            if (!name?.trim()) {
-                missing.push('<name> (first argument or --env)');
-            }
-            if (!scope) {
-                missing.push('--scope');
-            }
-            if (!baseUrl) {
-                missing.push('--api-base-url');
-            }
-            if (!authType) {
-                missing.push('--auth-type');
-            }
-            if (missing.length > 0) {
-                this.error(`Non-interactive mode requires: ${missing.join(', ')}. Example: nb env add -e local --scope project --api-base-url http://localhost:13000/api --auth-type oauth`);
-            }
+        if (flags.scope) {
+            values.scope = flags.scope;
         }
-        else {
-            if (!name?.trim()) {
-                const answer = await p.text({
-                    message: 'Environment name',
-                    placeholder: 'default',
-                    defaultValue: 'default',
-                });
-                if (p.isCancel(answer)) {
-                    this.exitCancelled();
-                }
-                name = answer;
-            }
-            if (!scope) {
-                const answer = await p.select({
-                    message: 'Where should this env be stored?',
-                    options: [
-                        { value: 'project', label: 'Project', hint: '.nocobase in this repo' },
-                        { value: 'global', label: 'Global', hint: 'user-level config' },
-                    ],
-                    initialValue: 'project',
-                });
-                if (p.isCancel(answer)) {
-                    this.exitCancelled();
-                }
-                scope = answer;
-            }
-            if (!baseUrl) {
-                const answer = await p.text({
-                    message: 'API base URL',
-                    placeholder: 'http://localhost:13000/api',
-                    defaultValue: 'http://localhost:13000/api',
-                });
-                if (p.isCancel(answer)) {
-                    this.exitCancelled();
-                }
-                baseUrl = answer;
-            }
-            if (!authType) {
-                const answer = await p.select({
-                    message: 'How do you want to authenticate?',
-                    options: [
-                        { value: 'oauth', label: 'OAuth (browser login)', hint: 'runs nb env auth after save' },
-                        { value: 'token', label: 'API token / API key' },
-                    ],
-                    initialValue: 'oauth',
-                });
-                if (p.isCancel(answer)) {
-                    this.exitCancelled();
-                }
-                authType = answer;
-            }
+        const apiFromFlag = flags['api-base-url'] ?? flags['base-url'];
+        if (typeof apiFromFlag === 'string' && apiFromFlag.trim() !== '') {
+            values.apiBaseUrl = apiFromFlag.trim();
         }
-        const accessTokenKeys = ['access-token', 'token'];
-        const accessTokenFlagPresent = accessTokenKeys.some((key) => Object.prototype.hasOwnProperty.call(flags, key));
-        if (accessTokenFlagPresent && !flags['access-token'] && !flags['token']) {
-            if (!interactive) {
-                this.error('When passing --access-token (or --token) without a value, run in a TTY or provide the token as the flag value.');
-            }
-            const prompted = await p.password({
-                message: 'Access token / API key',
-                validate: (value) => (value.trim() ? undefined : 'Token cannot be empty'),
-            });
-            if (p.isCancel(prompted)) {
-                this.exitCancelled();
-            }
-            flags['access-token'] = prompted;
+        if (flags['auth-type']) {
+            values.authType = flags['auth-type'];
         }
-        let token = flags['access-token'] ?? flags['token'];
-        if (!name?.trim()) {
-            this.error('Environment name cannot be empty.');
+        const token = flags['access-token'] ?? flags.token;
+        if (typeof token === 'string' && token !== '') {
+            values.accessToken = token;
         }
-        if (!baseUrl?.trim()) {
-            this.error('API base URL cannot be empty.');
+        return values;
+    }
+    buildPromptInitialValues(flags) {
+        const initialValues = {};
+        const defaultApiBaseUrl = flags['default-api-base-url']?.trim();
+        if (defaultApiBaseUrl) {
+            initialValues.apiBaseUrl = defaultApiBaseUrl;
         }
-        name = name.trim();
-        baseUrl = baseUrl.trim();
-        if (authType === 'token') {
-            if (!token && interactive) {
-                const answer = await p.password({
-                    message: 'Access token / API key',
-                    validate: (value) => (value.trim() ? undefined : 'Token cannot be empty'),
-                });
-                if (p.isCancel(answer)) {
-                    this.exitCancelled();
-                }
-                token = answer;
+        return initialValues;
+    }
+    buildEnvConfig(results, flags) {
+        const envConfig = {
+            baseUrl: String(results.apiBaseUrl ?? ''),
+        };
+        for (const [flagName, configKey] of Object.entries(ENV_RUNTIME_FLAG_MAP)) {
+            const value = flags[flagName];
+            if (typeof value === 'string' && value.trim() !== '') {
+                envConfig[configKey] = value.trim();
             }
-            if (!token?.trim()) {
-                this.error('Auth type token requires an access token. Pass `--access-token`, or run in a TTY to enter it.');
+        }
+        for (const [flagName, configKey] of Object.entries(ENV_BOOLEAN_RUNTIME_FLAG_MAP)) {
+            const value = flags[flagName];
+            if (typeof value === 'boolean') {
+                envConfig[configKey] = value;
             }
-            printVerbose(`Saving env "${name}" with API base URL ${baseUrl} (token auth)`);
-            await upsertEnv(name, { baseUrl, accessToken: token }, { scope });
-            this.log(`Saved env "${name}" and set it as current${scope ? ` in ${formatCliHomeScope(scope)} scope` : ''}.`);
-            return;
         }
-        printVerbose(`Saving env "${name}" with API base URL ${baseUrl} (OAuth next)`);
-        await upsertEnv(name, { baseUrl }, { scope });
-        this.log(`Saved env "${name}"${scope ? ` in ${formatCliHomeScope(scope)} scope` : ''}. Starting OAuth login (\`nb env auth ${name}\`).`);
-        const authArgv = [name];
-        if (scope) {
-            authArgv.push('-s', scope);
+        if (results.authType === 'token' && results.accessToken != null) {
+            envConfig.accessToken = String(results.accessToken);
+        }
+        return envConfig;
+    }
+    async run() {
+        const { args, flags } = await this.parse(EnvAdd);
+        const parsedFlags = flags;
+        setVerboseMode(parsedFlags.verbose);
+        if (!parsedFlags['no-intro']) {
+            p.intro('Connect a NocoBase Environment');
+        }
+        const results = await runPromptCatalog(EnvAdd.prompts, {
+            values: this.buildPromptValues(args.name, parsedFlags),
+            initialValues: this.buildPromptInitialValues(parsedFlags),
+            command: this,
+        });
+        const envName = String(results.name);
+        const scope = results.scope;
+        const envConfig = this.buildEnvConfig(results, parsedFlags);
+        printVerbose(`Saving env "${envName}" with scope "${scope}".`);
+        await upsertEnv(envName, envConfig, { scope });
+        if (results.authType === 'oauth') {
+            await this.config.runCommand('env:auth', [envName]);
         }
-        await this.config.runCommand('env:auth', authArgv);
+        await this.config.runCommand('env:update', [envName]);
+        p.outro(`Env "${envName}" added successfully.`);
     }
 }

package/dist/commands/env/auth.js

@@ -12,14 +12,16 @@ import { formatCliHomeScope } from '../../lib/cli-home.js';
 import { authenticateEnvWithOauth } from '../../lib/env-auth.js';
 import { failTask, startTask, succeedTask } from '../../lib/ui.js';
 export default class EnvAuth extends Command {
-    static summary = 'Authenticate an environment with OAuth';
+    static summary = 'Sign in to a saved NocoBase environment with OAuth';
     static examples = [
+        '<%= config.bin %> <%= command.id %>',
         '<%= config.bin %> <%= command.id %> prod',
+        '<%= config.bin %> <%= command.id %> --scope global',
     ];
     static args = {
         name: Args.string({
             description: 'Environment name (omit to use the current env)',
-            required: true,
+            required: false,
         }),
     };
     static flags = {
@@ -41,20 +43,19 @@ export default class EnvAuth extends Command {
         const nameArg = args.name?.trim();
         const nameFlag = flags.env?.trim() || undefined;
         if (nameArg && nameFlag && nameArg !== nameFlag) {
-            this.error(`Environment name was given both as the argument ("${nameArg}") and as --env ("${nameFlag}"); use only one.`);
+            this.error(`Environment name was provided both as the argument ("${nameArg}") and as --env ("${nameFlag}"). Please use only one.`);
         }
-        const envName = nameArg || nameFlag || undefined;
-        const envLabel = envName ?? (await getCurrentEnvName({ scope }));
-        startTask(`Authenticating env: ${envLabel}${scope ? ` (${formatCliHomeScope(scope)})` : ''}`);
+        const envName = nameArg || nameFlag || (await getCurrentEnvName({ scope }));
+        startTask(`Starting browser sign-in for "${envName}"${scope ? ` (${formatCliHomeScope(scope)} scope)` : ''}...`);
         try {
             await authenticateEnvWithOauth({
                 envName,
                 scope,
             });
-            succeedTask(`Authenticated env "${envLabel}" with OAuth${scope ? ` in ${formatCliHomeScope(scope)} scope` : ''}.`);
+            succeedTask(`Signed in to "${envName}"${scope ? ` in ${formatCliHomeScope(scope)} scope` : ''}.`);
         }
         catch (error) {
-            failTask(`Failed to authenticate env "${envLabel}".`);
+            failTask(`Sign-in failed for "${envName}"${scope ? ` in ${formatCliHomeScope(scope)} scope` : ''}.`);
             throw error;
         }
     }