@nocobase/cli 2.1.0-beta.15 → 2.1.0-beta.16

package/dist/commands/ps.js

@@ -0,0 +1,116 @@
+/**
+ * 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 { buildDockerDbContainerName, dockerContainerExists, dockerContainerIsRunning, formatMissingManagedAppEnvMessage, resolveManagedAppRuntime, } from '../lib/app-runtime.js';
+import { listEnvs } from '../lib/auth-store.js';
+import { renderTable } from '../lib/ui.js';
+function appUrl(runtime) {
+    const port = String(runtime.env.config.appPort ?? '').trim();
+    if (port) {
+        return `http://127.0.0.1:${port}`;
+    }
+    const baseUrl = String(runtime.env.config.baseUrl ?? '').trim();
+    return baseUrl.replace(/\/api\/?$/, '');
+}
+async function isLocalAppHealthy(runtime) {
+    const port = String(runtime.env.config.appPort ?? '').trim();
+    if (!port) {
+        return false;
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 1500);
+    try {
+        const response = await fetch(`http://127.0.0.1:${port}/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);
+    }
+}
+async function dockerStatus(containerName) {
+    if (!(await dockerContainerExists(containerName))) {
+        return 'missing';
+    }
+    return await dockerContainerIsRunning(containerName) ? 'running' : 'stopped';
+}
+async function dbStatus(runtime) {
+    if (!runtime.env.config.builtinDb) {
+        return runtime.kind === 'remote' ? 'external' : '-';
+    }
+    if (runtime.kind === 'remote') {
+        return 'external';
+    }
+    const dbDialect = String(runtime.env.config.dbDialect ?? 'postgres').trim() || 'postgres';
+    const containerName = buildDockerDbContainerName(runtime.envName, dbDialect, runtime.workspaceName);
+    return await dockerStatus(containerName);
+}
+async function appStatus(runtime) {
+    if (runtime.kind === 'remote') {
+        return 'remote';
+    }
+    if (runtime.kind === 'docker') {
+        return await dockerStatus(runtime.containerName);
+    }
+    return await isLocalAppHealthy(runtime) ? 'running' : 'stopped';
+}
+function sourceLabel(runtime) {
+    if (runtime.kind === 'remote') {
+        return 'remote';
+    }
+    return runtime.source;
+}
+export default class Ps extends Command {
+    static description = 'Show NocoBase runtime status for configured envs without starting or stopping anything.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --env app1',
+    ];
+    static flags = {
+        env: Flags.string({
+            char: 'e',
+            description: 'CLI env name to inspect. Omit to show all configured envs',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Ps);
+        const requestedEnv = flags.env?.trim() || undefined;
+        const envNames = requestedEnv
+            ? [requestedEnv]
+            : Object.keys((await listEnvs()).envs).sort();
+        if (!envNames.length) {
+            this.log('No NocoBase env is configured yet. Run `nb init` to create one first.');
+            return;
+        }
+        const rows = [];
+        for (const envName of envNames) {
+            const runtime = await resolveManagedAppRuntime(envName);
+            if (!runtime) {
+                if (requestedEnv) {
+                    this.error(formatMissingManagedAppEnvMessage(envName));
+                }
+                rows.push([envName, '-', 'missing', '-', '']);
+                continue;
+            }
+            rows.push([
+                runtime.envName,
+                sourceLabel(runtime),
+                await appStatus(runtime),
+                await dbStatus(runtime),
+                appUrl(runtime),
+            ]);
+        }
+        this.log(renderTable(['Env', 'Source', 'App', 'Database', 'URL'], rows));
+    }
+}

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, { 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, { env: { LOGGER_SILENT: 'true' } });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.error(message);
+        }
+    }
+}

package/dist/commands/start.js

@@ -0,0 +1,211 @@
+/**
+ * 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 { 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,
+            }));
+        }
+    }
+}

package/dist/commands/stop.js

@@ -0,0 +1,90 @@
+/**
+ * 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 { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime, runLocalNocoBaseCommand, stopDockerContainer, } from '../lib/app-runtime.js';
+import { failTask, startTask, succeedTask } from '../lib/ui.js';
+function formatStopFailure(envName, message) {
+    if (/does not exist/i.test(message)) {
+        return [
+            `Can't stop NocoBase for "${envName}" yet.`,
+            'The saved Docker app for this env could not be found on this machine.',
+            'If it was removed manually, reinstall or reconnect the env before trying again.',
+            `Details: ${message}`,
+        ].join('\n');
+    }
+    return [
+        `Couldn't stop NocoBase for "${envName}".`,
+        'Check that the local app or Docker runtime is still available, then try again.',
+        `Details: ${message}`,
+    ].join('\n');
+}
+export default class Stop extends Command {
+    static description = 'Stop NocoBase for the selected env. Local npm/git installs stop the app process, and Docker installs stop the saved app container.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --env local',
+        '<%= 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 stop. Defaults to the current env when omitted',
+        }),
+        verbose: Flags.boolean({
+            description: 'Show raw shutdown output from the underlying local or Docker command',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Stop);
+        const requestedEnv = flags.env?.trim() || undefined;
+        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 stop "${runtime.envName}" from this machine.`,
+                'This env only has an API connection, so there is no saved local app or Docker runtime to stop here.',
+                'If the app is running on a server, stop it there or reconnect this env to a local runtime first.',
+            ].join('\n'));
+        }
+        if (runtime.kind === 'docker') {
+            startTask(`Stopping NocoBase for "${runtime.envName}"...`);
+            try {
+                const state = await stopDockerContainer(runtime.containerName, {
+                    stdio: commandStdio,
+                });
+                succeedTask(state === 'already-stopped'
+                    ? `NocoBase is already stopped for "${runtime.envName}".`
+                    : `NocoBase has stopped for "${runtime.envName}".`);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                failTask(`Failed to stop NocoBase for "${runtime.envName}".`);
+                this.error(formatStopFailure(runtime.envName, message));
+            }
+            return;
+        }
+        startTask(`Stopping NocoBase for "${runtime.envName}"...`);
+        try {
+            await runLocalNocoBaseCommand(runtime, ['pm2', 'kill'], {
+                stdio: commandStdio,
+            });
+            succeedTask(`NocoBase has stopped for "${runtime.envName}".`);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            failTask(`Failed to stop NocoBase for "${runtime.envName}".`);
+            this.error(formatStopFailure(runtime.envName, message));
+        }
+    }
+}