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

package/dist/commands/env/list.js

@@ -0,0 +1,50 @@
+/**
+ * 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 { resolveManagedAppRuntime } from '../../lib/app-runtime.js';
+import { listEnvs } from '../../lib/auth-store.js';
+import { resolveDefaultConfigScope } from '../../lib/cli-home.js';
+import { renderTable } from '../../lib/ui.js';
+import { apiStatus, appUrl, resolveApiBaseUrl } from './shared.js';
+export default class EnvList extends Command {
+    static summary = 'List configured environments and API auth status';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    async run() {
+        await this.parse(EnvList);
+        const scope = resolveDefaultConfigScope();
+        const { currentEnv, envs } = await listEnvs({ scope });
+        const names = Object.keys(envs).sort();
+        if (!names.length) {
+            this.log('No envs configured.');
+            this.log('Run `nb env add <name> --api-base-url <url>` to add one.');
+            return;
+        }
+        const rows = [];
+        for (const name of names) {
+            const env = envs[name];
+            const runtime = await resolveManagedAppRuntime(name);
+            const statusConfig = {
+                ...env,
+                ...(runtime?.env.config ?? {}),
+            };
+            rows.push([
+                name === currentEnv ? '*' : '',
+                name,
+                runtime?.kind ?? env.kind ?? '-',
+                await apiStatus(name, statusConfig, { scope }),
+                runtime ? appUrl(runtime) : resolveApiBaseUrl(env),
+                env.auth?.type ?? '',
+                env.runtime?.version ?? '',
+            ]);
+        }
+        this.log(renderTable(['Current', 'Name', 'Kind', 'App Status', 'URL', 'Auth', 'Runtime'], rows));
+    }
+}

package/dist/commands/env/remove.js

@@ -0,0 +1,59 @@
+/**
+ * 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 { getCurrentEnvName, removeEnv } from '../../lib/auth-store.js';
+import { resolveDefaultConfigScope } from '../../lib/cli-home.js';
+import { confirmAction, isInteractiveTerminal, printVerbose, setVerboseMode } from '../../lib/ui.js';
+export default class EnvRemove extends Command {
+    static summary = 'Remove a configured environment';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> staging',
+        '<%= config.bin %> <%= command.id %> staging -f',
+    ];
+    static flags = {
+        force: Flags.boolean({
+            char: 'f',
+            description: 'Remove without confirmation',
+            default: false,
+        }),
+        verbose: Flags.boolean({
+            description: 'Show detailed progress output',
+            default: false,
+        }),
+    };
+    static args = {
+        name: Args.string({
+            description: 'Configured environment name',
+            required: true,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(EnvRemove);
+        setVerboseMode(flags.verbose);
+        const currentEnv = await getCurrentEnvName({ scope: resolveDefaultConfigScope() });
+        if (args.name === currentEnv && !flags.force) {
+            if (!isInteractiveTerminal()) {
+                this.error('Refusing to remove the current env without confirmation. Re-run with `--force`.');
+            }
+            const confirmed = await confirmAction(`Remove current env "${args.name}"?`, { defaultValue: false });
+            if (!confirmed) {
+                this.log('Canceled.');
+                return;
+            }
+        }
+        printVerbose(`Removing env "${args.name}"`);
+        const result = await removeEnv(args.name, { scope: resolveDefaultConfigScope() });
+        this.log(`Removed env "${result.removed}".`);
+        if (result.hasEnvs) {
+            this.log(`Current env: ${result.currentEnv}`);
+            return;
+        }
+        this.log('No envs configured.');
+    }
+}

package/dist/commands/env/shared.js

@@ -0,0 +1,158 @@
+/**
+ * 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, } from '../../lib/app-runtime.js';
+import { executeRawApiRequest } from '../../lib/api-client.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 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 || '-';
+}
+function collectErrorCodes(value) {
+    if (!value || typeof value !== 'object') {
+        return [];
+    }
+    if (Array.isArray(value)) {
+        return value.flatMap((item) => collectErrorCodes(item));
+    }
+    const out = [];
+    const record = value;
+    if (typeof record.code === 'string') {
+        out.push(record.code);
+    }
+    for (const key of ['data', 'error', 'errors']) {
+        out.push(...collectErrorCodes(record[key]));
+    }
+    return out;
+}
+function isAuthFailureData(value) {
+    const codes = collectErrorCodes(value);
+    return codes.some((code) => ['EMPTY_TOKEN', 'INVALID_TOKEN', 'EXPIRED_TOKEN', 'BLOCKED_TOKEN', 'EXPIRED_SESSION', 'NOT_EXIST_USER'].includes(code));
+}
+function isNetworkFailure(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    return (error.name === 'AbortError'
+        || /fetch failed|network|timeout|timed out|abort|ECONNREFUSED|ECONNRESET|ENOTFOUND|ETIMEDOUT|EAI_AGAIN|ENETUNREACH/i.test(error.message));
+}
+function isUnconfiguredFailure(error) {
+    return error instanceof Error && /missing (a )?base url|missing base URL/i.test(error.message);
+}
+function isAuthFailure(error) {
+    return (error instanceof Error
+        && /EMPTY_TOKEN|INVALID_TOKEN|EXPIRED_TOKEN|BLOCKED_TOKEN|EXPIRED_SESSION|NOT_EXIST_USER|invalid_grant|sign in|signin|authentication failed/i.test(error.message));
+}
+export async function apiStatus(envName, config, options = {}) {
+    if (!resolveApiBaseUrl(config)) {
+        return 'unconfigured';
+    }
+    try {
+        const response = await executeRawApiRequest({
+            envName,
+            scope: options.scope,
+            method: 'GET',
+            path: '/auth:check',
+            timeoutMs: options.timeoutMs ?? 2000,
+        });
+        if (response.ok) {
+            return 'ok';
+        }
+        if (response.status === 401 || response.status === 403 || isAuthFailureData(response.data)) {
+            return 'auth failed';
+        }
+        return 'error';
+    }
+    catch (error) {
+        if (isUnconfiguredFailure(error)) {
+            return 'unconfigured';
+        }
+        if (isAuthFailure(error)) {
+            return 'auth failed';
+        }
+        if (isNetworkFailure(error)) {
+            return 'unreachable';
+        }
+        return 'error';
+    }
+}
+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.dockerContainerPrefix || 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';
+}

package/dist/commands/env/update.js

@@ -0,0 +1,67 @@
+/**
+ * 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 path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Args, Command, Flags } from '@oclif/core';
+import { getCurrentEnvName } from '../../lib/auth-store.js';
+import { updateEnvRuntime } from '../../lib/bootstrap.js';
+import { resolveDefaultConfigScope } from '../../lib/cli-home.js';
+import { failTask, startTask, succeedTask } from '../../lib/ui.js';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+export default class EnvUpdate extends Command {
+    static summary = 'Refresh an environment runtime from swagger:get and persist connection overrides';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> prod',
+    ];
+    static args = {
+        name: Args.string({
+            description: 'Environment name (omit to use the current env)',
+            required: false,
+        }),
+    };
+    static flags = {
+        verbose: Flags.boolean({
+            description: 'Show detailed progress output',
+            default: false,
+        }),
+        'api-base-url': Flags.string({
+            description: 'NocoBase API base URL override. When provided, persist it to the target env before saving the refreshed runtime.',
+        }),
+        role: Flags.string({
+            description: 'Role override, sent as X-Role',
+        }),
+        token: Flags.string({
+            char: 't',
+            description: 'API key override. When provided, persist it to the target env before saving the refreshed runtime.',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(EnvUpdate);
+        const envName = args.name;
+        const envLabel = envName ?? (await getCurrentEnvName({ scope: resolveDefaultConfigScope() }));
+        startTask(`Updating env runtime: ${envLabel}`);
+        try {
+            const runtime = await updateEnvRuntime({
+                envName,
+                scope: resolveDefaultConfigScope(),
+                baseUrl: flags['api-base-url'],
+                role: flags.role,
+                token: flags.token,
+                configFile: path.join(path.dirname(path.dirname(path.dirname(__dirname))), 'nocobase-ctl.config.json'),
+                verbose: flags.verbose,
+            });
+            succeedTask(`Updated env "${envLabel}" to runtime "${runtime.version}".`);
+        }
+        catch (error) {
+            failTask(`Failed to update env "${envLabel}".`);
+            throw error;
+        }
+    }
+}

package/dist/commands/env/use.js

@@ -0,0 +1,28 @@
+/**
+ * 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 } from '@oclif/core';
+import { setCurrentEnv } from '../../lib/auth-store.js';
+import { resolveDefaultConfigScope } from '../../lib/cli-home.js';
+export default class EnvUse extends Command {
+    static summary = 'Switch the current environment';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> local',
+    ];
+    static args = {
+        name: Args.string({
+            description: 'Configured environment name',
+            required: true,
+        }),
+    };
+    async run() {
+        const { args } = await this.parse(EnvUse);
+        await setCurrentEnv(args.name, { scope: resolveDefaultConfigScope() });
+        this.log(`Current env: ${args.name}`);
+    }
+}

package/dist/commands/examples/prompts-stages.js

@@ -0,0 +1,150 @@
+/**
+ * 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 { runPromptCatalog, } from "../../lib/prompt-catalog.js";
+import { applyCliLocale, CLI_LOCALE_FLAG_DESCRIPTION, CLI_LOCALE_FLAG_OPTIONS, } from "../../lib/cli-locale.js";
+import { runPromptCatalogWebUI } from "../../lib/prompt-web-ui.js";
+import PromptsTest from "./prompts-test.js";
+function buildWebUiStagesFromTestPrompts(c) {
+    return [
+        {
+            sectionTitle: 'Step 1',
+            sectionDescription: 'intro, file, name, and boolean',
+            catalog: {
+                intro1: c.intro1,
+                file: c.file,
+                text: c.text,
+                boolean: c.boolean,
+            },
+        },
+        {
+            sectionTitle: 'Step 2',
+            sectionDescription: 'select, then the option1 run hook',
+            catalog: {
+                select: c.select,
+                onOption1: c.onOption1,
+            },
+        },
+        {
+            sectionTitle: 'Step 3',
+            sectionDescription: 'password, integer, and outro',
+            catalog: {
+                password: c.password,
+                integer: c.integer,
+                outro1: c.outro1,
+            },
+        },
+    ];
+}
+/**
+ * With `--ui`: `runPromptCatalogWebUI` using `stages` + `sectionTitle`, then
+ * `runPromptCatalog` on the same catalog as `prompts-test`. Without `--ui`, same terminal behavior
+ * as `prompts-test` (handy for comparing).
+ */
+export default class PromptsStages extends Command {
+    static hidden = true;
+    static args = {
+        file: Args.string({ description: 'file to read', required: false }),
+    };
+    static description = 'Demo: with --ui, `runPromptCatalogWebUI` with `stages` (section headings in the form); without --ui, same as `prompts-test`. The submitted preset runs through the same `PromptsTest.prompts` catalog as `prompts-test`.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>  # same terminal flow as `prompts-test`',
+        '<%= config.bin %> <%= command.id %> --ui  # `runPromptCatalogWebUI` with `stages` + `sectionTitle`',
+        '<%= config.bin %> <%= command.id %> -y ./README.md -p secret --ui',
+    ];
+    static flags = {
+        ui: Flags.boolean({
+            description: 'Open the localhost form: `runPromptCatalogWebUI` with `stages` and `sectionTitle` (vs `prompts-test --ui`, which uses one `catalog`). Without --ui, behavior matches `prompts-test` (Clack in TTY / presets).',
+            default: false,
+        }),
+        yes: Flags.boolean({
+            char: 'y',
+            description: 'Accept defaults only in the terminal (no Clack after submit); same semantics as `prompts-test` when used with the submitted or default preset.',
+            default: false,
+        }),
+        locale: Flags.string({
+            description: CLI_LOCALE_FLAG_DESCRIPTION,
+            options: CLI_LOCALE_FLAG_OPTIONS,
+        }),
+        file: Flags.string({
+            char: 'f',
+            description: 'Merged into initialValues.file (default for the text prompt when set)',
+        }),
+        text: Flags.string({
+            char: 't',
+            description: 'Merged into initialValues.text (default for the text prompt when set)',
+        }),
+        boolean: Flags.boolean({
+            char: 'b',
+            description: 'Merged into initialValues.boolean (default for confirm when set)',
+            allowNo: true,
+        }),
+        select: Flags.string({
+            char: 's',
+            description: 'Merged into initialValues.select (default for select when set)',
+            options: ['option1', 'option2', 'option3'],
+        }),
+        password: Flags.string({
+            char: 'p',
+            description: 'Merged into initialValues.password (required when -y / non-TTY if password is required)',
+        }),
+        integer: Flags.integer({
+            char: 'i',
+            description: 'Merged into initialValues.integer (default for integer prompt when set)',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(PromptsStages);
+        applyCliLocale(flags.locale);
+        let presetValues = this.buildPresetValuesFromParsed(args, flags);
+        if (flags.ui) {
+            presetValues = await runPromptCatalogWebUI({
+                stages: buildWebUiStagesFromTestPrompts(PromptsTest.prompts),
+                values: presetValues,
+                pageTitle: 'nb prompts-stages — Web UI',
+                documentHeading: 'nb prompts-stages — `stages` demo',
+                onServerStart: ({ host, port, url }) => {
+                    this.log(`Local Web UI (multi-stage) ready — ${url} (listening on ${host}:${port}). Submit the form in the browser to continue.`);
+                },
+                onOpenBrowserError: (url, err) => {
+                    this.log(`Open this URL in a browser: ${url} (${err instanceof Error ? err.message : String(err)})`);
+                },
+            });
+        }
+        const results = await runPromptCatalog(PromptsTest.prompts, {
+            initialValues: {},
+            values: presetValues,
+            yes: flags.yes || flags.ui,
+        });
+        this.log(JSON.stringify(results, null, 2));
+    }
+    buildPresetValuesFromParsed(args, flags) {
+        const preset = {};
+        const file = args.file ?? flags.file;
+        if (file !== undefined) {
+            preset.file = file;
+        }
+        if (flags.text !== undefined) {
+            preset.text = flags.text;
+        }
+        if (flags.boolean !== undefined) {
+            preset.boolean = flags.boolean;
+        }
+        if (flags.select !== undefined) {
+            preset.select = flags.select;
+        }
+        if (flags.password !== undefined) {
+            preset.password = flags.password;
+        }
+        if (flags.integer !== undefined) {
+            preset.integer = flags.integer;
+        }
+        return preset;
+    }
+}