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

package/README.md

@@ -35,19 +35,19 @@ npm install -g @nocobase/ctl@latest
 Add an environment:
 
 ```bash
-nb env add --name local --base-url http://localhost:13000/api
+nb env add local --base-url http://localhost:13000/api
 ```
 
 Add an environment with an API key:
 
 ```bash
-nb env add --name local --base-url http://localhost:13000/api --token <api-key>
+nb env add local --base-url http://localhost:13000/api --auth-type token --token <api-key>
 ```
 
 Authenticate an environment with OAuth:
 
 ```bash
-nb env auth -e local
+nb env auth local
 ```
 
 Show the current environment:
@@ -72,7 +72,7 @@ Update the runtime command cache from `swagger:get`:
 
 ```bash
 nb env update
-nb env update -e local
+nb env update local
 ```
 
 Use the generic resource commands:
@@ -96,10 +96,16 @@ If the `API documentation plugin` is disabled, the CLI will prompt to enable it.
 
 ## Environment Selection
 
-Use `-e, --env` to temporarily select an environment:
+`nb env update` and `nb env auth` take an optional environment name as the first argument (omit it to use the current env):
+
+```bash
+nb env update prod
+nb env auth prod
+```
+
+Use `-e, --env` on **runtime / API** commands to temporarily select an environment:
 
 ```bash
-nb env update -e prod
 nb api resource list --resource users -e prod
 ```
 
@@ -120,8 +126,8 @@ Use `-s, --scope` to select one explicitly:
 
 ```bash
 nb env list -s project
-nb env add -s global --name prod --base-url http://example.com/api --token <api-key>
-nb env auth -e prod -s global
+nb env add prod -s global --base-url http://example.com/api --auth-type token --token <api-key>
+nb env auth prod -s global
 nb env use local -s project
 ```
 
@@ -157,7 +163,7 @@ nb api resource --help
 Example:
 
 ```bash
-nb env update -e prod -s global
+nb env update prod -s global
 nb api resource list --resource users -e prod -j
 nb api resource list --resource users -e prod --role admin
 ```

package/bin/run.js

@@ -10,7 +10,7 @@ const root = path.resolve(__dirname, '..');
 const realRoot = fs.realpathSync(root);
 const isSourcePackage = realRoot.split(path.sep).join('/').endsWith('/packages/core/cli');
 let isDev = isSourcePackage;
-if (process.env.NODE_ENV === 'production') {
+if (process.env.NB_CLI_USE_DIST === '1') {
   isDev = false;
 }
 
@@ -47,15 +47,21 @@ if (isDev) {
 }
 
 function getCommandToken(argv) {
+  const tokens = [];
+
   for (const token of argv) {
     if (!token || token.startsWith('-')) {
       continue;
     }
 
-    return token;
+    tokens.push(token);
+  }
+
+  if (tokens[0] === 'api') {
+    return tokens[1] ?? tokens[0];
   }
 
-  return undefined;
+  return tokens[0];
 }
 
 function formatCliEntryError(error, argv) {

package/dist/commands/api/resource/index.js

@@ -0,0 +1,20 @@
+/**
+ * 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, loadHelpClass } from '@oclif/core';
+export default class Resource extends Command {
+    static summary = 'Work with generic collection resources';
+    async run() {
+        await this.parse(Resource);
+        const Help = await loadHelpClass(this.config);
+        await new Help(this.config, this.config.pjson.oclif.helpOptions ?? this.config.pjson.helpOptions).showHelp([
+            this.id ?? 'api:resource',
+            ...this.argv,
+        ]);
+    }
+}

package/dist/commands/build.js

@@ -26,7 +26,7 @@ export default class Build extends Command {
         '<%= config.bin %> <%= command.id %> @nocobase/acl @nocobase/actions',
     ];
     static flags = {
-        env: Flags.string({ description: 'Environment', char: 'e', required: false }),
+        'cwd': Flags.string({ description: 'Current working directory', char: 'c', required: false }),
         'no-dts': Flags.boolean({ description: 'not generate dts' }),
         sourcemap: Flags.boolean({ description: 'generate sourcemap' }),
     };
@@ -41,7 +41,7 @@ export default class Build extends Command {
             npmArgs.push('--sourcemap');
         }
         try {
-            await runNocoBaseCommand(npmArgs, process.cwd());
+            await runNocoBaseCommand(npmArgs, { cwd: flags['cwd'] });
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);

package/dist/commands/db/start.js

@@ -0,0 +1,22 @@
+/**
+ * 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';
+export default class DbStart extends Command {
+    static args = {
+        file: Args.string({ description: 'file to read' }),
+    };
+    static description = 'describe the command here';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    static flags = {};
+    async run() {
+        const { args, flags } = await this.parse(DbStart);
+    }
+}

package/dist/commands/dev.js

@@ -48,7 +48,7 @@ export default class Dev extends Command {
             npmArgs.push('--inspect', flags.inspect);
         }
         try {
-            await runNocoBaseCommand(npmArgs, process.cwd());
+            await runNocoBaseCommand(npmArgs);
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);

package/dist/commands/download.js

@@ -8,110 +8,282 @@
  */
 import fsp from 'node:fs/promises';
 import { Command, Flags } from '@oclif/core';
+import * as p from '@clack/prompts';
 import path from 'node:path';
+import { stdin as stdinStream, stdout as stdoutStream } from 'node:process';
 import { run } from "../lib/run-npm.js";
 export default class Download extends Command {
-    static description = 'Download a NocoBase app from npm (create-nocobase-app), Docker Hub, or git.';
+    static description = 'Scaffold or fetch NocoBase: npm (create-nocobase-app), docker (image pull), or git (shallow clone).';
     static examples = [
-        '<%= config.bin %> <%= command.id %> -s npm -v latest --app-root-path=./app --env-file=.env',
-        '<%= config.bin %> <%= command.id %> -s docker -v latest --docker-registry=nocobase/nocobase',
-        '<%= config.bin %> <%= command.id %> -s git -v main --git-url=https://github.com/nocobase/nocobase.git --app-root-path=./my-nocobase-app',
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> -y --source npm --version latest',
+        '<%= config.bin %> <%= command.id %> --source npm --version latest',
+        '<%= config.bin %> <%= command.id %> --source npm --version latest --output-dir=./app',
+        '<%= config.bin %> <%= command.id %> --source docker --version latest --docker-registry=nocobase/nocobase',
+        '<%= config.bin %> <%= command.id %> --source git --version latest --git-url=https://github.com/nocobase/nocobase.git',
     ];
     static flags = {
+        yes: Flags.boolean({
+            char: 'y',
+            description: 'Skip interactive prompts; use flags only (non-TTY implies -y)',
+            default: false,
+        }),
         source: Flags.string({
             char: 's',
-            description: 'Where to download from',
+            description: 'Distribution: npm runs create-nocobase-app, docker runs docker pull, git clones the repository',
             options: ['docker', 'npm', 'git'],
-            required: true,
+            required: false,
         }),
         version: Flags.string({
             char: 'v',
-            default: 'latest',
-            description: 'Version or tag: npm package dist-tag/version, Docker image tag, or git branch/tag',
+            description: 'npm: dist-tag or version for create-nocobase-app; docker: image tag; git: branch or tag (latest→main, beta→next, alpha→develop); default: latest',
         }),
-        'force-overwrite': Flags.boolean({
-            char: 'f',
-            description: 'Pass --force to create-nocobase-app (npm) or overwrite when supported',
+        replace: Flags.boolean({
+            char: 'r',
+            description: 'npm/git: delete the target project directory if it exists, then scaffold or clone again; docker: ignored',
             default: false,
         }),
         'dev': Flags.boolean({
-            description: 'Include dev dependencies in the app directory',
+            description: 'npm: install devDependencies in create-nocobase-app and run a non-production yarn install; git/docker: ignored',
             default: false,
         }),
-        'env-file': Flags.string({
-            description: 'Dotenv file whose variables are passed to create-nocobase-app as -e KEY=value (npm only)',
-        }),
-        'app-root-path': Flags.string({
-            description: 'Project directory name or path for the new app (default: my-nocobase-app)',
-            default: 'my-nocobase-app',
+        'output-dir': Flags.string({
+            char: 'o',
+            description: 'npm/git: output directory (relative to cwd); default ./nocobase-<version> using the same value as --version; docker: ignored',
         }),
-        'db-password': Flags.string({ description: 'DB password (npm: DB_PASSWORD)' }),
         'git-url': Flags.string({
-            description: 'Git remote URL to clone (git source)',
+            description: 'git: remote URL to clone (default: https://github.com/nocobase/nocobase.git)',
         }),
         'docker-registry': Flags.string({
-            description: 'Docker image repository without tag (default: nocobase/nocobase). Example: ghcr.io/nocobase/nocobase',
+            description: 'docker: image reference without tag (default: nocobase/nocobase); use -v for the tag, e.g. ghcr.io/nocobase/nocobase',
         }),
     };
+    resolveOutputDir(flags) {
+        const explicit = flags['output-dir'];
+        if (explicit) {
+            return explicit;
+        }
+        const tag = flags.version || 'latest';
+        const safe = tag.replace(/[/\\]/g, '-');
+        return `./nocobase-${safe}`;
+    }
+    defaultOutputDir(versionTag) {
+        const safe = versionTag.replace(/[/\\]/g, '-');
+        return `./nocobase-${safe}`;
+    }
+    /**
+     * When stdin/stdout are TTY and not `-y`, prompt for any missing download options.
+     */
+    async resolveDownloadFlags(flags) {
+        const interactive = Boolean(stdinStream.isTTY && stdoutStream.isTTY && !flags.yes);
+        let source = flags.source?.trim();
+        if (source === '') {
+            source = undefined;
+        }
+        let version = flags.version?.trim() || undefined;
+        let replace = flags.replace;
+        let dev = flags['dev'];
+        let outputDir = flags['output-dir']?.trim() || undefined;
+        if (outputDir === '') {
+            outputDir = undefined;
+        }
+        let gitUrl = flags['git-url']?.trim() || undefined;
+        if (gitUrl === '') {
+            gitUrl = undefined;
+        }
+        let dockerRegistry = flags['docker-registry']?.trim() || undefined;
+        if (dockerRegistry === '') {
+            dockerRegistry = undefined;
+        }
+        if (!interactive) {
+            if (!source) {
+                this.error('Distribution is required (--source npm|git|docker). Use a terminal for interactive setup, or pass -s/--source.');
+            }
+            const v = version || 'latest';
+            return {
+                source,
+                version: v,
+                replace,
+                'dev': dev,
+                'output-dir': outputDir,
+                'git-url': gitUrl,
+                'docker-registry': dockerRegistry,
+            };
+        }
+        p.intro('nb download');
+        if (!source) {
+            const src = await p.select({
+                message: 'How do you want to get NocoBase?',
+                options: [
+                    { value: 'npm', label: 'npm — create-nocobase-app' },
+                    { value: 'git', label: 'git — shallow clone' },
+                    { value: 'docker', label: 'docker — pull image' },
+                ],
+                initialValue: 'npm',
+            });
+            if (p.isCancel(src)) {
+                p.cancel('Download cancelled.');
+                this.exit(0);
+            }
+            source = src;
+        }
+        if (version === undefined) {
+            const verAns = await p.text({
+                message: 'Version / dist-tag / image tag / branch alias (-v)',
+                placeholder: 'latest',
+                initialValue: 'latest',
+            });
+            if (p.isCancel(verAns)) {
+                p.cancel('Download cancelled.');
+                this.exit(0);
+            }
+            version = verAns.trim() || 'latest';
+        }
+        const versionResolved = version || 'latest';
+        if (source === 'docker') {
+            if (dockerRegistry === undefined) {
+                const reg = await p.text({
+                    message: 'Docker image without tag (--docker-registry)',
+                    placeholder: 'nocobase/nocobase',
+                    initialValue: 'nocobase/nocobase',
+                });
+                if (p.isCancel(reg)) {
+                    p.cancel('Download cancelled.');
+                    this.exit(0);
+                }
+                dockerRegistry = reg.trim() || 'nocobase/nocobase';
+            }
+        }
+        if (source === 'git') {
+            if (gitUrl === undefined) {
+                const urlAns = await p.text({
+                    message: 'Git remote URL (--git-url)',
+                    placeholder: 'https://github.com/nocobase/nocobase.git',
+                    initialValue: 'https://github.com/nocobase/nocobase.git',
+                });
+                if (p.isCancel(urlAns)) {
+                    p.cancel('Download cancelled.');
+                    this.exit(0);
+                }
+                gitUrl = urlAns.trim() || 'https://github.com/nocobase/nocobase.git';
+            }
+        }
+        if (source === 'npm' || source === 'git') {
+            if (outputDir === undefined) {
+                const initialOut = this.defaultOutputDir(versionResolved);
+                const outAns = await p.text({
+                    message: 'Output directory relative to cwd (-o)',
+                    placeholder: initialOut,
+                    initialValue: initialOut,
+                });
+                if (p.isCancel(outAns)) {
+                    p.cancel('Download cancelled.');
+                    this.exit(0);
+                }
+                outputDir = outAns.trim() || initialOut;
+            }
+            const replaceAns = await p.confirm({
+                message: 'Delete existing output directory if present, then retry? (--replace)',
+                initialValue: replace,
+            });
+            if (p.isCancel(replaceAns)) {
+                p.cancel('Download cancelled.');
+                this.exit(0);
+            }
+            replace = replaceAns;
+        }
+        if (source === 'npm') {
+            const devAns = await p.confirm({
+                message: 'Install devDependencies and run a non-production yarn install? (--dev)',
+                initialValue: dev,
+            });
+            if (p.isCancel(devAns)) {
+                p.cancel('Download cancelled.');
+                this.exit(0);
+            }
+            dev = devAns;
+        }
+        return {
+            source,
+            version: versionResolved,
+            replace,
+            'dev': dev,
+            'output-dir': outputDir,
+            'git-url': gitUrl,
+            'docker-registry': dockerRegistry,
+        };
+    }
     async downloadFromDocker(flags) {
         const image = flags['docker-registry'] ?? 'nocobase/nocobase';
         const tag = flags.version ?? 'latest';
-        await run('docker', ['pull', `${image}:${tag}`], process.cwd());
+        await run('docker', ['pull', `${image}:${tag}`]);
     }
     async downloadFromNpm(flags) {
-        const appRoot = flags['app-root-path'] ?? 'my-nocobase-app';
         const versionSpec = flags.version || 'latest';
-        const npxArgs = ['-y', `create-nocobase-app@${versionSpec}`, appRoot];
-        if (!flags['--dev']) {
+        const outputDir = this.resolveOutputDir(flags);
+        const projectRoot = path.resolve(process.cwd(), outputDir);
+        const npxArgs = ['-y', `create-nocobase-app@${versionSpec}`, outputDir];
+        if (!flags['dev']) {
             npxArgs.push('--skip-dev-dependencies');
         }
-        if (flags['force-overwrite']) {
-            await fsp.rm(path.resolve(process.cwd(), appRoot), { recursive: true, force: true });
+        if (flags.replace) {
+            await fsp.rm(projectRoot, { recursive: true, force: true });
         }
-        await run('npx', npxArgs, process.cwd());
+        await run('npx', npxArgs);
         const installArgs = ['install'];
-        if (!flags['--dev']) {
+        if (!flags['dev']) {
             installArgs.push('--production');
         }
-        await run('yarn', installArgs, path.resolve(process.cwd(), appRoot));
+        await run('yarn', installArgs, { cwd: projectRoot });
+        return projectRoot;
     }
     async downloadFromGit(flags) {
         const repoUrl = flags['git-url'] ?? 'https://github.com/nocobase/nocobase.git';
-        const appRoot = flags['app-root-path'] ?? 'my-nocobase-app';
+        const versionSpec = flags.version || 'latest';
+        const outputDir = this.resolveOutputDir(flags);
         const versionToRef = {
             'latest': 'main',
             'beta': 'next',
             'alpha': 'develop',
         };
-        if (flags['force-overwrite']) {
-            await fsp.rm(path.resolve(process.cwd(), appRoot), { recursive: true, force: true });
+        if (flags.replace) {
+            await fsp.rm(path.resolve(process.cwd(), outputDir), { recursive: true, force: true });
         }
-        const branch = versionToRef[flags.version || 'latest'] || flags.version || 'latest';
+        const branch = versionToRef[versionSpec] || versionSpec;
         const gitArgs = ['clone'];
         gitArgs.push('--branch', branch);
-        gitArgs.push('--depth', '1', repoUrl, appRoot);
-        await run('git', gitArgs, process.cwd());
-        await run('yarn', ['install'], path.resolve(process.cwd(), appRoot));
+        gitArgs.push('--depth', '1', repoUrl, outputDir);
+        await run('git', gitArgs);
+        const projectRoot = path.resolve(process.cwd(), outputDir);
+        await run('yarn', ['install'], { cwd: projectRoot });
+        return projectRoot;
     }
+    /**
+     * @returns Final resolved flags and, for npm/git, the absolute project directory.
+     */
     async download() {
         const { flags } = await this.parse(Download);
-        switch (flags.source) {
-            case 'npm':
-                await this.downloadFromNpm(flags);
-                break;
-            case 'docker':
-                await this.downloadFromDocker(flags);
-                break;
-            case 'git':
-                await this.downloadFromGit(flags);
-                break;
+        const resolved = await this.resolveDownloadFlags(flags);
+        switch (resolved.source) {
+            case 'npm': {
+                const projectRoot = await this.downloadFromNpm(resolved);
+                return { resolved, projectRoot };
+            }
+            case 'docker': {
+                await this.downloadFromDocker(resolved);
+                return { resolved, projectRoot: undefined };
+            }
+            case 'git': {
+                const projectRoot = await this.downloadFromGit(resolved);
+                return { resolved, projectRoot };
+            }
             default:
-                this.error(`Invalid source: ${flags.source}`);
+                this.error(`Invalid --source: ${resolved.source}`);
         }
     }
     async run() {
         try {
-            await this.download();
+            return await this.download();
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);