@nocobase/cli 2.1.0-beta.21 → 2.1.0-beta.22

package/dist/commands/app/info.js

@@ -0,0 +1,140 @@
+/**
+ * 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 } from '../../lib/app-runtime.js';
+import { renderTable } from '../../lib/ui.js';
+import { appRootPath, dbStatus, runtimeStatus, storagePath } from './shared.js';
+function normalizeJsonValue(value) {
+    if (value === undefined || value === null || value === '') {
+        return '-';
+    }
+    if (typeof value === 'boolean' || typeof value === 'number') {
+        return value;
+    }
+    return String(value);
+}
+function normalizeValue(value) {
+    if (value === undefined || value === null || value === '') {
+        return '-';
+    }
+    if (typeof value === 'boolean') {
+        return value ? 'true' : 'false';
+    }
+    return String(value);
+}
+function maskSecret(value, showSecrets) {
+    const normalized = normalizeValue(value);
+    if (normalized === '-') {
+        return normalized;
+    }
+    return showSecrets ? normalized : '********';
+}
+function createGroupTable(title, values) {
+    const rows = Object.entries(values).map(([field, value]) => [field, normalizeValue(value)]);
+    return `${title}\n${renderTable(['Field', 'Value'], rows)}`;
+}
+function serializeGroup(values) {
+    return Object.fromEntries(Object.entries(values).map(([field, value]) => [field, normalizeJsonValue(value)]));
+}
+export default class AppInfo extends Command {
+    static hidden = false;
+    static description = 'Show grouped details for the selected NocoBase app env, including app, database, API, and auth settings.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --env app1',
+        '<%= config.bin %> <%= command.id %> --env app1 --json',
+        '<%= config.bin %> <%= command.id %> --env app1 --show-secrets',
+    ];
+    static flags = {
+        env: Flags.string({
+            char: 'e',
+            description: 'CLI env name to inspect. Defaults to the current env when omitted',
+        }),
+        json: Flags.boolean({
+            description: 'Output the result as JSON',
+            default: false,
+        }),
+        'show-secrets': Flags.boolean({
+            description: 'Show secret values in plain text',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(AppInfo);
+        const requestedEnv = flags.env?.trim() || undefined;
+        const showSecrets = flags['show-secrets'];
+        const runtime = await resolveManagedAppRuntime(requestedEnv);
+        if (!runtime) {
+            this.error(formatMissingManagedAppEnvMessage(requestedEnv));
+        }
+        const auth = runtime.env.auth;
+        const appGroup = {
+            appRootPath: appRootPath(runtime),
+            storagePath: storagePath(runtime),
+            appPort: runtime.env.config.appPort,
+            appStatus: await runtimeStatus(runtime),
+            source: runtime.source,
+            downloadVersion: runtime.env.config.downloadVersion,
+            dockerRegistry: runtime.env.config.dockerRegistry,
+            dockerPlatform: runtime.env.config.dockerPlatform,
+            timezone: runtime.env.config.timezone,
+        };
+        const dbGroup = {
+            databaseStatus: await dbStatus(runtime),
+            builtinDb: runtime.env.config.builtinDb,
+            dbDialect: runtime.env.config.dbDialect,
+            builtinDbImage: runtime.env.config.builtinDbImage,
+            dbHost: runtime.env.config.dbHost,
+            dbPort: runtime.env.config.dbPort,
+            dbDatabase: runtime.env.config.dbDatabase,
+            dbUser: runtime.env.config.dbUser,
+            dbPassword: maskSecret(runtime.env.config.dbPassword, showSecrets),
+        };
+        const authGroup = {
+            type: auth?.type,
+            expiresAt: auth?.type === 'oauth' ? auth.expiresAt : undefined,
+            scope: auth?.type === 'oauth' ? auth.scope : undefined,
+            issuer: auth?.type === 'oauth' ? auth.issuer : undefined,
+            clientId: auth?.type === 'oauth' ? auth.clientId : undefined,
+            resource: auth?.type === 'oauth' ? auth.resource : undefined,
+            accessToken: maskSecret(auth?.accessToken, showSecrets),
+            refreshToken: maskSecret(auth?.type === 'oauth' ? auth.refreshToken : undefined, showSecrets),
+        };
+        const apiGroup = {
+            apiBaseUrl: runtime.env.apiBaseUrl,
+            'auth.type': authGroup.type,
+            'auth.expiresAt': authGroup.expiresAt,
+            'auth.scope': authGroup.scope,
+            'auth.issuer': authGroup.issuer,
+            'auth.clientId': authGroup.clientId,
+            'auth.resource': authGroup.resource,
+            'auth.accessToken': authGroup.accessToken,
+            'auth.refreshToken': authGroup.refreshToken,
+        };
+        const output = {
+            ok: true,
+            env: runtime.envName,
+            kind: runtime.kind,
+            app: serializeGroup(appGroup),
+            db: serializeGroup(dbGroup),
+            api: {
+                apiBaseUrl: normalizeJsonValue(runtime.env.apiBaseUrl),
+                auth: serializeGroup(authGroup),
+            },
+        };
+        if (flags.json) {
+            this.log(JSON.stringify(output, null, 2));
+            return;
+        }
+        this.log([
+            createGroupTable('App', appGroup),
+            createGroupTable('DB', dbGroup),
+            createGroupTable('API', apiGroup),
+        ].join('\n\n'));
+    }
+}

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: true,
+            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 !== false;
+        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/ps.js

@@ -0,0 +1,60 @@
+/**
+ * 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, } from '../../lib/app-runtime.js';
+import { listEnvs } from '../../lib/auth-store.js';
+import { renderTable } from '../../lib/ui.js';
+import { appNetwork, appRootPath, appUrl, dbStatus, runtimeStatus, storagePath } from './shared.js';
+export default class AppPs extends Command {
+    static hidden = false;
+    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(AppPs);
+        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,
+                runtime.kind,
+                await runtimeStatus(runtime),
+                await dbStatus(runtime),
+                appNetwork(runtime),
+                appRootPath(runtime),
+                storagePath(runtime),
+                appUrl(runtime),
+            ]);
+        }
+        this.log(renderTable(['Env', 'Kind', 'App Status', 'Database Status', 'Network', 'App Root', 'Storage', 'URL'], rows));
+    }
+}

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);
+    }
+}

package/dist/commands/app/shared.js

@@ -0,0 +1,95 @@
+/**
+ * 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 { buildDockerDbContainerName, dockerContainerExists, dockerContainerIsRunning, defaultWorkspaceName, } from '../../lib/app-runtime.js';
+export function resolveApiBaseUrl(config) {
+    return String(config.apiBaseUrl ?? config.baseUrl ?? config.apibaseUrl ?? '').trim();
+}
+export function appUrl(runtime) {
+    const port = String(runtime.env.config.appPort ?? '').trim();
+    if (port) {
+        return `http://127.0.0.1:${port}`;
+    }
+    const baseUrl = resolveApiBaseUrl(runtime.env.config);
+    return baseUrl.replace(/\/api\/?$/, '');
+}
+export function appNetwork(runtime) {
+    if (runtime.kind === 'docker') {
+        return runtime.workspaceName?.trim() || defaultWorkspaceName();
+    }
+    return '-';
+}
+export function appRootPath(runtime) {
+    if (runtime.kind === 'http' || runtime.kind === 'docker') {
+        return '-';
+    }
+    if (runtime.kind === 'local') {
+        return String(runtime.projectRoot ?? runtime.env.appRootPath ?? '').trim() || '-';
+    }
+    return String(runtime.env.config.appRootPath ?? '').trim() || '-';
+}
+export function storagePath(runtime) {
+    if (runtime.kind === 'http') {
+        return '-';
+    }
+    const value = String(runtime.env.storagePath ?? runtime.env.config.storagePath ?? '').trim();
+    return value || '-';
+}
+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';
+}
+export async function dbStatus(runtime) {
+    if (!runtime.env.config.builtinDb) {
+        return runtime.kind === 'http' ? 'external' : '-';
+    }
+    if (runtime.kind === 'http') {
+        return 'external';
+    }
+    if (runtime.kind === 'ssh') {
+        return '-';
+    }
+    const dbDialect = String(runtime.env.config.dbDialect ?? 'postgres').trim() || 'postgres';
+    const containerName = buildDockerDbContainerName(runtime.envName, dbDialect, runtime.workspaceName);
+    return await dockerStatus(containerName);
+}
+export async function runtimeStatus(runtime) {
+    if (runtime.kind === 'http') {
+        return 'http';
+    }
+    if (runtime.kind === 'ssh') {
+        return 'ssh';
+    }
+    if (runtime.kind === 'docker') {
+        return await dockerStatus(runtime.containerName);
+    }
+    return await isLocalAppHealthy(runtime) ? 'running' : 'stopped';
+}