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

package/dist/commands/db/start.js

@@ -6,17 +6,65 @@
  * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
-import { Args, Command } from '@oclif/core';
+import { Command, Flags } from '@oclif/core';
+import { formatMissingManagedAppEnvMessage, startDockerContainer, } from '../../lib/app-runtime.js';
+import { failTask, startTask, succeedTask } from '../../lib/ui.js';
+import { formatUnmanagedDbMessage, resolveDbRuntime } from './shared.js';
+function formatDbStartFailure(envName, message) {
+    if (/does not exist/i.test(message)) {
+        return [
+            `Can't start the database for "${envName}" yet.`,
+            'The saved built-in database container 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 the database for "${envName}".`,
+        'Check that the built-in database runtime for this env is still available, then try again.',
+        `Details: ${message}`,
+    ].join('\n');
+}
 export default class DbStart extends Command {
-    static args = {
-        file: Args.string({ description: 'file to read' }),
-    };
-    static description = 'describe the command here';
+    static description = 'Start the built-in database container for the selected env.';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --env app1',
+        '<%= config.bin %> <%= command.id %> --env app1 --verbose',
     ];
-    static flags = {};
+    static flags = {
+        env: Flags.string({
+            char: 'e',
+            description: 'CLI env name to start the built-in database for. Defaults to the current env when omitted',
+        }),
+        verbose: Flags.boolean({
+            description: 'Show raw startup output from the underlying Docker command',
+            default: false,
+        }),
+    };
     async run() {
-        const { args, flags } = await this.parse(DbStart);
+        const { flags } = await this.parse(DbStart);
+        const requestedEnv = flags.env?.trim() || undefined;
+        const runtime = await resolveDbRuntime(requestedEnv);
+        if (!runtime) {
+            this.error(formatMissingManagedAppEnvMessage(requestedEnv));
+        }
+        if (runtime.kind !== 'builtin') {
+            this.error(formatUnmanagedDbMessage('start', runtime));
+        }
+        startTask(`Starting the built-in database for "${runtime.envName}"...`);
+        try {
+            const state = await startDockerContainer(runtime.containerName, {
+                stdio: flags.verbose ? 'inherit' : 'ignore',
+            });
+            succeedTask(state === 'already-running'
+                ? `The built-in database is already running for "${runtime.envName}"${runtime.address ? ` at ${runtime.address}` : ''}.`
+                : `The built-in database is running for "${runtime.envName}"${runtime.address ? ` at ${runtime.address}` : ''}.`);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            failTask(`Failed to start the built-in database for "${runtime.envName}".`);
+            this.error(formatDbStartFailure(runtime.envName, message));
+        }
     }
 }

package/dist/commands/db/stop.js

@@ -0,0 +1,70 @@
+/**
+ * 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, stopDockerContainer, } from '../../lib/app-runtime.js';
+import { failTask, startTask, succeedTask } from '../../lib/ui.js';
+import { formatUnmanagedDbMessage, resolveDbRuntime } from './shared.js';
+function formatDbStopFailure(envName, message) {
+    if (/does not exist/i.test(message)) {
+        return [
+            `Can't stop the database for "${envName}" yet.`,
+            'The saved built-in database container 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 the database for "${envName}".`,
+        'Check that the built-in database runtime for this env is still available, then try again.',
+        `Details: ${message}`,
+    ].join('\n');
+}
+export default class DbStop extends Command {
+    static description = 'Stop the built-in database container for the selected env.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --env app1',
+        '<%= config.bin %> <%= command.id %> --env app1 --verbose',
+    ];
+    static flags = {
+        env: Flags.string({
+            char: 'e',
+            description: 'CLI env name to stop the built-in database for. Defaults to the current env when omitted',
+        }),
+        verbose: Flags.boolean({
+            description: 'Show raw shutdown output from the underlying Docker command',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(DbStop);
+        const requestedEnv = flags.env?.trim() || undefined;
+        const runtime = await resolveDbRuntime(requestedEnv);
+        if (!runtime) {
+            this.error(formatMissingManagedAppEnvMessage(requestedEnv));
+        }
+        if (runtime.kind !== 'builtin') {
+            this.error(formatUnmanagedDbMessage('stop', runtime));
+        }
+        startTask(`Stopping the built-in database for "${runtime.envName}"...`);
+        try {
+            const state = await stopDockerContainer(runtime.containerName, {
+                stdio: flags.verbose ? 'inherit' : 'ignore',
+            });
+            succeedTask(state === 'already-stopped'
+                ? `The built-in database is already stopped for "${runtime.envName}".`
+                : `The built-in database has stopped for "${runtime.envName}".`);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            failTask(`Failed to stop the built-in database for "${runtime.envName}".`);
+            this.error(formatDbStopFailure(runtime.envName, message));
+        }
+    }
+}

package/dist/commands/dev.js

@@ -6,37 +6,121 @@
  * 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";
+import { Command, Flags } from '@oclif/core';
+import { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime, runLocalNocoBaseCommand, } from '../lib/app-runtime.js';
+import { printInfo } from '../lib/ui.js';
+function formatUnsupportedRuntimeMessage(kind, envName) {
+    if (kind === 'docker') {
+        return [
+            `Can't run dev mode for "${envName}".`,
+            'This env is managed by Docker, but `nb dev` requires a local npm or Git source directory.',
+            `Use \`nb logs --env ${envName}\` to inspect the Docker app, or create a source-based env with \`nb init --env ${envName} --source git\`.`,
+        ].join('\n');
+    }
+    return [
+        `Can't run dev mode for "${envName}".`,
+        'This env only has an API connection, but `nb dev` requires a local npm or Git source directory.',
+        `Create a source-based env with \`nb init --env ${envName} --source git\` if you want local development mode.`,
+    ].join('\n');
+}
+function appUrlForPort(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 Dev extends Command {
-    static args = {
-        file: Args.string({ description: 'file to read' }),
-    };
-    static description = 'describe the command here';
+    static description = 'Run NocoBase in local development mode for an npm or Git source env.';
     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',
+        '<%= config.bin %> <%= command.id %> --env app1',
+        '<%= config.bin %> <%= command.id %> --env app1 --db-sync',
+        '<%= config.bin %> <%= command.id %> --env app1 --port 12000',
+        '<%= config.bin %> <%= command.id %> --env app1 --client',
+        '<%= config.bin %> <%= command.id %> --env app1 --server',
+        '<%= config.bin %> <%= command.id %> --env app1 --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 }),
+        env: Flags.string({
+            char: 'e',
+            description: 'CLI env name for dev mode. Defaults to the current env when omitted',
+            required: false,
+        }),
+        'db-sync': Flags.boolean({
+            description: 'Synchronize the database before starting dev mode',
+            required: false,
+        }),
+        port: Flags.string({
+            description: 'Development server port',
+            char: 'p',
+            required: false,
+        }),
+        client: Flags.boolean({
+            description: 'Run client dev mode only',
+            char: 'c',
+            required: false,
+        }),
+        server: Flags.boolean({
+            description: 'Run server dev mode only',
+            char: 's',
+            required: false,
+        }),
+        inspect: Flags.string({
+            description: 'Node.js inspect port for server debugging',
+            char: 'i',
+            required: false,
+        }),
     };
     async run() {
         const { flags } = await this.parse(Dev);
+        const requestedEnv = flags.env?.trim() || undefined;
+        const runtime = await resolveManagedAppRuntime(requestedEnv);
+        if (!runtime) {
+            this.error(formatMissingManagedAppEnvMessage(requestedEnv));
+        }
+        if (runtime.kind === 'docker' || runtime.kind === 'remote') {
+            this.error(formatUnsupportedRuntimeMessage(runtime.kind, runtime.envName));
+        }
+        const devPort = flags.port
+            || (runtime.env.appPort !== undefined && runtime.env.appPort !== null
+                ? String(runtime.env.appPort).trim()
+                : undefined);
+        const appUrl = appUrlForPort(devPort);
+        if (await isAppAlreadyRunning(appUrl)) {
+            this.error([
+                `NocoBase is already running for "${runtime.envName}"${appUrl ? ` at ${appUrl}` : ''}.`,
+                flags.port
+                    ? `Choose another dev port with --port, or stop the running app with \`nb stop --env ${runtime.envName}\` first.`
+                    : `Run \`nb stop --env ${runtime.envName}\` before starting dev mode, or choose another dev port with --port.`,
+            ].join('\n'));
+        }
         const npmArgs = ['dev', '--rsbuild'];
         if (flags['db-sync']) {
             npmArgs.push('--db-sync');
         }
-        if (flags.port) {
-            npmArgs.push('--port', flags.port);
+        if (devPort) {
+            npmArgs.push('--port', devPort);
         }
         if (flags.client) {
             npmArgs.push('--client');
@@ -47,12 +131,19 @@ export default class Dev extends Command {
         if (flags.inspect) {
             npmArgs.push('--inspect', flags.inspect);
         }
+        printInfo(`Starting NocoBase dev mode for "${runtime.envName}" from ${runtime.projectRoot}. Press Ctrl+C to stop.`);
         try {
-            await runNocoBaseCommand(npmArgs);
+            await runLocalNocoBaseCommand(runtime, npmArgs, {
+                stdio: 'inherit',
+            });
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
-            this.error(message);
+            this.error([
+                `Couldn't start dev mode for "${runtime.envName}".`,
+                'Check that dependencies are installed and the saved env settings are valid, then try again.',
+                `Details: ${message}`,
+            ].join('\n'));
         }
     }
 }

package/dist/commands/down.js

@@ -0,0 +1,193 @@
+/**
+ * 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 fsp from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { buildDockerDbContainerName, formatMissingManagedAppEnvMessage, resolveManagedAppRuntime, runLocalNocoBaseCommand, } from '../lib/app-runtime.js';
+import { removeEnv } from '../lib/auth-store.js';
+import { commandSucceeds, run } from '../lib/run-npm.js';
+import { confirmAction, failTask, isInteractiveTerminal, printInfo, startTask, succeedTask, } from '../lib/ui.js';
+function resolveConfiguredPath(value) {
+    const text = String(value ?? '').trim();
+    if (!text) {
+        return undefined;
+    }
+    return path.isAbsolute(text) ? text : path.resolve(process.cwd(), text);
+}
+function assertSafeRemovalPath(target, label) {
+    const resolved = path.resolve(target);
+    const cwd = path.resolve(process.cwd());
+    const home = path.resolve(os.homedir());
+    const root = path.parse(resolved).root;
+    if (resolved === root || resolved === cwd || resolved === home) {
+        throw new Error(`Refusing to remove ${label} at "${resolved}" because it is too broad.`);
+    }
+}
+async function removePathIfExists(target, label) {
+    const resolved = path.resolve(target);
+    assertSafeRemovalPath(resolved, label);
+    await fsp.rm(resolved, { recursive: true, force: true });
+}
+async function dockerContainerExists(containerName) {
+    return await commandSucceeds('docker', ['container', 'inspect', containerName]);
+}
+async function removeDockerContainerIfExists(containerName) {
+    if (!(await dockerContainerExists(containerName))) {
+        return 'missing';
+    }
+    await run('docker', ['rm', '-f', containerName], {
+        errorName: 'docker rm',
+        stdio: 'ignore',
+    });
+    return 'removed';
+}
+function builtinDbContainerName(runtime) {
+    if (!runtime.env.config.builtinDb) {
+        return undefined;
+    }
+    const dbDialect = String(runtime.env.config.dbDialect ?? 'postgres').trim() || 'postgres';
+    const workspaceName = runtime.workspaceName;
+    return buildDockerDbContainerName(runtime.envName, dbDialect, workspaceName);
+}
+async function confirmRemoveData(envName, yes) {
+    if (yes) {
+        return true;
+    }
+    if (!isInteractiveTerminal()) {
+        throw new Error(`Refusing to remove user data for "${envName}" without confirmation. Re-run with --yes only if you are sure.`);
+    }
+    return await confirmAction(`Delete storage and managed database data for "${envName}"? This cannot be undone.`, { defaultValue: false });
+}
+function formatDownFailure(envName, message) {
+    return [
+        `Couldn't bring down NocoBase for "${envName}".`,
+        'Some local runtime resources may still exist. Check Docker or the local app process, then try again.',
+        `Details: ${message}`,
+    ].join('\n');
+}
+export default class Down extends Command {
+    static description = 'Stop NocoBase and remove local runtime containers for the selected env. Data, source files, and env config are kept unless explicitly requested.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --env app1',
+        '<%= config.bin %> <%= command.id %> --env app1 --remove-data',
+        '<%= config.bin %> <%= command.id %> --env app1 --remove-source --remove-env',
+    ];
+    static flags = {
+        env: Flags.string({
+            char: 'e',
+            description: 'CLI env name to bring down. Defaults to the current env when omitted',
+        }),
+        'remove-data': Flags.boolean({
+            description: 'Delete storage and managed database data after confirmation',
+            default: false,
+        }),
+        'remove-source': Flags.boolean({
+            description: 'Delete the npm/git source directory for local installs',
+            default: false,
+        }),
+        'remove-env': Flags.boolean({
+            description: 'Remove the CLI env config after local resources are removed',
+            default: false,
+        }),
+        yes: Flags.boolean({
+            char: 'y',
+            description: 'Confirm destructive actions without prompting',
+            default: false,
+        }),
+        verbose: Flags.boolean({
+            description: 'Show raw output from shutdown commands',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Down);
+        const requestedEnv = flags.env?.trim() || undefined;
+        const runtime = await resolveManagedAppRuntime(requestedEnv);
+        if (!runtime) {
+            this.error(formatMissingManagedAppEnvMessage(requestedEnv));
+        }
+        if (runtime.kind === 'remote') {
+            this.error([
+                `Can't bring down "${runtime.envName}" from this machine.`,
+                'This env only has an API connection, so there is no saved local app, Docker app, or managed database to remove here.',
+                'Use `nb env remove` if you only want to remove the CLI connection config.',
+            ].join('\n'));
+        }
+        if (flags['remove-data']) {
+            let confirmed = false;
+            try {
+                confirmed = await confirmRemoveData(runtime.envName, flags.yes);
+            }
+            catch (error) {
+                this.error(error instanceof Error ? error.message : String(error));
+            }
+            if (!confirmed) {
+                this.log('Canceled.');
+                return;
+            }
+        }
+        try {
+            if (runtime.kind === 'docker') {
+                startTask(`Removing Docker app container for "${runtime.envName}"...`);
+                const state = await removeDockerContainerIfExists(runtime.containerName);
+                succeedTask(state === 'removed'
+                    ? `Docker app container removed for "${runtime.envName}".`
+                    : `No Docker app container found for "${runtime.envName}".`);
+            }
+            else {
+                startTask(`Stopping local NocoBase app for "${runtime.envName}"...`);
+                await runLocalNocoBaseCommand(runtime, ['pm2', 'kill'], {
+                    stdio: flags.verbose ? 'inherit' : 'ignore',
+                });
+                succeedTask(`Local NocoBase app stopped for "${runtime.envName}".`);
+            }
+            const dbContainerName = builtinDbContainerName(runtime);
+            if (dbContainerName) {
+                startTask(`Removing built-in database container for "${runtime.envName}"...`);
+                const state = await removeDockerContainerIfExists(dbContainerName);
+                succeedTask(state === 'removed'
+                    ? `Built-in database container removed for "${runtime.envName}".`
+                    : `No built-in database container found for "${runtime.envName}".`);
+            }
+            if (flags['remove-data']) {
+                const storagePath = resolveConfiguredPath(runtime.env.config.storagePath);
+                if (storagePath) {
+                    startTask(`Deleting storage and managed database data for "${runtime.envName}"...`);
+                    await removePathIfExists(storagePath, 'storage data');
+                    succeedTask(`Storage and managed database data deleted for "${runtime.envName}".`);
+                }
+                else {
+                    printInfo(`No storage path is configured for "${runtime.envName}".`);
+                }
+            }
+            if (flags['remove-source']) {
+                if (runtime.kind === 'local') {
+                    startTask(`Deleting source files for "${runtime.envName}"...`);
+                    await removePathIfExists(runtime.projectRoot, 'source files');
+                    succeedTask(`Source files deleted for "${runtime.envName}".`);
+                }
+                else {
+                    printInfo(`No npm/git source directory is configured for "${runtime.envName}".`);
+                }
+            }
+            if (flags['remove-env']) {
+                startTask(`Removing CLI env config for "${runtime.envName}"...`);
+                await removeEnv(runtime.envName);
+                succeedTask(`CLI env config removed for "${runtime.envName}".`);
+            }
+            printInfo(`NocoBase is down for "${runtime.envName}".`);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            failTask(`Failed to bring down NocoBase for "${runtime.envName}".`);
+            this.error(formatDownFailure(runtime.envName, message));
+        }
+    }
+}