@nocobase/cli 2.1.0-alpha.3 → 2.1.0-alpha.31

package/dist/commands/app/down.js

@@ -0,0 +1,266 @@
+/**
+ * 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 * as p from '@clack/prompts';
+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 { resolveConfiguredEnvPath } from '../../lib/cli-home.js';
+import { commandOutput, commandSucceeds, run } from '../../lib/run-npm.js';
+import { failTask, isInteractiveTerminal, printInfo, startTask, succeedTask, } from '../../lib/ui.js';
+function resolveConfiguredPath(value) {
+    return resolveConfiguredEnvPath(value);
+}
+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';
+}
+async function dockerNetworkExists(networkName) {
+    return await commandSucceeds('docker', ['network', 'inspect', networkName]);
+}
+async function dockerNetworkHasActiveEndpoints(networkName) {
+    try {
+        const output = await commandOutput('docker', [
+            'network',
+            'inspect',
+            networkName,
+            '--format',
+            '{{json .Containers}}',
+        ], {
+            errorName: 'docker network inspect',
+        });
+        const containers = JSON.parse(output || '{}');
+        return Boolean(containers && typeof containers === 'object' && Object.keys(containers).length > 0);
+    }
+    catch {
+        return false;
+    }
+}
+async function removeDockerNetworkIfUnused(networkName) {
+    if (!(await dockerNetworkExists(networkName))) {
+        return 'missing';
+    }
+    try {
+        await run('docker', ['network', 'rm', networkName], {
+            errorName: 'docker network rm',
+            stdio: 'ignore',
+        });
+        return 'removed';
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (/has active endpoints|is in use|active endpoints/i.test(message)
+            || (await dockerNetworkExists(networkName) && await dockerNetworkHasActiveEndpoints(networkName))) {
+            return 'in-use';
+        }
+        throw error;
+    }
+}
+function builtinDbContainerName(runtime) {
+    if (!runtime.env.config.builtinDb) {
+        return undefined;
+    }
+    const dbDialect = String(runtime.env.config.dbDialect ?? 'postgres').trim() || 'postgres';
+    return buildDockerDbContainerName(runtime.envName, dbDialect, runtime.dockerContainerPrefix || runtime.workspaceName);
+}
+function managedDockerNetworkName(runtime) {
+    return runtime.dockerNetworkName?.trim() || runtime.workspaceName?.trim() || undefined;
+}
+async function confirmDownAll(envName, yes, options) {
+    if (yes) {
+        return true;
+    }
+    const usedCurrentEnv = options?.explicitEnv === false;
+    if (!isInteractiveTerminal()) {
+        if (usedCurrentEnv) {
+            throw new Error(`\`nb app down --all\` is using the current env "${envName}". Re-run with --env ${envName} --yes to delete everything for that env in non-interactive mode.`);
+        }
+        throw new Error(`\`nb app down --all\` needs confirmation. Re-run with --yes to delete everything for "${envName}" in non-interactive mode.`);
+    }
+    const answer = await p.confirm({
+        message: usedCurrentEnv
+            ? `Delete everything for current env "${envName}"? This removes the app, managed containers, storage data, and the saved CLI env config.`
+            : `Delete everything for "${envName}"? This removes the app, managed containers, storage data, and the saved CLI env config.`,
+        active: 'yes',
+        inactive: 'no',
+        initialValue: false,
+    });
+    if (p.isCancel(answer)) {
+        p.cancel('Down cancelled.');
+        return false;
+    }
+    return answer;
+}
+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 AppDown extends Command {
+    static hidden = false;
+    static description = 'Bring down the selected env by removing runtime containers and the saved local app files. Storage data and env config are kept unless explicitly requested.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --env app1',
+        '<%= config.bin %> <%= command.id %> --env app1 --all --yes',
+    ];
+    static flags = {
+        env: Flags.string({
+            char: 'e',
+            description: 'CLI env name to bring down. Defaults to the current env when omitted',
+        }),
+        all: Flags.boolean({
+            description: 'Delete everything for this env, including storage data and the saved env config',
+            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(AppDown);
+        const requestedEnv = flags.env?.trim() || undefined;
+        const explicitEnv = Boolean(requestedEnv);
+        const removeData = Boolean(flags.all);
+        const removeEnvConfig = Boolean(flags.all);
+        const runtime = await resolveManagedAppRuntime(requestedEnv);
+        if (!runtime) {
+            this.error(formatMissingManagedAppEnvMessage(requestedEnv));
+        }
+        if (runtime.kind === 'http') {
+            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 (runtime.kind === 'ssh') {
+            this.error([
+                `Can't bring down "${runtime.envName}" yet.`,
+                'SSH env support is reserved but not implemented yet.',
+                'Use `nb env remove` if you only want to remove the saved CLI config for now.',
+            ].join('\n'));
+        }
+        if (flags.all) {
+            let confirmed = false;
+            try {
+                confirmed = await confirmDownAll(runtime.envName, flags.yes, { explicitEnv });
+            }
+            catch (error) {
+                this.error(error instanceof Error ? error.message : String(error));
+            }
+            if (!confirmed) {
+                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}".`);
+            }
+            if (runtime.kind === 'local' || runtime.kind === 'docker') {
+                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}".`);
+                }
+                const networkName = managedDockerNetworkName(runtime);
+                if (networkName) {
+                    startTask(`Removing Docker network for "${runtime.envName}" if unused...`);
+                    const state = await removeDockerNetworkIfUnused(networkName);
+                    if (state === 'removed') {
+                        succeedTask(`Docker network removed for "${runtime.envName}".`);
+                    }
+                    else if (state === 'missing') {
+                        succeedTask(`No Docker network found for "${runtime.envName}".`);
+                    }
+                    else {
+                        succeedTask(`Docker network is still in use for "${runtime.envName}". Keeping it.`);
+                    }
+                }
+            }
+            if (runtime.kind === 'local') {
+                const localAppPath = resolveConfiguredPath(runtime.env.config.appRootPath) || runtime.projectRoot;
+                if (localAppPath) {
+                    startTask(`Removing local app files for "${runtime.envName}"...`);
+                    await removePathIfExists(localAppPath, `app files for "${runtime.envName}"`);
+                    succeedTask(`Local app files removed for "${runtime.envName}".`);
+                }
+                else {
+                    printInfo(`No saved local app path found for "${runtime.envName}".`);
+                }
+            }
+            if (removeData) {
+                const configuredStoragePath = resolveConfiguredPath(runtime.env.config.storagePath);
+                if (configuredStoragePath) {
+                    startTask(`Removing storage data for "${runtime.envName}"...`);
+                    await removePathIfExists(configuredStoragePath, `storage data for "${runtime.envName}"`);
+                    succeedTask(`Storage data removed for "${runtime.envName}".`);
+                }
+                else {
+                    printInfo(`No saved storage path found for "${runtime.envName}".`);
+                }
+            }
+            if (removeEnvConfig) {
+                startTask(`Removing saved CLI env config for "${runtime.envName}"...`);
+                const result = await removeEnv(runtime.envName);
+                succeedTask(`Saved CLI env config removed for "${runtime.envName}"${result.currentEnv ? ` (current env: ${result.currentEnv})` : ''}.`);
+            }
+        }
+        catch (error) {
+            failTask(`Failed to bring down NocoBase for "${runtime.envName}".`);
+            this.error(formatDownFailure(runtime.envName, error instanceof Error ? error.message : String(error)));
+        }
+    }
+}

package/dist/commands/app/logs.js

@@ -0,0 +1,98 @@
+/**
+ * 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, } from '../../lib/app-runtime.js';
+import { run } from '../../lib/run-npm.js';
+import { printInfo } from '../../lib/ui.js';
+function formatLogsFailure(envName, message) {
+    return [
+        `Couldn't show logs for "${envName}".`,
+        'Check that the saved local app or Docker container still exists on this machine, then try again.',
+        `Details: ${message}`,
+    ].join('\n');
+}
+export default class AppLogs extends Command {
+    static hidden = false;
+    static description = 'Show NocoBase logs for the selected env. Local npm/git installs use pm2 logs, and Docker installs use docker logs.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --env app1',
+        '<%= config.bin %> <%= command.id %> --env app1 --tail 200',
+        '<%= config.bin %> <%= command.id %> --env app1 --no-follow',
+    ];
+    static flags = {
+        env: Flags.string({
+            char: 'e',
+            description: 'CLI env name to inspect logs for. Defaults to the current env when omitted',
+        }),
+        tail: Flags.integer({
+            description: 'Number of recent log lines to show before following',
+            default: 100,
+            min: 0,
+        }),
+        follow: Flags.boolean({
+            char: 'f',
+            description: 'Keep streaming new log lines',
+            default: false,
+            allowNo: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(AppLogs);
+        const requestedEnv = flags.env?.trim() || undefined;
+        const runtime = await resolveManagedAppRuntime(requestedEnv);
+        if (!runtime) {
+            this.error(formatMissingManagedAppEnvMessage(requestedEnv));
+        }
+        if (runtime.kind === 'http') {
+            this.error([
+                `Can't show runtime logs for "${runtime.envName}" from this machine.`,
+                'This env only has an API connection, so there is no saved local app or Docker container to read logs from.',
+                'Connect it to a local checkout or reinstall it with npm, git, or Docker if you want CLI-managed logs.',
+            ].join('\n'));
+        }
+        if (runtime.kind === 'ssh') {
+            this.error([
+                `Can't show runtime logs for "${runtime.envName}" yet.`,
+                'SSH env support is reserved but not implemented yet.',
+                'Use a local or Docker env for CLI-managed logs for now.',
+            ].join('\n'));
+        }
+        const tail = String(flags.tail ?? 100);
+        const follow = flags.follow === true;
+        printInfo(follow
+            ? `Showing logs for "${runtime.envName}" (press Ctrl+C to stop).`
+            : `Showing recent logs for "${runtime.envName}".`);
+        try {
+            if (runtime.kind === 'docker') {
+                const dockerArgs = ['logs', '--tail', tail];
+                if (follow) {
+                    dockerArgs.push('--follow');
+                }
+                dockerArgs.push(runtime.containerName);
+                await run('docker', dockerArgs, {
+                    errorName: 'docker logs',
+                    stdio: 'inherit',
+                });
+                return;
+            }
+            const localArgs = ['pm2', 'logs', '--lines', tail];
+            if (!follow) {
+                localArgs.push('--nostream');
+            }
+            await runLocalNocoBaseCommand(runtime, localArgs, {
+                stdio: 'inherit',
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.error(formatLogsFailure(runtime.envName, message));
+        }
+    }
+}

package/dist/commands/app/restart.js

@@ -0,0 +1,75 @@
+/**
+ * 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';
+function argvHasToken(argv, tokens) {
+    return tokens.some((token) => argv.includes(token));
+}
+function pushFlag(argv, flag, value) {
+    if (value !== undefined) {
+        argv.push(flag, String(value));
+    }
+}
+export default class AppRestart extends Command {
+    static hidden = false;
+    static description = 'Restart NocoBase for the selected env by stopping it first, then starting it again.';
+    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 restart. Defaults to the current env when omitted',
+        }),
+        quickstart: Flags.boolean({ description: 'Quickstart the application after stopping it', 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 after stopping it (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 after stopping it', char: 'i', required: false }),
+        'launch-mode': Flags.string({ description: 'Launch Mode', required: false, options: ['pm2', 'node'] }),
+        verbose: Flags.boolean({
+            description: 'Show raw shutdown/startup output from the underlying local or Docker command',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(AppRestart);
+        const stopArgv = [];
+        const daemonFlagWasProvided = argvHasToken(this.argv, ['--daemon', '--no-daemon']);
+        pushFlag(stopArgv, '--env', flags.env?.trim() || undefined);
+        if (flags.verbose) {
+            stopArgv.push('--verbose');
+        }
+        await this.config.runCommand('app:stop', stopArgv);
+        const startArgv = [...stopArgv];
+        if (flags.quickstart) {
+            startArgv.push('--quickstart');
+        }
+        pushFlag(startArgv, '--port', flags.port);
+        if (daemonFlagWasProvided) {
+            startArgv.push(flags.daemon === false ? '--no-daemon' : '--daemon');
+        }
+        pushFlag(startArgv, '--instances', flags.instances);
+        pushFlag(startArgv, '--launch-mode', flags['launch-mode']);
+        await this.config.runCommand('app:start', startArgv);
+    }
+}