@nocobase/cli 2.1.0-beta.8 → 2.2.0-alpha.1

package/dist/commands/app/autostart/list.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 { Command } from '@oclif/core';
+import { getCurrentEnvName, listEnvs } from '../../../lib/auth-store.js';
+import { renderTable } from '../../../lib/ui.js';
+import { isAutostartEnabled } from './shared.js';
+export default class AppAutostartList extends Command {
+    static description = 'List app autostart status for configured envs.';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    async run() {
+        await this.parse(AppAutostartList);
+        const { envs } = await listEnvs();
+        const currentEnv = await getCurrentEnvName();
+        const names = Object.keys(envs).sort();
+        if (!names.length) {
+            this.log('No environments are configured.');
+            return;
+        }
+        const rows = names.map((name) => {
+            const env = envs[name];
+            return [
+                name === currentEnv ? '*' : '',
+                name,
+                env.kind ?? '-',
+                env.source ? String(env.source) : '-',
+                isAutostartEnabled(env) ? 'yes' : 'no',
+            ];
+        });
+        this.log(renderTable(['Current', 'Env', 'Kind', 'Source', 'Autostart'], rows));
+    }
+}

package/dist/commands/app/autostart/run.js

@@ -0,0 +1,84 @@
+/**
+ * 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 { listEnvs } from '../../../lib/auth-store.js';
+import { resolveManagedAppRuntime } from '../../../lib/app-runtime.js';
+import { renderTable } from '../../../lib/ui.js';
+import { ensureManagedAutostartRuntime, isAutostartEnabled } from './shared.js';
+function formatSummary(results) {
+    return renderTable(['Env', 'Status', 'Detail'], results.map((result) => [result.env, result.status, result.detail]));
+}
+export default class AppAutostartRun extends Command {
+    static description = 'Start every env that has app autostart enabled.';
+    static examples = ['<%= config.bin %> <%= command.id %>', '<%= config.bin %> <%= command.id %> --verbose'];
+    static flags = {
+        verbose: Flags.boolean({
+            description: 'Show raw startup output from the underlying local or Docker command',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(AppAutostartRun);
+        const { envs } = await listEnvs();
+        const enabledNames = Object.keys(envs)
+            .filter((name) => isAutostartEnabled(envs[name]))
+            .sort((left, right) => left.localeCompare(right));
+        if (!enabledNames.length) {
+            this.log('No environments have app autostart enabled.');
+            return;
+        }
+        const results = [];
+        for (const envName of enabledNames) {
+            const env = envs[envName];
+            try {
+                ensureManagedAutostartRuntime({ ...env, name: envName });
+            }
+            catch (error) {
+                results.push({
+                    env: envName,
+                    status: 'skipped',
+                    detail: error instanceof Error ? error.message : String(error),
+                });
+                continue;
+            }
+            const runtime = await resolveManagedAppRuntime(envName);
+            if (!runtime) {
+                results.push({
+                    env: envName,
+                    status: 'failed',
+                    detail: 'Env configuration could not be resolved.',
+                });
+                continue;
+            }
+            try {
+                const argv = ['--env', envName, '--yes'];
+                if (flags.verbose) {
+                    argv.push('--verbose');
+                }
+                await this.config.runCommand('app:start', argv);
+                results.push({
+                    env: envName,
+                    status: 'started',
+                    detail: `Started ${runtime.kind} app runtime.`,
+                });
+            }
+            catch (error) {
+                results.push({
+                    env: envName,
+                    status: 'failed',
+                    detail: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+        this.log(formatSummary(results));
+        if (results.some((result) => result.status === 'failed')) {
+            this.error('Some app autostart envs failed to start.');
+        }
+    }
+}

package/dist/commands/app/autostart/shared.js

@@ -0,0 +1,49 @@
+/**
+ * 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 { loadExactAuthConfig, saveAuthConfig } from '../../../lib/auth-store.js';
+export function isAutostartEnabled(config) {
+    return config?.autostart?.enabled === true;
+}
+export function ensureManagedAutostartRuntime(config) {
+    const kind = String(config.kind ?? '').trim();
+    const source = String(config.source ?? '').trim();
+    const inferredLocal = source === 'npm' || source === 'git' || source === 'local';
+    if (kind === 'local' || kind === 'docker' || (!kind && (source === 'docker' || inferredLocal))) {
+        return;
+    }
+    const envName = String(config.name ?? '').trim() || 'unknown';
+    throw new Error([
+        `Env "${envName}" cannot be added to app autostart.`,
+        'Only local and Docker envs with CLI-managed app runtimes can be started automatically on this machine.',
+    ].join('\n'));
+}
+export async function updateAutostartSetting(envName, enabled) {
+    const config = await loadExactAuthConfig();
+    const previous = config.envs[envName];
+    if (!previous) {
+        throw new Error(`Env "${envName}" is not configured`);
+    }
+    ensureManagedAutostartRuntime({ ...previous, name: envName });
+    const next = { ...previous };
+    const wasEnabled = isAutostartEnabled(previous);
+    if (enabled) {
+        next.autostart = { enabled: true };
+    }
+    else {
+        delete next.autostart;
+    }
+    config.envs[envName] = next;
+    if (wasEnabled !== enabled) {
+        await saveAuthConfig(config);
+    }
+    return {
+        config,
+        changed: wasEnabled !== enabled,
+    };
+}

package/dist/commands/app/destroy.js

@@ -0,0 +1,234 @@
+/**
+ * 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 { removeEnv } from '../../lib/auth-store.js';
+import { formatMissingManagedAppEnvMessage, managedAppLifecycleEnvVars, resolveManagedAppRuntime, runLocalNocoBaseCommand, } from '../../lib/app-runtime.js';
+import { hasExplicitEnvSelection } from '../../lib/env-guard.js';
+import { resolveEnvProxyEntryDir, resolveLegacyNginxEnvProxyAppOutputPath } from "../../lib/env-proxy.js";
+import { resolveConfiguredStoragePath } from '../../lib/env-paths.js';
+import { input } from "../../lib/inquirer.js";
+import { announceTargetEnv, failTask, isInteractiveTerminal, printInfo, startTask, succeedTask } from '../../lib/ui.js';
+import path from 'node:path';
+import { builtinDbContainerName, managedDockerNetworkName, removeDockerContainerIfExists, removeDockerNetworkIfUnused, removePathIfExists, resolveManagedLocalAppPath, shouldRemoveManagedLocalAppFiles, } from './shared.js';
+function formatDestroyFailure(envName, message) {
+    return [
+        `Couldn't destroy env "${envName}".`,
+        'Some managed local resources may still exist. Check Docker, local app files, and storage data, then try again.',
+        `Details: ${message}`,
+    ].join('\n');
+}
+function formatDestroyForceRequiredMessage(envName, explicitEnv) {
+    if (!explicitEnv) {
+        return [
+            `Refusing to destroy current env "${envName}" without explicit selection in non-interactive mode.`,
+            `Re-run with \`--env ${envName} --force\` to destroy this env.`,
+        ].join('\n');
+    }
+    return [
+        `Refusing to destroy env "${envName}" without confirmation in non-interactive mode.`,
+        `Re-run with \`--env ${envName} --force\` to destroy this env.`,
+    ].join('\n');
+}
+function buildDestroyPrompt(runtime, options) {
+    const subject = options.explicitEnv ? `env "${runtime.envName}"` : `current env "${runtime.envName}"`;
+    const lines = [`Destroy ${subject}?`];
+    if (runtime.kind === 'http' || runtime.kind === 'ssh') {
+        lines.push('This env has no CLI-managed local app or database runtime on this machine.');
+        lines.push('Only the saved CLI env config will be removed. External services are not touched.');
+    }
+    else {
+        lines.push('This removes managed app runtime resources.');
+        if (runtime.env.config.builtinDb) {
+            lines.push('CLI-managed built-in database runtime will also be removed.');
+        }
+        else {
+            lines.push('External database resources are not managed by the CLI and will be left untouched.');
+        }
+        if (options.removesManagedLocalAppFiles) {
+            lines.push('CLI-managed local app files will also be removed.');
+        }
+        lines.push('Env-specific proxy entry files generated by `nb proxy` will also be removed when present.');
+        if (options.removesStorageData) {
+            lines.push('Storage data will be removed.');
+        }
+        else {
+            lines.push('No saved storage path was found for this env.');
+        }
+        lines.push('The saved CLI env config will be removed.');
+    }
+    lines.push(`Type "${runtime.envName}" to confirm:`);
+    return lines.join('\n');
+}
+async function confirmDestroy(runtime, options) {
+    if (!isInteractiveTerminal()) {
+        if (!options.explicitEnv) {
+            throw new Error(formatDestroyForceRequiredMessage(runtime.envName, false));
+        }
+        if (options.force) {
+            return true;
+        }
+        throw new Error(formatDestroyForceRequiredMessage(runtime.envName, options.explicitEnv));
+    }
+    if (options.force) {
+        return true;
+    }
+    try {
+        await input({
+            message: buildDestroyPrompt(runtime, options),
+            required: true,
+            validate: (value) => (value.trim() === runtime.envName ? true : `Type "${runtime.envName}" to confirm.`),
+            placeholder: runtime.envName,
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export default class AppDestroy extends Command {
+    static hidden = true;
+    static description = 'Deprecated compatibility alias for `nb env remove <name> --purge`.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --env app1',
+        '<%= config.bin %> <%= command.id %> --env app1 --force',
+    ];
+    static flags = {
+        env: Flags.string({
+            char: 'e',
+            description: 'CLI env name to destroy. Defaults to the current env when omitted in interactive mode',
+        }),
+        force: Flags.boolean({
+            char: 'f',
+            description: 'Skip confirmation and destroy the selected env immediately',
+            default: false,
+        }),
+        verbose: Flags.boolean({
+            description: 'Show raw output from destruction commands',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(AppDestroy);
+        const requestedEnv = flags.env?.trim() || undefined;
+        const explicitEnv = Boolean(requestedEnv && hasExplicitEnvSelection(this.argv));
+        const runtime = await resolveManagedAppRuntime(requestedEnv);
+        if (!runtime) {
+            this.error(formatMissingManagedAppEnvMessage(requestedEnv));
+        }
+        const removesManagedLocalAppFiles = runtime.kind === 'local' &&
+            Boolean(resolveManagedLocalAppPath(runtime)) &&
+            shouldRemoveManagedLocalAppFiles(runtime);
+        const removesStorageData = (runtime.kind === 'local' || runtime.kind === 'docker') &&
+            Boolean(resolveConfiguredStoragePath(runtime.env.config));
+        let confirmed = false;
+        try {
+            confirmed = await confirmDestroy(runtime, {
+                explicitEnv,
+                force: flags.force,
+                removesManagedLocalAppFiles,
+                removesStorageData,
+            });
+        }
+        catch (error) {
+            this.error(error instanceof Error ? error.message : String(error));
+        }
+        if (!confirmed) {
+            return;
+        }
+        announceTargetEnv(runtime.envName);
+        try {
+            if (runtime.kind === 'docker') {
+                startTask(`Removing Docker app container for "${runtime.envName}"...`);
+                const state = await removeDockerContainerIfExists(runtime.containerName, {
+                    stdio: flags.verbose ? 'inherit' : 'ignore',
+                });
+                succeedTask(state === 'removed'
+                    ? `Docker app container removed for "${runtime.envName}".`
+                    : `No Docker app container found for "${runtime.envName}".`);
+            }
+            else if (runtime.kind === 'local') {
+                startTask(`Stopping local NocoBase app for "${runtime.envName}"...`);
+                await runLocalNocoBaseCommand(runtime, ['pm2', 'kill'], {
+                    env: managedAppLifecycleEnvVars(),
+                    stdio: flags.verbose ? 'inherit' : 'ignore',
+                });
+                succeedTask(`Local NocoBase app stopped for "${runtime.envName}".`);
+            }
+            if (runtime.kind === 'local' || runtime.kind === 'docker') {
+                const dbContainer = builtinDbContainerName(runtime);
+                if (dbContainer) {
+                    startTask(`Removing built-in database container for "${runtime.envName}"...`);
+                    const state = await removeDockerContainerIfExists(dbContainer, {
+                        stdio: flags.verbose ? 'inherit' : 'ignore',
+                    });
+                    succeedTask(state === 'removed'
+                        ? `Built-in database container removed for "${runtime.envName}".`
+                        : `No built-in database container found for "${runtime.envName}".`);
+                }
+                else {
+                    printInfo(`External database resources for "${runtime.envName}" were left untouched.`);
+                }
+                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 = resolveManagedLocalAppPath(runtime);
+                    if (localAppPath && removesManagedLocalAppFiles) {
+                        startTask(`Removing managed local app files for "${runtime.envName}"...`);
+                        await removePathIfExists(localAppPath, `managed app files for "${runtime.envName}"`);
+                        succeedTask(`Managed local app files removed for "${runtime.envName}".`);
+                    }
+                    else {
+                        printInfo(`No saved local app path found for "${runtime.envName}".`);
+                    }
+                }
+                const proxyEntryDirs = [
+                    resolveEnvProxyEntryDir(runtime.envName, { provider: 'nginx' }),
+                    resolveEnvProxyEntryDir(runtime.envName, { provider: 'caddy' }),
+                    path.dirname(resolveLegacyNginxEnvProxyAppOutputPath(runtime.envName)),
+                ];
+                startTask(`Removing proxy entry files for "${runtime.envName}"...`);
+                for (const proxyEntryDir of proxyEntryDirs) {
+                    await removePathIfExists(proxyEntryDir, `proxy entry files for "${runtime.envName}"`);
+                }
+                succeedTask(`Proxy entry files removed for "${runtime.envName}".`);
+                const configuredStoragePath = resolveConfiguredStoragePath(runtime.env.config);
+                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}".`);
+                }
+            }
+            else {
+                printInfo(`No CLI-managed local app or database runtime exists for "${runtime.envName}" on this machine.`);
+            }
+            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.lastEnv ? ` (last env: ${result.lastEnv})` : ''}.`);
+        }
+        catch (error) {
+            failTask(`Failed to destroy env "${runtime.envName}".`);
+            this.error(formatDestroyFailure(runtime.envName, error instanceof Error ? error.message : String(error)));
+        }
+    }
+}

package/dist/commands/app/down.js

@@ -0,0 +1,71 @@
+/**
+ * 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 { printWarning } from '../../lib/ui.js';
+export default class AppDown extends Command {
+    static hidden = true;
+    static description = 'Deprecated compatibility alias for `nb app stop --with-db` and `nb env remove <name> --purge`.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --env app1',
+        '<%= config.bin %> <%= command.id %> --env app1 --all --force',
+    ];
+    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: 'Compatibility alias for confirmation flags on the replacement command',
+            default: false,
+        }),
+        force: Flags.boolean({
+            char: 'f',
+            description: 'Compatibility alias for confirmation flags on the replacement command',
+            default: false,
+        }),
+        verbose: Flags.boolean({
+            description: 'Show raw output from shutdown commands',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(AppDown);
+        const runCommand = this.config.runCommand.bind(this.config);
+        const envName = flags.env?.trim();
+        const argv = [];
+        if (envName) {
+            argv.push('--env', envName);
+        }
+        if (flags.verbose) {
+            argv.push('--verbose');
+        }
+        if (flags.all) {
+            printWarning('`nb app down --all` is deprecated. Use `nb env remove <name> --purge` instead.');
+            if (flags.force || flags.yes) {
+                argv.push('--force');
+            }
+            await runCommand('app:destroy', argv);
+            return;
+        }
+        printWarning('`nb app down` is deprecated. Use `nb app stop --with-db` instead.');
+        argv.push('--with-db');
+        if (flags.yes) {
+            argv.push('--yes');
+        }
+        if (flags.force) {
+            argv.push('--force');
+        }
+        await runCommand('app:stop', argv);
+    }
+}

package/dist/commands/app/logs.js

@@ -0,0 +1,115 @@
+/**
+ * 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 { ensureCrossEnvConfirmed, hasExplicitEnvSelection } from '../../lib/env-guard.js';
+import { formatMissingManagedAppEnvMessage, managedAppLifecycleEnvVars, 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',
+        }),
+        yes: Flags.boolean({
+            char: 'y',
+            description: 'Confirm using --env when it targets a different env than the current env',
+            default: false,
+        }),
+        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;
+        if (requestedEnv && hasExplicitEnvSelection(this.argv)) {
+            const confirmed = await ensureCrossEnvConfirmed({
+                command: this,
+                requestedEnv,
+                yes: flags.yes,
+            });
+            if (!confirmed) {
+                return;
+            }
+        }
+        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, {
+                env: managedAppLifecycleEnvVars(),
+                stdio: 'inherit',
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.error(formatLogsFailure(runtime.envName, message));
+        }
+    }
+}