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

package/bin/run.js

@@ -9,6 +9,10 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
 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') {
+  isDev = false;
+}
 
 /**
  * In the monorepo, plain `node` cannot load `.ts`. Re-exec once with `--import tsx`
@@ -30,17 +34,15 @@ function reexecWithTsx() {
   process.exit(result.status === null ? 1 : result.status);
 }
 
-if (isSourcePackage && !process.env._NOCO_CLI_TSX_CHILD) {
+if (isDev && !process.env._NOCO_CLI_TSX_CHILD) {
   reexecWithTsx();
 }
 
-const bootstrapPath = isSourcePackage
-  ? path.join(root, 'src/lib/bootstrap.ts')
-  : path.join(root, 'dist/lib/bootstrap.js');
+const bootstrapPath = isDev ? path.join(root, 'src/lib/bootstrap.ts') : path.join(root, 'dist/lib/bootstrap.js');
 const { ensureRuntimeFromArgv } = await import(pathToFileURL(bootstrapPath).href);
 const { flush, run, settings } = await import('@oclif/core');
 
-if (isSourcePackage) {
+if (isDev) {
   settings.debug = true;
 }
 

package/dist/commands/{resource → api/resource}/create.js

@@ -1,5 +1,5 @@
 import { Command } from '@oclif/core';
-import { buildCreateArgs, createFlags, runResourceCommand } from '../../lib/resource-command.js';
+import { buildCreateArgs, createFlags, runResourceCommand } from '../../../lib/resource-command.js';
 export default class ResourceCreate extends Command {
     static summary = 'Create a record in a resource';
     static description = 'Create a record in a generic resource. Pass record content through --values as a JSON object.';

package/dist/commands/{resource → api/resource}/destroy.js

@@ -1,5 +1,5 @@
 import { Command } from '@oclif/core';
-import { buildDestroyArgs, destroyFlags, runResourceCommand } from '../../lib/resource-command.js';
+import { buildDestroyArgs, destroyFlags, runResourceCommand } from '../../../lib/resource-command.js';
 export default class ResourceDestroy extends Command {
     static summary = 'Delete records from a resource';
     static description = 'Delete records from a generic resource. Target records with --filter-by-tk or --filter.';

package/dist/commands/{resource → api/resource}/get.js

@@ -1,5 +1,5 @@
 import { Command } from '@oclif/core';
-import { buildGetArgs, getFlags, runResourceCommand } from '../../lib/resource-command.js';
+import { buildGetArgs, getFlags, runResourceCommand } from '../../../lib/resource-command.js';
 export default class ResourceGet extends Command {
     static summary = 'Get a record from a resource';
     static description = 'Get a record from a generic resource. Use --filter-by-tk for the primary key and association resource names with --source-id when needed.';

package/dist/commands/{resource → api/resource}/list.js

@@ -1,5 +1,5 @@
 import { Command } from '@oclif/core';
-import { buildListArgs, listFlags, runResourceCommand } from '../../lib/resource-command.js';
+import { buildListArgs, listFlags, runResourceCommand } from '../../../lib/resource-command.js';
 export default class ResourceList extends Command {
     static summary = 'List records from a resource';
     static description = 'List records from a generic resource. Use association resource names like posts.comments with --source-id when needed.';

package/dist/commands/{resource → api/resource}/query.js

@@ -1,5 +1,5 @@
 import { Command } from '@oclif/core';
-import { buildQueryArgs, queryFlags, runResourceCommand } from '../../lib/resource-command.js';
+import { buildQueryArgs, queryFlags, runResourceCommand } from '../../../lib/resource-command.js';
 export default class ResourceQuery extends Command {
     static summary = 'Run an aggregate query on a resource';
     static description = 'Run an aggregate query on a generic resource. Pass measures, dimensions, and orders as JSON arrays.';

package/dist/commands/{resource → api/resource}/update.js

@@ -1,5 +1,5 @@
 import { Command } from '@oclif/core';
-import { buildUpdateArgs, runResourceCommand, updateFlags } from '../../lib/resource-command.js';
+import { buildUpdateArgs, runResourceCommand, updateFlags } from '../../../lib/resource-command.js';
 export default class ResourceUpdate extends Command {
     static summary = 'Update records in a resource';
     static description = 'Update records in a generic resource. Target records with --filter-by-tk or --filter, and pass updated values through --values.';

package/dist/commands/build.js

@@ -0,0 +1,51 @@
+/**
+ * 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 { runNocoBaseCommand } from "../lib/run-npm.js";
+export default class Build extends Command {
+    static args = {
+        /** Matches `nb build @nocobase/acl @nocobase/actions` — zero or more package names. */
+        packages: Args.string({
+            description: 'package names to build',
+            multiple: true,
+            required: false,
+        }),
+    };
+    static description = 'Run the legacy NocoBase build (forwards to `npm run build` in the repo root)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --no-dts',
+        '<%= config.bin %> <%= command.id %> --sourcemap',
+        '<%= config.bin %> <%= command.id %> @nocobase/acl',
+        '<%= config.bin %> <%= command.id %> @nocobase/acl @nocobase/actions',
+    ];
+    static flags = {
+        env: Flags.string({ description: 'Environment', char: 'e', required: false }),
+        'no-dts': Flags.boolean({ description: 'not generate dts' }),
+        sourcemap: Flags.boolean({ description: 'generate sourcemap' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Build);
+        const packages = args.packages ?? [];
+        const npmArgs = ['build', ...packages];
+        if (flags['no-dts']) {
+            npmArgs.push('--no-dts');
+        }
+        if (flags.sourcemap) {
+            npmArgs.push('--sourcemap');
+        }
+        try {
+            await runNocoBaseCommand(npmArgs, process.cwd());
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.error(message);
+        }
+    }
+}

package/dist/commands/dev.js

@@ -0,0 +1,58 @@
+/**
+ * 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 { runNocoBaseCommand } from "../lib/run-npm.js";
+export default class Dev extends Command {
+    static args = {
+        file: Args.string({ description: 'file to read' }),
+    };
+    static description = 'describe the command here';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --db-sync',
+        '<%= config.bin %> <%= command.id %> --port 12000',
+        '<%= config.bin %> <%= command.id %> --client',
+        '<%= config.bin %> <%= command.id %> --server',
+        '<%= config.bin %> <%= command.id %> --inspect 9229',
+    ];
+    static flags = {
+        env: Flags.string({ description: 'Environment', char: 'e', required: false }),
+        'db-sync': Flags.boolean({ description: 'Sync the database', required: false }),
+        port: Flags.string({ description: 'Port', char: 'p', required: false }),
+        client: Flags.boolean({ description: 'Client', char: 'c', required: false }),
+        server: Flags.boolean({ description: 'Server', char: 's', required: false }),
+        inspect: Flags.string({ description: 'Inspect port', char: 'i', required: false }),
+    };
+    async run() {
+        const { flags } = await this.parse(Dev);
+        const npmArgs = ['dev', '--rsbuild'];
+        if (flags['db-sync']) {
+            npmArgs.push('--db-sync');
+        }
+        if (flags.port) {
+            npmArgs.push('--port', flags.port);
+        }
+        if (flags.client) {
+            npmArgs.push('--client');
+        }
+        if (flags.server) {
+            npmArgs.push('--server');
+        }
+        if (flags.inspect) {
+            npmArgs.push('--inspect', flags.inspect);
+        }
+        try {
+            await runNocoBaseCommand(npmArgs, process.cwd());
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.error(message);
+        }
+    }
+}

package/dist/commands/download.js

@@ -0,0 +1,121 @@
+/**
+ * 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 fsp from 'node:fs/promises';
+import { Command, Flags } from '@oclif/core';
+import path from 'node:path';
+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 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',
+    ];
+    static flags = {
+        source: Flags.string({
+            char: 's',
+            description: 'Where to download from',
+            options: ['docker', 'npm', 'git'],
+            required: true,
+        }),
+        version: Flags.string({
+            char: 'v',
+            default: 'latest',
+            description: 'Version or tag: npm package dist-tag/version, Docker image tag, or git branch/tag',
+        }),
+        'force-overwrite': Flags.boolean({
+            char: 'f',
+            description: 'Pass --force to create-nocobase-app (npm) or overwrite when supported',
+            default: false,
+        }),
+        'dev': Flags.boolean({
+            description: 'Include dev dependencies in the app directory',
+            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',
+        }),
+        'db-password': Flags.string({ description: 'DB password (npm: DB_PASSWORD)' }),
+        'git-url': Flags.string({
+            description: 'Git remote URL to clone (git source)',
+        }),
+        'docker-registry': Flags.string({
+            description: 'Docker image repository without tag (default: nocobase/nocobase). Example: ghcr.io/nocobase/nocobase',
+        }),
+    };
+    async downloadFromDocker(flags) {
+        const image = flags['docker-registry'] ?? 'nocobase/nocobase';
+        const tag = flags.version ?? 'latest';
+        await run('docker', ['pull', `${image}:${tag}`], process.cwd());
+    }
+    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']) {
+            npxArgs.push('--skip-dev-dependencies');
+        }
+        if (flags['force-overwrite']) {
+            await fsp.rm(path.resolve(process.cwd(), appRoot), { recursive: true, force: true });
+        }
+        await run('npx', npxArgs, process.cwd());
+        const installArgs = ['install'];
+        if (!flags['--dev']) {
+            installArgs.push('--production');
+        }
+        await run('yarn', installArgs, path.resolve(process.cwd(), appRoot));
+    }
+    async downloadFromGit(flags) {
+        const repoUrl = flags['git-url'] ?? 'https://github.com/nocobase/nocobase.git';
+        const appRoot = flags['app-root-path'] ?? 'my-nocobase-app';
+        const versionToRef = {
+            'latest': 'main',
+            'beta': 'next',
+            'alpha': 'develop',
+        };
+        if (flags['force-overwrite']) {
+            await fsp.rm(path.resolve(process.cwd(), appRoot), { recursive: true, force: true });
+        }
+        const branch = versionToRef[flags.version || 'latest'] || flags.version || 'latest';
+        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));
+    }
+    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;
+            default:
+                this.error(`Invalid source: ${flags.source}`);
+        }
+    }
+    async run() {
+        try {
+            await this.download();
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.error(message);
+        }
+    }
+}

package/dist/commands/install.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 { Command, Flags } from '@oclif/core';
+import { runNocoBaseCommand } from "../lib/run-npm.js";
+export default class Install extends Command {
+    static description = 'Run the legacy NocoBase install (forwards to `npm run install` in the repo root)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> -f',
+        '<%= config.bin %> <%= command.id %> -l zh-CN',
+        '<%= config.bin %> <%= command.id %> -m demo@nocobase.com',
+        '<%= config.bin %> <%= command.id %> -p admin123',
+        '<%= config.bin %> <%= command.id %> -n "Super Admin"',
+    ];
+    static flags = {
+        env: Flags.string({ description: 'Environment', char: 'e', required: false }),
+        force: Flags.boolean({ description: 'Reinstall the application by clearing the database', char: 'f', required: false }),
+        lang: Flags.string({ description: 'Language during installation', char: 'l', required: false }),
+        rootEmail: Flags.string({ description: 'Root user email', char: 'm', required: false }),
+        rootPassword: Flags.string({ description: 'Root user password', char: 'p', required: false }),
+        rootNickname: Flags.string({ description: 'Root user nickname', char: 'n', required: false }),
+    };
+    async run() {
+        const { flags } = await this.parse(Install);
+        const npmArgs = ['install'];
+        if (flags.force) {
+            npmArgs.push('--force');
+        }
+        if (flags.lang !== undefined) {
+            npmArgs.push('--lang', flags.lang);
+        }
+        if (flags.rootEmail !== undefined) {
+            npmArgs.push('--root-email', flags.rootEmail);
+        }
+        if (flags.rootPassword !== undefined) {
+            npmArgs.push('--root-password', flags.rootPassword);
+        }
+        if (flags.rootNickname !== undefined) {
+            npmArgs.push('--root-nickname', flags.rootNickname);
+        }
+        try {
+            await runNocoBaseCommand(npmArgs, process.cwd());
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.error(message);
+        }
+    }
+}

package/dist/commands/pm/disable.js

@@ -0,0 +1,32 @@
+/**
+ * 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';
+export default class PmDisable 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 = {
+        // flag with no value (-f, --force)
+        force: Flags.boolean({ char: 'f' }),
+        // flag with a value (-n, --name=VALUE)
+        name: Flags.string({ char: 'n', description: 'name to print' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(PmDisable);
+        const name = flags.name ?? 'world';
+        this.log(`hello ${name} from packages/core/cli/src/commands/pm/disable.ts`);
+        if (args.file && flags.force) {
+            this.log(`you input --force and --file: ${args.file}`);
+        }
+    }
+}

package/dist/commands/pm/enable.js

@@ -0,0 +1,32 @@
+/**
+ * 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';
+export default class PmEnable 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 = {
+        // flag with no value (-f, --force)
+        force: Flags.boolean({ char: 'f' }),
+        // flag with a value (-n, --name=VALUE)
+        name: Flags.string({ char: 'n', description: 'name to print' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(PmEnable);
+        const name = flags.name ?? 'world';
+        this.log(`hello ${name} from packages/core/cli/src/commands/pm/enable.ts`);
+        if (args.file && flags.force) {
+            this.log(`you input --force and --file: ${args.file}`);
+        }
+    }
+}

package/dist/commands/pm/list.js

@@ -0,0 +1,32 @@
+/**
+ * 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';
+export default class PmList 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 = {
+        // flag with no value (-f, --force)
+        force: Flags.boolean({ char: 'f' }),
+        // flag with a value (-n, --name=VALUE)
+        name: Flags.string({ char: 'n', description: 'name to print' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(PmList);
+        const name = flags.name ?? 'world';
+        this.log(`hello ${name} from packages/core/cli/src/commands/pm/list.ts`);
+        if (args.file && flags.force) {
+            this.log(`you input --force and --file: ${args.file}`);
+        }
+    }
+}

package/dist/commands/restart.js

@@ -0,0 +1,32 @@
+/**
+ * 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';
+export default class Restart 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 = {
+        // flag with no value (-f, --force)
+        force: Flags.boolean({ char: 'f' }),
+        // flag with a value (-n, --name=VALUE)
+        name: Flags.string({ char: 'n', description: 'name to print' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Restart);
+        const name = flags.name ?? 'world';
+        this.log(`hello ${name} from packages/core/cli/src/commands/restart.ts`);
+        if (args.file && flags.force) {
+            this.log(`you input --force and --file: ${args.file}`);
+        }
+    }
+}

package/dist/commands/scaffold/migration.js

@@ -0,0 +1,38 @@
+/**
+ * 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 { runNocoBaseCommand } from "../../lib/run-npm.js";
+export default class ScaffoldMigration extends Command {
+    static args = {
+        name: Args.string({ description: 'migration name', required: true }),
+    };
+    static description = 'Run the legacy NocoBase scaffold migration (forwards to `npm run scaffold:migration` in the repo root)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> migration-name --pkg @nocobase/plugin-acl',
+        '<%= config.bin %> <%= command.id %> migration-name --pkg @nocobase/plugin-acl --on afterLoad',
+    ];
+    static flags = {
+        pkg: Flags.string({ description: 'plugin package name', required: true }),
+        on: Flags.string({ description: 'on', required: false, options: ['beforeLoad', 'afterSync', 'afterLoad'] }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(ScaffoldMigration);
+        const npmArgs = ['create-migration', args.name, '--pkg', flags.pkg];
+        if (flags.on) {
+            npmArgs.push('--on', flags.on);
+        }
+        try {
+            await runNocoBaseCommand(npmArgs, process.cwd(), { env: { LOGGER_SILENT: 'true' } });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.error(message);
+        }
+    }
+}

package/dist/commands/scaffold/plugin.js

@@ -0,0 +1,37 @@
+/**
+ * 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 { runNocoBaseCommand } from "../../lib/run-npm.js";
+export default class ScaffoldPlugin extends Command {
+    static args = {
+        pkg: Args.string({ description: 'plugin package name', required: true }),
+    };
+    static description = 'Run the legacy NocoBase scaffold plugin (forwards to `npm run scaffold:plugin` in the repo root)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> @nocobase-example/plugin-hello',
+        '<%= config.bin %> <%= command.id %> @nocobase-example/plugin-hello --force-recreate',
+    ];
+    static flags = {
+        'force-recreate': Flags.boolean({ description: 'Force recreate the plugin', char: 'f', required: false }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(ScaffoldPlugin);
+        const npmArgs = ['pm', 'create', args.pkg];
+        if (flags['force-recreate']) {
+            npmArgs.push('--force-recreate');
+        }
+        try {
+            await runNocoBaseCommand(npmArgs, process.cwd(), { env: { LOGGER_SILENT: 'true' } });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.error(message);
+        }
+    }
+}

package/dist/commands/self-update.js

@@ -0,0 +1,46 @@
+/**
+ * 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 { spawn } from 'node:child_process';
+function runNpmInstallGlobal(args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn('npm', ['install', '-g', ...args], {
+            stdio: 'inherit',
+            shell: true,
+            env: process.env,
+        });
+        child.once('error', reject);
+        child.once('close', (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject(new Error(`npm exited with code ${code}`));
+        });
+    });
+}
+export default class SelfUpdate extends Command {
+    static description = 'Update the NocoBase CLI to the latest version';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    async run() {
+        this.log('Updating NocoBase CLI to the latest version...');
+        try {
+            await runNpmInstallGlobal(['@nocobase/cli']);
+            this.log('Update finished.');
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.error([
+                'Failed to update the CLI.',
+                'Try running manually: npm install -g @nocobase/cli',
+                message,
+            ].join('\n'), { exit: 1 });
+        }
+    }
+}

package/dist/commands/start.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 { Command, Flags } from '@oclif/core';
+import { runNocoBaseCommand } from "../lib/run-npm.js";
+export default class Start extends Command {
+    static description = 'Run the legacy NocoBase start (forwards to `npm run start` in the repo root)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --quickstart',
+        '<%= config.bin %> <%= command.id %> --port 12000',
+        '<%= config.bin %> <%= command.id %> --daemon',
+        '<%= config.bin %> <%= command.id %> --instances 2',
+        '<%= config.bin %> <%= command.id %> --launch-mode pm2',
+    ];
+    static flags = {
+        env: Flags.string({ description: 'Environment', char: 'e', required: false }),
+        quickstart: Flags.boolean({ description: 'Quickstart the application', required: false }),
+        port: Flags.string({ description: 'Port', char: 'p', required: false }),
+        daemon: Flags.boolean({ description: 'Run the application as a daemon', char: 'd', required: false }),
+        instances: Flags.integer({ description: 'Number of instances to run', char: 'i', required: false }),
+        'launch-mode': Flags.string({ description: 'Launch Mode', required: false, options: ['pm2', 'node'] }),
+    };
+    async run() {
+        const { flags } = await this.parse(Start);
+        const npmArgs = ['start'];
+        if (flags.quickstart) {
+            npmArgs.push('--quickstart');
+        }
+        if (flags.port) {
+            npmArgs.push('--port', flags.port);
+        }
+        if (flags.daemon) {
+            npmArgs.push('--daemon');
+        }
+        if (flags.instances) {
+            npmArgs.push('--instances', flags.instances.toString());
+        }
+        if (flags['launch-mode']) {
+            npmArgs.push('--launch-mode', flags['launch-mode']);
+        }
+        try {
+            await runNocoBaseCommand(npmArgs, process.cwd());
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.error(message);
+        }
+    }
+}

package/dist/commands/upgrade.js

@@ -0,0 +1,35 @@
+/**
+ * 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, Flags } from '@oclif/core';
+import { runNocoBaseCommand } from "../lib/run-npm.js";
+export default class Upgrade extends Command {
+    static description = 'Run the legacy NocoBase upgrade (forwards to `npm run upgrade` in the repo root)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --skip-code-update',
+    ];
+    static flags = {
+        env: Flags.string({ description: 'Environment', char: 'e', required: false }),
+        'skip-code-update': Flags.boolean({ description: 'Skip code update', char: 'S', required: false }),
+    };
+    async run() {
+        const { flags } = await this.parse(Upgrade);
+        const npmArgs = ['upgrade'];
+        if (flags['skip-code-update']) {
+            npmArgs.push('--skip-code-update');
+        }
+        try {
+            await runNocoBaseCommand(npmArgs, process.cwd());
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.error(message);
+        }
+    }
+}

package/dist/generated/command-registry.js

@@ -6,22 +6,34 @@
  * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
 import { Command } from '@oclif/core';
-import EnvAdd from "../commands/env/add.js";
-import EnvAuth from "../commands/env/auth.js";
-import EnvList from "../commands/env/list.js";
-import EnvRemove from "../commands/env/remove.js";
-import EnvUpdate from "../commands/env/update.js";
-import EnvUse from "../commands/env/use.js";
-import ResourceCreate from "../commands/resource/create.js";
-import ResourceDestroy from "../commands/resource/destroy.js";
-import ResourceGet from "../commands/resource/get.js";
-import ResourceList from "../commands/resource/list.js";
-import ResourceQuery from "../commands/resource/query.js";
-import ResourceUpdate from "../commands/resource/update.js";
+import { dirname, join, relative } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { collectCommandModulePaths, commandRelativePathToRegistryKey, } from "../lib/command-discovery.js";
 import { getCurrentEnvName, getEnv } from "../lib/auth-store.js";
 import { createGeneratedFlags, GeneratedApiCommand } from "../lib/generated-command.js";
 import { loadRuntimeSync } from "../lib/runtime-store.js";
+const registryFilePath = fileURLToPath(import.meta.url);
+const commandsRoot = join(dirname(registryFilePath), '../commands');
+const commandModuleExtension = registryFilePath.endsWith('.ts') ? '.ts' : '.js';
+async function loadCommandsFromDirectory() {
+    const absolutePaths = await collectCommandModulePaths(commandsRoot, commandModuleExtension);
+    const entries = await Promise.all(absolutePaths.map(async (absolutePath) => {
+        const rel = relative(commandsRoot, absolutePath).replace(/\\/g, '/');
+        const key = commandRelativePathToRegistryKey(rel);
+        const mod = await import(__rewriteRelativeImportExtension(pathToFileURL(absolutePath).href));
+        return [key, mod.default];
+    }));
+    return Object.fromEntries(entries);
+}
 function readEnvName(argv) {
     for (let index = 0; index < argv.length; index += 1) {
         const token = argv[index];
@@ -56,20 +68,7 @@ function createRuntimeIndexCommand(commandId, operation) {
     };
 }
 const registry = {
-    // env: Env,
-    'env:add': EnvAdd,
-    'env:auth': EnvAuth,
-    'env:list': EnvList,
-    'env:remove': EnvRemove,
-    'env:update': EnvUpdate,
-    'env:use': EnvUse,
-    // 'api:resource': Resource,
-    'api:resource:create': ResourceCreate,
-    'api:resource:destroy': ResourceDestroy,
-    'api:resource:get': ResourceGet,
-    'api:resource:list': ResourceList,
-    'api:resource:query': ResourceQuery,
-    'api:resource:update': ResourceUpdate,
+    ...(await loadCommandsFromDirectory()),
 };
 const envName = readEnvName(process.argv.slice(2)) ?? (await getCurrentEnvName());
 const env = await getEnv(envName);

package/dist/lib/bootstrap.js

@@ -1,8 +1,16 @@
+/**
+ * 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 { getCurrentEnvName, getEnv, setEnvRuntime, updateEnvConnection } from './auth-store.js';
 import { resolveAccessToken } from './env-auth.js';
 import { generateRuntime } from './runtime-generator.js';
 import { hasRuntimeSync, saveRuntime } from './runtime-store.js';
-import { confirmAction, printInfo, printVerbose, printWarning, setVerboseMode, stopTask, updateTask } from './ui.js';
+import { confirmAction, printInfo, printVerbose, printWarningBlock, setVerboseMode, stopTask, updateTask } from './ui.js';
 const APP_RETRY_INTERVAL = 2000;
 const APP_RETRY_TIMEOUT = 120000;
 function readFlag(argv, name) {
@@ -66,6 +74,9 @@ function isBuiltinCommand(argv) {
 export function shouldSkipRuntimeBootstrap(argv) {
     return hasVersionFlag(argv) || isBuiltinCommand(argv);
 }
+function shouldIgnoreBootstrapFailure(argv, commandToken) {
+    return !commandToken || hasHelpFlag(argv) || (commandToken === 'api' && argv.length === 1);
+}
 async function requestJson(url, options) {
     const headers = new Headers();
     if (options.token) {
@@ -215,6 +226,9 @@ function collectErrorEntries(data) {
 function hasInvalidTokenError(data) {
     return collectErrorEntries(data).some((entry) => entry?.code === 'INVALID_TOKEN');
 }
+function isNetworkFetchFailure(response) {
+    return response.status === 0;
+}
 export function formatSwaggerSchemaError(response, context) {
     if (hasInvalidTokenError(response.data)) {
         const entries = collectErrorEntries(response.data);
@@ -236,6 +250,17 @@ export function formatSwaggerSchemaError(response, context) {
             commandHint,
         ].join('\n');
     }
+    if (isNetworkFetchFailure(response)) {
+        const rawMessage = response.data?.error?.message || 'fetch failed';
+        return [
+            'Failed to reach the NocoBase server while loading the command runtime from `swagger:get`.',
+            `Base URL: ${context.baseUrl}`,
+            `Network error: ${rawMessage}`,
+            'Check that the NocoBase app is running, the base URL is correct, and the server is reachable from this machine.',
+            'If you recently changed the server address, update it with `nb env add --name <name> --base-url <url>` and retry `nb env update`.',
+            'Use `nb env list` to inspect the current env configuration.',
+        ].join('\n');
+    }
     return `Failed to load swagger schema from \`swagger:get\`.\n${JSON.stringify(response.data, null, 2)}`;
 }
 export function formatMissingRuntimeEnvError(commandToken) {
@@ -256,55 +281,59 @@ export function formatMissingRuntimeEnvError(commandToken) {
 export async function ensureRuntimeFromArgv(argv, options) {
     const commandToken = getCommandToken(argv);
     const isRootInvocation = !commandToken;
+    const canContinueWithoutRuntime = shouldIgnoreBootstrapFailure(argv, commandToken);
     setVerboseMode(hasBooleanFlag(argv, 'verbose'));
     if (shouldSkipRuntimeBootstrap(argv)) {
         return;
     }
-    const envName = readFlag(argv, 'env') ?? (await getCurrentEnvName());
-    const env = await getEnv(envName);
-    const baseUrl = readFlag(argv, 'base-url') ?? env?.baseUrl;
-    const role = readFlag(argv, 'role');
-    const token = await resolveAccessToken({
-        envName,
-        baseUrl,
-        token: readFlag(argv, 'token'),
-    });
-    const runtimeVersion = env?.runtime?.version;
-    if (runtimeVersion && hasRuntimeSync(runtimeVersion)) {
-        return;
-    }
-    if (!baseUrl) {
-        if (isRootInvocation) {
+    try {
+        const envName = readFlag(argv, 'env') ?? (await getCurrentEnvName());
+        const env = await getEnv(envName);
+        const baseUrl = readFlag(argv, 'base-url') ?? env?.baseUrl;
+        const role = readFlag(argv, 'role');
+        const token = await resolveAccessToken({
+            envName,
+            baseUrl,
+            token: readFlag(argv, 'token'),
+        });
+        const runtimeVersion = env?.runtime?.version;
+        if (runtimeVersion && hasRuntimeSync(runtimeVersion)) {
             return;
         }
-        throw new Error(formatMissingRuntimeEnvError(commandToken));
-    }
-    updateTask('Loading command runtime...');
-    try {
-        printVerbose(`Runtime source: ${baseUrl}`);
-        const document = await fetchSwaggerSchema(baseUrl, token, role, { envName, commandToken }, isRootInvocation
-            ? {
-                allowEnableApiDoc: false,
-                retryAppAvailability: false,
+        if (!baseUrl) {
+            if (isRootInvocation) {
+                return;
             }
-            : undefined);
-        const runtime = await generateRuntime(document, options.configFile, baseUrl);
-        await saveRuntime(runtime);
-        await setEnvRuntime(envName, {
-            version: runtime.version,
-            schemaHash: runtime.schemaHash,
-            generatedAt: runtime.generatedAt,
-        });
+            throw new Error(formatMissingRuntimeEnvError(commandToken));
+        }
+        updateTask('Loading command runtime...');
+        try {
+            printVerbose(`Runtime source: ${baseUrl}`);
+            const document = await fetchSwaggerSchema(baseUrl, token, role, { envName, commandToken }, isRootInvocation
+                ? {
+                    allowEnableApiDoc: false,
+                    retryAppAvailability: false,
+                }
+                : undefined);
+            const runtime = await generateRuntime(document, options.configFile, baseUrl);
+            await saveRuntime(runtime);
+            await setEnvRuntime(envName, {
+                version: runtime.version,
+                schemaHash: runtime.schemaHash,
+                generatedAt: runtime.generatedAt,
+            });
+        }
+        finally {
+            stopTask();
+        }
     }
     catch (error) {
-        if (!isRootInvocation) {
+        if (!canContinueWithoutRuntime) {
             throw error;
         }
-        const message = error instanceof Error ? error.message : String(error);
-        printWarning(`${message}\nContinuing with built-in help because runtime commands could not be loaded.`);
-    }
-    finally {
         stopTask();
+        const message = error instanceof Error ? error.message : String(error);
+        printWarningBlock(`Unable to load runtime commands. Showing built-in help instead.\n\n${message}`);
     }
 }
 export async function updateEnvRuntime(options) {

package/dist/lib/command-discovery.js

@@ -0,0 +1,39 @@
+/**
+ * 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 { readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+/**
+ * Recursively collect command module paths under `commandsRoot` (e.g. `dist/commands` → `.js`, `src/commands` → `.ts`).
+ */
+export async function collectCommandModulePaths(commandsRoot, extension) {
+    const entries = await readdir(commandsRoot, { withFileTypes: true });
+    const files = [];
+    for (const ent of entries) {
+        const full = join(commandsRoot, ent.name);
+        if (ent.isDirectory()) {
+            files.push(...(await collectCommandModulePaths(full, extension)));
+        }
+        else if (ent.isFile() && ent.name.endsWith(extension)) {
+            files.push(full);
+        }
+    }
+    return files.sort();
+}
+/**
+ * Map a path relative to `commands/` with `.js` / `.ts` to an oclif explicit-registry key.
+ * `resource/foo.js` → `api:resource:foo` (topic `api resource …`); other paths use `:` between segments.
+ */
+export function commandRelativePathToRegistryKey(relativePath) {
+    const normalized = relativePath.replace(/\\/g, '/').replace(/\.(js|ts)$/i, '');
+    const segments = normalized.split('/').filter(Boolean);
+    // if (segments[0] === 'resource' && segments.length >= 2) {
+    //   return ['api', 'resource', ...segments.slice(1)].join(':');
+    // }
+    return segments.join(':');
+}

package/dist/lib/env-auth.js

@@ -1,9 +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.
+ */
 import crypto from 'node:crypto';
 import { createServer } from 'node:http';
 import { spawn } from 'node:child_process';
 import { URL } from 'node:url';
 import { getCurrentEnvName, getEnv, setEnvOauthSession, } from './auth-store.js';
-import { printInfo, printVerbose, printWarning, updateTask } from './ui.js';
+import { printInfo, printVerbose, printWarning, printWarningBlock, updateTask } from './ui.js';
 const ACCESS_TOKEN_REFRESH_WINDOW_MS = 60_000;
 const LOOPBACK_HOST = '127.0.0.1';
 const OAUTH_LOGIN_TIMEOUT_MS = 5 * 60 * 1000;
@@ -62,9 +70,36 @@ function formatOauthError(prefix, data, fallbackStatus) {
     }
     return prefix;
 }
-async function fetchOauthServerMetadata(baseUrl) {
+function formatOauthFetchFailure(prefix, options) {
+    return [
+        prefix,
+        options.envName ? `Env: ${options.envName}` : undefined,
+        options.baseUrl ? `Base URL: ${options.baseUrl}` : undefined,
+        `Request URL: ${options.url}`,
+        `Network error: ${options.rawMessage || 'fetch failed'}`,
+        'Check that the NocoBase app is running, the base URL is correct, and the server is reachable from this machine.',
+        options.envName
+            ? `If the saved login is stale, run \`nb env auth -e ${options.envName}\` again after connectivity is restored.`
+            : 'If the saved login is stale, run `nb env auth -e <name>` again after connectivity is restored.',
+        'Use `nb env list` to inspect the current env configuration.',
+    ]
+        .filter(Boolean)
+        .join('\n');
+}
+async function fetchOauthServerMetadata(baseUrl, options = {}) {
     const metadataUrl = getOauthMetadataUrl(baseUrl);
-    const response = await fetch(metadataUrl);
+    let response;
+    try {
+        response = await fetch(metadataUrl);
+    }
+    catch (error) {
+        throw new Error(formatOauthFetchFailure('Failed to load OAuth metadata.', {
+            envName: options.envName,
+            baseUrl,
+            url: metadataUrl,
+            rawMessage: error?.message,
+        }));
+    }
     const data = await parseJsonResponse(response);
     if (!response.ok) {
         throw new Error(formatOauthError(`Failed to load OAuth metadata from ${metadataUrl}`, data, response.status));
@@ -246,7 +281,7 @@ async function refreshOauthAccessToken(options) {
     if (!options.auth.refreshToken || !options.auth.clientId) {
         throw new Error(`OAuth session for env "${options.envName}" cannot be refreshed. Run \`nb env auth -e ${options.envName}\`.`);
     }
-    const metadata = await fetchOauthServerMetadata(options.baseUrl);
+    const metadata = await fetchOauthServerMetadata(options.baseUrl, { envName: options.envName });
     const resource = options.auth.resource || getOauthResource(metadata.issuer);
     const body = new URLSearchParams({
         grant_type: 'refresh_token',
@@ -261,6 +296,13 @@ async function refreshOauthAccessToken(options) {
             'content-type': 'application/x-www-form-urlencoded',
         },
         body,
+    }).catch((error) => {
+        throw new Error(formatOauthFetchFailure(`Failed to refresh OAuth session for env "${options.envName}".`, {
+            envName: options.envName,
+            baseUrl: options.baseUrl,
+            url: metadata.token_endpoint,
+            rawMessage: error?.message,
+        }));
     });
     const data = await parseJsonResponse(response);
     if (!response.ok) {
@@ -338,7 +380,7 @@ export async function authenticateEnvWithOauth(options) {
         ].join('\n'));
     }
     updateTask(`Loading OAuth metadata for env "${envName}"...`);
-    const metadata = await fetchOauthServerMetadata(baseUrl);
+    const metadata = await fetchOauthServerMetadata(baseUrl, { envName });
     const state = encodeBase64Url(crypto.randomBytes(16));
     const { codeVerifier, codeChallenge } = buildPkcePair();
     const callback = await createLoopbackServer(state);
@@ -359,7 +401,7 @@ export async function authenticateEnvWithOauth(options) {
         updateTask(`Waiting for OAuth login for env "${envName}"...`);
         const opened = maybeOpenBrowser(authorizationUrl.toString());
         if (!opened) {
-            printWarning('Unable to open the browser automatically. Open this URL manually:');
+            printWarningBlock('Unable to open the browser automatically. Open this URL manually:');
         }
         else {
             printInfo('Complete the OAuth login in your browser.');

package/dist/lib/run-npm.js

@@ -0,0 +1,74 @@
+/**
+ * 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 { spawn } from 'node:child_process';
+export function run(name, args, cwd, options) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(name, [...args], {
+            stdio: 'inherit',
+            shell: true,
+            cwd,
+            env: {
+                ...options?.env,
+                ...process.env,
+            },
+        });
+        child.once('error', reject);
+        child.once('close', (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject(new Error(`${name} exited with code ${code}`));
+        });
+    });
+}
+/** Run `npm` with the given argument list in `cwd`, inheriting stdio. */
+export function runNpm(args, cwd) {
+    return new Promise((resolve, reject) => {
+        const child = spawn('yarn', [...args], {
+            stdio: 'inherit',
+            shell: true,
+            cwd,
+            env: process.env,
+        });
+        child.once('error', reject);
+        child.once('close', (code, signal) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            if (signal) {
+                reject(new Error(`npm exited due to signal ${signal}`));
+                return;
+            }
+            reject(new Error(`npm exited with code ${code}`));
+        });
+    });
+}
+export async function runNocoBaseCommand(args, cwd, options) {
+    return new Promise((resolve, reject) => {
+        const child = spawn('node', ['./node_modules/.bin/nocobase-v1', ...args], {
+            stdio: 'inherit',
+            shell: true,
+            cwd,
+            env: {
+                ...options?.env,
+                ...process.env,
+            },
+        });
+        child.once('error', reject);
+        child.once('close', (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject(new Error(`nocobase command exited with code ${code}`));
+        });
+    });
+}

package/dist/lib/ui.js

@@ -1,3 +1,11 @@
+/**
+ * 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 readline from 'node:readline/promises';
 import { stdin as input, stdout as output } from 'node:process';
 import ora from 'ora';
@@ -99,18 +107,19 @@ export function printSuccess(message) {
     }
     console.log(pc.green(message));
 }
-export function printWarning(message) {
+function clearActiveSpinner() {
     if (activeSpinner) {
-        if (!isInteractiveTerminal()) {
-            activeSpinner = undefined;
-            console.log(pc.yellow(message));
-            return;
-        }
-        activeSpinner.warn(pc.yellow(message));
+        activeSpinner.stop();
         activeSpinner = undefined;
-        return;
     }
-    console.log(pc.yellow(message));
+}
+export function printWarning(message) {
+    clearActiveSpinner();
+    console.log(pc.yellow(`⚠ Warning: ${message}`));
+}
+export function printWarningBlock(message) {
+    clearActiveSpinner();
+    console.log(pc.yellow(`⚠ Warning\n${message}\n`));
 }
 export function printVerboseWarning(message) {
     if (!verboseMode) {
@@ -154,10 +163,7 @@ export function failTask(message) {
     console.error(pc.red(message));
 }
 export function stopTask() {
-    if (activeSpinner) {
-        activeSpinner.stop();
-        activeSpinner = undefined;
-    }
+    clearActiveSpinner();
 }
 export function renderTable(headers, rows) {
     const widths = headers.map((header, index) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/cli",
-  "version": "2.1.0-alpha.18",
+  "version": "2.1.0-alpha.19",
   "description": "NocoBase Command Line Tool",
   "type": "module",
   "main": "dist/generated/command-registry.js",
@@ -59,5 +59,5 @@
     "type": "git",
     "url": "git+https://github.com/nocobase/nocobase.git"
   },
-  "gitHead": "e75843d4c557117bbcced047b88ed11d601ff86d"
+  "gitHead": "3d13700360eac1c0f9dbf6a5f167ed396a294a3c"
 }

package/dist/commands/api/index.js

@@ -1,8 +0,0 @@
-import { Command } from '@oclif/core';
-export default class Api extends Command {
-    static summary = 'Work with NocoBase APIs, environments, resources, and runtime commands';
-    static id = 'api';
-    async run() {
-        this.log('Use `nb api --help` to view available subcommands.');
-    }
-}

package/dist/commands/env/index.js

@@ -1,27 +0,0 @@
-import { Command, Flags } from '@oclif/core';
-import { getCurrentEnvName, getEnv } from '../../lib/auth-store.js';
-import { formatCliHomeScope } from '../../lib/cli-home.js';
-import { renderTable } from '../../lib/ui.js';
-export default class Env extends Command {
-    static summary = 'Show the current environment';
-    static id = 'env';
-    static flags = {
-        scope: Flags.string({
-            char: 's',
-            description: 'Config scope',
-            options: ['project', 'global'],
-        }),
-    };
-    async run() {
-        const { flags } = await this.parse(Env);
-        const scope = flags.scope;
-        const envName = await getCurrentEnvName({ scope });
-        const env = await getEnv(envName, { scope });
-        if (!env?.baseUrl) {
-            this.log(`No current env is configured${scope ? ` in ${formatCliHomeScope(scope)} scope` : ''}.`);
-            this.log('Run `nb env add --name <name> --base-url <url>` to add one.');
-            return;
-        }
-        this.log(renderTable(['Name', 'Base URL', 'Auth', 'Runtime'], [[envName, env?.baseUrl ?? '', env?.auth?.type ?? '', env?.runtime?.version ?? '']]));
-    }
-}

package/dist/commands/resource/index.js

@@ -1,7 +0,0 @@
-import { Command } from '@oclif/core';
-export default class Resource extends Command {
-    static summary = 'Work with generic collection resources';
-    async run() {
-        this.log('Use `nb api resource --help` to view available subcommands.');
-    }
-}