@nocobase/cli 2.1.0-beta.9 → 2.1.0

package/dist/commands/env/add.js

@@ -0,0 +1,406 @@
+/**
+ * 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 { Args, Command, Flags } from '@oclif/core';
+import { setCurrentEnv, upsertEnv } from '../../lib/auth-store.js';
+import { resolveDefaultConfigScope } from '../../lib/cli-home.js';
+import { ENV_BOOLEAN_CONFIG_FLAG_MAP, ENV_STRING_CONFIG_FLAG_MAP } from '../../lib/env-command-config.js';
+import { buildStoredEnvConfig } from '../../lib/env-config.js';
+import { runPromptCatalog, } from '../../lib/prompt-catalog.js';
+import { applyCliLocale, CLI_LOCALE_FLAG_DESCRIPTION, CLI_LOCALE_FLAG_OPTIONS, localeText, } from '../../lib/cli-locale.js';
+import { validateApiBaseUrl } from '../../lib/prompt-validators.js';
+import { printInfo, printStage, printSuccess, printVerbose, setVerboseMode } from '../../lib/ui.js';
+const envAddText = (key, values) => localeText(`commands.envAdd.${key}`, values);
+const envAddAccessTokenPrompt = {
+    type: 'text',
+    message: envAddText('prompts.accessToken.message'),
+    required: true,
+    hidden: (values) => values.authType !== 'token' || values.skipAuth === true,
+};
+const envAddUsernamePrompt = {
+    type: 'text',
+    message: envAddText('prompts.username.message'),
+    placeholder: envAddText('prompts.username.placeholder'),
+    required: true,
+    hidden: (values) => values.authType !== 'basic' || values.skipAuth === true,
+};
+const envAddPasswordPrompt = {
+    type: 'password',
+    message: envAddText('prompts.password.message'),
+    required: true,
+    hidden: (values) => values.authType !== 'basic' || values.skipAuth === true,
+};
+function formatDeferredAuthMessage(envName, authType) {
+    const normalizedAuthType = String(authType ?? '').trim();
+    const nextStep = `Authentication was skipped for env "${envName}". Run \`nb env auth ${envName}\` to finish setup.`;
+    if (normalizedAuthType === 'basic') {
+        return `${nextStep} You will be prompted for a username and password.`;
+    }
+    if (normalizedAuthType === 'token') {
+        return `${nextStep} You will be prompted for an access token.`;
+    }
+    if (normalizedAuthType === 'oauth') {
+        return `${nextStep} A browser sign-in flow will be started.`;
+    }
+    return nextStep;
+}
+export default class EnvAdd extends Command {
+    static summary = 'Save a named NocoBase API endpoint (basic, token, or OAuth), then switch the CLI to use it';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> local',
+        '<%= config.bin %> <%= command.id %> local --api-base-url http://localhost:13000/api --auth-type oauth',
+    ];
+    static args = {
+        name: Args.string({
+            description: 'Environment name to save (optional first argument; in a TTY, prompted when omitted; required when not using a TTY)',
+            required: false,
+        }),
+    };
+    static flags = {
+        env: Flags.string({
+            char: 'e',
+            hidden: true,
+            deprecated: true,
+            description: 'Environment name (same as the optional positional argument; for compatibility with -e/--env on other commands)',
+        }),
+        verbose: Flags.boolean({
+            description: 'Print detailed progress while writing config',
+            default: false,
+        }),
+        locale: Flags.string({
+            description: CLI_LOCALE_FLAG_DESCRIPTION,
+            options: CLI_LOCALE_FLAG_OPTIONS,
+        }),
+        'no-intro': Flags.boolean({
+            hidden: true,
+            description: 'Skip command intro when invoked by another CLI command',
+            default: false,
+        }),
+        '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',
+            description: 'Root URL for HTTP API calls, including the /api prefix (e.g. http://localhost:13000/api); prompted in a TTY when omitted',
+        }),
+        'auth-type': Flags.string({
+            char: 'a',
+            description: 'Authentication: basic (username/password login), token (API key), or oauth (browser login via `nb env auth`); prompted in a TTY when omitted',
+            options: ['basic', 'token', 'oauth'],
+        }),
+        'access-token': Flags.string({
+            char: 't',
+            aliases: ['token'],
+            description: 'API key or access token when using --auth-type token (prompted in a TTY when omitted)',
+        }),
+        username: Flags.string({
+            description: 'Username when using --auth-type basic (prompted in a TTY when omitted)',
+        }),
+        password: Flags.string({
+            description: 'Password when using --auth-type basic (prompted in a TTY when omitted)',
+        }),
+        'skip-auth': Flags.boolean({
+            description: 'Save the env now and finish authentication later with `nb env auth`',
+            default: false,
+        }),
+        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-path': Flags.string({
+            hidden: true,
+            description: 'App path saved with this env',
+        }),
+        'app-root-path': Flags.string({
+            hidden: true,
+            deprecated: true,
+            description: 'Application root path saved with this env',
+        }),
+        'storage-path': Flags.string({
+            hidden: true,
+            deprecated: true,
+            description: 'Storage path saved with this env',
+        }),
+        'app-public-path': Flags.string({
+            hidden: true,
+            description: 'Application public path saved with this env',
+        }),
+        'env-file': Flags.string({
+            hidden: true,
+            description: 'Docker env file 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',
+        }),
+        'builtin-db-image': Flags.string({
+            hidden: true,
+            description: 'Built-in database image 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',
+        }),
+        'db-schema': Flags.string({
+            hidden: true,
+            description: 'Database schema saved with this env',
+        }),
+        'db-table-prefix': Flags.string({
+            hidden: true,
+            description: 'Database table prefix saved with this env',
+        }),
+        'db-underscored': Flags.boolean({
+            allowNo: true,
+            hidden: true,
+            description: 'Whether this env uses underscored database naming',
+        }),
+        'root-username': Flags.string({
+            hidden: true,
+            description: 'Initial root username saved with this env',
+        }),
+        'root-email': Flags.string({
+            hidden: true,
+            description: 'Initial root email saved with this env',
+        }),
+        'root-password': Flags.string({
+            hidden: true,
+            description: 'Initial root password saved with this env',
+        }),
+        'root-nickname': Flags.string({
+            hidden: true,
+            description: 'Initial root nickname saved with this env',
+        }),
+    };
+    static prompts = {
+        name: {
+            type: 'text',
+            message: envAddText('prompts.name.message'),
+            placeholder: envAddText('prompts.name.placeholder'),
+            required: true,
+        },
+        apiBaseUrl: {
+            type: 'text',
+            message: envAddText('prompts.apiBaseUrl.message'),
+            placeholder: envAddText('prompts.apiBaseUrl.placeholder'),
+            required: true,
+            validate: validateApiBaseUrl,
+        },
+        authType: {
+            type: 'select',
+            message: envAddText('prompts.authType.message'),
+            options: [
+                {
+                    value: 'oauth',
+                    label: envAddText('prompts.authType.oauthLabel'),
+                    hint: envAddText('prompts.authType.oauthHint'),
+                },
+                { value: 'token', label: envAddText('prompts.authType.tokenLabel') },
+                {
+                    value: 'basic',
+                    label: envAddText('prompts.authType.basicLabel'),
+                    hint: envAddText('prompts.authType.basicHint'),
+                },
+            ],
+            initialValue: 'oauth',
+            required: true,
+        },
+        username: envAddUsernamePrompt,
+        password: envAddPasswordPrompt,
+        accessToken: envAddAccessTokenPrompt,
+    };
+    buildPromptValues(nameArg, flags) {
+        const values = {};
+        const name = nameArg?.trim() || flags.env?.trim();
+        if (name) {
+            values.name = name;
+        }
+        const apiFromFlag = flags['api-base-url'];
+        if (typeof apiFromFlag === 'string' && apiFromFlag.trim() !== '') {
+            values.apiBaseUrl = apiFromFlag.trim();
+        }
+        if (flags['auth-type']) {
+            values.authType = flags['auth-type'];
+        }
+        if (flags['skip-auth']) {
+            values.skipAuth = true;
+        }
+        const token = flags['access-token'] ?? flags.token;
+        if (typeof token === 'string' && token !== '') {
+            values.accessToken = token;
+        }
+        if (flags.username !== undefined) {
+            values.username = String(flags.username ?? '').trim();
+        }
+        if (flags.password !== undefined) {
+            values.password = String(flags.password ?? '');
+        }
+        return values;
+    }
+    buildPromptInitialValues(flags) {
+        const initialValues = {};
+        const defaultApiBaseUrl = flags['default-api-base-url']?.trim();
+        if (defaultApiBaseUrl) {
+            initialValues.apiBaseUrl = defaultApiBaseUrl;
+        }
+        return initialValues;
+    }
+    buildPromptCatalog(flags) {
+        if (!flags['skip-auth']) {
+            return EnvAdd.prompts;
+        }
+        return {
+            ...EnvAdd.prompts,
+            username: {
+                ...envAddUsernamePrompt,
+                hidden: () => true,
+            },
+            password: {
+                ...envAddPasswordPrompt,
+                hidden: () => true,
+            },
+            accessToken: {
+                ...envAddAccessTokenPrompt,
+                hidden: () => true,
+            },
+        };
+    }
+    buildEnvConfig(results, flags) {
+        const authType = String(results.authType ?? '').trim();
+        const authUsername = authType === 'basic' ? String(results.username ?? flags.username ?? '').trim() : '';
+        const envConfigInput = {
+            apiBaseUrl: results.apiBaseUrl,
+            authType,
+            authUsername: authUsername || undefined,
+            accessToken: results.accessToken,
+        };
+        for (const [flagName, configKey] of Object.entries(ENV_STRING_CONFIG_FLAG_MAP)) {
+            const value = flags[flagName];
+            envConfigInput[configKey] = value;
+        }
+        for (const [flagName, configKey] of Object.entries(ENV_BOOLEAN_CONFIG_FLAG_MAP)) {
+            const value = flags[flagName];
+            envConfigInput[configKey] = value;
+        }
+        return buildStoredEnvConfig(envConfigInput);
+    }
+    async run() {
+        const { args, flags } = await this.parse(EnvAdd);
+        const parsedFlags = flags;
+        if (parsedFlags['skip-auth'] && (parsedFlags['access-token'] !== undefined || parsedFlags.token !== undefined)) {
+            this.error('--skip-auth cannot be used with --access-token or --token.');
+        }
+        applyCliLocale(parsedFlags.locale);
+        setVerboseMode(parsedFlags.verbose);
+        if (!parsedFlags['no-intro']) {
+            printStage('Connect to NocoBase');
+        }
+        const results = await runPromptCatalog(this.buildPromptCatalog(parsedFlags), {
+            values: this.buildPromptValues(args.name, parsedFlags),
+            initialValues: this.buildPromptInitialValues(parsedFlags),
+            command: this,
+        });
+        const envName = String(results.name);
+        const envConfig = this.buildEnvConfig(results, parsedFlags);
+        printVerbose(`Saving env "${envName}" globally.`);
+        await upsertEnv(envName, envConfig, { scope: resolveDefaultConfigScope() });
+        await setCurrentEnv(envName, { scope: resolveDefaultConfigScope() });
+        if (parsedFlags['skip-auth']) {
+            printSuccess(`✔ Env "${envName}" was saved.`);
+            printInfo(formatDeferredAuthMessage(envName, results.authType));
+            return;
+        }
+        if (results.authType === 'oauth' || results.authType === 'basic') {
+            const authArgv = [envName];
+            if (results.authType === 'basic') {
+                authArgv.push('--auth-type', 'basic');
+                const username = String(results.username ?? '').trim();
+                const password = String(results.password ?? '');
+                if (username) {
+                    authArgv.push('--username', username);
+                }
+                if (password) {
+                    authArgv.push('--password', password);
+                }
+            }
+            await this.config.runCommand('env:auth', authArgv);
+        }
+        await this.config.runCommand('env:update', [envName]);
+        printSuccess(`✔ Env "${envName}" is ready.`);
+    }
+}

package/dist/commands/env/auth.js

@@ -0,0 +1,189 @@
+/**
+ * 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 { Args, Command, Flags } from '@oclif/core';
+import { getCurrentEnvName, getEnv, resolveConfiguredAuthType, updateEnvConnection } from '../../lib/auth-store.js';
+import { resolveDefaultConfigScope } from '../../lib/cli-home.js';
+import { authenticateEnvWithBasic, authenticateEnvWithOauth } from '../../lib/env-auth.js';
+import { runPromptCatalog } from '../../lib/prompt-catalog.js';
+import { failTask, isInteractiveTerminal, printStage, startTask, stopTask, succeedTask } from '../../lib/ui.js';
+import EnvAdd from "./add.js";
+const envAuthPrompts = {
+    authType: EnvAdd.prompts.authType,
+    username: EnvAdd.prompts.username,
+    password: EnvAdd.prompts.password,
+    accessToken: EnvAdd.prompts.accessToken,
+};
+function resolveExplicitAuthType(value) {
+    return value === 'basic' || value === 'token' || value === 'oauth' ? value : undefined;
+}
+function formatMissingEnvMessage(envName) {
+    return [`Env "${envName}" is not configured.`, `Run \`nb init --ui --env ${envName}\` first.`].join('\n');
+}
+export default class EnvAuth extends Command {
+    static summary = 'Authenticate a saved NocoBase environment with basic login, a token, or OAuth';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> prod',
+        '<%= config.bin %> <%= command.id %> prod --auth-type basic --username admin --password secret',
+        '<%= config.bin %> <%= command.id %> prod --auth-type token --access-token <api-key>',
+    ];
+    static args = {
+        name: Args.string({
+            description: 'Configured environment name to sign in to. Defaults to the current env when omitted',
+            required: false,
+        }),
+    };
+    static flags = {
+        env: Flags.string({
+            char: 'e',
+            hidden: true,
+            deprecated: true,
+            description: 'Environment name (same as the optional positional argument; for compatibility with -e/--env on other commands)',
+        }),
+        'auth-type': Flags.string({
+            char: 'a',
+            description: 'Authentication: basic (username/password login), token (API key), or oauth (browser login)',
+            options: ['basic', 'token', 'oauth'],
+        }),
+        'access-token': Flags.string({
+            char: 't',
+            description: 'API key or access token when using token authentication',
+        }),
+        username: Flags.string({
+            description: 'Username when using basic authentication (prompted in a TTY when omitted)',
+        }),
+        password: Flags.string({
+            description: 'Password when using basic authentication (prompted in a TTY when omitted)',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(EnvAuth);
+        const nameArg = args.name?.trim();
+        const nameFlag = flags.env?.trim() || undefined;
+        if (nameArg && nameFlag && nameArg !== nameFlag) {
+            this.error(`Environment name was provided both as the argument ("${nameArg}") and as --env ("${nameFlag}"). Please use only one.`);
+        }
+        const envName = nameArg || nameFlag || (await getCurrentEnvName({ scope: resolveDefaultConfigScope() }));
+        const env = await getEnv(envName, { scope: resolveDefaultConfigScope() });
+        if (!env) {
+            this.error(formatMissingEnvMessage(envName));
+        }
+        const tokenFromFlags = flags['access-token'];
+        const tokenFlagProvided = tokenFromFlags !== undefined;
+        const tokenValue = typeof tokenFromFlags === 'string' ? tokenFromFlags.trim() : '';
+        const tokenProvided = tokenValue !== '';
+        if (tokenFlagProvided && !tokenProvided) {
+            this.error('--access-token cannot be empty.');
+        }
+        const usernameFromFlags = flags.username;
+        const usernameFlagProvided = usernameFromFlags !== undefined;
+        const usernameProvided = typeof usernameFromFlags === 'string' && usernameFromFlags.trim() !== '';
+        if (usernameFlagProvided && !usernameProvided) {
+            this.error('--username cannot be empty.');
+        }
+        const passwordFromFlags = flags.password;
+        const passwordFlagProvided = passwordFromFlags !== undefined;
+        const passwordProvided = typeof passwordFromFlags === 'string' && passwordFromFlags.trim() !== '';
+        if (passwordFlagProvided && !passwordProvided) {
+            this.error('--password cannot be empty.');
+        }
+        const explicitAuthType = resolveExplicitAuthType(flags['auth-type']);
+        if (tokenFlagProvided && (usernameFlagProvided || passwordFlagProvided)) {
+            this.error('--access-token cannot be used with --username or --password.');
+        }
+        if (explicitAuthType === 'oauth' && (tokenFlagProvided || usernameFlagProvided || passwordFlagProvided)) {
+            this.error('--auth-type oauth cannot be used with --access-token, --username, or --password.');
+        }
+        if (explicitAuthType === 'token' && (usernameFlagProvided || passwordFlagProvided)) {
+            this.error('--auth-type token cannot be used with --username or --password.');
+        }
+        if (explicitAuthType === 'basic' && tokenFlagProvided) {
+            this.error('--auth-type basic cannot be used with --access-token.');
+        }
+        const savedAuthType = resolveConfiguredAuthType(env.config);
+        const resolvedAuthType = explicitAuthType ??
+            (tokenProvided ? 'token' : usernameFlagProvided || passwordFlagProvided ? 'basic' : savedAuthType);
+        if (resolvedAuthType === 'basic' && !usernameProvided && !isInteractiveTerminal()) {
+            this.error('--username is required when using basic authentication in non-interactive mode.');
+        }
+        if (resolvedAuthType === 'basic' && !passwordProvided && !isInteractiveTerminal()) {
+            this.error('--password is required when using basic authentication in non-interactive mode.');
+        }
+        const prompted = (resolvedAuthType === 'oauth'
+            ? { authType: 'oauth' }
+            : await runPromptCatalog(envAuthPrompts, {
+                values: {
+                    ...(resolvedAuthType ? { authType: resolvedAuthType } : {}),
+                    ...(usernameFlagProvided ? { username: String(usernameFromFlags ?? '').trim() } : {}),
+                    ...(passwordFlagProvided ? { password: String(passwordFromFlags ?? '') } : {}),
+                    ...(tokenFlagProvided ? { accessToken: tokenValue } : {}),
+                },
+                command: this,
+            })) ?? {};
+        const authType = resolveExplicitAuthType(prompted.authType ?? resolvedAuthType);
+        if (!authType) {
+            this.error('Choose an authentication type before continuing.');
+        }
+        printStage('Authenticating');
+        try {
+            if (authType === 'basic') {
+                const username = String(prompted.username ?? usernameFromFlags ?? '').trim();
+                const password = String(prompted.password ?? passwordFromFlags ?? '');
+                if (!username) {
+                    this.error('--username is required when using basic authentication.');
+                }
+                if (!password) {
+                    this.error('--password cannot be empty.');
+                }
+                startTask(`Signing in with username and password for "${envName}"...`);
+                const accessToken = await authenticateEnvWithBasic({
+                    envName,
+                    username,
+                    password,
+                    scope: resolveDefaultConfigScope(),
+                });
+                await updateEnvConnection(envName, {
+                    authType: 'basic',
+                    authUsername: username,
+                    accessToken,
+                }, { scope: resolveDefaultConfigScope() });
+                stopTask();
+            }
+            else if (authType === 'token') {
+                const accessToken = String(prompted.accessToken ?? tokenFromFlags ?? '').trim();
+                if (accessToken === '') {
+                    this.error('--access-token cannot be empty.');
+                }
+                startTask(`Saving access token for "${envName}"...`);
+                await updateEnvConnection(envName, {
+                    authType: 'token',
+                    accessToken,
+                }, { scope: resolveDefaultConfigScope() });
+                stopTask();
+            }
+            else {
+                startTask(`Starting browser sign-in for "${envName}"...`);
+                await updateEnvConnection(envName, {
+                    authType: 'oauth',
+                }, { scope: resolveDefaultConfigScope() });
+                await authenticateEnvWithOauth({
+                    envName,
+                    scope: resolveDefaultConfigScope(),
+                });
+                stopTask();
+            }
+            await this.config.runCommand('env:update', [envName]);
+            succeedTask(`✔ Authenticated "${envName}".`);
+        }
+        catch (error) {
+            failTask(`Authentication failed for "${envName}".`);
+            throw error;
+        }
+    }
+}

package/dist/commands/env/current.js

@@ -0,0 +1,21 @@
+/**
+ * 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 { getCurrentEnvName } from '../../lib/auth-store.js';
+import { resolveDefaultConfigScope } from '../../lib/cli-home.js';
+export default class EnvCurrent extends Command {
+    static summary = 'Show the current environment name';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    async run() {
+        await this.parse(EnvCurrent);
+        this.log(await getCurrentEnvName({ scope: resolveDefaultConfigScope() }));
+    }
+}