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

package/dist/lib/app-runtime.js

@@ -0,0 +1,142 @@
+/**
+ * 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 { getEnv, loadAuthConfig } from './auth-store.js';
+import { commandOutput, commandSucceeds, run, runNocoBaseCommand } from './run-npm.js';
+const DOCKER_APP_WORKDIR = '/app/nocobase';
+function sanitizeDockerResourceName(value) {
+    const normalized = value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9_.-]+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-+|-+$/g, '');
+    return normalized || 'nocobase';
+}
+export function defaultWorkspaceName(cwd = process.cwd()) {
+    return sanitizeDockerResourceName(`nb-${path.basename(cwd)}`);
+}
+export function buildDockerAppContainerName(envName, workspaceName) {
+    const workspace = workspaceName?.trim() || defaultWorkspaceName();
+    return sanitizeDockerResourceName(`${workspace}-${envName}-app`);
+}
+export function buildDockerDbContainerName(envName, dbDialect, workspaceName) {
+    const workspace = workspaceName?.trim() || defaultWorkspaceName();
+    const dialect = dbDialect.trim() || 'postgres';
+    return sanitizeDockerResourceName(`${workspace}-${envName}-${dialect}`);
+}
+function normalizeEnvSource(env) {
+    const source = String(env.config.source ?? '').trim();
+    if (source === 'docker' || source === 'npm' || source === 'git') {
+        return source;
+    }
+    if (env.config.appRootPath) {
+        return 'local';
+    }
+    return undefined;
+}
+export async function resolveManagedAppRuntime(envName) {
+    const config = await loadAuthConfig();
+    const env = await getEnv(envName, { config });
+    if (!env) {
+        return undefined;
+    }
+    const resolvedName = env.name || envName?.trim() || config.currentEnv || 'default';
+    const source = normalizeEnvSource(env);
+    const workspaceName = config.name?.trim() || defaultWorkspaceName();
+    if (source === 'docker') {
+        return {
+            kind: 'docker',
+            env,
+            envName: resolvedName,
+            source,
+            workspaceName,
+            containerName: buildDockerAppContainerName(resolvedName, workspaceName),
+        };
+    }
+    if (env.config.appRootPath) {
+        return {
+            kind: 'local',
+            env,
+            envName: resolvedName,
+            source: source === 'git' ? 'git' : source === 'npm' ? 'npm' : 'local',
+            projectRoot: env.appRootPath,
+            workspaceName,
+        };
+    }
+    return {
+        kind: 'remote',
+        env,
+        envName: resolvedName,
+        source,
+    };
+}
+export function formatMissingManagedAppEnvMessage(envName) {
+    const requested = String(envName ?? '').trim();
+    if (requested) {
+        return [
+            `Env "${requested}" is not configured in this workspace.`,
+            `If you want to create a new NocoBase AI environment, run \`nb init --env ${requested}\` first.`,
+        ].join('\n');
+    }
+    return 'No NocoBase env is configured yet. Run `nb init` to create one first.';
+}
+export async function runLocalNocoBaseCommand(runtime, args, options) {
+    await runNocoBaseCommand(args, {
+        cwd: runtime.projectRoot,
+        env: runtime.env.envVars,
+        stdio: options?.stdio,
+    });
+}
+export async function dockerContainerExists(containerName) {
+    return await commandSucceeds('docker', ['container', 'inspect', containerName]);
+}
+export async function dockerContainerIsRunning(containerName) {
+    try {
+        const output = await commandOutput('docker', ['inspect', '--format', '{{.State.Running}}', containerName], { errorName: 'docker inspect' });
+        return output.trim() === 'true';
+    }
+    catch (_error) {
+        return false;
+    }
+}
+export async function startDockerContainer(containerName, options) {
+    const exists = await dockerContainerExists(containerName);
+    if (!exists) {
+        throw new Error(`Docker app container "${containerName}" does not exist.`);
+    }
+    if (await dockerContainerIsRunning(containerName)) {
+        return 'already-running';
+    }
+    await run('docker', ['start', containerName], {
+        errorName: 'docker start',
+        stdio: options?.stdio,
+    });
+    return 'started';
+}
+export async function stopDockerContainer(containerName, options) {
+    const exists = await dockerContainerExists(containerName);
+    if (!exists) {
+        throw new Error(`Docker app container "${containerName}" does not exist.`);
+    }
+    if (!(await dockerContainerIsRunning(containerName))) {
+        return 'already-stopped';
+    }
+    await run('docker', ['stop', containerName], {
+        errorName: 'docker stop',
+        stdio: options?.stdio,
+    });
+    return 'stopped';
+}
+export async function runDockerNocoBaseCommand(containerName, args) {
+    await startDockerContainer(containerName);
+    await run('docker', ['exec', '-w', DOCKER_APP_WORKDIR, containerName, 'yarn', 'nocobase', ...args], {
+        errorName: 'docker exec',
+    });
+}

package/dist/lib/auth-store.js

@@ -21,6 +21,7 @@ export async function loadAuthConfig(options = {}) {
         const content = await fs.readFile(getConfigFile(options), 'utf8');
         const parsed = JSON.parse(content);
         return {
+            name: parsed.name || parsed.dockerResourcePrefix,
             currentEnv: parsed.currentEnv || 'default',
             envs: parsed.envs || {},
         };
@@ -53,6 +54,17 @@ export async function setCurrentEnv(envName, options = {}) {
     config.currentEnv = envName;
     await saveAuthConfig(config, options);
 }
+export async function ensureWorkspaceName(defaultName, options = {}) {
+    const config = await loadAuthConfig(options);
+    const existing = config.name?.trim();
+    if (existing) {
+        return existing;
+    }
+    const next = defaultName.trim();
+    config.name = next;
+    await saveAuthConfig(config, options);
+    return next;
+}
 export class Env {
     config;
     constructor(config = {}) {
@@ -87,11 +99,40 @@ export class Env {
         }
         return path.resolve(process.cwd(), storagePath);
     }
+    get appPort() {
+        return this.config.appPort;
+    }
+    get envVars() {
+        const out = {
+            STORAGE_PATH: this.storagePath,
+        };
+        const put = (key, value) => {
+            if (value === undefined || value === null) {
+                return;
+            }
+            out[key] = String(value);
+        };
+        put('APP_PORT', this.appPort);
+        put('APP_KEY', this.config.appKey);
+        put('TZ', this.config.timezone);
+        put('DB_DIALECT', this.config.dbDialect);
+        put('DB_HOST', this.config.dbHost);
+        put('DB_PORT', this.config.dbPort);
+        put('DB_DATABASE', this.config.dbDatabase);
+        put('DB_USER', this.config.dbUser);
+        put('DB_PASSWORD', this.config.dbPassword);
+        return out;
+    }
 }
 export async function getEnv(envName, options = {}) {
-    const config = await loadAuthConfig(options);
-    const resolved = envName || config.currentEnv || 'default';
-    return new Env({ ...config.envs[resolved], name: resolved });
+    const { config: snapshot, ...loadOptions } = options;
+    const config = snapshot ?? (await loadAuthConfig(loadOptions));
+    const resolved = envName?.trim() || config.currentEnv || 'default';
+    const envConfig = config.envs[resolved];
+    if (!envConfig) {
+        return undefined;
+    }
+    return new Env({ ...envConfig, name: resolved });
 }
 function areAuthConfigsEquivalent(left, right) {
     if (!left && !right) {

package/dist/lib/bootstrap.js

@@ -354,9 +354,13 @@ export async function updateEnvRuntime(options) {
     });
     if (!baseUrl) {
         throw new Error([
-            `Env "${envName}" is missing a base URL.`,
-            'Update it with `nb env add <name> --base-url <url>` first.',
-        ].join('\n'));
+            env
+                ? `Env "${envName}" is missing a base URL.`
+                : `Env "${envName}" is not configured. Run \`nb env add ${envName}\` first.`,
+            env ? 'Update it with `nb env add <name> --base-url <url>` first.' : '',
+        ]
+            .filter(Boolean)
+            .join('\n'));
     }
     updateTask('Loading command runtime...');
     try {

package/dist/lib/cli-locale.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 { readFileSync } from 'node:fs';
+export const SUPPORTED_CLI_LOCALES = ['en-US', 'zh-CN'];
+export const CLI_LOCALE_FLAG_OPTIONS = [...SUPPORTED_CLI_LOCALES];
+export const CLI_LOCALE_FLAG_DESCRIPTION = 'Language for CLI prompts and the local setup UI.';
+const DEFAULT_CLI_LOCALE = 'en-US';
+const localeCache = {};
+function normalizeCliLocale(value) {
+    const raw = String(value ?? '').trim();
+    if (!raw) {
+        return undefined;
+    }
+    const normalized = raw.replace(/\..*$/, '').replace(/_/g, '-').toLowerCase();
+    if (normalized === 'zh' || normalized.startsWith('zh-')) {
+        return 'zh-CN';
+    }
+    if (normalized === 'en' || normalized.startsWith('en-')) {
+        return 'en-US';
+    }
+    return undefined;
+}
+function loadLocaleMessages(locale) {
+    if (localeCache[locale]) {
+        return localeCache[locale];
+    }
+    const fileUrl = new URL(`../locale/${locale}.json`, import.meta.url);
+    const parsed = JSON.parse(readFileSync(fileUrl, 'utf8'));
+    localeCache[locale] = parsed;
+    return parsed;
+}
+function getPathValue(input, path) {
+    let current = input;
+    for (const part of path.split('.')) {
+        if (!current || typeof current !== 'object' || !Object.prototype.hasOwnProperty.call(current, part)) {
+            return undefined;
+        }
+        current = current[part];
+    }
+    return current;
+}
+function interpolateTemplate(template, values) {
+    return template.replace(/{{\s*([\w.]+)\s*}}/g, (_match, key) => {
+        const value = getPathValue(values, key);
+        return value === undefined || value === null ? '' : String(value);
+    });
+}
+export function detectCliLocale() {
+    const candidates = [
+        process.env.NB_LOCALE,
+        process.env.LC_ALL,
+        process.env.LC_MESSAGES,
+        process.env.LANG,
+        Intl.DateTimeFormat().resolvedOptions().locale,
+    ];
+    for (const candidate of candidates) {
+        const locale = normalizeCliLocale(candidate);
+        if (locale) {
+            return locale;
+        }
+    }
+    return DEFAULT_CLI_LOCALE;
+}
+export function resolveCliLocale(preferred) {
+    return normalizeCliLocale(preferred) ?? detectCliLocale();
+}
+export function applyCliLocale(preferred) {
+    const locale = resolveCliLocale(preferred);
+    process.env.NB_LOCALE = locale;
+    return locale;
+}
+export function createCliTranslate(preferred) {
+    const locale = resolveCliLocale(preferred);
+    return (key, values, fallback) => {
+        const messages = loadLocaleMessages(locale);
+        const template = getPathValue(messages, key);
+        if (typeof template !== 'string') {
+            return interpolateTemplate(fallback ?? key, values);
+        }
+        return interpolateTemplate(template, values);
+    };
+}
+export function translateCli(key, values, options) {
+    return createCliTranslate(options?.locale)(key, values, options?.fallback);
+}
+export function localeText(key, values, fallback) {
+    return {
+        key,
+        ...(values ? { values } : {}),
+        ...(fallback ? { fallback } : {}),
+    };
+}
+export function isLocalizedTextDef(value) {
+    return Boolean(value
+        && typeof value === 'object'
+        && typeof value.key === 'string');
+}
+export function resolveLocalizedText(text, options) {
+    if (text === undefined) {
+        return options?.fallback ?? '';
+    }
+    if (typeof text === 'string') {
+        return text;
+    }
+    return translateCli(text.key, text.values, {
+        locale: options?.locale,
+        fallback: text.fallback ?? options?.fallback,
+    });
+}