@nocobase/cli 2.1.0-alpha.24 → 2.1.0-alpha.26

package/dist/commands/source/test.js

@@ -0,0 +1,467 @@
+/**
+ * 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 { spawn } from 'node:child_process';
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import Install from '../install.js';
+import { defaultWorkspaceName } from '../../lib/app-runtime.js';
+import { findAvailableTcpPort, validateAvailableTcpPort } from '../../lib/prompt-validators.js';
+import { commandSucceeds, resolveProjectCwd, run, runNocoBaseCommand } from '../../lib/run-npm.js';
+import { failTask, printInfo, setVerboseMode, startTask, succeedTask } from '../../lib/ui.js';
+const DEFAULT_DB_HOST = '127.0.0.1';
+const DEFAULT_DB_DATABASE = 'nocobase-test';
+const DEFAULT_DB_USER = 'nocobase';
+const DEFAULT_DB_PASSWORD = 'nocobase';
+const DEFAULT_DB_DIALECT = 'postgres';
+const DEFAULT_TEST_TIMEZONE = 'UTC';
+const DEFAULT_TEST_DB_IMAGES = {
+    postgres: 'postgres:16',
+    mysql: 'mysql:8',
+    mariadb: 'mariadb:11',
+    kingbase: 'registry.cn-shanghai.aliyuncs.com/nocobase/kingbase:v009r001c001b0030_single_x86',
+};
+const DEFAULT_TEST_DB_DISTRIBUTOR_PORT = '23450';
+const DEFAULT_TEST_DB_DISTRIBUTOR_PREFIX = {
+    postgres: 'test',
+    mysql: 'test_',
+    mariadb: 'test_',
+};
+const DEFAULT_DB_PORTS = {
+    postgres: 5433,
+    mysql: 3307,
+    mariadb: 3307,
+    kingbase: 54322,
+};
+const TCP_PORT_READY_SCRIPT = [
+    "const net = require('node:net');",
+    "const port = Number(process.argv.at(-1));",
+    "const socket = net.createConnection({ host: '127.0.0.1', port });",
+    "socket.once('connect', () => { socket.end(); process.exit(0); });",
+    "socket.once('error', () => process.exit(1));",
+    "setTimeout(() => { socket.destroy(); process.exit(1); }, 200).unref();",
+].join('\n');
+function inferTestEnv(paths) {
+    const first = String(paths[0] ?? '').trim();
+    if (!first) {
+        return undefined;
+    }
+    const normalized = first.split('\\').join('/');
+    if (normalized.includes('/client/')
+        || normalized.includes('/client-v2/')
+        || normalized.includes('/flow-engine/')) {
+        return 'client-side';
+    }
+    return 'server-side';
+}
+function trimValue(value) {
+    return String(value ?? '').trim();
+}
+function resolveWorkspaceName(cwd) {
+    return defaultWorkspaceName(cwd);
+}
+function defaultTestDbPort(dbDialect) {
+    return String(DEFAULT_DB_PORTS[dbDialect] ?? DEFAULT_DB_PORTS.postgres);
+}
+function defaultTestDbImage(dbDialect) {
+    return DEFAULT_TEST_DB_IMAGES[dbDialect] ?? DEFAULT_TEST_DB_IMAGES.postgres;
+}
+function delay(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+function shouldRunServerTests(params) {
+    if (params.server) {
+        return true;
+    }
+    if (params.client) {
+        return false;
+    }
+    return inferTestEnv(params.paths) !== 'client-side';
+}
+function defaultTestDbDistributorPrefix(dbDialect) {
+    return DEFAULT_TEST_DB_DISTRIBUTOR_PREFIX[dbDialect];
+}
+function supportsTestDbDistributor(dbDialect) {
+    return Boolean(defaultTestDbDistributorPrefix(dbDialect));
+}
+function buildTestDbDistributorEnv(env) {
+    if (env.DB_DIALECT === 'mysql' || env.DB_DIALECT === 'mariadb') {
+        return {
+            ...env,
+            DB_APP_USER: env.DB_USER,
+            DB_USER: 'root',
+        };
+    }
+    return env;
+}
+async function waitForTcpPortReady(port, timeoutMs = 5000) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (await commandSucceeds(process.execPath, ['-e', TCP_PORT_READY_SCRIPT, port])) {
+            return;
+        }
+        await delay(100);
+    }
+    throw new Error(`Timed out while waiting for the test DB distributor on 127.0.0.1:${port}.`);
+}
+async function stopBackgroundProcess(child) {
+    if (child.exitCode !== null || child.killed) {
+        return;
+    }
+    await new Promise((resolve) => {
+        const finish = () => {
+            clearTimeout(timeout);
+            resolve();
+        };
+        const timeout = setTimeout(finish, 1000);
+        child.once('close', finish);
+        try {
+            child.kill();
+        }
+        catch {
+            finish();
+        }
+    });
+}
+async function startTestDbDistributor(params) {
+    const port = DEFAULT_TEST_DB_DISTRIBUTOR_PORT;
+    const prefix = defaultTestDbDistributorPrefix(params.env.DB_DIALECT);
+    if (!prefix) {
+        throw new Error(`The ${params.env.DB_DIALECT} test DB distributor is not supported.`);
+    }
+    const portError = await validateAvailableTcpPort(port);
+    if (portError) {
+        throw new Error(`Host port ${port} is unavailable for the test DB distributor. ${portError}`);
+    }
+    const distributorEnv = buildTestDbDistributorEnv(params.env);
+    const child = spawn(process.execPath, [
+        path.resolve(params.cwd, 'node_modules', 'tsx', 'dist', 'cli.mjs'),
+        path.resolve(params.cwd, 'packages', 'core', 'test', 'src', 'scripts', 'test-db-creator.ts'),
+    ], {
+        cwd: params.cwd,
+        env: {
+            ...process.env,
+            ...distributorEnv,
+            DB_TEST_DISTRIBUTOR_PORT: port,
+            DB_TEST_PREFIX: prefix,
+        },
+        stdio: params.stdio,
+        windowsHide: process.platform === 'win32',
+    });
+    let childError;
+    child.once('error', (error) => {
+        childError = error;
+    });
+    child.once('close', (code, signal) => {
+        if (code === 0) {
+            return;
+        }
+        childError = childError ?? new Error(signal
+            ? `test DB distributor exited due to signal ${signal}`
+            : `test DB distributor exited with code ${code ?? 'unknown'}`);
+    });
+    try {
+        await waitForTcpPortReady(port);
+    }
+    catch (error) {
+        await stopBackgroundProcess(child);
+        throw childError ?? error;
+    }
+    return {
+        port,
+        prefix,
+        stop: async () => {
+            await stopBackgroundProcess(child);
+        },
+    };
+}
+async function ensureDockerNetwork(networkName, options) {
+    if (await commandSucceeds('docker', ['network', 'inspect', networkName])) {
+        return;
+    }
+    await run('docker', ['network', 'create', networkName], {
+        errorName: 'docker network create',
+        stdio: options?.stdio ?? 'ignore',
+    });
+}
+async function removeDockerContainerIfExists(containerName, options) {
+    if (!(await commandSucceeds('docker', ['container', 'inspect', containerName]))) {
+        return 'missing';
+    }
+    await run('docker', ['rm', '-f', containerName], {
+        errorName: 'docker rm',
+        stdio: options?.stdio ?? 'ignore',
+    });
+    return 'removed';
+}
+function formatDbBootstrapFailure(message) {
+    return [
+        'Could not prepare the built-in test database.',
+        'The CLI was not able to recreate a clean Docker database for this test run.',
+        'Check Docker status, the selected port, and local storage permissions, then try again.',
+        `Details: ${message}`,
+    ].join('\n');
+}
+function buildTestDbConfig(params) {
+    const dbDialect = trimValue(params.dbDialect) || DEFAULT_DB_DIALECT;
+    const workspaceName = resolveWorkspaceName(params.cwd);
+    const storagePath = path.join(params.cwd, 'storage', 'test');
+    const plan = Install.buildBuiltinDbPlan({
+        envName: 'test',
+        workspaceName,
+        storagePath,
+        source: 'test',
+        dbDialect,
+        dbHost: DEFAULT_DB_HOST,
+        dbPort: trimValue(params.dbPort) || defaultTestDbPort(dbDialect),
+        dbDatabase: trimValue(params.dbDatabase) || DEFAULT_DB_DATABASE,
+        dbUser: trimValue(params.dbUser) || DEFAULT_DB_USER,
+        dbPassword: trimValue(params.dbPassword) || DEFAULT_DB_PASSWORD,
+        builtinDbImage: trimValue(params.builtinDbImage) || defaultTestDbImage(dbDialect),
+    });
+    return {
+        storagePath,
+        containerName: plan.containerName,
+        networkName: plan.networkName,
+        dataDir: plan.dataDir,
+        args: plan.args,
+        env: {
+            APP_ENV_PATH: '.env',
+            STORAGE_PATH: storagePath,
+            TZ: DEFAULT_TEST_TIMEZONE,
+            DB_DIALECT: plan.dbDialect,
+            DB_HOST: plan.dbHost,
+            DB_PORT: plan.dbPort,
+            DB_DATABASE: plan.dbDatabase,
+            DB_USER: plan.dbUser,
+            DB_PASSWORD: plan.dbPassword,
+        },
+    };
+}
+async function prepareTestDatabase(config, options) {
+    let nextConfig = config;
+    await ensureDockerNetwork(nextConfig.networkName, {
+        stdio: options?.stdio,
+    });
+    await removeDockerContainerIfExists(nextConfig.containerName, {
+        stdio: options?.stdio,
+    });
+    await fsp.rm(nextConfig.storagePath, { recursive: true, force: true });
+    const portError = await validateAvailableTcpPort(nextConfig.env.DB_PORT);
+    if (portError) {
+        if (options?.dbPortExplicit) {
+            throw new Error(`Host port ${nextConfig.env.DB_PORT} is unavailable. ${portError}`);
+        }
+        const fallbackPort = await findAvailableTcpPort();
+        printInfo(`Host port ${nextConfig.env.DB_PORT} is unavailable for the test database, so the CLI will use ${fallbackPort} instead.`);
+        nextConfig = buildTestDbConfig({
+            cwd: path.dirname(path.dirname(nextConfig.storagePath)),
+            dbDialect: nextConfig.env.DB_DIALECT,
+            dbPort: fallbackPort,
+            dbDatabase: nextConfig.env.DB_DATABASE,
+            dbUser: nextConfig.env.DB_USER,
+            dbPassword: nextConfig.env.DB_PASSWORD,
+            builtinDbImage: undefined,
+        });
+    }
+    await fsp.mkdir(nextConfig.dataDir, { recursive: true });
+    await run('docker', nextConfig.args, {
+        errorName: 'docker run',
+        stdio: options?.stdio ?? 'ignore',
+    });
+    await waitForTcpPortReady(nextConfig.env.DB_PORT, 30_000);
+    return nextConfig;
+}
+export default class SourceTest extends Command {
+    static hidden = false;
+    static args = {
+        paths: Args.string({
+            description: 'test file paths or globs to pass through',
+            multiple: true,
+            required: false,
+        }),
+    };
+    static description = 'Run project tests from the selected app directory. Before running tests, the CLI recreates a built-in Docker test database and injects `DB_*` values internally.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --cwd /path/to/app',
+        '<%= config.bin %> <%= command.id %> packages/core/server/src/__tests__/foo.test.ts',
+        '<%= config.bin %> <%= command.id %> --server --coverage',
+        '<%= config.bin %> <%= command.id %> --db-port 5433',
+    ];
+    static flags = {
+        cwd: Flags.string({
+            char: 'c',
+            description: 'App directory to run tests from. Defaults to the current working directory',
+            required: false,
+        }),
+        watch: Flags.boolean({
+            char: 'w',
+            description: 'Run Vitest in watch mode',
+            default: false,
+        }),
+        run: Flags.boolean({
+            description: 'Run once without watch mode',
+            default: false,
+        }),
+        allowOnly: Flags.boolean({
+            description: 'Allow `.only` tests',
+            default: false,
+        }),
+        bail: Flags.boolean({
+            description: 'Stop after the first failure',
+            default: false,
+        }),
+        coverage: Flags.boolean({
+            description: 'Enable coverage reporting',
+            default: false,
+        }),
+        'single-thread': Flags.string({
+            description: 'Forward single-thread mode to the underlying test runner',
+            required: false,
+        }),
+        server: Flags.boolean({
+            description: 'Force server-side test mode',
+            default: false,
+        }),
+        client: Flags.boolean({
+            description: 'Force client-side test mode',
+            default: false,
+        }),
+        'db-clean': Flags.boolean({
+            char: 'd',
+            description: 'Clean the database before tests when supported by the underlying app command',
+            default: false,
+        }),
+        'db-dialect': Flags.string({
+            description: 'Built-in test database dialect to start',
+            options: ['postgres', 'mysql', 'mariadb', 'kingbase'],
+            required: false,
+        }),
+        'db-image': Flags.string({
+            description: 'Built-in test database Docker image to start',
+            aliases: ['builtin-db-image'],
+            required: false,
+        }),
+        'db-port': Flags.string({
+            description: 'Host TCP port to publish for the built-in test database',
+            required: false,
+        }),
+        'db-database': Flags.string({
+            description: 'Database name to inject for tests',
+            required: false,
+        }),
+        'db-user': Flags.string({
+            description: 'Database user to inject for tests',
+            required: false,
+        }),
+        'db-password': Flags.string({
+            description: 'Database password to inject for tests',
+            required: false,
+        }),
+        verbose: Flags.boolean({
+            description: 'Show raw Docker and test runner output',
+            default: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(SourceTest);
+        setVerboseMode(flags.verbose);
+        if (flags.server && flags.client) {
+            this.error('Cannot use `--server` and `--client` together.');
+        }
+        const cwd = resolveProjectCwd(flags.cwd);
+        const commandArgs = ['test', ...(args.paths ?? [])];
+        if (flags.watch) {
+            commandArgs.push('--watch');
+        }
+        if (flags.run || !flags.watch) {
+            commandArgs.push('--run');
+        }
+        if (flags.allowOnly) {
+            commandArgs.push('--allowOnly');
+        }
+        if (flags.bail) {
+            commandArgs.push('--bail');
+        }
+        if (flags.coverage) {
+            commandArgs.push('--coverage');
+        }
+        if (flags.server) {
+            commandArgs.push('--server');
+        }
+        else if (flags.client) {
+            commandArgs.push('--client');
+        }
+        if (flags['db-clean']) {
+            commandArgs.push('--db-clean');
+        }
+        if (flags['single-thread'] !== undefined) {
+            commandArgs.push(`--single-thread=${flags['single-thread']}`);
+        }
+        else if (!flags.client && !flags.server && inferTestEnv(args.paths ?? []) === 'server-side') {
+            commandArgs.push('--single-thread=true');
+        }
+        startTask('Recreating the built-in test database...');
+        let testDbConfig;
+        let testDbDistributor;
+        try {
+            testDbConfig = await prepareTestDatabase(buildTestDbConfig({
+                cwd,
+                dbDialect: flags['db-dialect'],
+                builtinDbImage: flags['db-image'],
+                dbPort: flags['db-port'],
+                dbDatabase: flags['db-database'],
+                dbUser: flags['db-user'],
+                dbPassword: flags['db-password'],
+            }), {
+                stdio: flags.verbose ? 'inherit' : 'ignore',
+                dbPortExplicit: Boolean(flags['db-port']),
+            });
+            if (shouldRunServerTests({
+                server: flags.server,
+                client: flags.client,
+                paths: args.paths ?? [],
+            })
+                && supportsTestDbDistributor(testDbConfig.env.DB_DIALECT)) {
+                testDbDistributor = await startTestDbDistributor({
+                    cwd,
+                    env: testDbConfig.env,
+                    stdio: flags.verbose ? 'inherit' : 'ignore',
+                });
+                testDbConfig.env.DB_TEST_DISTRIBUTOR_PORT = testDbDistributor.port;
+                testDbConfig.env.DB_TEST_PREFIX = testDbDistributor.prefix;
+            }
+            succeedTask(`The built-in test database is ready at ${testDbConfig.env.DB_HOST}:${testDbConfig.env.DB_PORT}.`);
+            printInfo(`Test DB settings: DB_DIALECT=${testDbConfig.env.DB_DIALECT} DB_HOST=${testDbConfig.env.DB_HOST} DB_PORT=${testDbConfig.env.DB_PORT} DB_DATABASE=${testDbConfig.env.DB_DATABASE} DB_USER=${testDbConfig.env.DB_USER}`);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            failTask('Failed to recreate the built-in test database.');
+            this.error(formatDbBootstrapFailure(message));
+            return;
+        }
+        try {
+            await runNocoBaseCommand(commandArgs, {
+                cwd,
+                stdio: flags.verbose ? 'inherit' : 'ignore',
+                env: testDbConfig.env,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.error(message);
+        }
+        finally {
+            await testDbDistributor?.stop();
+        }
+    }
+}

package/dist/commands/start.js

@@ -6,206 +6,7 @@
  * 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 { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime, runLocalNocoBaseCommand, startDockerContainer, } from '../lib/app-runtime.js';
-import { failTask, printInfo, startTask, succeedTask } from '../lib/ui.js';
-function argvHasToken(argv, tokens) {
-    return tokens.some((token) => argv.includes(token));
-}
-function formatDockerStartFailure(envName, message) {
-    if (/does not exist/i.test(message)) {
-        return [
-            `Can't start NocoBase for "${envName}" yet.`,
-            'The saved Docker app for this env could not be found on this machine.',
-            `Try reinstalling the env, or check whether the container was removed outside the CLI.`,
-            `Details: ${message}`,
-        ].join('\n');
-    }
-    return [
-        `Couldn't start NocoBase for "${envName}".`,
-        'Check that the Docker runtime for this env is still available, then try again.',
-        `Details: ${message}`,
-    ].join('\n');
-}
-function formatLocalStartFailure(envName, options) {
-    const sourceLabel = options?.source === 'git'
-        ? 'the local Git checkout'
-        : options?.source === 'npm'
-            ? 'the local npm app'
-            : 'the local app';
-    const portHint = options?.port ? ` Expected app port: ${options.port}.` : '';
-    return [
-        `Couldn't start NocoBase for "${envName}".`,
-        `The CLI was not able to start ${sourceLabel} successfully.`,
-        `Check that the app dependencies, database connection, and local env settings are ready, then try again.${portHint}`,
-    ].join('\n');
-}
-function formatAppUrl(port) {
-    const value = String(port ?? '').trim();
-    if (!value) {
-        return undefined;
-    }
-    return `http://127.0.0.1:${value}`;
-}
-async function isAppAlreadyRunning(appUrl) {
-    if (!appUrl) {
-        return false;
-    }
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 1500);
-    try {
-        const response = await fetch(`${appUrl}/api/__health_check`, {
-            signal: controller.signal,
-        });
-        const text = await response.text();
-        return response.ok && text.trim().toLowerCase() === 'ok';
-    }
-    catch (_error) {
-        return false;
-    }
-    finally {
-        clearTimeout(timeout);
-    }
-}
-export default class Start extends Command {
-    static description = 'Start NocoBase for the selected env. Local npm/git installs run the app command, and Docker installs start the saved app container.';
-    static examples = [
-        '<%= config.bin %> <%= command.id %>',
-        '<%= config.bin %> <%= command.id %> --env local',
-        '<%= config.bin %> <%= command.id %> --env local --quickstart',
-        '<%= config.bin %> <%= command.id %> --env local --port 12000',
-        '<%= config.bin %> <%= command.id %> --env local --daemon',
-        '<%= config.bin %> <%= command.id %> --env local --no-daemon',
-        '<%= config.bin %> <%= command.id %> --env local --instances 2',
-        '<%= config.bin %> <%= command.id %> --env local --launch-mode pm2',
-        '<%= config.bin %> <%= command.id %> --env local --verbose',
-        '<%= config.bin %> <%= command.id %> --env local-docker',
-    ];
-    static flags = {
-        env: Flags.string({
-            char: 'e',
-            description: 'CLI env name to start. Defaults to the current env when omitted',
-        }),
-        quickstart: Flags.boolean({ description: 'Quickstart the application', required: false }),
-        port: Flags.string({ description: 'Port (overrides appPort from env config when set)', char: 'p', required: false }),
-        daemon: Flags.boolean({
-            description: 'Run the application as a daemon (default: true; use --no-daemon to stay in the foreground)',
-            char: 'd',
-            required: false,
-            default: true,
-            allowNo: true,
-        }),
-        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'] }),
-        verbose: Flags.boolean({
-            description: 'Show raw startup output from the underlying local or Docker command',
-            default: false,
-        }),
-    };
-    async run() {
-        const { flags } = await this.parse(Start);
-        const requestedEnv = flags.env?.trim() || undefined;
-        const daemonFlagWasProvided = argvHasToken(this.argv, ['--daemon', '--no-daemon']);
-        const runtime = await resolveManagedAppRuntime(requestedEnv);
-        const commandStdio = flags.verbose ? 'inherit' : 'ignore';
-        if (!runtime) {
-            this.error(formatMissingManagedAppEnvMessage(requestedEnv));
-        }
-        if (runtime.kind === 'remote') {
-            this.error([
-                `Can't start "${runtime.envName}" from this machine.`,
-                'This env only has an API connection, so there is no saved local app or Docker runtime to launch here.',
-                'Connect it to a local checkout or reinstall it with npm, git, or Docker if you want CLI-managed start and stop.',
-            ].join('\n'));
-        }
-        if (runtime.kind === 'docker') {
-            const unsupportedFlags = [
-                flags.quickstart ? '--quickstart' : undefined,
-                flags.port ? '--port' : undefined,
-                daemonFlagWasProvided ? (flags.daemon ? '--daemon' : '--no-daemon') : undefined,
-                flags.instances !== undefined ? '--instances' : undefined,
-                flags['launch-mode'] ? '--launch-mode' : undefined,
-            ].filter(Boolean);
-            if (unsupportedFlags.length > 0) {
-                this.error([
-                    `Can't apply ${unsupportedFlags.join(', ')} to "${runtime.envName}".`,
-                    'This env is managed by Docker, so those options are only available for local npm/git installs.',
-                    `Run \`nb start --env ${runtime.envName}\` to start the saved container, or recreate the env if you need different runtime settings.`,
-                ].join('\n'));
-            }
-            const appUrl = formatAppUrl(runtime.env.appPort === undefined || runtime.env.appPort === null
-                ? undefined
-                : String(runtime.env.appPort));
-            startTask(`Starting NocoBase for "${runtime.envName}"...`);
-            try {
-                const state = await startDockerContainer(runtime.containerName, {
-                    stdio: commandStdio,
-                });
-                succeedTask(state === 'already-running'
-                    ? `NocoBase is already running for "${runtime.envName}"${appUrl ? ` at ${appUrl}` : ''}.`
-                    : `NocoBase is running for "${runtime.envName}"${appUrl ? ` at ${appUrl}` : ''}.`);
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                failTask(`Failed to start NocoBase for "${runtime.envName}".`);
-                this.error(formatDockerStartFailure(runtime.envName, message));
-            }
-            return;
-        }
-        const npmArgs = ['start'];
-        if (flags.quickstart) {
-            npmArgs.push('--quickstart');
-        }
-        if (flags.port) {
-            npmArgs.push('--port', flags.port);
-        }
-        else if (runtime.env.appPort !== undefined && runtime.env.appPort !== null && String(runtime.env.appPort).trim() !== '') {
-            npmArgs.push('--port', String(runtime.env.appPort));
-        }
-        if (flags.daemon !== false) {
-            npmArgs.push('--daemon');
-        }
-        if (flags.instances !== undefined) {
-            npmArgs.push('--instances', flags.instances.toString());
-        }
-        if (flags['launch-mode']) {
-            npmArgs.push('--launch-mode', flags['launch-mode']);
-        }
-        const appUrl = formatAppUrl(flags.port
-            || (runtime.env.appPort !== undefined && runtime.env.appPort !== null
-                ? String(runtime.env.appPort).trim()
-                : undefined));
-        if (await isAppAlreadyRunning(appUrl)) {
-            if (flags.daemon === false) {
-                printInfo(`NocoBase is already running for "${runtime.envName}"${appUrl ? ` at ${appUrl}` : ''}. Use \`nb stop --env ${runtime.envName}\` before starting it again in the foreground.`);
-            }
-            else {
-                succeedTask(`NocoBase is already running for "${runtime.envName}"${appUrl ? ` at ${appUrl}` : ''}.`);
-            }
-            return;
-        }
-        if (flags.daemon === false) {
-            printInfo(`Starting NocoBase for "${runtime.envName}" in the foreground${appUrl ? ` at ${appUrl}` : ''}. Press Ctrl+C to stop.`);
-        }
-        else {
-            startTask(`Starting NocoBase for "${runtime.envName}" in the background...`);
-        }
-        try {
-            await runLocalNocoBaseCommand(runtime, npmArgs, {
-                stdio: commandStdio,
-            });
-            if (flags.daemon !== false) {
-                succeedTask(`NocoBase is starting for "${runtime.envName}"${appUrl ? ` at ${appUrl}` : ''}.`);
-            }
-        }
-        catch (error) {
-            failTask(`Failed to start NocoBase for "${runtime.envName}".`);
-            this.error(formatLocalStartFailure(runtime.envName, {
-                port: flags.port || (runtime.env.appPort !== undefined && runtime.env.appPort !== null
-                    ? String(runtime.env.appPort).trim()
-                    : undefined),
-                source: runtime.source,
-            }));
-        }
-    }
+import AppStart from './app/start.js';
+export default class Start extends AppStart {
+    static hidden = true;
 }