@nocobase/cli 2.1.0-beta.2 → 2.1.0-beta.21

package/dist/commands/env/add.js

@@ -0,0 +1,307 @@
+/**
+ * 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 { upsertEnv } from '../../lib/auth-store.js';
+import { resolveDefaultConfigScope } from '../../lib/cli-home.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 { 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',
+    'builtin-db-image': 'builtinDbImage',
+    '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',
+};
+const envAddText = (key, values) => localeText(`commands.envAdd.${key}`, values);
+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 = [
+        '<%= 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: 'Label for this environment (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: token (API key) or oauth (browser login via `nb env auth`); prompted in a TTY when omitted',
+            options: ['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)',
+        }),
+        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',
+        }),
+        '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',
+        }),
+    };
+    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') },
+            ],
+            initialValue: 'oauth',
+            required: true,
+        },
+        accessToken: {
+            type: 'text',
+            message: envAddText('prompts.accessToken.message'),
+            placeholder: envAddText('prompts.accessToken.placeholder'),
+            required: true,
+            hidden: (values) => values.authType !== 'token',
+        },
+    };
+    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'];
+        }
+        const token = flags['access-token'] ?? flags.token;
+        if (typeof token === 'string' && token !== '') {
+            values.accessToken = token;
+        }
+        return values;
+    }
+    buildPromptInitialValues(flags) {
+        const initialValues = {};
+        const defaultApiBaseUrl = flags['default-api-base-url']?.trim();
+        if (defaultApiBaseUrl) {
+            initialValues.apiBaseUrl = defaultApiBaseUrl;
+        }
+        return initialValues;
+    }
+    buildEnvConfig(results, flags) {
+        const source = String(flags.source ?? '').trim();
+        const appRootPath = String(flags['app-root-path'] ?? '').trim();
+        const kind = source === 'docker'
+            ? 'docker'
+            : source === 'npm' || source === 'git' || source === 'local' || appRootPath
+                ? 'local'
+                : 'http';
+        const envConfig = {
+            kind,
+            apiBaseUrl: 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();
+            }
+        }
+        for (const [flagName, configKey] of Object.entries(ENV_BOOLEAN_RUNTIME_FLAG_MAP)) {
+            const value = flags[flagName];
+            if (typeof value === 'boolean') {
+                envConfig[configKey] = value;
+            }
+        }
+        if (flags['builtin-db'] === false) {
+            envConfig.builtinDbImage = undefined;
+        }
+        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;
+        applyCliLocale(parsedFlags.locale);
+        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 envConfig = this.buildEnvConfig(results, parsedFlags);
+        printVerbose(`Saving env "${envName}" globally.`);
+        await upsertEnv(envName, envConfig, { scope: resolveDefaultConfigScope() });
+        if (results.authType === 'oauth') {
+            await this.config.runCommand('env:auth', [envName]);
+        }
+        await this.config.runCommand('env:update', [envName]);
+        p.outro(`Env "${envName}" added successfully.`);
+    }
+}

package/dist/commands/env/auth.js

@@ -0,0 +1,55 @@
+/**
+ * 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 } from '../../lib/auth-store.js';
+import { resolveDefaultConfigScope } 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 = 'Sign in to a saved NocoBase environment with OAuth';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> prod',
+    ];
+    static args = {
+        name: Args.string({
+            description: 'Environment name (omit to use the current env)',
+            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)',
+        }),
+    };
+    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() }));
+        startTask(`Starting browser sign-in for "${envName}"...`);
+        try {
+            await authenticateEnvWithOauth({
+                envName,
+                scope: resolveDefaultConfigScope(),
+            });
+            succeedTask(`Signed in to "${envName}".`);
+        }
+        catch (error) {
+            failTask(`Sign-in failed for "${envName}".`);
+            throw error;
+        }
+    }
+}

package/dist/commands/env/list.js

@@ -0,0 +1,36 @@
+/**
+ * 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 { listEnvs } from '../../lib/auth-store.js';
+import { resolveDefaultConfigScope } from '../../lib/cli-home.js';
+import { renderTable } from '../../lib/ui.js';
+function resolveApiBaseUrl(config) {
+    return String(config.apiBaseUrl ?? config.baseUrl ?? config.apibaseUrl ?? '').trim();
+}
+export default class EnvList extends Command {
+    static summary = 'List configured environments';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    async run() {
+        await this.parse(EnvList);
+        const { currentEnv, envs } = await listEnvs({ scope: resolveDefaultConfigScope() });
+        const names = Object.keys(envs).sort();
+        if (!names.length) {
+            this.log('No envs configured.');
+            this.log('Run `nb env add <name> --api-base-url <url>` to add one.');
+            return;
+        }
+        const rows = names.map((name) => {
+            const env = envs[name];
+            return [name === currentEnv ? '*' : '', name, resolveApiBaseUrl(env), env.auth?.type ?? '', env.runtime?.version ?? ''];
+        });
+        this.log(renderTable(['Current', 'Name', 'Base URL', 'Auth', 'Runtime'], rows));
+    }
+}

package/dist/commands/env/remove.js

@@ -0,0 +1,59 @@
+/**
+ * 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, removeEnv } from '../../lib/auth-store.js';
+import { resolveDefaultConfigScope } from '../../lib/cli-home.js';
+import { confirmAction, isInteractiveTerminal, printVerbose, setVerboseMode } from '../../lib/ui.js';
+export default class EnvRemove extends Command {
+    static summary = 'Remove a configured environment';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> staging',
+        '<%= config.bin %> <%= command.id %> staging -f',
+    ];
+    static flags = {
+        force: Flags.boolean({
+            char: 'f',
+            description: 'Remove without confirmation',
+            default: false,
+        }),
+        verbose: Flags.boolean({
+            description: 'Show detailed progress output',
+            default: false,
+        }),
+    };
+    static args = {
+        name: Args.string({
+            description: 'Configured environment name',
+            required: true,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(EnvRemove);
+        setVerboseMode(flags.verbose);
+        const currentEnv = await getCurrentEnvName({ scope: resolveDefaultConfigScope() });
+        if (args.name === currentEnv && !flags.force) {
+            if (!isInteractiveTerminal()) {
+                this.error('Refusing to remove the current env without confirmation. Re-run with `--force`.');
+            }
+            const confirmed = await confirmAction(`Remove current env "${args.name}"?`, { defaultValue: false });
+            if (!confirmed) {
+                this.log('Canceled.');
+                return;
+            }
+        }
+        printVerbose(`Removing env "${args.name}"`);
+        const result = await removeEnv(args.name, { scope: resolveDefaultConfigScope() });
+        this.log(`Removed env "${result.removed}".`);
+        if (result.hasEnvs) {
+            this.log(`Current env: ${result.currentEnv}`);
+            return;
+        }
+        this.log('No envs configured.');
+    }
+}

package/dist/commands/env/update.js

@@ -0,0 +1,67 @@
+/**
+ * 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 path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Args, Command, Flags } from '@oclif/core';
+import { getCurrentEnvName } from '../../lib/auth-store.js';
+import { updateEnvRuntime } from '../../lib/bootstrap.js';
+import { resolveDefaultConfigScope } from '../../lib/cli-home.js';
+import { failTask, startTask, succeedTask } from '../../lib/ui.js';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+export default class EnvUpdate extends Command {
+    static summary = 'Refresh an environment runtime from swagger:get and persist connection overrides';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> prod',
+    ];
+    static args = {
+        name: Args.string({
+            description: 'Environment name (omit to use the current env)',
+            required: false,
+        }),
+    };
+    static flags = {
+        verbose: Flags.boolean({
+            description: 'Show detailed progress output',
+            default: false,
+        }),
+        'api-base-url': Flags.string({
+            description: 'NocoBase API base URL override. When provided, persist it to the target env before saving the refreshed runtime.',
+        }),
+        role: Flags.string({
+            description: 'Role override, sent as X-Role',
+        }),
+        token: Flags.string({
+            char: 't',
+            description: 'API key override. When provided, persist it to the target env before saving the refreshed runtime.',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(EnvUpdate);
+        const envName = args.name;
+        const envLabel = envName ?? (await getCurrentEnvName({ scope: resolveDefaultConfigScope() }));
+        startTask(`Updating env runtime: ${envLabel}`);
+        try {
+            const runtime = await updateEnvRuntime({
+                envName,
+                scope: resolveDefaultConfigScope(),
+                baseUrl: flags['api-base-url'],
+                role: flags.role,
+                token: flags.token,
+                configFile: path.join(path.dirname(path.dirname(path.dirname(__dirname))), 'nocobase-ctl.config.json'),
+                verbose: flags.verbose,
+            });
+            succeedTask(`Updated env "${envLabel}" to runtime "${runtime.version}".`);
+        }
+        catch (error) {
+            failTask(`Failed to update env "${envLabel}".`);
+            throw error;
+        }
+    }
+}

package/dist/commands/env/use.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 { Args, Command } from '@oclif/core';
+import { setCurrentEnv } from '../../lib/auth-store.js';
+import { resolveDefaultConfigScope } from '../../lib/cli-home.js';
+export default class EnvUse extends Command {
+    static summary = 'Switch the current environment';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> local',
+    ];
+    static args = {
+        name: Args.string({
+            description: 'Configured environment name',
+            required: true,
+        }),
+    };
+    async run() {
+        const { args } = await this.parse(EnvUse);
+        await setCurrentEnv(args.name, { scope: resolveDefaultConfigScope() });
+        this.log(`Current env: ${args.name}`);
+    }
+}